fix: typecheck in worker, stop using symbol

Author: mnahkies

e2e/openapi.yaml

@@ -43,7 +43,6 @@ paths:
       responses:
         200:
           $ref: '#/components/responses/GetHeaders'
-  # TODO: add tests for enum handling and open/closed
   /validation/numbers/random-number:
     get:
       tags:

packages/openapi-code-generator/src/test/typescript-compiler-worker-pool.test-utils.ts

@@ -0,0 +1,40 @@
+import {Piscina} from "piscina"
+
+import path from "node:path"
+import {filename} from "./typescript-compiler-worker.test-utils"
+
+let pool: Piscina | null = null
+
+export function startWorkerPool() {
+  if (pool) {
+    throw new Error("already started")
+  }
+
+  pool = new Piscina({
+    filename: path.resolve(__dirname, "./workerWrapper.js"),
+    workerData: {fullpath: filename},
+    concurrentTasksPerWorker: 1,
+    maxThreads: 4,
+    minThreads: 4,
+    idleTimeout: 5_000,
+  })
+}
+
+export function stopWorkerPool() {
+  if (!pool) {
+    throw new Error("worker pool not started")
+  }
+
+  pool.destroy()
+  pool = null
+}
+
+export async function typecheckInWorker(
+  compilationUnits: {filename: string; content: string}[],
+) {
+  if (!pool) {
+    throw new Error("worker pool not started")
+  }
+
+  await pool.run(compilationUnits)
+}

packages/openapi-code-generator/src/test/typescript-compiler-worker.test-utils.ts

@@ -1,22 +1,21 @@
 import fs from "node:fs"
 import path from "node:path"
 import ts from "typescript"
-import type {CompilationUnit} from "../typescript/common/compilation-units"
 import {TypescriptFormatterBiome} from "../typescript/common/typescript-formatter.biome"
 
-export async function typecheck(compilationUnits: CompilationUnit[]) {
-  const formatter = await TypescriptFormatterBiome.createNodeFormatter()
+export const filename = path.resolve(__filename)
+
+const whenFormatter = TypescriptFormatterBiome.createNodeFormatter()
+
+export default async function typecheck(
+  compilationUnits: {filename: string; content: string}[],
+) {
+  const formatter = await whenFormatter
 
   const files: Record<string, string> = {}
 
   for (const unit of compilationUnits) {
-    const formatted = await formatter.format(
-      unit.filename,
-      unit.getRawFileContent({
-        allowUnusedImports: false,
-        includeHeader: false,
-      }),
-    )
+    const formatted = await formatter.format(unit.filename, unit.content)
 
     if (formatted.err) {
       throw formatted.err

packages/openapi-code-generator/src/test/workerWrapper.js

@@ -0,0 +1,4 @@
+const tsx = require("tsx/cjs/api")
+const {workerData} = require("node:worker_threads")
+
+module.exports = tsx.require(workerData.fullpath, __filename)

packages/openapi-code-generator/src/typescript/common/type-builder.spec.ts

@@ -1,16 +1,28 @@
-import {describe, expect, it} from "@jest/globals"
+import {describe, expect, it, jest} from "@jest/globals"
 import type {CompilerOptions} from "../../core/loaders/tsconfig.loader"
 import {testVersions, unitTestInput} from "../../test/input.test-utils"
 import {ImportBuilder} from "./import-builder"
 import {TypeBuilder, type TypeBuilderConfig} from "./type-builder"
 import {TypescriptFormatterBiome} from "./typescript-formatter.biome"
 
-import {typecheck} from "../../test/typescript.test-utils"
+import {
+  startWorkerPool,
+  stopWorkerPool,
+  typecheckInWorker,
+} from "../../test/typescript-compiler-worker-pool.test-utils"
 import {CompilationUnit} from "./compilation-units"
 
 describe.each(testVersions)(
   "%s - typescript/common/type-builder",
   (version) => {
+    beforeAll(() => {
+      startWorkerPool()
+    })
+
+    afterAll(() => {
+      stopWorkerPool()
+    })
+
     it("can build a type for a simple object correctly", async () => {
       const {code, types} = await getActual("components/schemas/SimpleObject")
 
@@ -460,7 +472,22 @@ describe.each(testVersions)(
       )
       const types = builder.toCompilationUnit()
 
-      await typecheck([usage, builder.toCompilationUnit()])
+      await typecheckInWorker([
+        {
+          filename: usage.filename,
+          content: usage.getRawFileContent({
+            allowUnusedImports: false,
+            includeHeader: false,
+          }),
+        },
+        {
+          filename: types.filename,
+          content: types.getRawFileContent({
+            allowUnusedImports: false,
+            includeHeader: false,
+          }),
+        },
+      ])
 
       return {
         code: (

packages/openapi-code-generator/src/typescript/common/type-builder.ts

@@ -19,10 +19,12 @@ import {buildExport} from "./typescript-common"
 
 const staticTypes = {
   EmptyObject: "export type EmptyObject = { [key: string]: never }",
+  // TODO: results in  TS4023: Exported variable '<schema>' has or is using name '_brand' from external module "<path>" but cannot be named.
+  // Brand: "export const _brand = Symbol.for('brand')",
   UnknownEnumStringValue:
-    "export type UnknownEnumStringValue = (string & {_: 'unknown enum string value'})",
+    "export type UnknownEnumStringValue = (string & {_brand: 'unknown enum string value'})",
   UnknownEnumNumberValue:
-    "export type UnknownEnumNumberValue = (number & {_: 'unknown enum number value'})",
+    "export type UnknownEnumNumberValue = (number & {_brand: 'unknown enum number value'})",
 }
 
 type StaticType = keyof typeof staticTypes