moonflower 1.4.8 → 1.5.0

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: {