@flink-app/flink 2.0.0-alpha.51 → 2.0.0-alpha.53

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @flink-app/flink
 
+## 2.0.0-alpha.53
+
+### Minor Changes
+
+-   333aa52: feat: add worker thread parallelization for JSON schema generation
+
+    Implements worker thread pool for parallel JSON schema generation during compilation, providing significant speedup for large projects with 50+ schemas.
+
+    **Key features:**
+
+    -   Worker pool with automatic sizing based on CPU cores and memory
+    -   Parallel schema generation using ts-json-schema-generator
+    -   Automatic fallback to single-threaded mode for small projects (<50 schemas)
+    -   Configurable via environment variables:
+        -   `FLINK_USE_WORKERS=false` to disable workers entirely
+        -   `FLINK_WORKER_THRESHOLD=N` to customize the schema count threshold
+    -   Graceful error handling with automatic cleanup
+    -   Identical output to single-threaded mode (verified)
+
+    **Performance:**
+
+    -   Projects with 50+ schemas: ~2-2.5x speedup expected
+    -   Projects with <50 schemas: Uses efficient single-threaded mode (no overhead)
+    -   Memory overhead: ~80-160MB for worker pool (scales with CPU count)
+
+    **Usage:**
+    No configuration needed - workers are automatically enabled for large projects. To disable:
+
+    ```bash
+    FLINK_USE_WORKERS=false flink build
+    ```
+
+    To customize threshold:
+
+    ```bash
+    FLINK_WORKER_THRESHOLD=30 flink build
+    ```
+
+## 2.0.0-alpha.52
+
+### Patch Changes
+
+-   fe9f8f2: Improved compilation performance by parallelizing handler schema extraction. Projects with many handlers (90+) will see 3-10x faster build times.
+
 ## 2.0.0-alpha.51
 
 ## 2.0.0-alpha.50

package/cli/build.ts

@@ -40,16 +40,21 @@ module.exports = async function run(args: string[]) {
         process.exit(1);
     }
 
-    await Promise.all([
-        compiler.parseRepos(),
-        compiler.parseHandlers(exclude.split(",")),
-        compiler.parseTools(),
-        compiler.parseAgents(),
-        compiler.parseJobs(),
-        compiler.generateStartScript(),
-    ]);
-
-    console.log(`Compilation done, took ${Date.now() - startTime}ms`);
-
-    compiler.emit();
+    try {
+        await Promise.all([
+            compiler.parseRepos(),
+            compiler.parseHandlers(exclude.split(",")),
+            compiler.parseTools(),
+            compiler.parseAgents(),
+            compiler.parseJobs(),
+            compiler.generateStartScript(),
+        ]);
+
+        console.log(`Compilation done, took ${Date.now() - startTime}ms`);
+
+        compiler.emit();
+    } finally {
+        // Cleanup worker pool and other resources
+        await compiler.cleanup();
+    }
 };

package/dist/cli/build.js

@@ -65,6 +65,9 @@ module.exports = function run(args) {
                     if (!compiler.getPreEmitDiagnostics()) {
                         process.exit(1);
                     }
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 4, 6]);
                     return [4 /*yield*/, Promise.all([
                             compiler.parseRepos(),
                             compiler.parseHandlers(exclude.split(",")),
@@ -73,11 +76,19 @@ module.exports = function run(args) {
                             compiler.parseJobs(),
                             compiler.generateStartScript(),
                         ])];
-                case 2:
+                case 3:
                     _a.sent();
                     console.log("Compilation done, took ".concat(Date.now() - startTime, "ms"));
                     compiler.emit();
-                    return [2 /*return*/];
+                    return [3 /*break*/, 6];
+                case 4: 
+                // Cleanup worker pool and other resources
+                return [4 /*yield*/, compiler.cleanup()];
+                case 5:
+                    // Cleanup worker pool and other resources
+                    _a.sent();
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
             }
         });
     });

package/dist/src/TypeScriptCompiler.d.ts

