moonflower 1.4.8 → 1.5.0

package/src/openapi/analyzerModule/analyzerModule.ts

@@ -1,4 +1,20 @@
+import crypto from 'crypto'
+import { existsSync } from 'fs'
 import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+function resolveWorkerUrl(): URL {
+	const candidates = ['./analyzerWorker.mjs', './analyzerWorker.test.mjs']
+	for (const candidate of candidates) {
+		const url = new URL(candidate, import.meta.url)
+		if (existsSync(fileURLToPath(url))) {
+			return url
+		}
+	}
+	throw new Error(
+		'analyzerWorker.mjs not found. Run yarn build, or run tests via yarn test (which compiles the worker first).',
+	)
+}
 import { SourceFile, SyntaxKind } from 'ts-morph'
 import { Project } from 'ts-morph'
 
@@ -13,9 +29,10 @@ 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'
+import { WorkerPool, WorkerResult, WorkerTask } from './workerPool'
 
 type Props = {
 	logLevel?: Parameters<(typeof Logger)['setLevel']>[0]
@@ -27,23 +44,27 @@ 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
  */
-export const prepareOpenApiSpec = ({
+export const prepareOpenApiSpec = async ({
 	logLevel,
 	tsconfigPath,
 	sourceFilePaths,
 	sourceFileDiscovery,
 	incremental,
-}: Props) => {
+	profiling = 'stats',
+}: Props): Promise<void> => {
 	const openApiManager = OpenApiManager.getInstance()
 
 	if (openApiManager.isReady()) {
@@ -81,7 +102,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
 		})()
 
@@ -116,10 +139,12 @@ export const prepareOpenApiSpec = ({
 		}
 		return path.resolve(process.cwd(), 'node_modules', '.cache', 'moonflower')
 	})()
-	const endpoints = analyzeMultipleSourceFiles(filesToAnalyze, {
+	const endpoints = await analyzeMultipleSourceFiles(filesToAnalyze, {
 		incremental: incremental !== false,
 		cachePath,
 		timestampCache: {},
+		profiling,
+		tsconfigPath: path.resolve(tsconfigPath),
 	})
 
 	openApiManager.setStats({
@@ -147,29 +172,167 @@ export const prepareOpenApiSpec = ({
 	openApiManager.markAsReady()
 }
 
-export const analyzeMultipleSourceFiles = (
+export const analyzeMultipleSourceFiles = async (
 	files: DiscoveredSourceFile[],
 	config: {
 		incremental: boolean
 		cachePath: string
 		timestampCache: TimestampCache
+		profiling?: 'stats' | 'off' | 'debug'
+		tsconfigPath: string
 	},
 	filterEndpointPaths?: string[],
-): EndpointData[] => {
+): Promise<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`)
+	// Separate cached files from those needing analysis
+	type CachedFile = { endpoints: EndpointData[]; fileName: string; timing: 0; endpointTimings: [] }
+	type UncachedFile = { file: DiscoveredSourceFile; timestamp: number }
+
+	const cached: CachedFile[] = []
+	const uncached: UncachedFile[] = []
+
+	for (const file of files) {
+		const timestamp = getSourceFileTimestamp(file.sourceFile, config.timestampCache)
+		const hit = config.incremental
+			? SourceFileCache.getCachedResults(file.sourceFile, timestamp, config.cachePath)
+			: null
+		if (hit) {
+			Logger.debug(`[${file.fileName}] Found cached results`)
+			cached.push({ endpoints: hit.endpoints, fileName: file.fileName, timing: 0, endpointTimings: [] })
+		} else {
+			uncached.push({ file, timestamp })
+		}
+	}
+
+	if (uncached.length === 0) {
+		if (profiling !== 'off') {
+			Logger.info(`Router analysis took ${Math.round(performance.now() - startTime)}ms`)
+		}
+		return cached.flatMap((f) => f.endpoints)
+	}
+
+	// Build one task per endpoint across all uncached files
+	const OPERATIONS = ['get', 'post', 'put', 'delete', 'del', 'patch']
+	const operationsPattern = OPERATIONS.join('|')
+
+	type FileTask = { task: WorkerTask; fileName: string }
+	const allTasks: FileTask[] = []
+
+	for (const { file } of uncached) {
+		for (const routerName of file.routers.named) {
+			const routerPattern = new RegExp(`${routerName}\\.(?:${operationsPattern})`)
+			let endpointIndex = 0
+			file.sourceFile.forEachChild((node) => {
+				const nodeText = node.getText()
+				if (routerPattern.test(nodeText)) {
+					if (
+						!filterEndpointPaths ||
+						filterEndpointPaths.some((p) => resolveEndpointPath(node)?.includes(p))
+					) {
+						allTasks.push({
+							fileName: file.fileName,
+							task: {
+								taskId: crypto.randomUUID(),
+								tsconfigPath: config.tsconfigPath,
+								sourceFilePath: file.sourceFile.getFilePath(),
+								routerName,
+								endpointIndex,
+							},
+						})
+					}
+					endpointIndex++
+				}
+			})
+		}
+	}
+
+	// Dispatch all tasks to the worker pool
+	const pool = new WorkerPool(resolveWorkerUrl())
+
+	type EndpointTiming = { method: string; path: string; timing: number; sectionTimings: SectionTiming[] }
+	type FileResult = {
+		endpoints: EndpointData[]
+		fileName: string
+		timing: number
+		endpointTimings: EndpointTiming[]
+	}
+
+	let results: WorkerResult[]
+	try {
+		results = await pool.runAll(allTasks.map((ft) => ft.task))
+	} finally {
+		pool.terminate()
+	}
+
+	// Group results by file
+	const byFile = new Map<string, FileResult>()
+	for (const { file } of uncached) {
+		byFile.set(file.fileName, { endpoints: [], fileName: file.fileName, timing: 0, endpointTimings: [] })
+	}
+
+	for (let i = 0; i < results.length; i++) {
+		const result = results[i]
+		const fileName = allTasks[i].fileName
+		const fileResult = byFile.get(fileName)!
+
+		if ('error' in result) {
+			Logger.error(`[${fileName}] Worker error: ${result.error}`)
+			continue
+		}
+
+		fileResult.endpoints.push(result.endpoint)
+		fileResult.timing += result.timing
+		fileResult.endpointTimings.push({
+			method: result.endpoint.method,
+			path: result.endpoint.path,
+			timing: result.timing,
+			sectionTimings: result.sectionTimings,
 		})
+	}
+
+	// Write cache for each uncached file
+	for (const { file, timestamp } of uncached) {
+		const fileResult = byFile.get(file.fileName)!
+		if (fileResult.endpoints.length > 0) {
+			SourceFileCache.cacheResults(file.sourceFile, timestamp, config.cachePath, fileResult.endpoints)
+		}
+	}
+
+	const analyzedFiles = [...cached, ...Array.from(byFile.values())]
+
+	if (profiling !== 'off') {
+		Logger.info(`Router analysis took ${Math.round(performance.now() - startTime)}ms`)
+	}
+
+	if (profiling === 'stats') {
+		analyzedFiles
+			.map((f) => ({ fileName: f.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) => ({ fileName: f.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 +343,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 +385,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/analyzerWorker.ts

@@ -0,0 +1,73 @@
+import { Node, Project, ts } from 'ts-morph'
+import { parentPort } from 'worker_threads'
+
+import { parseEndpoint } from './parseEndpoint'
+import { WorkerResult, WorkerTask } from './workerPool'
+
+const OPERATIONS = ['get', 'post', 'put', 'delete', 'del', 'patch']
+const OPERATIONS_PATTERN = OPERATIONS.join('|')
+
+let project: Project | null = null
+let currentTsconfigPath: string | null = null
+
+function getProject(tsconfigPath: string): Project {
+	if (!project || currentTsconfigPath !== tsconfigPath) {
+		project = new Project({
+			tsConfigFilePath: tsconfigPath,
+			skipFileDependencyResolution: true,
+		})
+		currentTsconfigPath = tsconfigPath
+	}
+	return project
+}
+
+parentPort!.on('message', (task: WorkerTask) => {
+	try {
+		const proj = getProject(task.tsconfigPath)
+
+		let sourceFile = proj.getSourceFile(task.sourceFilePath)
+		if (!sourceFile) {
+			sourceFile = proj.addSourceFileAtPath(task.sourceFilePath)
+		}
+
+		const routerPattern = new RegExp(`${task.routerName}\\.(?:${OPERATIONS_PATTERN})`)
+		let index = 0
+		let targetNode: Node<ts.Node> | undefined
+
+		sourceFile.forEachChild((node) => {
+			if (targetNode) return
+			if (routerPattern.test(node.getText())) {
+				if (index === task.endpointIndex) {
+					targetNode = node
+				}
+				index++
+			}
+		})
+
+		if (!targetNode) {
+			const result: WorkerResult = {
+				taskId: task.taskId,
+				error: `Endpoint not found: routerName=${task.routerName} index=${task.endpointIndex} in ${task.sourceFilePath}`,
+			}
+			parentPort!.postMessage(result)
+			return
+		}
+
+		const t1 = performance.now()
+		const { endpoint, sectionTimings } = parseEndpoint(targetNode, task.sourceFilePath)
+
+		const result: WorkerResult = {
+			taskId: task.taskId,
+			endpoint,
+			sectionTimings,
+			timing: performance.now() - t1,
+		}
+		parentPort!.postMessage(result)
+	} catch (err) {
+		const result: WorkerResult = {
+			taskId: task.taskId,
+			error: String(err),
+		}
+		parentPort!.postMessage(result)
+	}
+})

package/src/openapi/analyzerModule/nodeParsers.ts

@@ -278,112 +278,12 @@ const isZodCallExpression = (node: Node): boolean => {
 const getZodCallShape = (node: Node): ShapeOfType['shape'] => {
 	const callExpression = node.asKind(SyntaxKind.CallExpression)!
 	const returnType = callExpression.getReturnType()
-	const typeName = returnType.getSymbol()?.getName() ?? ''
-
-	if (typeName === 'ZodNumber') {
-		return 'number'
-	}
-	if (typeName === 'ZodString') {
-		return 'string'
-	}
-	if (typeName === 'ZodBoolean') {
-		return 'boolean'
-	}
-	if (typeName === 'ZodBigInt') {
-		return 'bigint'
-	}
-
-	if (typeName === 'ZodObject') {
-		const argNode = callExpression.getFirstChildByKind(SyntaxKind.SyntaxList)?.getFirstChild()
-		const objectLiteral = argNode?.asKind(SyntaxKind.ObjectLiteralExpression)
-		if (!objectLiteral) {
-			return 'unknown_zod_object'
-		}
-		const syntaxList = objectLiteral.getFirstChildByKind(SyntaxKind.SyntaxList)
-		if (!syntaxList) {
-			return []
-		}
-		const properties = syntaxList.getChildrenOfKind(SyntaxKind.PropertyAssignment)
-		return properties.map((prop) => {
-			const identifier = prop.getFirstChildByKind(SyntaxKind.Identifier)!.getText()
-			const valueNode = prop.getLastChild()!
-			return {
-				role: 'property' as const,
-				identifier,
-				shape: isZodCallExpression(valueNode)
-					? getZodCallShape(valueNode)
-					: getValidatorPropertyShape(valueNode),
-				optional: false,
-			}
-		})
-	}
-
-	if (typeName === 'ZodArray') {
-		const argNode = callExpression.getFirstChildByKind(SyntaxKind.SyntaxList)?.getFirstChild()
-		if (argNode) {
-			const elementShape = isZodCallExpression(argNode)
-				? getZodCallShape(argNode)
-				: getValidatorPropertyShape(argNode)
-			return [
-				{
-					role: 'array' as const,
-					shape: elementShape,
-					optional: false,
-				},
-			]
-		}
-		// Handle chained form: z.string().array()
-		const propertyAccess = callExpression.getFirstChildByKind(SyntaxKind.PropertyAccessExpression)
-		const receiverCall = propertyAccess?.getFirstChildByKind(SyntaxKind.CallExpression)
-		if (receiverCall && isZodCallExpression(receiverCall)) {
-			return [
-				{
-					role: 'array' as const,
-					shape: getZodCallShape(receiverCall),
-					optional: false,
-				},
-			]
-		}
-		return 'unknown_zod_array'
+	const outputProp = returnType.getProperty('_output')
+	if (outputProp) {
+		return getProperTypeShape(outputProp.getTypeAtLocation(callExpression), callExpression)
 	}
-
-	if (typeName === 'ZodEnum') {
-		const typeArgs = returnType.getTypeArguments()
-		if (typeArgs.length > 0) {
-			const enumType = typeArgs[0]
-			const properties = enumType.getProperties()
-			const shapes: ShapeOfUnionEntry[] = properties.map((prop) => ({
-				role: 'union_entry' as const,
-				shape: getProperTypeShape(prop.getTypeAtLocation(callExpression), callExpression, []),
-				optional: false,
-			}))
-			if (shapes.length === 1) {
-				return shapes[0].shape
-			}
-			if (shapes.length > 1) {
-				return [
-					{
-						role: 'union' as const,
-						shape: shapes,
-						optional: false,
-					},
-				]
-			}
-		}
-		return 'unknown_zod_enum'
-	}
-
-	if (typeName === 'ZodOptional') {
-		const innerCallExpression = callExpression
-			.getFirstChildByKind(SyntaxKind.PropertyAccessExpression)
-			?.getFirstChildByKind(SyntaxKind.CallExpression)
-		if (innerCallExpression && isZodCallExpression(innerCallExpression)) {
-			return getZodCallShape(innerCallExpression)
-		}
-		return 'unknown_zod_optional'
-	}
-
 	const fileName = node.getSourceFile().getFilePath().split('/').pop()
+	const typeName = returnType.getSymbol()?.getName() ?? ''
 	Logger.warn(`[${fileName}] Unknown zod type: ${typeName}`)
 	return 'unknown_zod'
 }

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/TestCase.ts

@@ -11,6 +11,7 @@ export const TestCase = {
 	parsesZodQueryNumberArray: 'parses-zod-query-number-array',
 	parsesZodQueryObjectArray: 'parses-zod-query-object-array',
 	parsesZodQueryOptionalArray: 'parses-zod-query-optional-array',
+	parsesZodPipe: 'parses-zod-pipe',
 	parsesReturnRecordStringUnknown: 'parses-return-record-string-unknown',
 	parsesReturnObjectWithRecordProperty: 'parses-return-object-with-record-property',
 	parsesBufferReturnedFromFunction: 'parses-buffer-returned-from-function',

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.data.ts

@@ -147,3 +147,9 @@ router.get(`/test/${TestCase.parsesZodQueryOptionalArray}`, (ctx) => {
 		tags: z.array(z.string()).optional(),
 	})
 })
+
+router.post(`/test/${TestCase.parsesZodPipe}`, (ctx) => {
+	useRequestBody(ctx, {
+		value: z.string().pipe(z.coerce.number()),
+	})
+})

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!`)
 			}
@@ -315,6 +315,14 @@ describe('OpenApi Analyzer (Zod Validator)', () => {
 				])
 				expect(endpoint.requestQuery[0].optional).toEqual(true)
 			})
+
+			it('parses zod pipe validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesZodPipe)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('value')
+				expect(endpoint.objectBody[0].signature).toEqual('number')
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
 		})
 	})
 })