ts-runtime-validation 1.6.16 → 1.7.0

package/src/services/SchemaProcessor.test.ts

@@ -0,0 +1,464 @@
+import fs from "fs";
+import path from "path";
+import { SchemaProcessor } from "./SchemaProcessor";
+import { FileInfo } from "./FileDiscovery";
+import { DuplicateSymbolError } from "../errors";
+
+const testDir = path.resolve(__dirname, "../test-tmp/schema-processor");
+
+const createTestFile = async (filePath: string, content: string) => {
+    const fullPath = path.resolve(testDir, filePath);
+    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.promises.writeFile(fullPath, content);
+    return fullPath;
+};
+
+const cleanup = async () => {
+    if (fs.existsSync(testDir)) {
+        await fs.promises.rm(testDir, { recursive: true, force: true });
+    }
+};
+
+beforeEach(cleanup);
+afterAll(cleanup);
+
+describe("SchemaProcessor", () => {
+    describe("processFiles", () => {
+        it("should process valid TypeScript files", async () => {
+            const filePath = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                    email?: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false
+            });
+
+            const files: FileInfo[] = [{ path: filePath }];
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(1);
+            expect(schemaMap.has(filePath)).toBe(true);
+
+            const schema = schemaMap.get(filePath)!;
+            expect(schema.definitions).toBeDefined();
+            expect(schema.definitions!.IUser).toBeDefined();
+            expect(schema.definitions!.IUser).toMatchObject({
+                type: "object",
+                properties: {
+                    id: { type: "string" },
+                    name: { type: "string" },
+                    email: { type: "string" }
+                },
+                required: ["id", "name"],
+                additionalProperties: false
+            });
+        });
+
+        it("should handle parallel processing", 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: true,
+                verbose: false
+            });
+
+            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);
+        });
+
+        it("should handle sequential processing", 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
+            });
+
+            const files: FileInfo[] = [{ path: file1 }];
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(1);
+        });
+
+        it("should handle files with syntax errors gracefully", async () => {
+            const validFile = await createTestFile("valid.jsonschema.ts", `
+                export interface IValid {
+                    id: string;
+                }
+            `);
+
+            const invalidFile = await createTestFile("invalid.jsonschema.ts", `
+                export interface IInvalid {
+                    id: string
+                    // missing semicolon and other syntax errors
+                    name string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false
+            });
+
+            const files: FileInfo[] = [
+                { path: validFile },
+                { path: invalidFile }
+            ];
+
+            // Should not throw but should process valid files
+            const schemaMap = await processor.processFiles(files);
+            
+            // At least valid file should be processed
+            expect(schemaMap.size).toBeGreaterThan(0);
+            expect(schemaMap.has(validFile)).toBe(true);
+        });
+
+        it("should respect additionalProperties setting", async () => {
+            const filePath = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const processorStrict = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const processorLoose = new SchemaProcessor({
+                additionalProperties: true,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: filePath }];
+            
+            const strictSchema = await processorStrict.processFiles(files);
+            const looseSchema = await processorLoose.processFiles(files);
+
+            const strictUser = strictSchema.get(filePath)!.definitions!.IUser as any;
+            const looseUser = looseSchema.get(filePath)!.definitions!.IUser as any;
+            
+            expect(strictUser.additionalProperties).toBe(false);
+            // Note: ts-json-schema-generator may not set additionalProperties: true explicitly
+            expect(looseUser.additionalProperties === true || looseUser.additionalProperties === undefined).toBe(true);
+        });
+    });
+
+    describe("validateSchemaCompatibility", () => {
+        it("should pass with identical schemas", async () => {
+            const file1 = await createTestFile("user1.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("user2.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+            
+            expect(() => {
+                processor.validateSchemaCompatibility(schemaMap);
+            }).not.toThrow();
+        });
+
+        it("should throw DuplicateSymbolError for conflicting schemas", async () => {
+            const file1 = await createTestFile("user1.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("user2.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    email: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+            
+            expect(() => {
+                processor.validateSchemaCompatibility(schemaMap);
+            }).toThrow(DuplicateSymbolError);
+        });
+
+        it("should allow different symbols with same name in different contexts", async () => {
+            const file1 = await createTestFile("api/user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+                
+                export interface IProduct {
+                    id: string;
+                    title: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: file1 }];
+            const schemaMap = await processor.processFiles(files);
+            
+            expect(() => {
+                processor.validateSchemaCompatibility(schemaMap);
+            }).not.toThrow();
+        });
+    });
+
+    describe("mergeSchemas", () => {
+        it("should merge multiple schemas correctly", 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
+            });
+
+            const files: FileInfo[] = [
+                { path: file1 },
+                { path: file2 }
+            ];
+
+            const schemaMap = await processor.processFiles(files);
+            const mergedSchema = processor.mergeSchemas(schemaMap);
+
+            expect(mergedSchema.$schema).toBe("http://json-schema.org/draft-07/schema#");
+            expect(mergedSchema.definitions).toBeDefined();
+            expect(mergedSchema.definitions!.IUser).toBeDefined();
+            expect(mergedSchema.definitions!.IProduct).toBeDefined();
+        });
+
+        it("should preserve schema version from first file", async () => {
+            const file1 = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name: string;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: file1 }];
+            const schemaMap = await processor.processFiles(files);
+            const mergedSchema = processor.mergeSchemas(schemaMap);
+
+            expect(mergedSchema.$schema).toMatch(/json-schema\.org/);
+        });
+
+        it("should handle empty schema map", () => {
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const schemaMap = new Map();
+            const mergedSchema = processor.mergeSchemas(schemaMap);
+
+            expect(mergedSchema.$schema).toBe("http://json-schema.org/draft-07/schema#");
+            expect(mergedSchema.definitions).toEqual({});
+        });
+    });
+
+    describe("error handling", () => {
+        it("should handle missing files gracefully", async () => {
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: false
+            });
+
+            const files: FileInfo[] = [
+                { path: "/nonexistent/file.ts" }
+            ];
+
+            // Should not throw but return empty map
+            const schemaMap = await processor.processFiles(files);
+            expect(schemaMap.size).toBe(0);
+        });
+
+        it("should provide verbose error information", async () => {
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false,
+                verbose: true
+            });
+
+            const files: FileInfo[] = [
+                { path: "/nonexistent/file.ts" }
+            ];
+
+            await processor.processFiles(files);
+            
+            expect(consoleWarnSpy).toHaveBeenCalled();
+            consoleWarnSpy.mockRestore();
+        });
+    });
+
+    describe("TypeScript features", () => {
+        it("should handle union types", async () => {
+            const filePath = await createTestFile("types.jsonschema.ts", `
+                export type Status = "active" | "inactive" | "pending";
+                
+                export interface IUser {
+                    id: string;
+                    status: Status;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: filePath }];
+            const schemaMap = await processor.processFiles(files);
+
+            expect(schemaMap.size).toBe(1);
+            const schema = schemaMap.get(filePath)!;
+            expect(schema.definitions!.Status).toBeDefined();
+            expect(schema.definitions!.IUser).toBeDefined();
+        });
+
+        it("should handle optional properties", async () => {
+            const filePath = await createTestFile("user.jsonschema.ts", `
+                export interface IUser {
+                    id: string;
+                    name?: string;
+                    email?: string;
+                    age: number;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: filePath }];
+            const schemaMap = await processor.processFiles(files);
+
+            const schema = schemaMap.get(filePath)!;
+            const userSchema = schema.definitions!.IUser as any;
+            
+            expect(userSchema.required).toEqual(expect.arrayContaining(["id", "age"]));
+            expect(userSchema.required).not.toContain("name");
+            expect(userSchema.required).not.toContain("email");
+        });
+
+        it("should handle nested interfaces", async () => {
+            const filePath = await createTestFile("nested.jsonschema.ts", `
+                export interface IAddress {
+                    street: string;
+                    city: string;
+                    country: string;
+                }
+                
+                export interface IUser {
+                    id: string;
+                    name: string;
+                    address: IAddress;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: filePath }];
+            const schemaMap = await processor.processFiles(files);
+
+            const schema = schemaMap.get(filePath)!;
+            expect(schema.definitions!.IAddress).toBeDefined();
+            expect(schema.definitions!.IUser).toBeDefined();
+            
+            const userSchema = schema.definitions!.IUser as any;
+            expect(userSchema.properties.address.$ref).toBe("#/definitions/IAddress");
+        });
+    });
+});

