@flink-app/flink 0.12.1-alpha.9 → 0.13.0

package/src/TypeScriptCompiler.ts

@@ -1,8 +1,8 @@
-import { promises as fsPromises } from "fs";
+import fs, { promises as fsPromises } from "fs";
 import { JSONSchema7 } from "json-schema";
 import { join } from "path";
 import glob from "tiny-glob";
-import { CompletedConfig, Config, createFormatter, createParser, Schema, SchemaGenerator } from "ts-json-schema-generator";
+import { CompletedConfig, createFormatter, createParser, createProgram, Schema, SchemaGenerator } from "ts-json-schema-generator";
 import {
     ArrayLiteralExpression,
     DiagnosticCategory,
@@ -24,6 +24,7 @@ import { getCollectionNameForRepo, getHttpMethodFromHandlerName, getRepoInstance
 class TypeScriptCompiler {
     private project: Project;
     private schemaGenerator?: SchemaGenerator;
+    private isEsm: boolean;
 
     /**
      * Parsed typescript schemas that will be added to intermediate
@@ -41,16 +42,72 @@ class TypeScriptCompiler {
     private tsSchemasSymbolsToImports: Symbol[] = [];
 
     constructor(private cwd: string) {
+        // Detect if project is using ESM based solely on package.json "type": "module"
+        this.isEsm = this.isEsmProject(cwd);
+
+        const compilerOptions: ts.CompilerOptions = {
+            noEmit: false, // We need to emit files
+            outDir: join(cwd, "dist"),
+        };
+
+        // Set appropriate module settings based on detected module system
+        if (this.isEsm) {
+            // For ESM projects, use ESNext module with Node resolution
+            compilerOptions.module = ts.ModuleKind.ESNext;
+            compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+            compilerOptions.esModuleInterop = true;
+        } else {
+            // For CommonJS projects, use CommonJS module with Node resolution
+            compilerOptions.module = ts.ModuleKind.CommonJS;
+            compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+        }
+
+        const tsConfigPath = join(cwd, "tsconfig.json");
+        console.log("TypeScript config path:", require("path").resolve(tsConfigPath));
+        console.log("TypeScript version:", ts.version);
+
         this.project = new Project({
-            tsConfigFilePath: join(cwd, "tsconfig.json"),
-            compilerOptions: {
-                noEmit: false,
-                outDir: join(cwd, "dist"),
-                // incremental: true,
-            },
+            tsConfigFilePath: tsConfigPath,
+            compilerOptions,
         });
 
         console.log("Loaded", this.project.getSourceFiles().length, "source file(s) from", cwd);
+        console.log("Module system:", this.isEsm ? "ESM" : "CommonJS");
+        console.log("Using module:", compilerOptions.module === ts.ModuleKind.ESNext ? "ESNext" : "CommonJS");
+    }
+
+    /**
+     * Detects if the project is using ESM (ECMAScript Modules)
+     * by checking type in package.json.
+     */
+    private isEsmProject(cwd: string): boolean {
+        try {
+            // Check package.json for "type": "module"
+            const packageJsonPath = join(cwd, "package.json");
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                return packageJson.type === "module";
+            }
+        } catch (error) {
+            // If we can't determine, default to CommonJS
+            console.warn("Error detecting module system, defaulting to CommonJS:", error);
+        }
+
+        return false;
+    }
+
+    /**
+     * Gets the module specifier for imports, adding .js extension for ESM
+     */
+    private getModuleSpecifier(fromFile: SourceFile, toFile: SourceFile): string {
+        let moduleSpecifier = fromFile.getRelativePathAsModuleSpecifierTo(toFile);
+
+        // Add .js extension for ESM imports (only for relative paths)
+        if (this.isEsm && !moduleSpecifier.startsWith("@") && !moduleSpecifier.endsWith(".js")) {
+            moduleSpecifier += ".js";
+        }
+
+        return moduleSpecifier;
     }
 
     /**
@@ -139,9 +196,9 @@ autoRegisteredHandlers.push(...handlers);
 
         await generatedFile.save();
 
-        await this.createIntermediateSchemaFile();
+        const schemaFilePath = await this.createIntermediateSchemaFile();
 
-        const jsonSchemas = await this.generateAndSaveJsonSchemas(handlers.schemasToGenerate);
+        const jsonSchemas = await this.generateAndSaveJsonSchemas(handlers.schemasToGenerate, schemaFilePath);
 
         this.appendSchemasToHandlerSourceFiles(handlers.schemasToGenerate, jsonSchemas);
 
@@ -173,12 +230,20 @@ autoRegisteredHandlers.push(...handlers);
 
             imports.push({
                 defaultImport: "* as " + namespaceImport,
-                moduleSpecifier: generatedFile.getRelativePathAsModuleSpecifierTo(sf),
+                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
             });
 
             const assumedHttpMethod = getHttpMethodFromHandlerName(sf.getBaseName());
 
-            const schemaTypes = await this.extractSchemasFromHandlerSourceFile(sf);
+            // Only extract schemas for auto-registered handlers
+            const schemaTypes = isAutoRegister ? await this.extractSchemasFromHandlerSourceFile(sf) : undefined;
+
+            // Remove existing metadata variables if they exist (to avoid redeclaration errors)
+            const existingVars = sf.getVariableStatements().filter((vs) => {
+                const varNames = vs.getDeclarations().map((d) => d.getName());
+                return varNames.some((name) => ["__assumedHttpMethod", "__file", "__query", "__params"].includes(name));
+            });
+            existingVars.forEach((v) => v.remove());
 
             // Append schemas and metadata to source file that will be part of emitted dist bundle (javascript)
             sf.addVariableStatement({
@@ -214,10 +279,11 @@ autoRegisteredHandlers.push(...handlers);
                     `{handler: ${namespaceImport}, assumedHttpMethod: ${assumedHttpMethod ? "HttpMethod." + assumedHttpMethod : undefined}}`
                 );
                 i++;
-            }
 
-            if (schemaTypes) {
-                schemasToGenerate.push({ ...schemaTypes, sourceFile: sf });
+                // Add schemas to generate list
+                if (schemaTypes) {
+                    schemasToGenerate.push({ ...schemaTypes, sourceFile: sf });
+                }
             }
         }
 
@@ -252,7 +318,7 @@ autoRegisteredHandlers.push(...handlers);
 
             imports.push({
                 defaultImport: sf.getBaseNameWithoutExtension(),
-                moduleSpecifier: generatedFile.getRelativePathAsModuleSpecifierTo(sf),
+                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
             });
 
             reposArr.insertElement(
@@ -288,10 +354,11 @@ autoRegisteredHandlers.push(...handlers);
         const sf = this.createSourceFile(
             ["start.ts"],
             `// Generated ${new Date()}
-import "./generatedHandlers";
-import "./generatedRepos";
-import "./generatedJobs";
-import "..${appEntryScript.replace(/\.ts/g, "")}";
+import "./generatedHandlers${this.isEsm ? ".js" : ""}";
+import "./generatedRepos${this.isEsm ? ".js" : ""}";
+import "./generatedJobs${this.isEsm ? ".js" : ""}";
+import "..${appEntryScript.replace(/\.ts/g, "")}${this.isEsm ? ".js" : ""}";
+export default {}; // Export an empty object to make it a module
 `
         );
 
@@ -410,15 +477,19 @@ import "..${appEntryScript.replace(/\.ts/g, "")}";
              * We need extract `{car: Car}` into its own interface and make sure
              * to import types if needed to
              */
-            const declaration = schema.getSymbolOrThrow().getDeclarations()[0];
-
-            const typeRefIdentifiers = declaration
-                .getDescendantsOfKind(SyntaxKind.TypeReference)
-                .map((typeRef) => typeRef.getFirstChildByKindOrThrow(SyntaxKind.Identifier));
-
-            typeRefIdentifiers.forEach((tr) => {
-                this.tsSchemasSymbolsToImports.push(tr.getSymbolOrThrow().getDeclaredType().getSymbolOrThrow());
-            });
+            const declarations = schema.getSymbolOrThrow().getDeclarations();
+            const declaration = declarations[0];
+
+            // Only extract type references if declaration exists (won't exist for empty object literals like {})
+            if (declaration) {
+                const typeRefIdentifiers = declaration
+                    .getDescendantsOfKind(SyntaxKind.TypeReference)
+                    .map((typeRef) => typeRef.getFirstChildByKindOrThrow(SyntaxKind.Identifier));
+
+                typeRefIdentifiers.forEach((tr) => {
+                    this.tsSchemasSymbolsToImports.push(tr.getSymbolOrThrow().getDeclaredType().getSymbolOrThrow());
+                });
+            }
 
             generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} { ${schema
                 .getProperties()
@@ -436,8 +507,10 @@ import "..${appEntryScript.replace(/\.ts/g, "")}";
         return;
     }
 
-    private initJsonSchemaGenerator() {
+    private initJsonSchemaGenerator(schemaFilePath: string) {
+        const tsconfigPath = join(this.cwd, "tsconfig.json");
         const conf: CompletedConfig = {
+            path: schemaFilePath, // Point to the intermediate schema file
             expose: "none", // Do not create shared $ref definitions.
             topRef: false, // Removes the wrapper object around the schema.
             additionalProperties: false,
@@ -451,23 +524,39 @@ import "..${appEntryScript.replace(/\.ts/g, "")}";
             extraTags: [],
             functions: "fail",
             discriminatorType: "json-schema",
+            // tsconfig: tsconfigPath,
         };
+
+        console.log("Creating TypeScript program for schema generation:");
+        console.log("  Schema file:", schemaFilePath);
+        console.log("  tsconfig:", tsconfigPath);
+
+        // Create a fresh TypeScript Program that includes the schema file
+        // This ensures ts-json-schema-generator can find the types we just generated
+        const program = createProgram(conf);
+
+        console.log("  TypeScript version:", ts.version);
+        console.log("  Program root files:", program.getRootFileNames().length);
+
         const formatter = createFormatter(conf);
-        const parser = createParser(this.project.getProgram().compilerObject, conf);
-        const generator = new SchemaGenerator(this.project.getProgram().compilerObject, parser, formatter, conf);
+        const parser = createParser(program, conf);
+        const generator = new SchemaGenerator(program, parser, formatter, conf);
 
         return generator;
     }
 
-    private async generateAndSaveJsonSchemas(schemas: { reqSchemaType?: string; resSchemaType?: string }[]) {
+    private async generateAndSaveJsonSchemas(schemas: { reqSchemaType?: string; resSchemaType?: string }[], schemaFilePath: string) {
+        // Reset schema generator to use the newly created intermediate schema file
+        this.schemaGenerator = undefined;
+
         const jsonSchemas: Schema[] = [];
 
         for (const { reqSchemaType, resSchemaType } of schemas) {
             if (reqSchemaType) {
-                jsonSchemas.push({ definitions: { [reqSchemaType]: this.generateJsonSchema(reqSchemaType) } });
+                jsonSchemas.push({ definitions: { [reqSchemaType]: this.generateJsonSchema(reqSchemaType, schemaFilePath) } });
             }
             if (resSchemaType) {
-                jsonSchemas.push({ definitions: { [resSchemaType]: this.generateJsonSchema(resSchemaType) } });
+                jsonSchemas.push({ definitions: { [resSchemaType]: this.generateJsonSchema(resSchemaType, schemaFilePath) } });
             }
         }
 
@@ -494,9 +583,9 @@ import "..${appEntryScript.replace(/\.ts/g, "")}";
         return mergedSchemas;
     }
 
-    private generateJsonSchema(typeName: string) {
+    private generateJsonSchema(typeName: string, schemaFilePath: string) {
         if (!this.schemaGenerator) {
-            this.schemaGenerator = this.initJsonSchemaGenerator();
+            this.schemaGenerator = this.initJsonSchemaGenerator(schemaFilePath);
         }
         return this.schemaGenerator.createSchema(typeName);
     }
@@ -563,7 +652,10 @@ ${this.parsedTsSchemas.join("\n\n")}`
 
         addImports(schemaSourceFile, this.tsSchemasSymbolsToImports);
 
-        return schemaSourceFile.save();
+        await schemaSourceFile.save();
+
+        // Return the file path so it can be used by ts-json-schema-generator
+        return schemaSourceFile.getFilePath();
     }
 
     /**
@@ -617,6 +709,13 @@ ${this.parsedTsSchemas.join("\n\n")}`
             const reqJsonSchema = JSON.stringify(reqSchemaType ? jsonSchemaDefs[reqSchemaType] : undefined);
             const resJsonSchema = JSON.stringify(resSchemaType ? jsonSchemaDefs[resSchemaType] : undefined);
 
+            // Remove existing __schemas variable if it exists (to avoid redeclaration errors)
+            const existingSchemas = sourceFile.getVariableStatements().filter((vs) => {
+                const varNames = vs.getDeclarations().map((d) => d.getName());
+                return varNames.includes("__schemas");
+            });
+            existingSchemas.forEach((v) => v.remove());
+
             sourceFile.addVariableStatement({
                 declarationKind: VariableDeclarationKind.Const,
                 isExported: true,
@@ -660,8 +759,15 @@ autoRegisteredJobs.push(...jobs);
 
             imports.push({
                 defaultImport: "* as " + namespaceImport,
-                moduleSpecifier: generatedFile.getRelativePathAsModuleSpecifierTo(sf),
+                moduleSpecifier: this.getModuleSpecifier(generatedFile, sf),
+            });
+
+            // Remove existing __file variable if it exists (to avoid redeclaration errors)
+            const existingFile = sf.getVariableStatements().filter((vs) => {
+                const varNames = vs.getDeclarations().map((d) => d.getName());
+                return varNames.includes("__file");
             });
+            existingFile.forEach((v) => v.remove());
 
             // Append metadata to source file that will be part of emitted dist bundle (javascript)
             sf.addVariableStatement({

package/src/index.ts

@@ -9,3 +9,15 @@ export * from "./FlinkPlugin";
 export * from "./FlinkJob";
 export * from "./auth/FlinkAuthUser";
 export * from "./auth/FlinkAuthPlugin";
+
+// Re-export Express types for plugins and consumer apps
+// This ensures type consistency across the framework and plugins
+export type {
+    Request as ExpressRequest,
+    Response as ExpressResponse,
+    NextFunction as ExpressNextFunction,
+    RequestHandler as ExpressRequestHandler,
+    ErrorRequestHandler as ExpressErrorRequestHandler,
+    Express,
+    static as expressStatic,
+} from "express";

package/tsconfig.json

@@ -13,7 +13,7 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "experimentalDecorators": true,
-    "checkJs": true,
+    "checkJs": false,
     "typeRoots": ["./typings", "./node_modules/@types"],
     "declaration": true,
     "outDir": "dist"

package/dist/cli/generate-schemas.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/generate-schemas.js

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var path_1 = require("path");
-var ts_json_schema_generator_1 = require("ts-json-schema-generator");
-var ts_morph_1 = require("ts-morph");
-var FsUtils_1 = require("../src/FsUtils");
-var cli_utils_1 = require("./cli-utils");
-module.exports = function run(args) {
-    return __awaiter(this, void 0, void 0, function () {
-        var dir, verbose, typesDir, outFile, project, schemaDeclarations, generator, jsonSchemas, _i, _a, sf, sourceFileInterfaceDeclarations, sourceFileEnumDeclarations, sourceFileDeclarations, schema, mergedSchemas, file;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (args.includes("--help")) {
-                        console.log("\n    Description\n      Generates JSON schemas for types located in schemas directory or if any other directory\n      is specified with option --types-dir. \n\n      Outputs generated file(s) to dir '.flink' or if any other --out-dir is specified.\n\n    Usage\n      $ flink generate-schemas <dir> --types-dir <types-dir> --out-file <out-file>\n\n      <dir> is project root as directory where tsconfig.son resides.\n       \n    Options            \n      --types-dir   Directory where typescript types are located relative to <dir>, default \"./src/schemas\"\n      --out-file    Path to file that will contain generated json schemas relative to <dir>, default \"./.flink/generated-schemas.json\"\n      --help        Displays this message\n      ");
-                        process.exit(0);
-                    }
-                    dir = "./";
-                    if (args[0] && !args[0].startsWith("--")) {
-                        dir = args[0];
-                    }
-                    verbose = cli_utils_1.getOption(args, "verbose", false, {
-                        isBoolean: true,
-                    });
-                    typesDir = cli_utils_1.getOption(args, "types-dir", "./src/schemas");
-                    outFile = cli_utils_1.getOption(args, "out-file", "./.flink/generated-schemas.json");
-                    project = new ts_morph_1.Project({
-                        tsConfigFilePath: path_1.join(dir, "tsconfig.json"),
-                        skipAddingFilesFromTsConfig: true,
-                        compilerOptions: {
-                            noEmit: true,
-                        },
-                    });
-                    project.addSourceFilesAtPaths(path_1.join(dir, typesDir, "**/*.ts"));
-                    console.log("Found", project.getSourceFiles().length, "files");
-                    schemaDeclarations = [];
-                    generator = initJsonSchemaGenerator(project);
-                    jsonSchemas = [];
-                    for (_i = 0, _a = project.getSourceFiles(); _i < _a.length; _i++) {
-                        sf = _a[_i];
-                        if (sf.getDefaultExportSymbol()) {
-                            console.warn("WARN: Schema file " + sf.getBaseName() + " has default export, but only named exports are picked up by json schemas parser");
-                        }
-                        sourceFileInterfaceDeclarations = sf.getChildrenOfKind(ts_morph_1.SyntaxKind.InterfaceDeclaration);
-                        sourceFileEnumDeclarations = sf.getChildrenOfKind(ts_morph_1.SyntaxKind.EnumDeclaration);
-                        sourceFileDeclarations = __spreadArray(__spreadArray([], sourceFileEnumDeclarations), sourceFileInterfaceDeclarations);
-                        schemaDeclarations.push.apply(schemaDeclarations, sourceFileDeclarations.map(function (d) { return d.compilerNode; }));
-                        verbose &&
-                            console.log("Found", sourceFileDeclarations.length, "schema(s) in file", sf.getBaseName());
-                        try {
-                            schema = generator.createSchemaFromNodes(sourceFileInterfaceDeclarations.map(function (d) { return d.compilerNode; }));
-                            jsonSchemas.push(schema);
-                            // console.log("Created schemas");
-                        }
-                        catch (err) {
-                            console.error("Failed to generate schema in file", sf.getBaseName() + ":", err);
-                        }
-                    }
-                    mergedSchemas = jsonSchemas.reduce(function (out, schema) {
-                        if (schema)
-                            if (schema.definitions) {
-                                out.definitions = __assign(__assign({}, out.definitions), schema.definitions);
-                            }
-                        return out;
-                    }, {
-                        $schema: "http://json-schema.org/draft-07/schema#",
-                        $ref: "#/definitions/Schemas",
-                        definitions: {},
-                    });
-                    file = path_1.join(dir, outFile);
-                    return [4 /*yield*/, FsUtils_1.writeJsonFile(file, mergedSchemas, {
-                            ensureDir: true,
-                        })];
-                case 1:
-                    _b.sent();
-                    console.log("Wrote file", file);
-                    return [2 /*return*/];
-            }
-        });
-    });
-};
-function initJsonSchemaGenerator(project) {
-    var formatter = ts_json_schema_generator_1.createFormatter({});
-    var parser = ts_json_schema_generator_1.createParser(project.getProgram().compilerObject, {});
-    var generator = new ts_json_schema_generator_1.SchemaGenerator(project.getProgram().compilerObject, parser, formatter, { expose: "export" });
-    return generator;
-}

package/spec/mock-project/dist/src/handlers/GetCarWithTypeSchema.js

@@ -1,60 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__schemas = exports.__params = exports.__query = exports.__file = exports.__assumedHttpMethod = exports.Route = void 0;
-var flink_1 = require("@flink-app/flink");
-exports.Route = {
-    path: "/car-with-type-schema",
-    method: flink_1.HttpMethod.get,
-    permissions: "*",
-};
-var GetCarWithTypeSchema = function (_a) {
-    var ctx = _a.ctx, req = _a.req;
-    return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_b) {
-            return [2 /*return*/, {
-                    data: {
-                        model: "Volvo",
-                    },
-                }];
-        });
-    });
-};
-exports.default = GetCarWithTypeSchema;
-exports.__assumedHttpMethod = "get", exports.__file = "GetCarWithTypeSchema.ts", exports.__query = [], exports.__params = [];
-exports.__schemas = { reqSchema: undefined, resSchema: { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "additionalProperties": false, "properties": { "model": { "type": "string" }, "metadata": { "type": "object", "properties": { "created": { "type": "string", "format": "date-time" } }, "additionalProperties": false } }, "required": ["model"], "definitions": {} } };

package/spec/mock-project/package-lock.json

@@ -1,108 +0,0 @@
-{
-  "name": "flink-test-app",
-  "version": "0.1.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "flink-test-app",
-      "version": "0.1.0",
-      "dependencies": {
-        "@flink-app/flink": "../../"
-      },
-      "devDependencies": {}
-    },
-    "../..": {
-      "name": "@flink-app/flink",
-      "version": "0.2.0-beta.3",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/cors": "^2.8.10",
-        "@types/express": "^4.17.11",
-        "@types/fs-extra": "^9.0.12",
-        "@types/mongodb": "3.6.12",
-        "@types/uuid": "^8.3.0",
-        "ajv": "^8.2.0",
-        "ajv-formats": "^2.1.0",
-        "body-parser": "^1.19.0",
-        "cors": "^2.8.5",
-        "express": "^4.17.1",
-        "folder-hash": "^4.0.1",
-        "fs-extra": "^10.0.0",
-        "mkdirp": "^1.0.4",
-        "mock-json-schema": "^1.0.8",
-        "mongodb": "^3.6.6",
-        "node-color-log": "^5.2.0",
-        "passport": "^0.4.1",
-        "passport-jwt": "^4.0.0",
-        "reflect-metadata": "^0.1.13",
-        "tiny-glob": "^0.2.9",
-        "ts-json-schema-generator": "^0.94.1",
-        "ts-morph": "^11.0.0",
-        "typescript": "4.2.3",
-        "uuid": "^8.3.2"
-      },
-      "bin": {
-        "flink": "dist/bin/flink.js"
-      },
-      "devDependencies": {
-        "@types/folder-hash": "^4.0.0",
-        "@types/jasmine": "^3.7.1",
-        "@types/json-schema": "^7.0.7",
-        "@types/mkdirp": "^1.0.1",
-        "@types/node": "^15.0.1",
-        "jasmine": "^3.7.0",
-        "jasmine-spec-reporter": "^7.0.0",
-        "jasmine-ts": "^0.3.3",
-        "nodemon": "^2.0.7",
-        "ts-node": "^9.1.1"
-      }
-    },
-    "node_modules/@flink-app/flink": {
-      "resolved": "../..",
-      "link": true
-    }
-  },
-  "dependencies": {
-    "@flink-app/flink": {
-      "version": "file:../..",
-      "requires": {
-        "@types/cors": "^2.8.10",
-        "@types/express": "^4.17.11",
-        "@types/folder-hash": "^4.0.0",
-        "@types/fs-extra": "^9.0.12",
-        "@types/jasmine": "^3.7.1",
-        "@types/json-schema": "^7.0.7",
-        "@types/mkdirp": "^1.0.1",
-        "@types/mongodb": "3.6.12",
-        "@types/node": "^15.0.1",
-        "@types/uuid": "^8.3.0",
-        "ajv": "^8.2.0",
-        "ajv-formats": "^2.1.0",
-        "body-parser": "^1.19.0",
-        "cors": "^2.8.5",
-        "express": "^4.17.1",
-        "folder-hash": "^4.0.1",
-        "fs-extra": "^10.0.0",
-        "jasmine": "^3.7.0",
-        "jasmine-spec-reporter": "^7.0.0",
-        "jasmine-ts": "^0.3.3",
-        "mkdirp": "^1.0.4",
-        "mock-json-schema": "^1.0.8",
-        "mongodb": "^3.6.6",
-        "node-color-log": "^5.2.0",
-        "nodemon": "^2.0.7",
-        "passport": "^0.4.1",
-        "passport-jwt": "^4.0.0",
-        "reflect-metadata": "^0.1.13",
-        "tiny-glob": "^0.2.9",
-        "ts-json-schema-generator": "^0.94.1",
-        "ts-morph": "^11.0.0",
-        "ts-node": "^9.1.1",
-        "typescript": "4.2.3",
-        "uuid": "^8.3.2"
-      }
-    }
-  }
-}