ts-runtime-validation 1.8.1 → 1.8.3

package/src/services/SchemaProcessor.test.ts

@@ -414,6 +414,240 @@ describe("SchemaProcessor", () => {
         });
     });
 
+    describe("single-pass processing", () => {
+        it("should use single-pass when glob and rootPath are provided with multiple files", async () => {
+            const file1 = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("product.jsonschema.ts", `
+                export interface IProduct {
+                    id: string;
+                    title: string;
+                    price: number;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false,
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(2);
+            expect(schemaMap.has(file1)).toBe(true);
+            expect(schemaMap.has(file2)).toBe(true);
+
+            // Both files should have all definitions (single-pass partitioning)
+            const schema1 = schemaMap.get(file1)!;
+            const schema2 = schemaMap.get(file2)!;
+            expect(schema1.definitions!.IUser).toBeDefined();
+            expect(schema1.definitions!.IProduct).toBeDefined();
+            expect(schema2.definitions!.IUser).toBeDefined();
+            expect(schema2.definitions!.IProduct).toBeDefined();
+        });
+
+        it("should fall back to per-file processing when duplicate type names exist", async () => {
+            const file1 = await createTestFile("a/types.jsonschema.ts", `
+                export interface IDuplicate {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("b/types.jsonschema.ts", `
+                export interface IDuplicate {
+                    id: string;
+                    email: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false,
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+
+            // Falls back to per-file: each file only has its own definitions
+            const schema1 = schemaMap.get(file1)!;
+            const schema2 = schemaMap.get(file2)!;
+            expect(schema1.definitions!.IDuplicate).toBeDefined();
+            expect(schema2.definitions!.IDuplicate).toBeDefined();
+
+            // The schemas should differ (different implementations)
+            expect((schema1.definitions!.IDuplicate as any).properties.name).toBeDefined();
+            expect((schema2.definitions!.IDuplicate as any).properties.email).toBeDefined();
+        });
+
+        it("should not use single-pass for a single file", async () => {
+            const file1 = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false,
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files: FileInfo[] = [{ path: file1 }];
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(1);
+            const schema = schemaMap.get(file1)!;
+            expect(schema.definitions!.IUser).toBeDefined();
+        });
+
+        it("should not use single-pass when glob is not provided", async () => {
+            const file1 = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("product.jsonschema.ts", `
+                export interface IProduct {
+                    id: string;
+                    title: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false
+                // no glob or rootPath
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(2);
+            // Per-file: each file only has its own definitions
+            const schema1 = schemaMap.get(file1)!;
+            expect(schema1.definitions!.IUser).toBeDefined();
+            expect(schema1.definitions!.IProduct).toBeUndefined();
+        });
+
+        it("should include referenced types from non-schema files in single-pass output", async () => {
+            await createTestFile("shared/BaseType.ts", `
+                export interface IBaseType {
+                    id: string;
+                }
+            `);
+
+            const file1 = await createTestFile("a.jsonschema.ts", `
+                import { IBaseType } from "./shared/BaseType";
+                export interface ITypeA {
+                    base: IBaseType;
+                }
+            `);
+
+            const file2 = await createTestFile("b.jsonschema.ts", `
+                import { IBaseType } from "./shared/BaseType";
+                export interface ITypeB {
+                    base: IBaseType;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false,
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+            const mergedSchema = processor.mergeSchemas(schemaMap);
+
+            // IBaseType should appear in the merged output even though
+            // it's not directly in a .jsonschema.ts file
+            expect(mergedSchema.definitions!.IBaseType).toBeDefined();
+            expect(mergedSchema.definitions!.ITypeA).toBeDefined();
+            expect(mergedSchema.definitions!.ITypeB).toBeDefined();
+        });
+
+        it("should produce same merged schema whether using single-pass or per-file", async () => {
+            const file1 = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("product.jsonschema.ts", `
+                export interface IProduct {
+                    id: string;
+                    title: string;
+                    price: number;
+                }
+            `);
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            // Single-pass (with glob/rootPath)
+            const singlePassProcessor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+            const singlePassMap = await singlePassProcessor.processFiles(files);
+            const singlePassMerged = singlePassProcessor.mergeSchemas(singlePassMap);
+
+            // Per-file (without glob/rootPath)
+            const perFileProcessor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+            const perFileMap = await perFileProcessor.processFiles(files);
+            const perFileMerged = perFileProcessor.mergeSchemas(perFileMap);
+
+            // Merged schemas should be identical
+            expect(singlePassMerged).toStrictEqual(perFileMerged);
+        });
+    });
+
     describe("error handling", () => {
         it("should handle missing files gracefully", async () => {
             const processor = new SchemaProcessor({

package/src/services/SchemaProcessor.ts

@@ -1,6 +1,8 @@
 import * as tsj from "ts-json-schema-generator";
 import { Config, Schema } from "ts-json-schema-generator";
 import assert from "assert";
+import path from "path";
+import { Project } from "ts-morph";
 import { SchemaGenerationError, DuplicateSymbolError } from "../errors";
 import { FileInfo } from "./FileDiscovery";
 
@@ -9,6 +11,8 @@ export interface SchemaProcessorOptions {
     tsconfigPath?: string;
     parallel?: boolean;
     verbose?: boolean;
+    glob?: string;
+    rootPath?: string;
 }
 
 export interface ProcessingResult {
@@ -21,8 +25,8 @@ export class SchemaProcessor {
     constructor(private options: SchemaProcessorOptions) {}
 
     public async processFiles(files: FileInfo[]): Promise<Map<string, Schema>> {
-        const { parallel = true, verbose = false } = this.options;
-        
+        const { parallel = true, verbose = false, glob, rootPath } = this.options;
+
         if (verbose) {
             console.log(`Processing ${files.length} files...`);
         }
@@ -30,6 +34,17 @@ export class SchemaProcessor {
         // Sort files by path to ensure consistent processing order
         const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
 
+        // Use single-pass processing when possible (avoids creating N TypeScript programs)
+        if (glob && rootPath && sortedFiles.length > 1) {
+            try {
+                return await this.processSinglePass(sortedFiles, rootPath, glob);
+            } catch (error) {
+                if (verbose) {
+                    console.log(`Single-pass processing failed, falling back to per-file processing: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+
         const results = parallel
             ? await this.processInParallel(sortedFiles)
             : await this.processSequentially(sortedFiles);
@@ -37,6 +52,92 @@ export class SchemaProcessor {
         return this.consolidateSchemas(results);
     }
 
+    private async processSinglePass(
+        files: FileInfo[],
+        rootPath: string,
+        glob: string
+    ): Promise<Map<string, Schema>> {
+        const { additionalProperties, tsconfigPath, verbose } = this.options;
+
+        // Pre-check: scan all TS files in rootPath for duplicate exported type names.
+        // If duplicates exist, per-file processing is needed to detect schema conflicts.
+        if (this.hasDuplicateTypeNames(rootPath)) {
+            throw new Error("Duplicate type names detected across source files");
+        }
+
+        const resolvedRoot = path.resolve(rootPath);
+        const globPattern = path.join(resolvedRoot, "**", glob);
+
+        if (verbose) {
+            console.log(`Single-pass processing with pattern: ${globPattern}`);
+        }
+
+        const config: Config = {
+            path: globPattern,
+            type: "*",
+            additionalProperties,
+            encodeRefs: false,
+            sortProps: true,
+            ...(tsconfigPath ? { tsconfig: tsconfigPath } : {}),
+        };
+
+        const schemaGenerator = tsj.createGenerator(config);
+        const fullSchema = schemaGenerator.createSchema(config.type);
+
+        return this.partitionSchemaByFile(files, fullSchema);
+    }
+
+    private hasDuplicateTypeNames(rootPath: string): boolean {
+        const project = new Project({ skipAddingFilesFromTsConfig: true });
+        const allTsFiles = project.addSourceFilesAtPaths(
+            path.join(path.resolve(rootPath), "**/*.{ts,tsx}")
+        );
+
+        const seen = new Set<string>();
+
+        for (const sf of allTsFiles) {
+            const names: string[] = [];
+            for (const t of sf.getTypeAliases()) {
+                if (t.isExported()) names.push(t.getName());
+            }
+            for (const i of sf.getInterfaces()) {
+                if (i.isExported()) names.push(i.getName());
+            }
+            for (const e of sf.getEnums()) {
+                if (e.isExported()) names.push(e.getName());
+            }
+            for (const name of names) {
+                if (seen.has(name)) return true;
+                seen.add(name);
+            }
+        }
+
+        return false;
+    }
+
+    private partitionSchemaByFile(
+        files: FileInfo[],
+        fullSchema: Schema
+    ): Map<string, Schema> {
+        const defs = fullSchema.definitions ?? {};
+        const schemaVersion = fullSchema.$schema || "http://json-schema.org/draft-07/schema#";
+        const schemaMap = new Map<string, Schema>();
+
+        if (Object.keys(defs).length === 0) return schemaMap;
+
+        // Since we've verified no duplicate type names exist, assign all definitions
+        // to each file. Downstream code (extractTypeInfo) uses ts-morph to correctly
+        // attribute each definition to its actual source file.
+        for (const file of files) {
+            schemaMap.set(file.path, {
+                $schema: schemaVersion,
+                definitions: { ...defs },
+            });
+        }
+
+        return schemaMap;
+    }
+
     private async processInParallel(files: FileInfo[]): Promise<ProcessingResult[]> {
         const promises = files.map(file => this.processFile(file));
         const results = await Promise.allSettled(promises);