@@ -4,6 +4,11 @@ declare class TypeScriptCompiler {
     private project;
     private schemaGenerator?;
     private isEsm;
+    /**
+     * Worker pool for parallel JSON schema generation.
+     * Initialized on first use, terminated on cleanup.
+     */
+    private workerPool?;
     /**
      * Parsed typescript schemas that will be added to intermediate
      * schemas.ts file.
@@ -17,6 +22,11 @@ declare class TypeScriptCompiler {
      * This will be added to file in a batch for performance reasons.
      */
     private tsSchemasSymbolsToImports;
+    /**
+     * Cache for schema analysis to avoid reprocessing the same types.
+     * Key: schema type text, Value: generated schema interface name
+     */
+    private schemaCache;
     constructor(cwd: string);
     /**
      * Loads additional source paths from tsconfig.json's flink configuration.
@@ -138,6 +148,10 @@ declare class TypeScriptCompiler {
     private saveIntermediateTsSchema;
     private initJsonSchemaGenerator;
     private generateAndSaveJsonSchemas;
+    /**
+     * Generate schemas sequentially (single-threaded fallback)
+     */
+    private generateSchemasSequentially;
     private generateJsonSchema;
     private extractSchemaTypeFromHandler;
     /**
@@ -164,5 +178,9 @@ declare class TypeScriptCompiler {
      * Scans project for jobs so they can be registered during start.
      */
     parseJobs(): Promise<SourceFile>;
+    /**
+     * Cleanup resources, including worker pool
+     */
+    cleanup(): Promise<void>;
 }
 export default TypeScriptCompiler;

package/dist/src/TypeScriptCompiler.js

@@ -90,6 +90,7 @@ var ts_morph_1 = require("ts-morph");
 var FsUtils_1 = require("./FsUtils");
 var TypeScriptUtils_1 = require("./TypeScriptUtils");
 var utils_1 = require("./utils");
