moonflower 1.4.7 → 1.4.9

package/src/openapi/analyzerModule/analyzerModule.ts

@@ -13,7 +13,7 @@ import { ApiDocsHeader, OpenApiManager } from '../manager/OpenApiManager'
 import { EndpointData, ExposedModelData } from '../types'
 import { getSourceFileTimestamp, TimestampCache } from './getSourceFileTimestamp'
 import { getValuesOfObjectLiteral, resolveEndpointPath } from './nodeParsers'
-import { parseEndpoint } from './parseEndpoint'
+import { parseEndpoint, SectionTiming } from './parseEndpoint'
 import { parseExposedModel, parseNamedExposedModels } from './parseExposedModels'
 import { SourceFileCache } from './sourceFileCache'
 
@@ -27,12 +27,15 @@ type Props = {
 		| {
 				cachePath: string
 		  }
+	profiling?: 'stats' | 'off' | 'debug'
 }
 
 type FileDiscoveryConfig = {
 	rootPath: string
 }
 
+type EndpointTiming = { method: string; path: string; timing: number; sectionTimings: SectionTiming[] }
+
 /**
  * @param tsconfigPath Path to tsconfig file relative to project root
  * @param sourceFilePaths Array of router source files relative to project root
@@ -43,6 +46,7 @@ export const prepareOpenApiSpec = ({
 	sourceFilePaths,
 	sourceFileDiscovery,
 	incremental,
+	profiling = 'stats',
 }: Props) => {
 	const openApiManager = OpenApiManager.getInstance()
 
@@ -81,7 +85,9 @@ export const prepareOpenApiSpec = ({
 				targetPath: typeof sourceFileDiscovery === 'object' ? sourceFileDiscovery.rootPath : '.',
 				tsConfigPath: tsconfigPath,
 			})
-			Logger.info(`File discovery took ${Math.round(performance.now() - startTime)}ms`)
+			if (profiling !== 'off') {
+				Logger.info(`File discovery took ${Math.round(performance.now() - startTime)}ms`)
+			}
 			return files
 		})()
 
@@ -120,6 +126,7 @@ export const prepareOpenApiSpec = ({
 		incremental: incremental !== false,
 		cachePath,
 		timestampCache: {},
+		profiling,
 	})
 
 	openApiManager.setStats({
@@ -153,23 +160,49 @@ export const analyzeMultipleSourceFiles = (
 		incremental: boolean
 		cachePath: string
 		timestampCache: TimestampCache
+		profiling?: 'stats' | 'off' | 'debug'
 	},
 	filterEndpointPaths?: string[],
 ): EndpointData[] => {
+	const profiling = config.profiling ?? 'stats'
 	const startTime = performance.now()
 	const analyzedFiles = files.map((file) => analyzeSourceFileWithCache(file, config, filterEndpointPaths))
-	Logger.info(`Router analysis took ${Math.round(performance.now() - startTime)}ms`)
 
-	analyzedFiles
-		.map((f, index) => ({
-			fileName: files[index].fileName,
-			timeTaken: f.timing,
-		}))
-		.sort((a, b) => b.timeTaken - a.timeTaken)
-		.filter((t) => t.timeTaken > 500)
-		.forEach((t) => {
-			Logger.info(`- [${t.fileName}] Took ${Math.round(t.timeTaken)}ms to analyze`)
-		})
+	if (profiling !== 'off') {
+		Logger.info(`Router analysis took ${Math.round(performance.now() - startTime)}ms`)
+	}
+
+	if (profiling === 'stats') {
+		analyzedFiles
+			.map((f, index) => ({ fileName: files[index].fileName, timeTaken: f.timing }))
+			.sort((a, b) => b.timeTaken - a.timeTaken)
+			.filter((t) => t.timeTaken > 500)
+			.forEach((t) => {
+				Logger.info(`- [${t.fileName}] Took ${Math.round(t.timeTaken)}ms to analyze`)
+			})
+	} else if (profiling === 'debug') {
+		analyzedFiles
+			.map((f, index) => ({
+				fileName: files[index].fileName,
+				timeTaken: f.timing,
+				endpointTimings: f.endpointTimings,
+			}))
+			.sort((a, b) => b.timeTaken - a.timeTaken)
+			.forEach((t) => {
+				Logger.info(`- [${t.fileName}] Took ${Math.round(t.timeTaken)}ms to analyze`)
+				t.endpointTimings
+					.sort((a, b) => b.timing - a.timing)
+					.forEach((ep) => {
+						Logger.info(`  - ${ep.method} ${ep.path} (${Math.round(ep.timing)}ms)`)
+						ep.sectionTimings
+							.filter((s) => s.timing >= 1)
+							.sort((a, b) => b.timing - a.timing)
+							.forEach((s) => {
+								Logger.info(`    - ${s.section}: ${Math.round(s.timing)}ms`)
+							})
+					})
+			})
+	}
 
 	return analyzedFiles.flatMap((f) => f.endpoints)
 }
@@ -180,38 +213,40 @@ export const analyzeSourceFileWithCache = (
 		incremental: boolean
 		cachePath: string
 		timestampCache: TimestampCache
+		profiling?: 'stats' | 'off' | 'debug'
 	},
 	filterEndpointPaths?: string[],
-): { endpoints: EndpointData[]; timing: number } => {
+): { endpoints: EndpointData[]; timing: number; endpointTimings: EndpointTiming[] } => {
 	const timestamp = getSourceFileTimestamp(file.sourceFile, config.timestampCache)
 	const cachedResults = SourceFileCache.getCachedResults(file.sourceFile, timestamp, config.cachePath)
 
 	if (cachedResults) {
 		Logger.debug(`[${file.fileName}] Found cached results`)
-		return { endpoints: cachedResults.endpoints, timing: 0 }
+		return { endpoints: cachedResults.endpoints, timing: 0, endpointTimings: [] }
 	}
 	Logger.debug(`[${file.fileName}] Analyzing...`)
 
 	const t1 = performance.now()
-	const endpoints = analyzeSourceFileEndpoints(file, filterEndpointPaths)
+	const { endpoints, endpointTimings } = analyzeSourceFileEndpoints(file, filterEndpointPaths)
 	const t2 = performance.now()
 	Logger.debug(`[${file.fileName}] Analyzed in ${t2 - t1}ms`)
 	SourceFileCache.cacheResults(file.sourceFile, timestamp, config.cachePath, endpoints)
-	return { endpoints, timing: t2 - t1 }
+	return { endpoints, timing: t2 - t1, endpointTimings }
 }
 
 export const analyzeSourceFileEndpoints = (
 	file: DiscoveredSourceFile,
 	filterEndpointPaths?: string[],
-): EndpointData[] => {
+): { endpoints: EndpointData[]; endpointTimings: EndpointTiming[] } => {
 	const endpoints: EndpointData[] = []
+	const endpointTimings: EndpointTiming[] = []
 	const operations = ['get', 'post', 'put', 'delete', 'del', 'patch']
 	const joinedOperations = operations.join('|')
 
 	file.routers.named.forEach((routerName) => {
+		const routerPattern = new RegExp(`${routerName}\\.(?:${joinedOperations})`)
 		file.sourceFile.forEachChild((node) => {
 			const nodeText = node.getText()
-			const routerPattern = new RegExp(`${routerName}\\.(?:${joinedOperations})`)
 
 			if (routerPattern.test(nodeText)) {
 				const endpointPath = resolveEndpointPath(node) ?? ''
@@ -220,12 +255,20 @@ export const analyzeSourceFileEndpoints = (
 					return
 				}
 
-				endpoints.push(parseEndpoint(node, file.fileName))
+				const t1 = performance.now()
+				const { endpoint, sectionTimings } = parseEndpoint(node, file.fileName)
+				endpointTimings.push({
+					method: endpoint.method,
+					path: endpoint.path,
+					timing: performance.now() - t1,
+					sectionTimings,
+				})
+				endpoints.push(endpoint)
 			}
 		})
 	})
 
-	return endpoints
+	return { endpoints, endpointTimings }
 }
 
 export const analyzeSourceFileApiHeader = (sourceFile: SourceFile): ApiDocsHeader | null => {

package/src/openapi/analyzerModule/nodeParsers.ts

@@ -829,11 +829,12 @@ const computeProperTypeShape = (type: Type, atLocation: Node, stack: Type[]): Sh
 			.getProperties()
 			.map((prop) => {
 				const valueDeclaration = prop.getValueDeclaration() || prop.getDeclarations()[0]!
+				const shape = getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack)
 				if (!valueDeclaration) {
 					return {
 						role: 'property' as const,
 						identifier: prop.getName(),
-						shape: getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+						shape,
 						optional: false,
 					}
 				}
@@ -846,18 +847,17 @@ const computeProperTypeShape = (type: Type, atLocation: Node, stack: Type[]): Sh
 					return {
 						role: 'property' as const,
 						identifier: prop.getName(),
-						shape: getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+						shape,
 						optional: false,
 					}
 				}
 
 				const isOptional = prop.getTypeAtLocation(atLocation).isNullable()
 
-				const shape = getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack)
 				return {
 					role: 'property' as const,
 					identifier: prop.getName(),
-					shape: shape,
+					shape,
 					optional: isOptional,
 				}
 			})

package/src/openapi/analyzerModule/parseEndpoint.ts

@@ -14,7 +14,12 @@ import {
 	resolveEndpointPath,
 } from './nodeParsers'
 
-export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
+export type SectionTiming = { section: string; timing: number }
+
+export const parseEndpoint = (
+	node: Node<ts.Node>,
+	sourceFilePath: string,
+): { endpoint: EndpointData; sectionTimings: SectionTiming[] } => {
 	const parsedEndpointMethod = node
 		.getFirstDescendantByKind(SyntaxKind.PropertyAccessExpression)!
 		.getText()
@@ -46,9 +51,20 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 		error: Error
 	}[] = []
 
+	const sectionTimings: SectionTiming[] = []
+
+	const time = <T>(section: string, fn: () => T): T => {
+		const t1 = performance.now()
+		const result = fn()
+		sectionTimings.push({ section, timing: performance.now() - t1 })
+		return result
+	}
+
+	const hookNodes = getHookNodes(node)
+
 	// API documentation
 	try {
-		const entries = parseApiDocumentation(node)
+		const entries = time('useApiEndpoint', () => parseApiDocumentation(hookNodes.useApiEndpoint))
 		entries.forEach((param) => {
 			endpointData[param.identifier] = param.value as string & string[]
 		})
@@ -62,7 +78,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request params
 	try {
-		endpointData.requestPathParams = parseRequestParams(node, endpointPath)
+		endpointData.requestPathParams = time('usePathParams', () =>
+			parseRequestParams(hookNodes.usePathParams, endpointPath),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'path',
@@ -73,7 +91,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request query
 	try {
-		endpointData.requestQuery = parseRequestObjectInput(node, 'useQueryParams')
+		endpointData.requestQuery = time('useQueryParams', () =>
+			parseRequestObjectInput(hookNodes.useQueryParams, 'useQueryParams'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'query',
@@ -84,7 +104,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request headers
 	try {
-		endpointData.requestHeaders = parseRequestObjectInput(node, 'useHeaderParams')
+		endpointData.requestHeaders = time('useHeaderParams', () =>
+			parseRequestObjectInput(hookNodes.useHeaderParams, 'useHeaderParams'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'headers',
@@ -95,7 +117,7 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Raw request body
 	try {
-		const parsedBody = parseRequestRawBody(node)
+		const parsedBody = time('useRequestRawBody', () => parseRequestRawBody(hookNodes.useRequestRawBody))
 		if (parsedBody) {
 			endpointData.rawBody = parsedBody
 		}
@@ -109,7 +131,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Object request body
 	try {
-		endpointData.objectBody = parseRequestObjectInput(node, 'useRequestBody')
+		endpointData.objectBody = time('useRequestBody', () =>
+			parseRequestObjectInput(hookNodes.useRequestBody, 'useRequestBody'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'objectBody',
@@ -120,7 +144,7 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request response
 	try {
-		endpointData.responses = parseRequestResponse(node)
+		endpointData.responses = time('response', () => parseRequestResponse(node))
 	} catch (err) {
 		warningData.push({
 			segment: 'response',
@@ -129,28 +153,36 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 		Logger.error('Error', err)
 	}
 
-	return endpointData
+	return { endpoint: endpointData, sectionTimings }
 }
 
-const getHookNode = (
-	endpointNode: Node<ts.Node>,
-	hookName:
-		| 'useApiEndpoint'
-		| 'usePathParams'
-		| 'useQueryParams'
-		| 'useHeaderParams'
-		| 'useRequestBody'
-		| 'useRequestRawBody',
-) => {
-	const callExpressions = endpointNode.getDescendantsOfKind(SyntaxKind.CallExpression)
-	const matchingCallExpressions = callExpressions.filter((node) => {
-		return node.getFirstChildByKind(SyntaxKind.Identifier)?.getText() === hookName
-	})
-	return matchingCallExpressions[0] ?? null
+type HookName =
+	| 'useApiEndpoint'
+	| 'usePathParams'
+	| 'useQueryParams'
+	| 'useHeaderParams'
+	| 'useRequestBody'
+	| 'useRequestRawBody'
+
+const getHookNodes = (endpointNode: Node<ts.Node>): Record<HookName, Node<ts.CallExpression> | null> => {
+	const result: Record<HookName, Node<ts.CallExpression> | null> = {
+		useApiEndpoint: null,
+		usePathParams: null,
+		useQueryParams: null,
+		useHeaderParams: null,
+		useRequestBody: null,
+		useRequestRawBody: null,
+	}
+	for (const node of endpointNode.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const name = node.getFirstChildByKind(SyntaxKind.Identifier)?.getText() as HookName | undefined
+		if (name && name in result && result[name] === null) {
+			result[name] = node
+		}
+	}
+	return result
 }
 
-const parseApiDocumentation = (node: Node<ts.Node>) => {
-	const hookNode = getHookNode(node, 'useApiEndpoint')
+const parseApiDocumentation = (hookNode: Node<ts.CallExpression> | null) => {
 	if (!hookNode) {
 		return []
 	}
@@ -170,8 +202,10 @@ const parseApiDocumentation = (node: Node<ts.Node>) => {
 	}[]
 }
 
-const parseRequestParams = (node: Node<ts.Node>, endpointPath: string): EndpointData['requestPathParams'] => {
-	const hookNode = getHookNode(node, 'usePathParams')
+const parseRequestParams = (
+	hookNode: Node<ts.CallExpression> | null,
+	endpointPath: string,
+): EndpointData['requestPathParams'] => {
 	if (!hookNode) {
 		return []
 	}
@@ -203,8 +237,9 @@ const parseRequestParams = (node: Node<ts.Node>, endpointPath: string): Endpoint
 		}))
 }
 
-const parseRequestRawBody = (node: Node<ts.Node>): NonNullable<EndpointData['rawBody']> | null => {
-	const hookNode = getHookNode(node, 'useRequestRawBody')
+const parseRequestRawBody = (
+	hookNode: Node<ts.CallExpression> | null,
+): NonNullable<EndpointData['rawBody']> | null => {
 	if (!hookNode) {
 		return null
 	}
@@ -222,10 +257,9 @@ const parseRequestRawBody = (node: Node<ts.Node>): NonNullable<EndpointData['raw
 }
 
 const parseRequestObjectInput = (
-	node: Node<ts.Node>,
+	hookNode: Node<ts.CallExpression> | null,
 	nodeName: 'useQueryParams' | 'useHeaderParams' | 'useRequestBody',
 ): EndpointData['requestQuery'] | EndpointData['objectBody'] => {
-	const hookNode = getHookNode(node, nodeName)
 	if (!hookNode) {
 		return []
 	}

package/src/openapi/analyzerModule/test/openApiAnalyzer.spec.ts

@@ -23,7 +23,7 @@ describe('OpenApi Analyzer', () => {
 				},
 				[`/test/${id}`],
 			)
-			const endpoint = analysisResult.find((endpoint) => endpoint.path.startsWith(`/test/${id}`))
+			const endpoint = analysisResult.endpoints.find((endpoint) => endpoint.path.startsWith(`/test/${id}`))
 			if (!endpoint) {
 				throw new Error(`No endpoint with id ${id} found!`)
 			}
@@ -39,7 +39,7 @@ describe('OpenApi Analyzer', () => {
 				},
 				[`/test/${id}`],
 			)
-			const endpoints = analysisResult.filter((endpoint) => endpoint.path.startsWith(`/test/${id}`))
+			const endpoints = analysisResult.endpoints.filter((endpoint) => endpoint.path.startsWith(`/test/${id}`))
 			if (endpoints.length === 0) {
 				throw new Error(`No endpoint with id ${id} found!`)
 			}

package/src/openapi/analyzerModule/test/openApiAnalyzer.zod.spec.ts

@@ -19,7 +19,7 @@ describe('OpenApi Analyzer (Zod Validator)', () => {
 				},
 				[`/test/${id}`],
 			)
-			const endpoint = analysisResult.find((endpoint) => endpoint.path.startsWith(`/test/${id}`))
+			const endpoint = analysisResult.endpoints.find((endpoint) => endpoint.path.startsWith(`/test/${id}`))
 			if (!endpoint) {
 				throw new Error(`No endpoint with id ${id} found!`)
 			}