@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/spec/TypeScriptSourceParser.spec.ts

@@ -0,0 +1,1215 @@
+import { TypeScriptSourceParser } from "../src/schema-extraction";
+
+describe("TypeScriptSourceParser", () => {
+    describe("detectSchemaType", () => {
+        it("should detect Zod schemas", () => {
+            const source = `
+                export const Tool: FlinkToolProps = {
+                    inputSchema: z.object({ name: z.string() })
+                }
+            `;
+            const result = TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasZodSchemas).toBe(true);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(true);
+        });
+
+        it("should detect JSON schemas", () => {
+            const source = `
+                export const Tool: FlinkToolProps = {
+                    inputJsonSchema: { type: "object" }
+                }
+            `;
+            const result = TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasJsonSchemas).toBe(true);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(true);
+        });
+
+        it("should detect neither for TypeScript-only tools", () => {
+            const source = `
+                const handler: FlinkTool<Ctx, Input, Output> = async () => {};
+            `;
+            const result = TypeScriptSourceParser.detectSchemaType(source);
+            expect(result.hasZodSchemas).toBe(false);
+            expect(result.hasJsonSchemas).toBe(false);
+            expect(result.shouldSkipTypeScriptExtraction).toBe(false);
+        });
+    });
+
+    describe("parseFlinkToolTypeArgs", () => {
+        it("should extract type arguments from FlinkTool declaration", () => {
+            const source = `const handler: FlinkTool<Ctx, CreateDocInput, ToolResult<DocOutput>> = async () => {};`;
+            const result = TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+
+            expect(result).toEqual({
+                contextType: "Ctx",
+                inputType: "CreateDocInput",
+                outputType: "ToolResult<DocOutput>",
+            });
+        });
+
+        it("should handle inline object types", () => {
+            const source = `const handler: FlinkTool<Ctx, { foo: string }, ToolResult<Output>> = async () => {};`;
+            const result = TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+
+            expect(result?.inputType).toBe("{ foo: string }");
+        });
+
+        it("should handle empty object input", () => {
+            const source = `const handler: FlinkTool<Ctx, {}, ToolResult<Output>> = async () => {};`;
+            const result = TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+
+            expect(result?.inputType).toBe("{}");
+        });
+
+        it("should return null if no FlinkTool found", () => {
+            const source = `const handler = async () => {};`;
+            const result = TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+
+            expect(result).toBeNull();
+        });
+
+        it("should handle whitespace variations", () => {
+            const source = `const handler: FlinkTool<Ctx,Input,Output> = async () => {};`;
+            const result = TypeScriptSourceParser.parseFlinkToolTypeArgs(source);
+
+            expect(result).toEqual({
+                contextType: "Ctx",
+                inputType: "Input",
+                outputType: "Output",
+            });
+        });
+    });
+
+    describe("shouldGenerateSchema", () => {
+        it("should return false for 'any'", () => {
+            expect(TypeScriptSourceParser.shouldGenerateSchema("any")).toBe(false);
+        });
+
+        it("should return false for primitives", () => {
+            expect(TypeScriptSourceParser.shouldGenerateSchema("string")).toBe(false);
+            expect(TypeScriptSourceParser.shouldGenerateSchema("number")).toBe(false);
+            expect(TypeScriptSourceParser.shouldGenerateSchema("boolean")).toBe(false);
+        });
+
+        it("should return true for inline objects", () => {
+            expect(TypeScriptSourceParser.shouldGenerateSchema("{}")).toBe(true);
+            expect(TypeScriptSourceParser.shouldGenerateSchema("{ foo: string }")).toBe(true);
+        });
+
+        it("should return true for named types", () => {
+            expect(TypeScriptSourceParser.shouldGenerateSchema("User")).toBe(true);
+            expect(TypeScriptSourceParser.shouldGenerateSchema("CreateDocInput")).toBe(true);
+        });
+    });
+
+    describe("unwrapToolResultType", () => {
+        it("should extract type from ToolResult<T>", () => {
+            expect(TypeScriptSourceParser.unwrapToolResultType("ToolResult<DocOutput>")).toBe("DocOutput");
+        });
+
+        it("should handle complex generic types", () => {
+            expect(TypeScriptSourceParser.unwrapToolResultType("ToolResult<Array<Doc>>")).toBe("Array<Doc>");
+        });
+
+        it("should return as-is if not ToolResult", () => {
+            expect(TypeScriptSourceParser.unwrapToolResultType("DocOutput")).toBe("DocOutput");
+        });
+    });
+
+    describe("convertInlineObjectToInterface", () => {
+        it("should convert empty object", () => {
+            const result = TypeScriptSourceParser.convertInlineObjectToInterface("{}", "MyInput");
+            expect(result).toBe("export interface MyInput {}");
+        });
+
+        it("should convert single property", () => {
+            const result = TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string }", "MyInput");
+            expect(result).toContain("export interface MyInput");
+            expect(result).toContain("foo: string;");
+        });
+
+        it("should convert multiple properties", () => {
+            const result = TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string; bar: number }", "MyInput");
+            expect(result).toContain("export interface MyInput");
+            expect(result).toContain("foo: string;");
+            expect(result).toContain("bar: number;");
+        });
+
+        it("should handle properties with commas", () => {
+            const result = TypeScriptSourceParser.convertInlineObjectToInterface("{ foo: string, bar: number }", "MyInput");
+            expect(result).toContain("foo: string");
+            expect(result).toContain("bar: number");
+        });
+    });
+
+    describe("findTypeDefinition", () => {
+        it("should find interface definitions", () => {
+            const source = `
+                interface User {
+                    name: string;
+                    age: number;
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "User");
+
+            expect(result).not.toBeNull();
+            expect(result?.kind).toBe("interface");
+            expect(result?.name).toBe("User");
+            expect(result?.definition).toContain("interface User");
+        });
+
+        it("should find type alias definitions", () => {
+            const source = `
+                type UserId = string;
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "UserId");
+
+            expect(result).not.toBeNull();
+            expect(result?.kind).toBe("type");
+            expect(result?.name).toBe("UserId");
+        });
+
+        it("should find interfaces with JSDoc", () => {
+            const source = `
+                /**
+                 * User model
+                 */
+                interface User {
+                    name: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "User");
+
+            expect(result).not.toBeNull();
+            expect(result?.definition).toContain("/**");
+        });
+
+        it("should return null for non-existent types", () => {
+            const source = `interface User { name: string; }`;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "NonExistent");
+
+            expect(result).toBeNull();
+        });
+
+        it("should handle interfaces with generics", () => {
+            const source = `
+                interface List<T> {
+                    items: T[];
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "List");
+
+            expect(result).not.toBeNull();
+            expect(result?.definition).toContain("interface List<T>");
+        });
+
+        it("should handle interfaces with extends", () => {
+            const source = `
+                interface Admin extends User {
+                    role: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "Admin");
+
+            expect(result).not.toBeNull();
+            expect(result?.definition).toContain("extends User");
+        });
+
+        it("should handle interfaces with nested objects", () => {
+            const source = `
+                interface ToolOutput {
+                    content: string;
+                    metadata?: {
+                        title: string;
+                        documentId: string;
+                        modifiedTime?: string | null;
+                    };
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "ToolOutput");
+
+            expect(result).not.toBeNull();
+            expect(result?.kind).toBe("interface");
+            expect(result?.definition).toContain("interface ToolOutput");
+            expect(result?.definition).toContain("content: string");
+            expect(result?.definition).toContain("metadata?:");
+            expect(result?.definition).toContain("title: string");
+            expect(result?.definition).toContain("modifiedTime?: string | null");
+
+            // Critical: Must include BOTH closing braces
+            const braceCount = (result?.definition.match(/}/g) || []).length;
+            expect(braceCount).toBe(2); // One for nested object, one for interface
+        });
+
+        it("should handle deeply nested objects", () => {
+            const source = `
+                interface Complex {
+                    level1: {
+                        level2: {
+                            level3: string;
+                        };
+                        other: number;
+                    };
+                    sibling: boolean;
+                }
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "Complex");
+
+            expect(result).not.toBeNull();
+            expect(result?.definition).toContain("level3: string");
+            expect(result?.definition).toContain("sibling: boolean");
+
+            // Must have 3 closing braces: level2's object, level1's object, and the interface itself
+            const braceCount = (result?.definition.match(/}/g) || []).length;
+            expect(braceCount).toBe(3);
+        });
+
+        // Regression: issue #77 - object type alias without a trailing semicolon
+        it("should find object type alias without trailing semicolon", () => {
+            const source = `
+                type Params = {
+                    id: string
+                    jti: string
+                }
+
+                const handler = async () => {}
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "Params");
+
+            expect(result).not.toBeNull();
+            expect(result?.kind).toBe("type");
+            expect(result?.name).toBe("Params");
+            expect(result?.definition).toContain("id: string");
+            expect(result?.definition).toContain("jti: string");
+            // Must stop at the object's closing brace, not run into the handler body
+            expect(result?.definition).not.toContain("const handler");
+        });
+
+        it("should find object type alias without trailing semicolon at EOF", () => {
+            const source = `type Params = {\n    id: string\n    jti: string\n}`;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "Params");
+
+            expect(result).not.toBeNull();
+            expect(result?.kind).toBe("type");
+            expect(result?.definition).toContain("id: string");
+            expect(result?.definition).toContain("jti: string");
+        });
+
+        it("should capture full union type alias spanning braces without trailing semicolon", () => {
+            const source = `
+                type Shape = { a: string } | { b: number }
+
+                const x = 1
+            `;
+            const result = TypeScriptSourceParser.findTypeDefinition(source, "Shape");
+
+            expect(result).not.toBeNull();
+            expect(result?.definition).toContain("a: string");
+            expect(result?.definition).toContain("b: number");
+            expect(result?.definition).not.toContain("const x");
+        });
+    });
+
+    describe("renameTypeDefinition", () => {
+        it("should rename interface", () => {
+            const def = "interface User { name: string; }";
+            const result = TypeScriptSourceParser.renameTypeDefinition(def, "User", "Person");
+
+            expect(result).toBe("export interface Person { name: string; }");
+        });
+
+        it("should rename type alias", () => {
+            const def = "type UserId = string;";
+            const result = TypeScriptSourceParser.renameTypeDefinition(def, "UserId", "PersonId");
+
+            expect(result).toBe("export type PersonId = string;");
+        });
+
+        it("should not export if exportIt is false", () => {
+            const def = "interface User { name: string; }";
+            const result = TypeScriptSourceParser.renameTypeDefinition(def, "User", "Person", false);
+
+            expect(result).toBe("interface Person { name: string; }");
+        });
+    });
+
+    describe("extractReferencedTypes", () => {
+        it("should extract type references from interface", () => {
+            const def = `
+                interface Document {
+                    author: User;
+                    tags: Tag[];
+                    metadata: Metadata;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).toContain("User");
+            expect(result).toContain("Tag");
+            expect(result).toContain("Metadata");
+        });
+
+        it("should not extract built-in types", () => {
+            const def = `
+                interface Doc {
+                    title: string;
+                    count: number;
+                    date: Date;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).not.toContain("Date");
+            expect(result.length).toBe(0);
+        });
+
+        it("should not extract types from JSDoc comments", () => {
+            const def = `
+                /**
+                 * Title for the document
+                 * Optional user info
+                 */
+                interface Doc {
+                    title: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).not.toContain("Title");
+            expect(result).not.toContain("Optional");
+        });
+
+        it("should handle union types", () => {
+            const def = `
+                interface Result {
+                    data: Success | Error;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).toContain("Success");
+            expect(result).toContain("Error");
+        });
+
+        it("should handle intersection types", () => {
+            const def = `
+                interface Combined {
+                    data: Base & Extra;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).toContain("Base");
+            expect(result).toContain("Extra");
+        });
+
+        it("should handle Array generics", () => {
+            const def = `
+                interface List {
+                    items: Array<Item>;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result).toContain("Item");
+        });
+
+        it("should not include duplicates", () => {
+            const def = `
+                interface Doc {
+                    author: User;
+                    editor: User;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractReferencedTypes(def);
+
+            expect(result.filter((t: string) => t === "User").length).toBe(1);
+        });
+    });
+
+    describe("isInlineObjectType", () => {
+        it("should return true for inline objects", () => {
+            expect(TypeScriptSourceParser.isInlineObjectType("{}")).toBe(true);
+            expect(TypeScriptSourceParser.isInlineObjectType("{ foo: string }")).toBe(true);
+        });
+
+        it("should return false for named types", () => {
+            expect(TypeScriptSourceParser.isInlineObjectType("User")).toBe(false);
+            expect(TypeScriptSourceParser.isInlineObjectType("CreateDocInput")).toBe(false);
+        });
+    });
+
+    describe("isBuiltInType", () => {
+        it("should return true for built-in types", () => {
+            expect(TypeScriptSourceParser.isBuiltInType("String")).toBe(true);
+            expect(TypeScriptSourceParser.isBuiltInType("Array")).toBe(true);
+            expect(TypeScriptSourceParser.isBuiltInType("Promise")).toBe(true);
+        });
+
+        it("should return false for custom types", () => {
+            expect(TypeScriptSourceParser.isBuiltInType("User")).toBe(false);
+            expect(TypeScriptSourceParser.isBuiltInType("CustomType")).toBe(false);
+        });
+    });
+
+    describe("parseJsDocDescription", () => {
+        it("should parse single-line JSDoc comment", () => {
+            const result = TypeScriptSourceParser.parseJsDocDescription("/** Max cars to retrieve */");
+            expect(result).toBe("Max cars to retrieve");
+        });
+
+        it("should parse multi-line JSDoc comment", () => {
+            const jsDoc = `/**
+             * Max cars to retrieve
+             * from the database
+             */`;
+            const result = TypeScriptSourceParser.parseJsDocDescription(jsDoc);
+            expect(result).toBe("Max cars to retrieve from the database");
+        });
+
+        it("should return empty string for empty input", () => {
+            expect(TypeScriptSourceParser.parseJsDocDescription("")).toBe("");
+        });
+
+        it("should handle JSDoc with extra whitespace", () => {
+            const jsDoc = `/**
+             *    Max items
+             *    to process
+             */`;
+            const result = TypeScriptSourceParser.parseJsDocDescription(jsDoc);
+            expect(result).toBe("Max items to process");
+        });
+
+        it("should handle JSDoc without leading asterisks", () => {
+            const result = TypeScriptSourceParser.parseJsDocDescription("/** Simple description */");
+            expect(result).toBe("Simple description");
+        });
+    });
+
+    describe("extractPropertiesFromObjectType", () => {
+        it("should extract properties with JSDoc comments", () => {
+            const objectBody = `
+                /** Max cars to retrieve */
+                limit: string;
+                /** Current page number */
+                page: number;
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max cars to retrieve" },
+                { name: "page", description: "Current page number" }
+            ]);
+        });
+
+        it("should extract properties without JSDoc comments", () => {
+            const objectBody = `
+                limit: string;
+                page: number;
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "limit", description: "" },
+                { name: "page", description: "" }
+            ]);
+        });
+
+        it("should handle optional properties", () => {
+            const objectBody = `
+                /** Max items */
+                limit: string;
+                page?: number;
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max items" },
+                { name: "page", description: "" }
+            ]);
+        });
+
+        it("should handle mixed JSDoc presence", () => {
+            const objectBody = `
+                /** Max items */
+                limit: string;
+                page: number;
+                /** Sort order */
+                sort?: string;
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max items" },
+                { name: "page", description: "" },
+                { name: "sort", description: "Sort order" }
+            ]);
+        });
+
+        it("should handle empty object body", () => {
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType("");
+            expect(result).toEqual([]);
+        });
+
+        it("should handle complex property types", () => {
+            const objectBody = `
+                /** Array of IDs */
+                ids: string[];
+                /** Nested object */
+                metadata: { key: string; value: string };
+                /** Union type */
+                status: "active" | "inactive";
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "ids", description: "Array of IDs" },
+                { name: "metadata", description: "Nested object" },
+                { name: "status", description: "Union type" }
+            ]);
+        });
+
+        it("should handle multi-line JSDoc comments", () => {
+            const objectBody = `
+                /**
+                 * Maximum number of items
+                 * to retrieve from the API
+                 */
+                limit: string;
+                page: number;
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "limit", description: "Maximum number of items to retrieve from the API" },
+                { name: "page", description: "" }
+            ]);
+        });
+
+        // Regression: issue #77 - newline-separated properties without `;`/`,` delimiters
+        it("should extract all properties separated only by newlines", () => {
+            const objectBody = `
+                callId: string
+                userId: string
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "callId", description: "" },
+                { name: "userId", description: "" }
+            ]);
+        });
+
+        it("should extract newline-separated properties with JSDoc and no delimiters", () => {
+            const objectBody = `
+                /** The call id */
+                callId: string
+                /** The user id */
+                userId: string
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "callId", description: "The call id" },
+                { name: "userId", description: "The user id" }
+            ]);
+        });
+
+        it("should not split multi-line union types separated by leading pipes", () => {
+            const objectBody = `
+                status:
+                    | "active"
+                    | "inactive"
+                limit: number
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "status", description: "" },
+                { name: "limit", description: "" }
+            ]);
+        });
+
+        it("should handle newline-separated nested objects without delimiters", () => {
+            const objectBody = `
+                meta: {
+                    title: string
+                }
+                limit: number
+            `;
+            const result = TypeScriptSourceParser.extractPropertiesFromObjectType(objectBody);
+
+            expect(result).toEqual([
+                { name: "meta", description: "" },
+                { name: "limit", description: "" }
+            ]);
+        });
+    });
+
+    describe("copyTypeWithDependencies", () => {
+        it("should copy a simple interface with no dependencies", () => {
+            const source = `
+                interface User {
+                    name: string;
+                    age: number;
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "User", "UserSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface UserSchema");
+            expect(result.mainDefinition).toContain("name: string");
+            expect(result.dependencies.length).toBe(0);
+            expect(result.copiedTypes.has("User")).toBe(true);
+        });
+
+        it("should copy interface with dependencies recursively", () => {
+            const source = `
+                interface User {
+                    profile: Profile;
+                }
+                interface Profile {
+                    name: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "User", "UserSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface UserSchema");
+            expect(result.dependencies.length).toBe(1);
+            expect(result.dependencies[0]).toContain("export interface Profile");
+            expect(result.copiedTypes.has("User")).toBe(true);
+            expect(result.copiedTypes.has("Profile")).toBe(true);
+        });
+
+        it("should handle inline object types", () => {
+            const source = "";
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "{ foo: string }", "FooSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface FooSchema");
+            expect(result.mainDefinition).toContain("foo: string");
+            expect(result.dependencies.length).toBe(0);
+        });
+
+        it("should not copy already-copied types", () => {
+            const source = `
+                interface User {
+                    profile: Profile;
+                }
+                interface Profile {
+                    name: string;
+                }
+            `;
+            const copiedTypes = new Set(["Profile"]);
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "User", "UserSchema", copiedTypes);
+
+            expect(result.mainDefinition).toContain("export interface UserSchema");
+            expect(result.dependencies.length).toBe(0); // Profile already copied
+        });
+
+        it("should skip built-in types", () => {
+            const source = `
+                interface User {
+                    name: string;
+                    createdAt: Date;
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "User", "UserSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface UserSchema");
+            expect(result.dependencies.length).toBe(0); // Date is built-in
+        });
+
+        it("should return null mainDefinition for non-existent type", () => {
+            const source = "interface Foo { bar: string; }";
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "NonExistent", "Schema", new Set());
+
+            expect(result.mainDefinition).toBeNull();
+            expect(result.dependencies.length).toBe(0);
+            expect(result.imports.length).toBe(0);
+        });
+
+        it("should extract imports for referenced types from other files", () => {
+            const source = `
+                import { TextSpan } from './TextSpan';
+                import { Element } from '../Canvas';
+
+                interface UpdateInput {
+                    elementId: string;
+                    content: string | TextSpan[];
+                    element: Element;
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "UpdateInput", "UpdateInputSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface UpdateInputSchema");
+            expect(result.mainDefinition).toContain("TextSpan");
+            expect(result.mainDefinition).toContain("Element");
+            expect(result.imports.length).toBe(2);
+            expect(result.imports).toContain('import { TextSpan } from \'./TextSpan\'');
+            expect(result.imports).toContain('import { Element } from \'../Canvas\'');
+            expect(result.copiedTypes.has("UpdateInput")).toBe(true);
+            expect(result.copiedTypes.has("TextSpan")).toBe(true);
+            expect(result.copiedTypes.has("Element")).toBe(true);
+        });
+
+        it("should handle mixed local and imported types", () => {
+            const source = `
+                import { Address } from './Address';
+
+                interface Profile {
+                    name: string;
+                }
+
+                interface User {
+                    profile: Profile;
+                    address: Address;
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "User", "UserSchema", new Set());
+
+            expect(result.mainDefinition).toContain("export interface UserSchema");
+            expect(result.dependencies.length).toBe(1); // Profile is local
+            expect(result.dependencies[0]).toContain("export interface Profile");
+            expect(result.imports.length).toBe(1); // Address is imported
+            expect(result.imports[0]).toContain('import { Address } from \'./Address\'');
+            expect(result.copiedTypes.has("User")).toBe(true);
+            expect(result.copiedTypes.has("Profile")).toBe(true);
+            expect(result.copiedTypes.has("Address")).toBe(true);
+        });
+
+        it("should not duplicate imports", () => {
+            const source = `
+                import { TextSpan } from './TextSpan';
+
+                interface UpdateInput {
+                    title: TextSpan;
+                    content: TextSpan[];
+                }
+            `;
+            const result = TypeScriptSourceParser.copyTypeWithDependencies(source, "UpdateInput", "UpdateInputSchema", new Set());
+
+            expect(result.imports.length).toBe(1); // Only one import for TextSpan
+            expect(result.imports[0]).toContain('import { TextSpan } from \'./TextSpan\'');
+        });
+    });
+
+    describe("extractImportForType", () => {
+        it("should extract import type statements", () => {
+            const source = `
+                import type { User } from '../schemas/User';
+                import type Profile from '../schemas/Profile';
+            `;
+            const userImport = TypeScriptSourceParser.extractImportForType(source, 'User');
+            const profileImport = TypeScriptSourceParser.extractImportForType(source, 'Profile');
+
+            expect(userImport).toBe("import type { User } from '../schemas/User'");
+            expect(profileImport).toBe("import type Profile from '../schemas/Profile'");
+        });
+
+    describe("extractImportForType (original tests)", () => {
+        it("should extract named import", () => {
+            const source = `
+                import { User } from '../schemas/User';
+                import Profile from '../schemas/Profile';
+            `;
+            const result = TypeScriptSourceParser.extractImportForType(source, "User");
+
+            expect(result).toBe("import { User } from '../schemas/User'");
+        });
+
+        it("should extract default import", () => {
+            const source = `
+                import { User } from '../schemas/User';
+                import Profile from '../schemas/Profile';
+            `;
+            const result = TypeScriptSourceParser.extractImportForType(source, "Profile");
+
+            expect(result).toBe("import Profile from '../schemas/Profile'");
+        });
+
+        it("should return null for non-existent import", () => {
+            const source = "import { User } from '../schemas/User';";
+            const result = TypeScriptSourceParser.extractImportForType(source, "NonExistent");
+
+            expect(result).toBeNull();
+        });
+
+        it("should handle multiple named imports", () => {
+            const source = "import { User, Profile, Settings } from '../types';";
+            const result = TypeScriptSourceParser.extractImportForType(source, "Profile");
+
+            expect(result).toBe("import { User, Profile, Settings } from '../types'");
+        });
+    });  // end of nested describe
+    });  // end of extractImportForType
+
+    describe("adjustImportPathForSchemas", () => {
+        it("should adjust path for schemas directory", () => {
+            const importStmt = 'import { User } from "../schemas/User"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { User } from "../../src/schemas/User"');
+        });
+
+        it("should handle double-dot paths", () => {
+            const importStmt = 'import Profile from "../../schemas/Profile"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import Profile from "../../src/schemas/Profile"');
+        });
+
+        it("should adjust relative imports from clients directory", () => {
+            const importStmt = 'import { Client } from "../clients/SupermetricsClient"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { Client } from "../../src/clients/SupermetricsClient"');
+        });
+
+        it("should adjust relative imports from any directory", () => {
+            const importStmt = 'import { Util } from "../utils/helper"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { Util } from "../../src/utils/helper"');
+        });
+
+        it("should adjust relative imports from nested directories", () => {
+            const importStmt = 'import { Type } from "../../types/User"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { Type } from "../../src/types/User"');
+        });
+
+        it("should not modify package imports", () => {
+            const importStmt = 'import { User } from "@company/shared"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { User } from "@company/shared"');
+        });
+
+        it("should handle single quotes", () => {
+            const importStmt = "import { User } from '../schemas/User'";
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe("import { User } from '../../src/schemas/User'");
+        });
+
+        it("should preserve subdirectory structure", () => {
+            const importStmt = 'import { DeleteReq } from "../../schemas/User/DeleteReq"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { DeleteReq } from "../../src/schemas/User/DeleteReq"');
+        });
+
+        it("should preserve nested subdirectory structure", () => {
+            const importStmt = 'import { Type } from "../schemas/Management/User/Type"';
+            const result = TypeScriptSourceParser.adjustImportPathForSchemas(importStmt);
+
+            expect(result).toBe('import { Type } from "../../src/schemas/Management/User/Type"');
+        });
+    });
+
+    describe("consolidateImports", () => {
+        it("should consolidate duplicate imports from same module", () => {
+            const imports = [
+                'import { Ad } from "../../src/schemas/Ad"',
+                'import { AdStatus } from "../../src/schemas/Ad"',
+                'import { User } from "../../src/schemas/User"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result).toContain('import { Ad, AdStatus } from "../../src/schemas/Ad"');
+            expect(result).toContain('import { User } from "../../src/schemas/User"');
+            expect(result.length).toBe(2);
+        });
+
+        it("should handle multiple imports from same module", () => {
+            const imports = [
+                'import { Ad } from "../../src/schemas/Ad"',
+                'import { AdStatus, CreateAdRequest } from "../../src/schemas/Ad"',
+                'import { AdProgressResponse } from "../../src/schemas/Ad"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result).toContain('import { Ad, AdProgressResponse, AdStatus, CreateAdRequest } from "../../src/schemas/Ad"');
+            expect(result.length).toBe(1);
+        });
+
+        it("should preserve default imports", () => {
+            const imports = [
+                'import React from "react"',
+                'import { useState } from "react"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result).toContain('import React, { useState } from "react"');
+            expect(result.length).toBe(1);
+        });
+
+        it("should handle single quotes", () => {
+            const imports = [
+                "import { Ad } from '../../src/schemas/Ad'",
+                "import { AdStatus } from '../../src/schemas/Ad'",
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result[0]).toContain('from "../../src/schemas/Ad"');
+        });
+
+        it("should deduplicate named imports", () => {
+            const imports = [
+                'import { Ad } from "../../src/schemas/Ad"',
+                'import { Ad, AdStatus } from "../../src/schemas/Ad"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            // Ad should only appear once in the named imports (not counting the module path)
+            const importStatement = result.find((s) => s.includes("../../src/schemas/Ad"))!;
+            // Extract just the import list part: { Ad, AdStatus }
+            const importListMatch = importStatement.match(/\{([^}]+)\}/);
+            expect(importListMatch).toBeTruthy();
+            const importList = importListMatch![1];
+            const adMatches = (importList.match(/\bAd\b/g) || []).length;
+            expect(adMatches).toBe(1); // "Ad" appears once, "AdStatus" doesn't count
+            expect(importStatement).toContain("AdStatus");
+        });
+
+        it("should handle imports from different modules", () => {
+            const imports = [
+                'import { User } from "../../src/schemas/User"',
+                'import { Client } from "../../src/clients/SupermetricsClient"',
+                'import { BudgetPeriod } from "../../src/schemas/BudgetPeriod"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result.length).toBe(3);
+            expect(result).toContain('import { User } from "../../src/schemas/User"');
+            expect(result).toContain('import { Client } from "../../src/clients/SupermetricsClient"');
+            expect(result).toContain('import { BudgetPeriod } from "../../src/schemas/BudgetPeriod"');
+        });
+
+        it("should sort named imports alphabetically", () => {
+            const imports = [
+                'import { ZebraType } from "../../src/schemas/Types"',
+                'import { AppleType } from "../../src/schemas/Types"',
+                'import { BananaType } from "../../src/schemas/Types"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result[0]).toBe('import { AppleType, BananaType, ZebraType } from "../../src/schemas/Types"');
+        });
+
+        it("should handle import type statements", () => {
+            const imports = [
+                'import type { User } from "../../src/schemas/User"',
+                'import type { Profile } from "../../src/schemas/User"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            // Note: We consolidate by removing the 'type' keyword for runtime schema generation
+            expect(result[0]).toBe('import { Profile, User } from "../../src/schemas/User"');
+        });
+
+        it("should consolidate mixed import and import type", () => {
+            const imports = [
+                'import { User } from "../../src/schemas/User"',
+                'import type { UserRole } from "../../src/schemas/User"',
+            ];
+            const result = TypeScriptSourceParser.consolidateImports(imports);
+
+            expect(result[0]).toBe('import { User, UserRole } from "../../src/schemas/User"');
+        });
+    });
+
+    describe("extractPropertyMetadata", () => {
+        it("should extract properties from interface definition", () => {
+            const source = `
+                interface Query {
+                    /** Max cars to retrieve */
+                    limit: string;
+                    page?: number;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max cars to retrieve" },
+                { name: "page", description: "" }
+            ]);
+        });
+
+        it("should extract properties from type alias", () => {
+            const source = `
+                type Query = {
+                    /** Max items */
+                    limit: string;
+                    /** Current page */
+                    page: number;
+                };
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max items" },
+                { name: "page", description: "Current page" }
+            ]);
+        });
+
+        it("should return null for non-existent type", () => {
+            const source = `
+                interface User {
+                    name: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+            expect(result).toBeNull();
+        });
+
+        // Regression: issue #77 - semicolon-free type alias used as handler Params
+        it("should extract all params from a semicolon-free type alias (issue #77 case A)", () => {
+            const source = `
+                type Params = {
+                    callId: string
+                    userId: string
+                }
+
+                const handler: Handler<Ctx, void, void, Params> = async () => {}
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Params");
+
+            expect(result).toEqual([
+                { name: "callId", description: "" },
+                { name: "userId", description: "" }
+            ]);
+        });
+
+        it("should extract all params from an inline semicolon-free type alias (issue #77 case B)", () => {
+            const source = `
+                type Params = { id: string; jti: string }
+
+                const handler: Handler<Ctx, void, {}, Params> = async () => {}
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Params");
+
+            expect(result).toEqual([
+                { name: "id", description: "" },
+                { name: "jti", description: "" }
+            ]);
+        });
+
+        it("should handle empty interface", () => {
+            const source = `
+                interface Query {}
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+            expect(result).toEqual([]);
+        });
+
+        it("should handle nested object properties", () => {
+            const source = `
+                interface Query {
+                    /** Filter options */
+                    filter: {
+                        /** Start date */
+                        startDate: string;
+                        /** End date */
+                        endDate: string;
+                    };
+                    /** Max items */
+                    limit: number;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "filter", description: "Filter options" },
+                { name: "limit", description: "Max items" }
+            ]);
+        });
+
+        it("should handle properties without JSDoc", () => {
+            const source = `
+                interface Params {
+                    id: string;
+                    category: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Params");
+
+            expect(result).toEqual([
+                { name: "id", description: "" },
+                { name: "category", description: "" }
+            ]);
+        });
+
+        it("should handle interface with generics", () => {
+            const source = `
+                interface Query<T> {
+                    /** Max items */
+                    limit: string;
+                    data: T;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max items" },
+                { name: "data", description: "" }
+            ]);
+        });
+
+        it("should handle interface with extends", () => {
+            const source = `
+                interface Query extends BaseQuery {
+                    /** Max items */
+                    limit: string;
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max items" }
+            ]);
+        });
+
+        it("should extract from real-world handler example", () => {
+            const source = `
+                import { GetHandler, RouteProps } from "@flink-app/flink";
+
+                type Query = {
+                    /**
+                     * Max cars to retrieve
+                     */
+                    limit: string;
+                };
+
+                const GetCars: GetHandler<any, CarListRes, any, Query> = async ({ ctx, req }) => {
+                    return { data: { cars: [] } };
+                };
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "limit", description: "Max cars to retrieve" }
+            ]);
+        });
+
+        it("should handle properties with complex types", () => {
+            const source = `
+                interface Query {
+                    /** Array of IDs */
+                    ids: string[];
+                    /** Date range */
+                    range: { start: Date; end: Date };
+                    /** Status filter */
+                    status: "active" | "inactive" | "pending";
+                }
+            `;
+            const result = TypeScriptSourceParser.extractPropertyMetadata(source, "Query");
+
+            expect(result).toEqual([
+                { name: "ids", description: "Array of IDs" },
+                { name: "range", description: "Date range" },
+                { name: "status", description: "Status filter" }
+            ]);
+        });
+    });
+});