+var WorkerPool_1 = require("./workers/WorkerPool");
 var TypeScriptCompiler = /** @class */ (function () {
     function TypeScriptCompiler(cwd) {
         this.cwd = cwd;
@@ -106,6 +107,11 @@ var TypeScriptCompiler = /** @class */ (function () {
          * This will be added to file in a batch for performance reasons.
          */
         this.tsSchemasSymbolsToImports = [];
+        /**
+         * Cache for schema analysis to avoid reprocessing the same types.
+         * Key: schema type text, Value: generated schema interface name
+         */
+        this.schemaCache = new Map();
         // Detect if project is using ESM based solely on package.json "type": "module"
         this.isEsm = this.isEsmProject(cwd);
         var compilerOptions = {
@@ -385,20 +391,24 @@ var TypeScriptCompiler = /** @class */ (function () {
      */
     TypeScriptCompiler.prototype.parseHandlers = function () {
         return __awaiter(this, arguments, void 0, function (excludeDirs) {
-            var generatedFile, handlersArr, handlers, schemaFilePath, jsonSchemas;
+            var startTime, generatedFile, handlersArr, handlers, handlerParseTime, schemaGenStartTime, schemaFilePath, jsonSchemas, schemaGenTime;
             if (excludeDirs === void 0) { excludeDirs = []; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        startTime = Date.now();
                         generatedFile = this.createSourceFile(["generatedHandlers.ts"], "// Generated ".concat(new Date(), "\nimport { autoRegisteredHandlers, HttpMethod } from \"@flink-app/flink\";\nexport const handlers = [];\nautoRegisteredHandlers.push(...handlers);\n    "));
                         handlersArr = generatedFile.getVariableDeclarationOrThrow("handlers").getFirstDescendantByKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
                         return [4 /*yield*/, this.parseHandlerDir(generatedFile, handlersArr)];
                     case 1:
                         handlers = _a.sent();
+                        handlerParseTime = Date.now() - startTime;
+                        console.log("\u2713 Handler parsing completed in ".concat(handlerParseTime, "ms"));
                         generatedFile.addImportDeclarations(handlers.imports);
                         return [4 /*yield*/, generatedFile.save()];
                     case 2:
                         _a.sent();
+                        schemaGenStartTime = Date.now();
                         return [4 /*yield*/, this.createIntermediateSchemaFile()];
                     case 3:
                         schemaFilePath = _a.sent();
@@ -406,6 +416,8 @@ var TypeScriptCompiler = /** @class */ (function () {
                     case 4:
                         jsonSchemas = _a.sent();
                         this.appendSchemasToHandlerSourceFiles(handlers.schemasToGenerate, jsonSchemas);
+                        schemaGenTime = Date.now() - schemaGenStartTime;
+                        console.log("\u2713 Schema generation completed in ".concat(schemaGenTime, "ms"));
                         return [2 /*return*/, generatedFile];
                 }
             });
@@ -416,93 +428,111 @@ var TypeScriptCompiler = /** @class */ (function () {
      */
     TypeScriptCompiler.prototype.parseHandlerDir = function (generatedFile, handlersArr) {
         return __awaiter(this, void 0, void 0, function () {
-            var imports, i, schemasToGenerate, _i, _a, sf, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes, _b, existingVars;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var imports, schemasToGenerate, handlerFiles, handlerResults, autoRegisterIndex, _i, handlerResults_1, result, sf, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes, existingVars;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         imports = [];
-                        i = 0;
                         schemasToGenerate = [];
-                        _i = 0, _a = this.project.getSourceFiles();
-                        _c.label = 1;
+                        handlerFiles = this.project.getSourceFiles().filter(function (sf) { return sf.getFilePath().includes("src/handlers/"); });
+                        console.log("Processing ".concat(handlerFiles.length, " handlers..."));
+                        return [4 /*yield*/, Promise.all(handlerFiles.map(function (sf, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var startTime, isAutoRegister, namespaceImport, assumedHttpMethod, schemaTypes, _a, elapsed;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            startTime = Date.now();
+                                            isAutoRegister = this.isAutoRegisterableHandler(sf);
+                                            namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + index;
+                                            assumedHttpMethod = (0, utils_1.getHttpMethodFromHandlerName)(sf.getBaseName());
+                                            console.log("[".concat(index + 1, "/").concat(handlerFiles.length, "] Processing ").concat(sf.getBaseName(), "..."));
+                                            if (!isAutoRegister) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, this.extractSchemasFromHandlerSourceFile(sf)];
+                                        case 1:
+                                            _a = _b.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            _a = undefined;
+                                            _b.label = 3;
+                                        case 3:
+                                            schemaTypes = _a;
+                                            elapsed = Date.now() - startTime;
+                                            if (elapsed > 100) {
+                                                console.log("  \u2514\u2500 Completed in ".concat(elapsed, "ms"));
+                                            }
+                                            return [2 /*return*/, {
+                                                    sf: sf,
+                                                    isAutoRegister: isAutoRegister,
+                                                    namespaceImport: namespaceImport,
+                                                    assumedHttpMethod: assumedHttpMethod,
+                                                    schemaTypes: schemaTypes,
+                                                    index: index,
+                                                }];
+                                    }
+                                });
+                            }); }))];
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
-                        sf = _a[_i];
-                        if (!sf.getFilePath().includes("src/handlers/")) {
-                            return [3 /*break*/, 5];
-                        }
-                        isAutoRegister = this.isAutoRegisterableHandler(sf);
-                        console.log("Detected handler ".concat(sf.getBaseName(), " ").concat(!isAutoRegister ? "(requires manual registration)" : ""));
-                        namespaceImport = sf.getBaseNameWithoutExtension().replace(/\./g, "_") + "_" + i;
-                        imports.push({
-                            defaultImport: "* as " + namespaceImport,
-                            moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
-                        });
-                        assumedHttpMethod = (0, utils_1.getHttpMethodFromHandlerName)(sf.getBaseName());
-                        if (!isAutoRegister) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.extractSchemasFromHandlerSourceFile(sf)];
-                    case 2:
-                        _b = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _b = undefined;
-                        _c.label = 4;
-                    case 4:
-                        schemaTypes = _b;
-                        existingVars = sf.getVariableStatements().filter(function (vs) {
-                            var varNames = vs.getDeclarations().map(function (d) { return d.getName(); });
-                            return varNames.some(function (name) { return ["__assumedHttpMethod", "__file", "__query", "__params"].includes(name); });
-                        });
-                        existingVars.forEach(function (v) { return v.remove(); });
-                        // Append schemas and metadata to source file that will be part of emitted dist bundle (javascript)
-                        sf.addVariableStatement({
-                            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-                            isExported: true,
-                            declarations: [
-                                {
-                                    name: "__assumedHttpMethod",
-                                    initializer: "\"".concat(assumedHttpMethod || "", "\""),
-                                },
-                                {
-                                    name: "__file",
-                                    initializer: "\"".concat(sf.getBaseName(), "\""),
-                                },
-                                {
-                                    name: "__query",
-                                    initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.queryMetadata) || [])
-                                        .map(function (_a) {
-                                        var description = _a.description, name = _a.name;
-                                        return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
-                                    })
-                                        .join(","), "]"),
-                                },
-                                {
-                                    name: "__params",
-                                    initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.paramsMetadata) || [])
-                                        .map(function (_a) {
-                                        var description = _a.description, name = _a.name;
-                                        return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
-                                    })
-                                        .join(","), "]"),
-                                },
-                            ],
-                        });
-                        if (isAutoRegister) {
-                            handlersArr.insertElement(i, "{handler: ".concat(namespaceImport, ", assumedHttpMethod: ").concat(assumedHttpMethod ? "HttpMethod." + assumedHttpMethod : undefined, "}"));
-                            i++;
-                            // Add schemas to generate list
-                            if (schemaTypes) {
-                                schemasToGenerate.push(__assign(__assign({}, schemaTypes), { sourceFile: sf }));
+                        handlerResults = _a.sent();
+                        autoRegisterIndex = 0;
+                        for (_i = 0, handlerResults_1 = handlerResults; _i < handlerResults_1.length; _i++) {
+                            result = handlerResults_1[_i];
+                            sf = result.sf, isAutoRegister = result.isAutoRegister, namespaceImport = result.namespaceImport, assumedHttpMethod = result.assumedHttpMethod, schemaTypes = result.schemaTypes;
+                            imports.push({
+                                defaultImport: "* as " + namespaceImport,
+                                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
+                            });
+                            existingVars = sf.getVariableStatements().filter(function (vs) {
+                                var varNames = vs.getDeclarations().map(function (d) { return d.getName(); });
+                                return varNames.some(function (name) { return ["__assumedHttpMethod", "__file", "__query", "__params"].includes(name); });
+                            });
+                            existingVars.forEach(function (v) { return v.remove(); });
+                            // Append schemas and metadata to source file that will be part of emitted dist bundle (javascript)
+                            sf.addVariableStatement({
+                                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+                                isExported: true,
+                                declarations: [
+                                    {
+                                        name: "__assumedHttpMethod",
+                                        initializer: "\"".concat(assumedHttpMethod || "", "\""),
+                                    },
+                                    {
+                                        name: "__file",
+                                        initializer: "\"".concat(sf.getBaseName(), "\""),
+                                    },
+                                    {
+                                        name: "__query",
+                                        initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.queryMetadata) || [])
+                                            .map(function (_a) {
+                                            var description = _a.description, name = _a.name;
+                                            return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
+                                        })
+                                            .join(","), "]"),
+                                    },
+                                    {
+                                        name: "__params",
+                                        initializer: "[".concat(((schemaTypes === null || schemaTypes === void 0 ? void 0 : schemaTypes.paramsMetadata) || [])
+                                            .map(function (_a) {
+                                            var description = _a.description, name = _a.name;
+                                            return "{description: \"".concat(description, "\", name: \"").concat(name, "\"}");
+                                        })
+                                            .join(","), "]"),
+                                    },
+                                ],
+                            });
+                            if (isAutoRegister) {
+                                handlersArr.insertElement(autoRegisterIndex, "{handler: ".concat(namespaceImport, ", assumedHttpMethod: ").concat(assumedHttpMethod ? "HttpMethod." + assumedHttpMethod : undefined, "}"));
+                                autoRegisterIndex++;
+                                // Add schemas to generate list
+                                if (schemaTypes) {
+                                    schemasToGenerate.push(__assign(__assign({}, schemaTypes), { sourceFile: sf }));
+                                }
                             }
                         }
-                        _c.label = 5;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/, {
-                            imports: imports,
-                            schemasToGenerate: schemasToGenerate,
-                        }];
+                        return [2 /*return*/, {
+                                imports: imports,
+                                schemasToGenerate: schemasToGenerate,
+                            }];
                 }
             });
         });
