moonflower 0.9.0

package/src/openapi/analyzerModule/analyzerModule.ts

@@ -0,0 +1,228 @@
+import * as path from 'path'
+import { SourceFile, SyntaxKind } from 'ts-morph'
+import { Project } from 'ts-morph'
+
+import { discoverImportedName } from '../discoveryModule/discoverImports/discoverImports'
+import {
+	DiscoveredSourceFile,
+	discoverRouterFiles,
+} from '../discoveryModule/discoverRouterFiles/discoverRouterFiles'
+import { discoverRouters } from '../discoveryModule/discoverRouters/discoverRouters'
+import { ApiDocsHeader, OpenApiManager } from '../manager/OpenApiManager'
+import { EndpointData, ExposedModelData } from '../types'
+import { getValuesOfObjectLiteral } from './nodeParsers'
+import { parseEndpoint } from './parseEndpoint'
+import { parseExposedModel, parseNamedExposedModels } from './parseExposedModels'
+
+type Props = {
+	tsconfigPath: string
+	sourceFilePaths?: string[]
+	sourceFileDiscovery?: boolean | FileDiscoveryConfig
+}
+
+type FileDiscoveryConfig = {
+	rootPath: string
+}
+
+/**
+ * @param tsconfigPath Path to tsconfig file relative to project root
+ * @param sourceFilePaths Array of router source files relative to project root
+ */
+export const prepareOpenApiSpec = ({ tsconfigPath, sourceFilePaths, sourceFileDiscovery }: Props) => {
+	const openApiManager = OpenApiManager.getInstance()
+
+	if (openApiManager.isReady()) {
+		return
+	}
+
+	const project = new Project({
+		tsConfigFilePath: path.resolve(tsconfigPath),
+	})
+
+	const { explicitRouters, discoveredRouterFiles, allSourceFiles } = (() => {
+		const sourceFilesToAdd = sourceFilePaths ?? []
+		const resolvedSourceFilePaths = sourceFilesToAdd.map((filepath) => path.resolve(filepath))
+		const sourceFiles = resolvedSourceFilePaths.map((filePath) => project.getSourceFileOrThrow(filePath))
+		const explicitRouters = sourceFiles.flatMap((file) => ({
+			fileName: file.getFilePath(),
+			sourceFile: file,
+			routers: discoverRouters(file),
+		}))
+
+		const { discoveredRouterFiles, discoveredSourceFiles } = (() => {
+			if (sourceFileDiscovery === false) {
+				return { discoveredRouterFiles: [], discoveredSourceFiles: [] }
+			}
+
+			return discoverRouterFiles({
+				targetPath: typeof sourceFileDiscovery === 'object' ? sourceFileDiscovery.rootPath : '.',
+				tsConfigPath: tsconfigPath,
+			})
+		})()
+
+		const allSourceFiles = sourceFiles.reduce(
+			(acc, current) =>
+				acc.some((r) => r.getFilePath() === current.getFilePath()) ? acc : acc.concat(current),
+			discoveredSourceFiles
+		)
+
+		return { explicitRouters, discoveredRouterFiles, allSourceFiles }
+	})()
+
+	const filesToAnalyze = explicitRouters.reduce(
+		(acc, current) => (acc.some((r) => r.fileName === current.fileName) ? acc : acc.concat(current)),
+		discoveredRouterFiles
+	)
+
+	const apiHeaders = allSourceFiles
+		.flatMap((file) => analyzeSourceFileApiHeader(file))
+		.filter((headers) => !!headers)
+	if (apiHeaders.length > 0 && apiHeaders[0]) {
+		openApiManager.setHeader(apiHeaders[0])
+	}
+
+	const exposedModels = allSourceFiles.flatMap((file) => analyzeSourceFileExposedModels(file))
+
+	openApiManager.setExposedModels(exposedModels)
+
+	const endpoints = filesToAnalyze.flatMap((file) => analyzeSourceFileEndpoints(file))
+
+	openApiManager.setStats({
+		discoveredRouterFiles: discoveredRouterFiles.map((file) => ({
+			path: file.fileName,
+			routers: file.routers.named.map((r) => ({
+				name: r,
+				endpoints: endpoints
+					.filter((e) => e.sourceFilePath === file.fileName)
+					.map((e) => `${e.method.toUpperCase()} ${e.path}`),
+			})),
+		})),
+		explicitRouterFiles: explicitRouters.map((file) => ({
+			path: file.fileName,
+			routers: file.routers.named.map((r) => ({
+				name: r,
+				endpoints: endpoints
+					.filter((e) => e.sourceFilePath === file.fileName)
+					.map((e) => `${e.method.toUpperCase()} ${e.path}`),
+			})),
+		})),
+	})
+
+	openApiManager.setEndpoints(endpoints)
+	openApiManager.markAsReady()
+}
+
+export const analyzeSourceFileEndpoints = (
+	file: DiscoveredSourceFile,
+	filterEndpointPaths?: string[]
+): EndpointData[] => {
+	const endpoints: EndpointData[] = []
+
+	file.routers.named.forEach((routerName) => {
+		file.sourceFile.forEachChild((node) => {
+			const nodeText = node.getText()
+			const operations = ['get', 'post', 'put', 'delete', 'del', 'patch']
+			const targetNodes = operations.map((op) => `${routerName}.${op}`)
+
+			if (targetNodes.some((targetNode) => nodeText.includes(targetNode))) {
+				const endpointText = node.getFirstDescendantByKind(SyntaxKind.StringLiteral)?.getText() ?? ''
+				const endpointPath = endpointText.substring(1, endpointText.length - 1)
+				if (!!filterEndpointPaths && !filterEndpointPaths.some((path) => endpointPath.includes(path))) {
+					return
+				}
+
+				endpoints.push(parseEndpoint(node, file.fileName))
+			}
+		})
+	})
+	return endpoints
+}
+
+export const analyzeSourceFileApiHeader = (sourceFile: SourceFile): ApiDocsHeader | null => {
+	const nameOfUseApiHeader = discoverImportedName({
+		sourceFile,
+		originalName: 'useApiHeader',
+	})
+
+	if (!nameOfUseApiHeader) {
+		return null
+	}
+
+	const node = sourceFile
+		.forEachChildAsArray()
+		.filter((node) => node.isKind(SyntaxKind.ExpressionStatement))
+		.find((node) => nameOfUseApiHeader && node.getText().startsWith(nameOfUseApiHeader))
+
+	if (!node) {
+		return null
+	}
+
+	const targetNode = node.getFirstDescendantByKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+	const values = getValuesOfObjectLiteral(targetNode)
+
+	const collapseObject = (v: string | string[] | typeof values): any => {
+		if (typeof v === 'string') {
+			return v
+		}
+		if (Array.isArray(v) && v.every((value) => typeof value === 'string')) {
+			return v
+		}
+
+		return v.reduce((acc, current) => {
+			if (typeof current === 'string') {
+				return acc
+			}
+			return {
+				...acc,
+				[current.identifier]: collapseObject(current.value as string[]),
+			}
+		}, {})
+	}
+	return collapseObject(values)
+}
+
+export const analyzeSourceFileExposedModels = (sourceFile: SourceFile): ExposedModelData[] => {
+	const models: ExposedModelData[] = []
+
+	const nameOfUseExposeApiModel = discoverImportedName({
+		sourceFile,
+		originalName: 'useExposeApiModel',
+	})
+
+	const nameOfUseExposeNamedApiModels = discoverImportedName({
+		sourceFile,
+		originalName: 'useExposeNamedApiModels',
+	})
+
+	sourceFile
+		.forEachChildAsArray()
+		.filter((node) => node.isKind(SyntaxKind.ExpressionStatement))
+		.map((node) => {
+			if (nameOfUseExposeApiModel && node.getText().startsWith(nameOfUseExposeApiModel)) {
+				const callExpressionNode = node.getFirstChild()
+				const syntaxListChildren = callExpressionNode?.getChildrenOfKind(SyntaxKind.SyntaxList) || []
+
+				const firstChild = syntaxListChildren[0].getFirstChild()
+				if (!firstChild) {
+					return
+				}
+
+				models.push(parseExposedModel(firstChild))
+				return
+			}
+
+			if (nameOfUseExposeNamedApiModels && node.getText().startsWith(nameOfUseExposeNamedApiModels)) {
+				const callExpressionNode = node.getFirstChild()
+				const syntaxListChildren = callExpressionNode?.getChildrenOfKind(SyntaxKind.SyntaxList) || []
+
+				const firstChild = syntaxListChildren[0].getFirstChild()
+				if (!firstChild) {
+					return
+				}
+
+				const parsedModels = parseNamedExposedModels(firstChild)
+				parsedModels.forEach((model) => models.push(model))
+			}
+		})
+	return models
+}