@flink-app/flink 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @flink-app/flink
 
+## 0.13.3
+
+### Patch Changes
+
+-   Use projects tsconfig.json for schema generation
+
+## 0.13.2
+
+### Patch Changes
+
+-   -   Fix schema generator to support built-in types, generic parameters, utility types, and recursive schemas.
+    -   Prevented schema generator from attempting to import built-in TypeScript types (Array, Date, etc.) from lib files.
+    -   Fixed generic type parameter resolution (e.g., PaginatedResponse<T> now correctly expands to concrete types)
+
 ## 0.13.1
 
 ### Patch Changes

package/dist/src/TypeScriptCompiler.js

@@ -482,9 +482,8 @@ var TypeScriptCompiler = /** @class */ (function () {
     };
     TypeScriptCompiler.prototype.saveIntermediateTsSchema = function (schema, handlerFile, suffix) {
         return __awaiter(this, void 0, void 0, function () {
-            var handlerFileName, generatedSchemaInterfaceStr, schemaInterfaceName, schemaSymbol, interfaceName, declaration, _i, _a, typeToImport, arrayTypeArg, schemaSymbol, interfaceName, declaration, props, _b, _c, typeToImport, declarations, declaration, typeRefIdentifiers;
-            var _this = this;
-            return __generator(this, function (_d) {
+            var handlerFileName, generatedSchemaInterfaceStr, schemaInterfaceName, schemaSymbol, interfaceName, declaration, _i, _a, typeToImport, arrayTypeArg, schemaSymbol, interfaceName, declaration, props, _b, _c, typeToImport, declarations, declaration, propertySignatures, _d, _e, prop, propType, typeSymbol, typeDeclaration, elementType, elementSymbol, elementDeclaration;
+            return __generator(this, function (_f) {
                 if (schema.isAny()) {
                     return [2 /*return*/]; // 'any' indicates that no schema is used
                 }
@@ -541,19 +540,49 @@ var TypeScriptCompiler = /** @class */ (function () {
                 else if (schema.isObject()) {
                     declarations = schema.getSymbolOrThrow().getDeclarations();
                     declaration = declarations[0];
-                    // Only extract type references if declaration exists (won't exist for empty object literals like {})
-                    if (declaration) {
-                        typeRefIdentifiers = declaration
-                            .getDescendantsOfKind(ts_morph_1.SyntaxKind.TypeReference)
-                            .map(function (typeRef) { return typeRef.getFirstChildByKindOrThrow(ts_morph_1.SyntaxKind.Identifier); });
-                        typeRefIdentifiers.forEach(function (tr) {
-                            _this.tsSchemasSymbolsToImports.push(tr.getSymbolOrThrow().getDeclaredType().getSymbolOrThrow());
-                        });
+                    propertySignatures = schema.getProperties().map(function (prop) {
+                        var propName = prop.getName();
+                        var propType = prop.getTypeAtLocation(handlerFile);
+                        var propTypeText = propType.getText(undefined, ts_morph_1.ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+                        // Check if property is optional
+                        // For utility types (Omit, Pick, etc.), properties may not have value declarations
+                        var valueDeclaration = prop.getValueDeclaration();
+                        var isOptional = false;
+                        if (valueDeclaration) {
+                            // Property has a source declaration (normal case)
+                            isOptional = valueDeclaration.getType().isNullable() || valueDeclaration.compilerNode.questionToken !== undefined;
+                        }
+                        else {
+                            // Property is synthetic (from utility types like Omit, Pick, etc.)
+                            // Check if the property itself is optional by examining the symbol flags
+                            isOptional = !!(prop.getFlags() & ts_morph_1.ts.SymbolFlags.Optional);
+                        }
+                        return "".concat(propName).concat(isOptional ? "?" : "", ": ").concat(propTypeText);
+                    });
+                    // Extract type references for imports from resolved types
+                    for (_d = 0, _e = schema.getProperties(); _d < _e.length; _d++) {
+                        prop = _e[_d];
+                        propType = prop.getTypeAtLocation(handlerFile);
+                        typeSymbol = propType.getSymbol();
+                        if (typeSymbol) {
+                            typeDeclaration = typeSymbol.getDeclarations()[0];
+                            if (typeDeclaration && typeDeclaration.getSourceFile() !== handlerFile) {
+                                this.tsSchemasSymbolsToImports.push(typeSymbol);
+                            }
+                        }
+                        // Also check for array element types
+                        if (propType.isArray()) {
+                            elementType = propType.getArrayElementType();
+                            elementSymbol = elementType === null || elementType === void 0 ? void 0 : elementType.getSymbol();
+                            if (elementSymbol) {
+                                elementDeclaration = elementSymbol.getDeclarations()[0];
+                                if (elementDeclaration && elementDeclaration.getSourceFile() !== handlerFile) {
+                                    this.tsSchemasSymbolsToImports.push(elementSymbol);
+                                }
+                            }
+                        }
                     }
-                    generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " { ").concat(schema
-                        .getProperties()
-                        .map(function (p) { return p.getValueDeclarationOrThrow().getText(); })
-                        .join("\n"), " }");
+                    generatedSchemaInterfaceStr = "export interface ".concat(schemaInterfaceName, " { ").concat(propertySignatures.join(";\n"), " }");
                 }
                 else {
                     console.log("[WARN] Unknown schema type", schema.getText());
@@ -583,7 +612,7 @@ var TypeScriptCompiler = /** @class */ (function () {
             extraTags: [],
             functions: "fail",
             discriminatorType: "json-schema",
-            // tsconfig: tsconfigPath,
+            tsconfig: tsconfigPath,
         };
         console.log("Creating TypeScript program for schema generation:");
         console.log("  Schema file:", schemaFilePath);
@@ -604,9 +633,7 @@ var TypeScriptCompiler = /** @class */ (function () {
                     if (info.file) {
                         var _b = info.file.getLineAndCharacterOfPosition(info.start), line = _b.line, character = _b.character;
                         var fileName = info.file.fileName.replace(this.cwd, ".");
-                        var message = typeof info.messageText === "string"
-                            ? info.messageText
-                            : info.messageText.messageText;
+                        var message = typeof info.messageText === "string" ? info.messageText : info.messageText.messageText;
                         console.error("  ".concat(fileName, ":").concat(line + 1, ":").concat(character + 1));
                         console.error("  ".concat(message, "\n"));
                     }

package/dist/src/TypeScriptUtils.js

@@ -71,6 +71,42 @@ function addImport(toSourceFile, symbol) {
         });
     }
 }
+/**
+ * Checks if a symbol should be filtered out from imports.
+ * Returns true for built-in types, TypeScript lib types, and generic type parameters.
+ * @param symbol
+ * @returns
+ */
+function shouldFilterSymbolFromImport(symbol) {
+    var symbolDeclaration = symbol.getDeclarations()[0];
+    if (!symbolDeclaration) {
+        return true; // Filter out symbols without declarations
+    }
+    var symbolSourceFile = symbolDeclaration.getSourceFile();
+    var sourceFilePath = symbolSourceFile.getFilePath();
+    // Filter out TypeScript lib files (lib.*.d.ts)
+    if (sourceFilePath.includes("/node_modules/typescript/lib/")) {
+        return true;
+    }
+    // Filter out common built-in global types by name
+    var symbolName = symbol.getEscapedName();
+    var builtInTypes = new Set([
+        "Array", "Date", "String", "Number", "Boolean", "Object", "Function",
+        "RegExp", "Error", "Promise", "Set", "Map", "WeakMap", "WeakSet",
+        "ArrayBuffer", "DataView", "Int8Array", "Uint8Array", "Uint8ClampedArray",
+        "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array",
+        "Readonly", "Partial", "Required", "Pick", "Record", "Exclude", "Extract", "Omit", "NonNullable",
+        "ReadonlyArray", "ReadonlyMap", "ReadonlySet"
+    ]);
+    if (builtInTypes.has(symbolName)) {
+        return true;
+    }
+    // Filter out single-letter type parameters (generic parameters like T, K, V, etc.)
+    if (symbolName.length === 1 && symbolName.match(/^[A-Z]$/)) {
+        return true;
+    }
+    return false;
+}
 /**
  * Adds imports to modules where provided symbols resides.
  * Imports are added to provided source file.
@@ -81,6 +117,10 @@ function addImports(toSourceFile, symbols) {
     var importsByModuleSpecifier = new Map();
     for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
         var symbol = symbols_1[_i];
+        // Filter out built-in types and generic parameters
+        if (shouldFilterSymbolFromImport(symbol)) {
+            continue;
+        }
         var symbolDeclaration = symbol.getDeclarations()[0];
         if (!symbolDeclaration) {
             throw new Error("Missing declaration for symbol " + symbol.getFullyQualifiedName());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flink-app/flink",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Typescript only framework for creating REST-like APIs on top of Express and mongodb",
   "types": "dist/src/index.d.ts",
   "main": "dist/src/index.js",

package/src/TypeScriptCompiler.ts

@@ -480,21 +480,57 @@ export default {}; // Export an empty object to make it a module
             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());
-                });
+            // Build property signatures using resolved types instead of source text
+            // This ensures generic type parameters are properly expanded
+            const propertySignatures = schema.getProperties().map((prop) => {
+                const propName = prop.getName();
+                const propType = prop.getTypeAtLocation(handlerFile);
+                const propTypeText = propType.getText(undefined, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+
+                // Check if property is optional
+                // For utility types (Omit, Pick, etc.), properties may not have value declarations
+                const valueDeclaration = prop.getValueDeclaration();
+                let isOptional = false;
+
+                if (valueDeclaration) {
+                    // Property has a source declaration (normal case)
+                    isOptional = valueDeclaration.getType().isNullable() || (valueDeclaration.compilerNode as any).questionToken !== undefined;
+                } else {
+                    // Property is synthetic (from utility types like Omit, Pick, etc.)
+                    // Check if the property itself is optional by examining the symbol flags
+                    isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
+                }
+
+                return `${propName}${isOptional ? "?" : ""}: ${propTypeText}`;
+            });
+
+            // Extract type references for imports from resolved types
+            for (const prop of schema.getProperties()) {
+                const propType = prop.getTypeAtLocation(handlerFile);
+
+                // Get symbol for the property type
+                const typeSymbol = propType.getSymbol();
+                if (typeSymbol) {
+                    const typeDeclaration = typeSymbol.getDeclarations()[0];
+                    if (typeDeclaration && typeDeclaration.getSourceFile() !== handlerFile) {
+                        this.tsSchemasSymbolsToImports.push(typeSymbol);
+                    }
+                }
+
+                // Also check for array element types
+                if (propType.isArray()) {
+                    const elementType = propType.getArrayElementType();
+                    const elementSymbol = elementType?.getSymbol();
+                    if (elementSymbol) {
+                        const elementDeclaration = elementSymbol.getDeclarations()[0];
+                        if (elementDeclaration && elementDeclaration.getSourceFile() !== handlerFile) {
+                            this.tsSchemasSymbolsToImports.push(elementSymbol);
+                        }
+                    }
+                }
             }
 
-            generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} { ${schema
-                .getProperties()
-                .map((p) => p.getValueDeclarationOrThrow().getText())
-                .join("\n")} }`;
+            generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} { ${propertySignatures.join(";\n")} }`;
         } else {
             console.log("[WARN] Unknown schema type", schema.getText());
         }
@@ -524,7 +560,7 @@ export default {}; // Export an empty object to make it a module
             extraTags: [],
             functions: "fail",
             discriminatorType: "json-schema",
-            // tsconfig: tsconfigPath,
+            tsconfig: tsconfigPath,
         };
 
         console.log("Creating TypeScript program for schema generation:");
@@ -546,9 +582,7 @@ export default {}; // Export an empty object to make it a module
                     if (info.file) {
                         const { line, character } = info.file.getLineAndCharacterOfPosition(info.start);
                         const fileName = info.file.fileName.replace(this.cwd, ".");
-                        const message = typeof info.messageText === "string"
-                            ? info.messageText
-                            : info.messageText.messageText;
+                        const message = typeof info.messageText === "string" ? info.messageText : info.messageText.messageText;
 
                         console.error(`  ${fileName}:${line + 1}:${character + 1}`);
                         console.error(`  ${message}\n`);

package/src/TypeScriptUtils.ts

@@ -71,6 +71,50 @@ export function addImport(toSourceFile: SourceFile, symbol: Symbol) {
     }
 }
 
+/**
+ * Checks if a symbol should be filtered out from imports.
+ * Returns true for built-in types, TypeScript lib types, and generic type parameters.
+ * @param symbol
+ * @returns
+ */
+function shouldFilterSymbolFromImport(symbol: Symbol): boolean {
+    const symbolDeclaration = symbol.getDeclarations()[0];
+
+    if (!symbolDeclaration) {
+        return true; // Filter out symbols without declarations
+    }
+
+    const symbolSourceFile = symbolDeclaration.getSourceFile();
+    const sourceFilePath = symbolSourceFile.getFilePath();
+
+    // Filter out TypeScript lib files (lib.*.d.ts)
+    if (sourceFilePath.includes("/node_modules/typescript/lib/")) {
+        return true;
+    }
+
+    // Filter out common built-in global types by name
+    const symbolName = symbol.getEscapedName();
+    const builtInTypes = new Set([
+        "Array", "Date", "String", "Number", "Boolean", "Object", "Function",
+        "RegExp", "Error", "Promise", "Set", "Map", "WeakMap", "WeakSet",
+        "ArrayBuffer", "DataView", "Int8Array", "Uint8Array", "Uint8ClampedArray",
+        "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array",
+        "Readonly", "Partial", "Required", "Pick", "Record", "Exclude", "Extract", "Omit", "NonNullable",
+        "ReadonlyArray", "ReadonlyMap", "ReadonlySet"
+    ]);
+
+    if (builtInTypes.has(symbolName)) {
+        return true;
+    }
+
+    // Filter out single-letter type parameters (generic parameters like T, K, V, etc.)
+    if (symbolName.length === 1 && symbolName.match(/^[A-Z]$/)) {
+        return true;
+    }
+
+    return false;
+}
+
 /**
  * Adds imports to modules where provided symbols resides.
  * Imports are added to provided source file.
@@ -81,6 +125,11 @@ export function addImports(toSourceFile: SourceFile, symbols: Symbol[]) {
     const importsByModuleSpecifier = new Map<string, { defaultImportName?: string; namedImports: string[] }>();
 
     for (const symbol of symbols) {
+        // Filter out built-in types and generic parameters
+        if (shouldFilterSymbolFromImport(symbol)) {
+            continue;
+        }
+
         const symbolDeclaration = symbol.getDeclarations()[0];
 
         if (!symbolDeclaration) {