package/src/services/SchemaProcessor.ts

@@ -0,0 +1,173 @@
+import * as tsj from "ts-json-schema-generator";
+import { Config, Schema } from "ts-json-schema-generator";
+import assert from "assert";
+import { SchemaGenerationError, DuplicateSymbolError } from "../errors";
+import { FileInfo } from "./FileDiscovery";
+
+export interface SchemaProcessorOptions {
+    additionalProperties: boolean;
+    tsconfigPath?: string;
+    parallel?: boolean;
+    verbose?: boolean;
+}
+
+export interface ProcessingResult {
+    file: string;
+    schema: Schema | null;
+    error?: Error;
+}
+
+export class SchemaProcessor {
+    constructor(private options: SchemaProcessorOptions) {}
+
+    public async processFiles(files: FileInfo[]): Promise<Map<string, Schema>> {
+        const { parallel = true, verbose = false } = this.options;
+        
+        if (verbose) {
+            console.log(`Processing ${files.length} files...`);
+        }
+
+        const results = parallel
+            ? await this.processInParallel(files)
+            : await this.processSequentially(files);
+
+        return this.consolidateSchemas(results);
+    }
+
+    private async processInParallel(files: FileInfo[]): Promise<ProcessingResult[]> {
+        const promises = files.map(file => this.processFile(file));
+        const results = await Promise.allSettled(promises);
+        
+        return results.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            } else {
+                return {
+                    file: files[index].path,
+                    schema: null,
+                    error: result.reason
+                };
+            }
+        });
+    }
+
+    private async processSequentially(files: FileInfo[]): Promise<ProcessingResult[]> {
+        const results: ProcessingResult[] = [];
+        
+        for (const file of files) {
+            try {
+                const result = await this.processFile(file);
+                results.push(result);
+            } catch (error) {
+                results.push({
+                    file: file.path,
+                    schema: null,
+                    error: error instanceof Error ? error : new Error(String(error))
+                });
+            }
+        }
+        
+        return results;
+    }
+
+    private async processFile(file: FileInfo): Promise<ProcessingResult> {
+        const { additionalProperties, tsconfigPath, verbose } = this.options;
+        
+        try {
+            if (verbose) {
+                console.log(`Processing: ${file.path}`);
+            }
+
+            const config: Config = {
+                path: file.path,
+                type: "*",
+                additionalProperties,
+                encodeRefs: false,
+                sortProps: true,
+                ...(tsconfigPath ? { tsconfig: tsconfigPath } : {}),
+            };
+
+            const schemaGenerator = tsj.createGenerator(config);
+            const schema = schemaGenerator.createSchema(config.type);
+            
+            return {
+                file: file.path,
+                schema,
+                error: undefined
+            };
+        } catch (error) {
+            throw new SchemaGenerationError(
+                `Failed to process ${file.path}: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
+    private consolidateSchemas(results: ProcessingResult[]): Map<string, Schema> {
+        const schemaMap = new Map<string, Schema>();
+        const errors: Error[] = [];
+        
+        for (const result of results) {
+            if (result.error) {
+                errors.push(result.error);
+                continue;
+            }
+            
+            if (result.schema) {
+                schemaMap.set(result.file, result.schema);
+            }
+        }
+        
+        if (errors.length > 0 && this.options.verbose) {
+            console.warn(`Encountered ${errors.length} errors during processing:`);
+            errors.forEach(error => console.warn(`  - ${error.message}`));
+        }
+        
+        return schemaMap;
+    }
+
+    public validateSchemaCompatibility(schemaMap: Map<string, Schema>): void {
+        const definitions: { [id: string]: any } = {};
+        
+        schemaMap.forEach((fileSchema, filePath) => {
+            const defs = fileSchema.definitions ?? {};
+            
+            Object.keys(defs).forEach((key) => {
+                if (definitions[key] !== undefined) {
+                    try {
+                        assert.deepEqual(definitions[key], defs[key]);
+                    } catch (e) {
+                        throw new DuplicateSymbolError(
+                            `Duplicate symbol '${key}' found with different implementations`,
+                            key,
+                            filePath,
+                            definitions[key],
+                            defs[key]
+                        );
+                    }
+                }
+                definitions[key] = defs[key];
+            });
+        });
+    }
+
+    public mergeSchemas(schemaMap: Map<string, Schema>): Schema {
+        const definitions: { [id: string]: Schema } = {};
+        let schemaVersion = "";
+        
+        schemaMap.forEach((fileSchema) => {
+            if (!schemaVersion && fileSchema["$schema"]) {
+                schemaVersion = fileSchema["$schema"];
+            }
+            
+            const defs = fileSchema.definitions ?? {};
+            Object.keys(defs).forEach((key) => {
+                definitions[key] = defs[key] as Schema;
+            });
+        });
+        
+        return {
+            $schema: schemaVersion || "http://json-schema.org/draft-07/schema#",
+            definitions,
+        };
+    }
+}