@@ -884,7 +914,7 @@ var TypeScriptCompiler = /** @class */ (function () {
     };
     TypeScriptCompiler.prototype.saveIntermediateTsSchema = function (schema, handlerFile, suffix) {
         return __awaiter(this, void 0, void 0, function () {
-            var schemaText, handlerFileName, generatedSchemaInterfaceStr, schemaInterfaceName, schemaSymbol, interfaceName, declaration, _i, _a, typeToImport, typeSymbol, declaredTypeSymbol, _b, _c, prop, propDecl, propText, interfaceNameMatches, _d, interfaceNameMatches_1, match, referencedInterfaceName, referencedInterfaceDecl, arrayTypeArg, schemaSymbol, interfaceName, declaration, props, _e, _f, typeToImport, typeSymbol, declaredTypeSymbol, schemaSymbol, declarations, declaration, propertySignatures, _g, _h, prop, propType, typeSymbol, typeDeclaration, elementType, elementSymbol, elementDeclaration, currentPropTypeText, interfaceNameMatches, _j, interfaceNameMatches_2, match, interfaceName, interfaceDecl, typeArgs, _k, typeArgs_1, typeArg, argSymbol, argDeclaration, _l, _m, typeToImport, typeSymbol, declaredTypeSymbol;
+            var schemaText, cacheKey, handlerFileName, generatedSchemaInterfaceStr, schemaInterfaceName, schemaSymbol, interfaceName, declaration, _i, _a, typeToImport, typeSymbol, declaredTypeSymbol, _b, _c, prop, propDecl, propText, interfaceNameMatches, _d, interfaceNameMatches_1, match, referencedInterfaceName, referencedInterfaceDecl, arrayTypeArg, schemaSymbol, interfaceName, declaration, props, _e, _f, typeToImport, typeSymbol, declaredTypeSymbol, schemaSymbol, declarations, declaration, propertySignatures, _g, _h, prop, propType, typeSymbol, typeDeclaration, elementType, elementSymbol, elementDeclaration, currentPropTypeText, interfaceNameMatches, _j, interfaceNameMatches_2, match, interfaceName, interfaceDecl, typeArgs, _k, typeArgs_1, typeArg, argSymbol, argDeclaration, _l, _m, typeToImport, typeSymbol, declaredTypeSymbol;
             return __generator(this, function (_o) {
                 if (schema.isAny()) {
                     return [2 /*return*/]; // 'any' indicates that no schema is used
@@ -893,6 +923,10 @@ var TypeScriptCompiler = /** @class */ (function () {
                 if (schemaText === "void" || schemaText === "undefined") {
                     return [2 /*return*/];
                 }
+                cacheKey = "".concat(handlerFile.getFilePath(), ":").concat(schemaText, ":").concat(suffix);
+                if (this.schemaCache.has(cacheKey)) {
+                    return [2 /*return*/, this.schemaCache.get(cacheKey)];
+                }
                 handlerFileName = handlerFile.getBaseNameWithoutExtension().replace(/\./g, "_");
                 generatedSchemaInterfaceStr = "";
                 schemaInterfaceName = "".concat(handlerFileName, "_").concat(suffix);
@@ -1067,8 +1101,10 @@ var TypeScriptCompiler = /** @class */ (function () {
                 }
                 if (generatedSchemaInterfaceStr) {
                     this.parsedTsSchemas.push(generatedSchemaInterfaceStr);
+                    this.schemaCache.set(cacheKey, schemaInterfaceName);
                     return [2 /*return*/, schemaInterfaceName];
                 }
+                this.schemaCache.set(cacheKey, undefined);
                 return [2 /*return*/];
             });
         });
@@ -1132,43 +1168,117 @@ var TypeScriptCompiler = /** @class */ (function () {
     };
     TypeScriptCompiler.prototype.generateAndSaveJsonSchemas = function (schemas, schemaFilePath) {
         return __awaiter(this, void 0, void 0, function () {
-            var jsonSchemas, _i, schemas_1, _a, reqSchemaType, resSchemaType, mergedSchemas, filePath;
-            var _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var tsconfigPath, useWorkers, workerThreshold, schemaTypes, _i, schemas_1, _a, reqSchemaType, resSchemaType, definitions, workerScriptPath, stats, startTime, results, duration, _b, results_1, result, error_1, mergedSchemas, filePath;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         // Reset schema generator to use the newly created intermediate schema file
                         this.schemaGenerator = undefined;
-                        jsonSchemas = [];
+                        tsconfigPath = (0, path_1.join)(this.cwd, "tsconfig.json");
+                        useWorkers = process.env.FLINK_USE_WORKERS !== "false";
+                        workerThreshold = parseInt(process.env.FLINK_WORKER_THRESHOLD || "50", 10);
+                        schemaTypes = [];
                         for (_i = 0, schemas_1 = schemas; _i < schemas_1.length; _i++) {
                             _a = schemas_1[_i], reqSchemaType = _a.reqSchemaType, resSchemaType = _a.resSchemaType;
-                            if (reqSchemaType) {
-                                jsonSchemas.push({ definitions: (_b = {}, _b[reqSchemaType] = this.generateJsonSchema(reqSchemaType, schemaFilePath), _b) });
-                            }
-                            if (resSchemaType) {
-                                jsonSchemas.push({ definitions: (_c = {}, _c[resSchemaType] = this.generateJsonSchema(resSchemaType, schemaFilePath), _c) });
-                            }
+                            if (reqSchemaType)
+                                schemaTypes.push(reqSchemaType);
+                            if (resSchemaType)
+                                schemaTypes.push(resSchemaType);
                         }
-                        mergedSchemas = jsonSchemas.reduce(function (out, schema) {
-                            if (schema.definitions) {
-                                out.definitions = __assign(__assign({}, out.definitions), schema.definitions);
+                        definitions = {};
+                        if (!(useWorkers && schemaTypes.length >= workerThreshold)) return [3 /*break*/, 10];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 5, , 9]);
+                        if (!!this.workerPool) return [3 /*break*/, 3];
+                        workerScriptPath = (0, path_1.join)(__dirname, "workers", "SchemaGeneratorWorker.js");
+                        this.workerPool = new WorkerPool_1.WorkerPool(workerScriptPath);
+                        return [4 /*yield*/, this.workerPool.initialize()];
+                    case 2:
+                        _c.sent();
+                        stats = this.workerPool.getStats();
+                        console.log("\u2713 Worker pool initialized with ".concat(stats.poolSize, " workers"));
+                        _c.label = 3;
+                    case 3:
+                        startTime = Date.now();
+                        return [4 /*yield*/, Promise.all(schemaTypes.map(function (typeName) {
+                                return _this.workerPool.execute({ schemaFilePath: schemaFilePath, typeName: typeName, tsconfigPath: tsconfigPath });
+                            }))];
+                    case 4:
+                        results = _c.sent();
+                        duration = Date.now() - startTime;
+                        console.log("\u2713 Generated ".concat(schemaTypes.length, " schemas in ").concat(duration, "ms using workers"));
+                        // Merge results
+                        for (_b = 0, results_1 = results; _b < results_1.length; _b++) {
+                            result = results_1[_b];
+                            if (result.error) {
+                                throw new Error("Schema generation failed for ".concat(result.typeName, ": ").concat(result.error));
                             }
-                            return out;
-                        }, {
+                            definitions[result.typeName] = result.schema;
+                        }
+                        return [3 /*break*/, 9];
+                    case 5:
+                        error_1 = _c.sent();
+                        console.warn("Worker pool failed, falling back to single-threaded mode:", error_1.message);
+                        if (!this.workerPool) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.workerPool.terminate().catch(function () { })];
+                    case 6:
+                        _c.sent();
+                        this.workerPool = undefined;
+                        _c.label = 7;
+                    case 7: return [4 /*yield*/, this.generateSchemasSequentially(schemas, schemaFilePath)];
+                    case 8:
+                        // Fall back to single-threaded generation
+                        definitions = _c.sent();
+                        return [3 /*break*/, 9];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        // Use single-threaded generation for small schema counts or when workers disabled
+                        if (!useWorkers) {
+                            console.log("✓ Workers disabled, using single-threaded schema generation");
+                        }
+                        return [4 /*yield*/, this.generateSchemasSequentially(schemas, schemaFilePath)];
+                    case 11:
+                        definitions = _c.sent();
+                        _c.label = 12;
+                    case 12:
+                        mergedSchemas = {
                             $schema: "http://json-schema.org/draft-07/schema#",
                             $ref: "#/definitions/Schemas",
-                            definitions: {},
-                        });
+                            definitions: definitions,
+                        };
                         filePath = (0, path_1.join)(this.cwd, ".flink", "schemas", "schemas.json");
                         return [4 /*yield*/, (0, FsUtils_1.writeJsonFile)(filePath, mergedSchemas)];
-                    case 1:
-                        _d.sent();
+                    case 13:
+                        _c.sent();
                         this.project.addSourceFileAtPath(filePath);
                         return [2 /*return*/, mergedSchemas];
                 }
             });
         });
     };
+    /**
+     * Generate schemas sequentially (single-threaded fallback)
+     */
+    TypeScriptCompiler.prototype.generateSchemasSequentially = function (schemas, schemaFilePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var definitions, _i, schemas_2, _a, reqSchemaType, resSchemaType;
+            return __generator(this, function (_b) {
+                definitions = {};
+                for (_i = 0, schemas_2 = schemas; _i < schemas_2.length; _i++) {
+                    _a = schemas_2[_i], reqSchemaType = _a.reqSchemaType, resSchemaType = _a.resSchemaType;
+                    if (reqSchemaType) {
+                        definitions[reqSchemaType] = this.generateJsonSchema(reqSchemaType, schemaFilePath);
+                    }
+                    if (resSchemaType) {
+                        definitions[resSchemaType] = this.generateJsonSchema(resSchemaType, schemaFilePath);
+                    }
+                }
+                return [2 /*return*/, definitions];
+            });
+        });
+    };
     TypeScriptCompiler.prototype.generateJsonSchema = function (typeName, schemaFilePath) {
         if (!this.schemaGenerator) {
             this.schemaGenerator = this.initJsonSchemaGenerator(schemaFilePath);
@@ -1349,6 +1459,25 @@ var TypeScriptCompiler = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Cleanup resources, including worker pool
+     */
+    TypeScriptCompiler.prototype.cleanup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.workerPool) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.workerPool.terminate()];
+                    case 1:
+                        _a.sent();
+                        this.workerPool = undefined;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
     return TypeScriptCompiler;
 }());
 exports.default = TypeScriptCompiler;

package/dist/src/workers/SchemaGeneratorWorker.d.ts

@@ -0,0 +1 @@
+export {};