@flink-app/flink 0.13.3 → 0.13.5

package/src/TypeScriptCompiler.ts

@@ -409,6 +409,48 @@ export default {}; // Export an empty object to make it a module
         }
     }
 
+    /**
+     * Recursively copies an interface and all its dependencies from the same file
+     */
+    private copyInterfaceWithDependencies(interfaceDecl: any, handlerFile: SourceFile): void {
+        const interfaceName = interfaceDecl.getName?.() || interfaceDecl.getFirstChildByKind(SyntaxKind.Identifier)?.getText();
+        if (!interfaceName) return;
+
+        // Check if already copied
+        const existingInterface = this.parsedTsSchemas.find(
+            s => s.includes(`interface ${interfaceName} `) || s.includes(`type ${interfaceName} =`)
+        );
+        if (existingInterface) return;
+
+        // Copy the interface
+        this.parsedTsSchemas.push(interfaceDecl.getText());
+
+        // Find and recursively copy dependencies from the same file
+        // First, find direct type references in this interface
+        const typeRefIdentifiers = interfaceDecl
+            .getDescendantsOfKind(SyntaxKind.TypeReference)
+            .filter((typeRefNode: any) => !!typeRefNode.getFirstChildIfKind(SyntaxKind.Identifier))
+            .map((typeRefNode: any) => typeRefNode.getFirstChildIfKindOrThrow(SyntaxKind.Identifier));
+
+        for (const typeRefIdentifier of typeRefIdentifiers) {
+            const typeSymbol = typeRefIdentifier.getSymbol();
+            if (typeSymbol) {
+                const declaredType = typeSymbol.getDeclaredType();
+                const declaration = declaredType.getSymbol()?.getDeclarations()[0];
+                if (declaration && declaration.getSourceFile() === handlerFile) {
+                    // Same file - recursively copy this dependency
+                    this.copyInterfaceWithDependencies(declaration, handlerFile);
+                } else if (declaration && declaration.getSourceFile() !== handlerFile) {
+                    // Different file - add to imports
+                    const declaredTypeSymbol = declaredType.getSymbol();
+                    if (declaredTypeSymbol) {
+                        this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
+                    }
+                }
+            }
+        }
+    }
+
     private async saveIntermediateTsSchema(schema: Type<ts.Type>, handlerFile: SourceFile, suffix: string) {
         if (schema.isAny()) {
             return; // 'any' indicates that no schema is used
@@ -431,7 +473,7 @@ export default {}; // Export an empty object to make it a module
 
             if (declaration.getSourceFile() === handlerFile) {
                 // Interface is declared within handler file
-                generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} {          
+                generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} {
           ${schema
               .getProperties()
               .map((p) => p.getValueDeclarationOrThrow().getText())
@@ -439,7 +481,34 @@ export default {}; // Export an empty object to make it a module
         }`;
 
                 for (const typeToImport of getTypesToImport(declaration)) {
-                    this.tsSchemasSymbolsToImports.push(typeToImport.getSymbolOrThrow().getDeclaredType().getSymbolOrThrow());
+                    const typeSymbol = typeToImport.getSymbol();
+                    if (typeSymbol) {
+                        const declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
+                        if (declaredTypeSymbol) {
+                            this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
+                        }
+                    }
+                }
+
+                // Also check for utility types with indexed access patterns like Partial<Foo["bar"]>
+                for (const prop of schema.getProperties()) {
+                    const propDecl = prop.getValueDeclaration();
+                    if (propDecl) {
+                        const propText = propDecl.getText();
+                        // Match interface names in patterns like: Partial<InterfaceName["prop"]>
+                        const interfaceNameMatches = propText.match(/\b([A-Z][a-zA-Z0-9]*)\s*\[/g);
+                        if (interfaceNameMatches) {
+                            for (const match of interfaceNameMatches) {
+                                const referencedInterfaceName = match.replace(/\s*\[$/, '').trim();
+                                // Try to find this interface in the handler file
+                                const referencedInterfaceDecl = handlerFile.getInterface(referencedInterfaceName) || handlerFile.getTypeAlias(referencedInterfaceName);
+                                if (referencedInterfaceDecl) {
+                                    // Interface is in same file - copy it and all its dependencies recursively
+                                    this.copyInterfaceWithDependencies(referencedInterfaceDecl, handlerFile);
+                                }
+                            }
+                        }
+                    }
                 }
             } else {
                 // Interface is imported from other file
@@ -468,7 +537,13 @@ export default {}; // Export an empty object to make it a module
                 }
 
                 for (const typeToImport of getTypesToImport(declaration)) {
-                    this.tsSchemasSymbolsToImports.push(typeToImport.getSymbolOrThrow().getDeclaredType().getSymbolOrThrow());
+                    const typeSymbol = typeToImport.getSymbol();
+                    if (typeSymbol) {
+                        const declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
+                        if (declaredTypeSymbol) {
+                            this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
+                        }
+                    }
                 }
             }
         } else if (schema.isObject()) {
@@ -477,8 +552,11 @@ export default {}; // Export an empty object to make it a module
              * We need extract `{car: Car}` into its own interface and make sure
              * to import types if needed to
              */
-            const declarations = schema.getSymbolOrThrow().getDeclarations();
-            const declaration = declarations[0];
+
+            // Try to get symbol - it may not exist for utility types (Partial, Omit, Pick, etc.)
+            const schemaSymbol = schema.getSymbol();
+            const declarations = schemaSymbol?.getDeclarations();
+            const declaration = declarations?.[0];
 
             // Build property signatures using resolved types instead of source text
             // This ensures generic type parameters are properly expanded
@@ -528,6 +606,51 @@ export default {}; // Export an empty object to make it a module
                         }
                     }
                 }
+
+                // Check for utility types (Partial, Omit, Pick, etc.) and extract their type arguments
+                // For example: Partial<Foo["bar"]> should extract Foo
+                // Use a pragmatic text-based approach to find interface references in type expressions
+                // Match interface names in patterns like: Partial<InterfaceName["prop"]>, Omit<InterfaceName, "key">, etc.
+                const currentPropTypeText = propType.getText(undefined, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+                const interfaceNameMatches = currentPropTypeText.match(/\b([A-Z][a-zA-Z0-9]*)\s*\[/g);
+                if (interfaceNameMatches) {
+                    for (const match of interfaceNameMatches) {
+                        const interfaceName = match.replace(/\s*\[$/, '').trim();
+                        // Try to find this interface in the handler file
+                        const interfaceDecl = handlerFile.getInterface(interfaceName) || handlerFile.getTypeAlias(interfaceName);
+                        if (interfaceDecl) {
+                            // Interface is in same file - copy it and all its dependencies recursively
+                            this.copyInterfaceWithDependencies(interfaceDecl, handlerFile);
+                        }
+                    }
+                }
+
+                // Also check regular type arguments (for types like Array<Foo>, Promise<Bar>)
+                const typeArgs = propType.getTypeArguments();
+                if (typeArgs && typeArgs.length > 0) {
+                    for (const typeArg of typeArgs) {
+                        const argSymbol = typeArg.getSymbol();
+                        if (argSymbol) {
+                            const argDeclaration = argSymbol.getDeclarations()[0];
+                            if (argDeclaration && argDeclaration.getSourceFile() !== handlerFile) {
+                                this.tsSchemasSymbolsToImports.push(argSymbol);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // If we have a declaration, check if we need to import any types
+            if (declaration) {
+                for (const typeToImport of getTypesToImport(declaration)) {
+                    const typeSymbol = typeToImport.getSymbol();
+                    if (typeSymbol) {
+                        const declaredTypeSymbol = typeSymbol.getDeclaredType().getSymbol();
+                        if (declaredTypeSymbol) {
+                            this.tsSchemasSymbolsToImports.push(declaredTypeSymbol);
+                        }
+                    }
+                }
             }
 
             generatedSchemaInterfaceStr = `export interface ${schemaInterfaceName} { ${propertySignatures.join(";\n")} }`;

package/src/utils.ts

@@ -75,6 +75,7 @@ export function getHttpMethodFromHandlerName(handlerFilename: string) {
     if (handlerFilename.startsWith(HttpMethod.post)) return HttpMethod.post;
     if (handlerFilename.startsWith(HttpMethod.put)) return HttpMethod.put;
     if (handlerFilename.startsWith(HttpMethod.delete)) return HttpMethod.delete;
+    if (handlerFilename.startsWith(HttpMethod.patch)) return HttpMethod.patch;
 }
 
 export function getJsDocComment(comment: string) {
@@ -100,3 +101,77 @@ const pathParamsRegex = /:([a-zA-Z0-9]+)/g;
 export function getPathParams(path: string) {
     return path.match(pathParamsRegex)?.map((match) => match.slice(1)) || [];
 }
+
+/**
+ * Extracts data at a given JSON path (e.g., "/jobs/5/result")
+ * Returns the value at that path, or undefined if not found
+ */
+export function getDataAtPath(data: any, instancePath: string): any {
+    if (!instancePath || instancePath === "/") {
+        return data;
+    }
+
+    const parts = instancePath.split("/").filter((p) => p.length > 0);
+    let current = data;
+
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+
+    return current;
+}
+
+/**
+ * Formats validation errors with context about the problematic data
+ * @param errors AJV validation errors
+ * @param data The full data object that failed validation
+ * @param maxDataLength Maximum length of data to show (default 500)
+ */
+export function formatValidationErrors(errors: any[] | null | undefined, data: any, maxDataLength = 500): string {
+    if (!errors || errors.length === 0) {
+        return "Unknown validation error";
+    }
+
+    const formatted: string[] = [];
+
+    // Group errors by instance path to avoid repetition
+    const errorsByPath = new Map<string, any[]>();
+    for (const error of errors) {
+        const path = error.instancePath || "/";
+        if (!errorsByPath.has(path)) {
+            errorsByPath.set(path, []);
+        }
+        errorsByPath.get(path)!.push(error);
+    }
+
+    errorsByPath.forEach((pathErrors, path) => {
+        const dataAtPath = getDataAtPath(data, path);
+        let dataStr = JSON.stringify(dataAtPath);
+
+        // Truncate if too long
+        if (dataStr.length > maxDataLength) {
+            dataStr = dataStr.substring(0, maxDataLength) + "... (truncated)";
+        }
+
+        formatted.push(`\nPath: ${path}`);
+        formatted.push(`Data: ${dataStr}`);
+        formatted.push(`Errors:`);
+
+        for (const error of pathErrors) {
+            if (error.keyword === "required") {
+                formatted.push(`  - Missing required property: ${error.params.missingProperty}`);
+            } else if (error.keyword === "type") {
+                formatted.push(`  - Invalid type at ${error.schemaPath}: expected ${error.params.type}, got ${typeof dataAtPath}`);
+            } else if (error.keyword === "anyOf" || error.keyword === "oneOf") {
+                formatted.push(`  - ${error.message}`);
+            } else {
+                formatted.push(`  - ${error.message} (${error.keyword})`);
+            }
+        }
+    });
+
+    return formatted.join("\n");
+}