moonflower 1.5.0 → 1.5.2

package/src/openapi/analyzerModule/analyzerModule.ts

@@ -53,6 +53,13 @@ type FileDiscoveryConfig = {
 
 type EndpointTiming = { method: string; path: string; timing: number; sectionTimings: SectionTiming[] }
 
+/**
+ * Number of uncached files at or below which analysis runs inline on the (already-warm) main-thread
+ * Project instead of fanning out to worker threads. Each worker pays a multi-second cold-start to
+ * build its own Project, so parallelism only wins once there are several files to share that cost.
+ */
+const INLINE_ANALYSIS_FILE_THRESHOLD = 2
+
 /**
  * @param tsconfigPath Path to tsconfig file relative to project root
  * @param sourceFilePaths Array of router source files relative to project root
@@ -213,45 +220,6 @@ export const analyzeMultipleSourceFiles = async (
 		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
@@ -259,37 +227,63 @@ export const analyzeMultipleSourceFiles = async (
 		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)!
+	// The caller (prepareOpenApiSpec) already built and warmed a ts-morph Project on this thread, so
+	// inline analysis runs against a hot type-checker. A worker, by contrast, must spawn a thread and
+	// build its own Project from scratch — a multi-second cold-start. That cold-start only pays off
+	// when there are enough uncached files that spreading the parse work across workers beats it; below
+	// the threshold (e.g. the common single-file incremental rebuild), inline is strictly faster.
+	if (uncached.length <= INLINE_ANALYSIS_FILE_THRESHOLD) {
+		for (const { file } of uncached) {
+			const { endpoints, endpointTimings } = analyzeSourceFileEndpoints(file, filterEndpointPaths)
+			const fileResult = byFile.get(file.fileName)!
+			fileResult.endpoints = endpoints
+			fileResult.endpointTimings = endpointTimings
+			fileResult.timing = endpointTimings.reduce((sum, t) => sum + t.timing, 0)
+		}
+	} else {
+		// One task per file: each worker analyzes a whole file in a single pass, paying its Project
+		// cold-start once and reusing the warmed-up checker for every endpoint in that file. Cap the
+		// pool at one worker per file so we never spin up a worker with nothing to do.
+		type FileTask = { task: WorkerTask; fileName: string }
+		const allTasks: FileTask[] = uncached.map(({ file }) => ({
+			fileName: file.fileName,
+			task: {
+				taskId: crypto.randomUUID(),
+				tsconfigPath: config.tsconfigPath,
+				sourceFilePath: file.sourceFile.getFilePath(),
+				routerNames: file.routers.named,
+				filterEndpointPaths,
+			},
+		}))
 
-		if ('error' in result) {
-			Logger.error(`[${fileName}] Worker error: ${result.error}`)
-			continue
+		const pool = new WorkerPool(resolveWorkerUrl(), allTasks.length)
+		let results: WorkerResult[]
+		try {
+			results = await pool.runAll(allTasks.map((ft) => ft.task))
+		} finally {
+			pool.terminate()
 		}
 
-		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,
-		})
+		// Each result maps 1:1 to a file task.
+		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 = result.endpoints
+			fileResult.endpointTimings = result.endpointTimings
+			fileResult.timing = result.endpointTimings.reduce((sum, t) => sum + t.timing, 0)
+		}
 	}
 
 	// Write cache for each uncached file

package/src/openapi/analyzerModule/analyzerWorker.ts

@@ -1,8 +1,10 @@
-import { Node, Project, ts } from 'ts-morph'
+import { Project } from 'ts-morph'
 import { parentPort } from 'worker_threads'
 
+import { EndpointData } from '../types'
+import { resolveEndpointPath } from './nodeParsers'
 import { parseEndpoint } from './parseEndpoint'
-import { WorkerResult, WorkerTask } from './workerPool'
+import { EndpointTiming, WorkerResult, WorkerTask } from './workerPool'
 
 const OPERATIONS = ['get', 'post', 'put', 'delete', 'del', 'patch']
 const OPERATIONS_PATTERN = OPERATIONS.join('|')
@@ -30,37 +32,39 @@ parentPort!.on('message', (task: WorkerTask) => {
 			sourceFile = proj.addSourceFileAtPath(task.sourceFilePath)
 		}
 
-		const routerPattern = new RegExp(`${task.routerName}\\.(?:${OPERATIONS_PATTERN})`)
-		let index = 0
-		let targetNode: Node<ts.Node> | undefined
+		const endpoints: EndpointData[] = []
+		const endpointTimings: EndpointTiming[] = []
 
-		sourceFile.forEachChild((node) => {
-			if (targetNode) return
-			if (routerPattern.test(node.getText())) {
-				if (index === task.endpointIndex) {
-					targetNode = node
+		task.routerNames.forEach((routerName) => {
+			const routerPattern = new RegExp(`${routerName}\\.(?:${OPERATIONS_PATTERN})`)
+			sourceFile!.forEachChild((node) => {
+				if (!routerPattern.test(node.getText())) {
+					return
 				}
-				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
-		}
+				if (task.filterEndpointPaths) {
+					const endpointPath = resolveEndpointPath(node) ?? ''
+					if (!task.filterEndpointPaths.some((p) => endpointPath.includes(p))) {
+						return
+					}
+				}
 
-		const t1 = performance.now()
-		const { endpoint, sectionTimings } = parseEndpoint(targetNode, task.sourceFilePath)
+				const t1 = performance.now()
+				const { endpoint, sectionTimings } = parseEndpoint(node, task.sourceFilePath)
+				endpointTimings.push({
+					method: endpoint.method,
+					path: endpoint.path,
+					timing: performance.now() - t1,
+					sectionTimings,
+				})
+				endpoints.push(endpoint)
+			})
+		})
 
 		const result: WorkerResult = {
 			taskId: task.taskId,
-			endpoint,
-			sectionTimings,
-			timing: performance.now() - t1,
+			endpoints,
+			endpointTimings,
 		}
 		parentPort!.postMessage(result)
 	} catch (err) {

package/src/openapi/analyzerModule/workerPool.ts

@@ -8,15 +8,21 @@ export type WorkerTask = {
 	taskId: string
 	tsconfigPath: string
 	sourceFilePath: string
-	routerName: string
-	endpointIndex: number
+	routerNames: string[]
+	filterEndpointPaths?: string[]
+}
+
+export type EndpointTiming = {
+	method: string
+	path: string
+	timing: number
+	sectionTimings: SectionTiming[]
 }
 
 export type WorkerResultSuccess = {
 	taskId: string
-	endpoint: EndpointData
-	sectionTimings: SectionTiming[]
-	timing: number
+	endpoints: EndpointData[]
+	endpointTimings: EndpointTiming[]
 }
 
 export type WorkerResultError = {
@@ -32,8 +38,12 @@ export class WorkerPool {
 	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))
+	constructor(workerUrl: URL, maxWorkers?: number) {
+		const cpuBound = Math.max(1, Math.min(os.cpus().length - 1, 8))
+		// Never spin up more workers than there are files to analyze: each extra worker would
+		// just pay the ts-morph Project cold-start (full TS program load + type-checker warmup)
+		// for nothing while contending for CPU with the workers that actually have work.
+		const size = maxWorkers === undefined ? cpuBound : Math.max(1, Math.min(cpuBound, maxWorkers))
 		this.workers = Array.from({ length: size }, () => {
 			const worker = new Worker(workerUrl)
 			worker.on('message', (result: WorkerResult) => {