moonflower 1.4.9 → 1.5.0

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

@@ -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)
+			})
 		})
 	})
 })

package/src/openapi/analyzerModule/test/workerGlobalSetup.ts

@@ -0,0 +1,25 @@
+import { buildSync } from 'esbuild'
+import { existsSync, unlinkSync } from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const workerSrc = path.join(__dirname, '..', 'analyzerWorker.ts')
+const workerOut = path.join(__dirname, '..', 'analyzerWorker.test.mjs')
+
+export function setup() {
+	buildSync({
+		entryPoints: [workerSrc],
+		outfile: workerOut,
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		external: ['ts-morph', '@ts-morph/common', 'typescript', 'worker_threads'],
+	})
+}
+
+export function teardown() {
+	if (existsSync(workerOut)) {
+		unlinkSync(workerOut)
+	}
+}

package/src/openapi/analyzerModule/workerPaths.ts

@@ -0,0 +1,4 @@
+import os from 'os'
+import path from 'path'
+
+export const TEST_WORKER_PATH = path.join(os.tmpdir(), 'moonflower-analyzerWorker.test.mjs')

package/src/openapi/analyzerModule/workerPool.ts

@@ -0,0 +1,92 @@
+import os from 'os'
+import { Worker } from 'worker_threads'
+
+import { EndpointData } from '../types'
+import { SectionTiming } from './parseEndpoint'
+
+export type WorkerTask = {
+	taskId: string
+	tsconfigPath: string
+	sourceFilePath: string
+	routerName: string
+	endpointIndex: number
+}
+
+export type WorkerResultSuccess = {
+	taskId: string
+	endpoint: EndpointData
+	sectionTimings: SectionTiming[]
+	timing: number
+}
+
+export type WorkerResultError = {
+	taskId: string
+	error: string
+}
+
+export type WorkerResult = WorkerResultSuccess | WorkerResultError
+
+export class WorkerPool {
+	private workers: Worker[]
+	private idle: Worker[]
+	private queue: Array<{ task: WorkerTask; resolve: (r: WorkerResult) => void }> = []
+	private pending = new Map<string, (r: WorkerResult) => void>()
+
+	constructor(workerUrl: URL) {
+		const size = Math.max(1, Math.min(os.cpus().length - 1, 8))
+		this.workers = Array.from({ length: size }, () => {
+			const worker = new Worker(workerUrl)
+			worker.on('message', (result: WorkerResult) => {
+				const resolve = this.pending.get(result.taskId)
+				if (resolve) {
+					this.pending.delete(result.taskId)
+					resolve(result)
+				}
+				this.idle.push(worker)
+				this.flush()
+			})
+			worker.on('error', (err) => {
+				// Find any pending task for this worker and reject it
+				// (worker crashed — shouldn't happen, but handle gracefully)
+				for (const [taskId, resolve] of this.pending) {
+					resolve({ taskId, error: String(err) })
+					this.pending.delete(taskId)
+					break
+				}
+				this.idle.push(worker)
+				this.flush()
+			})
+			return worker
+		})
+		this.idle = [...this.workers]
+	}
+
+	run(task: WorkerTask): Promise<WorkerResult> {
+		return new Promise((resolve) => {
+			if (this.idle.length > 0) {
+				const worker = this.idle.pop()!
+				this.pending.set(task.taskId, resolve)
+				worker.postMessage(task)
+			} else {
+				this.queue.push({ task, resolve })
+			}
+		})
+	}
+
+	runAll(tasks: WorkerTask[]): Promise<WorkerResult[]> {
+		return Promise.all(tasks.map((t) => this.run(t)))
+	}
+
+	terminate() {
+		this.workers.forEach((w) => w.terminate())
+	}
+
+	private flush() {
+		while (this.queue.length > 0 && this.idle.length > 0) {
+			const { task, resolve } = this.queue.shift()!
+			const worker = this.idle.pop()!
+			this.pending.set(task.taskId, resolve)
+			worker.postMessage(task)
+		}
+	}
+}

package/src/test/app.spec.ts

@@ -3,13 +3,22 @@ import Koa from 'koa'
 import * as os from 'os'
 import * as path from 'path'
 import request from 'supertest'
-import { describe, expect, it, vi } from 'vitest'
+import { beforeAll, describe, expect, it, vi } from 'vitest'
 
 import { generateOpenApiSpec } from '../openapi/generatorModule/generatorModule'
 import { initOpenApiEngine } from '../openapi/initOpenApiEngine'
 import { OpenApiManager } from '../openapi/manager/OpenApiManager'
 import { app } from './app'
 
+// The OpenAPI engine runs the TypeScript analyzer lazily on first request, and any request that
+// reaches the initOpenApiEngine middleware awaits its readiness. Requests that match a route never
+// reach it, but unmatched ones (e.g. the 405 test) do, so the first such request pays the full
+// analyzer cold-start cost. That can exceed a single test's default 5s timeout in CI. Warm the
+// engine up once here so no individual test bears that cost.
+beforeAll(async () => {
+	await request(app.callback()).get('/api-json')
+}, 60_000)
+
 describe('TestAppRouter', () => {
 	it('includes content type header', async () => {
 		const response = await request(app.callback()).get('/test/hello')

package/vite.config.ts

@@ -24,6 +24,7 @@ const entries = {
 	'validators/BuiltInValidators': resolve(__dirname, 'src/validators/BuiltInValidators.ts'),
 	'validators/ParamWrappers': resolve(__dirname, 'src/validators/ParamWrappers.ts'),
 	'cli/cli': resolve(__dirname, 'src/cli/cli.ts'),
+	'openapi/analyzerModule/analyzerWorker': resolve(__dirname, 'src/openapi/analyzerModule/analyzerWorker.ts'),
 }
 
 export const baseViteConfig: ViteUserConfig = {
@@ -50,7 +51,10 @@ export const baseViteConfig: ViteUserConfig = {
 				'fs/promises',
 				'assert',
 				'crypto',
+				'os',
 				'perf_hooks',
+				'url',
+				'worker_threads',
 				'@ts-morph/common',
 				'typescript',
 				'ts-morph',
@@ -90,6 +94,7 @@ export const baseViteConfig: ViteUserConfig = {
 	},
 	test: {
 		globals: true,
+		globalSetup: 'src/openapi/analyzerModule/test/workerGlobalSetup.ts',
 		setupFiles: 'src/setupTests.ts',
 		include: ['src/**/*.spec.ts'],
 		coverage: {