moonflower 1.4.8 → 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,31 +213,33 @@ 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('|')
 
@@ -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/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,11 +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(hookNodes.useApiEndpoint)
+		const entries = time('useApiEndpoint', () => parseApiDocumentation(hookNodes.useApiEndpoint))
 		entries.forEach((param) => {
 			endpointData[param.identifier] = param.value as string & string[]
 		})
@@ -64,7 +78,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request params
 	try {
-		endpointData.requestPathParams = parseRequestParams(hookNodes.usePathParams, endpointPath)
+		endpointData.requestPathParams = time('usePathParams', () =>
+			parseRequestParams(hookNodes.usePathParams, endpointPath),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'path',
@@ -75,7 +91,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request query
 	try {
-		endpointData.requestQuery = parseRequestObjectInput(hookNodes.useQueryParams, 'useQueryParams')
+		endpointData.requestQuery = time('useQueryParams', () =>
+			parseRequestObjectInput(hookNodes.useQueryParams, 'useQueryParams'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'query',
@@ -86,7 +104,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Request headers
 	try {
-		endpointData.requestHeaders = parseRequestObjectInput(hookNodes.useHeaderParams, 'useHeaderParams')
+		endpointData.requestHeaders = time('useHeaderParams', () =>
+			parseRequestObjectInput(hookNodes.useHeaderParams, 'useHeaderParams'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'headers',
@@ -97,7 +117,7 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Raw request body
 	try {
-		const parsedBody = parseRequestRawBody(hookNodes.useRequestRawBody)
+		const parsedBody = time('useRequestRawBody', () => parseRequestRawBody(hookNodes.useRequestRawBody))
 		if (parsedBody) {
 			endpointData.rawBody = parsedBody
 		}
@@ -111,7 +131,9 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 
 	// Object request body
 	try {
-		endpointData.objectBody = parseRequestObjectInput(hookNodes.useRequestBody, 'useRequestBody')
+		endpointData.objectBody = time('useRequestBody', () =>
+			parseRequestObjectInput(hookNodes.useRequestBody, 'useRequestBody'),
+		)
 	} catch (err) {
 		warningData.push({
 			segment: 'objectBody',
@@ -122,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',
@@ -131,7 +153,7 @@ export const parseEndpoint = (node: Node<ts.Node>, sourceFilePath: string) => {
 		Logger.error('Error', err)
 	}
 
-	return endpointData
+	return { endpoint: endpointData, sectionTimings }
 }
 
 type HookName =

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!`)
 			}