ts-runtime-validation 1.6.16 → 1.8.0

package/src/services/SchemaProcessor.ts

@@ -0,0 +1,194 @@
+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...`);
+        }
+
+        // Sort files by path to ensure consistent processing order
+        const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
+
+        const results = parallel
+            ? await this.processInParallel(sortedFiles)
+            : await this.processSequentially(sortedFiles);
+
+        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);
+        
+        // Map results back to original file order to maintain consistency
+        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[] = [];
+        
+        // Sort results by file path to ensure consistent order
+        const sortedResults = [...results].sort((a, b) => a.file.localeCompare(b.file));
+        
+        for (const result of sortedResults) {
+            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 } = {};
+        
+        // Sort by file path for consistent processing order
+        const sortedEntries = [...schemaMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+        
+        for (const [filePath, fileSchema] of sortedEntries) {
+            const defs = fileSchema.definitions ?? {};
+            
+            // Sort definition keys for consistent processing
+            Object.keys(defs).sort().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 = "";
+        
+        // Sort by file path for consistent processing order
+        const sortedEntries = [...schemaMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+        
+        for (const [, fileSchema] of sortedEntries) {
+            if (!schemaVersion && fileSchema["$schema"]) {
+                schemaVersion = fileSchema["$schema"];
+            }
+            
+            const defs = fileSchema.definitions ?? {};
+            // Sort definition keys for consistent processing
+            Object.keys(defs).sort().forEach((key) => {
+                definitions[key] = defs[key] as Schema;
+            });
+        }
+        
+        // Sort definitions alphabetically
+        const sortedDefinitions: { [id: string]: Schema } = {};
+        Object.keys(definitions).sort().forEach(key => {
+            sortedDefinitions[key] = definitions[key];
+        });
+        
+        return {
+            $schema: schemaVersion || "http://json-schema.org/draft-07/schema#",
+            definitions: sortedDefinitions,
+        };
+    }
+}

package/src/services/SchemaWriter.test.ts

@@ -0,0 +1,304 @@
+import fs from "fs";
+import path from "path";
+import { SchemaWriter } from "./SchemaWriter";
+import { CodeGenerationError } from "../errors";
+
+const testDir = path.resolve(__dirname, "../../.test-tmp/schema-writer");
+
+const cleanup = async () => {
+    if (fs.existsSync(testDir)) {
+        await fs.promises.rm(testDir, { recursive: true, force: true });
+    }
+};
+
+beforeEach(cleanup);
+afterAll(cleanup);
+
+describe("SchemaWriter", () => {
+    describe("writeJsonSchema", () => {
+        it("should write JSON schema with pretty formatting", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const schema: any = {
+                $schema: "http://json-schema.org/draft-07/schema#",
+                definitions: {
+                    IUser: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            name: { type: "string" }
+                        },
+                        required: ["id", "name"],
+                        additionalProperties: false
+                    }
+                }
+            };
+
+            const outputFile = path.join(testDir, "schema.json");
+            await writer.writeJsonSchema(schema, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+            
+            const content = await fs.promises.readFile(outputFile, 'utf-8');
+            const parsed = JSON.parse(content);
+            
+            expect(parsed).toEqual(schema);
+            // Pretty formatted should have indentation
+            expect(content).toMatch(/\n    /);
+        });
+
+        it("should write minified JSON schema", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: true
+            });
+
+            const schema: any = {
+                $schema: "http://json-schema.org/draft-07/schema#",
+                definitions: {
+                    IUser: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" }
+                        }
+                    }
+                }
+            };
+
+            const outputFile = path.join(testDir, "schema.json");
+            await writer.writeJsonSchema(schema, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+            
+            const content = await fs.promises.readFile(outputFile, 'utf-8');
+            const parsed = JSON.parse(content);
+            
+            expect(parsed).toEqual(schema);
+            // Minified should not have extra whitespace
+            expect(content).not.toMatch(/\n    /);
+        });
+
+        it("should create output directory if it doesn't exist", async () => {
+            const nestedPath = path.join(testDir, "nested", "deep", "path");
+            const writer = new SchemaWriter({
+                outputPath: nestedPath,
+                minify: false
+            });
+
+            const schema = { $schema: "test" };
+            const outputFile = path.join(nestedPath, "schema.json");
+            
+            await writer.writeJsonSchema(schema, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+        });
+
+        it("should throw CodeGenerationError on write failure", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const schema = { $schema: "test" };
+            // Try to write to an invalid path (file as directory)
+            const invalidPath = path.join(testDir, "file.json", "invalid");
+            
+            // Create file first to make path invalid
+            await fs.promises.mkdir(testDir, { recursive: true });
+            await fs.promises.writeFile(path.join(testDir, "file.json"), "test");
+
+            await expect(writer.writeJsonSchema(schema, invalidPath))
+                .rejects.toThrow(CodeGenerationError);
+        });
+    });
+
+    describe("writeTypeScriptFile", () => {
+        it("should write TypeScript file correctly", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const content = `export interface IUser {
+    id: string;
+    name: string;
+}`;
+
+            const outputFile = path.join(testDir, "types.ts");
+            await writer.writeTypeScriptFile(content, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+            
+            const fileContent = await fs.promises.readFile(outputFile, 'utf-8');
+            expect(fileContent).toBe(content);
+        });
+
+        it("should create directories for TypeScript files", async () => {
+            const nestedPath = path.join(testDir, "src", "types");
+            const writer = new SchemaWriter({
+                outputPath: nestedPath,
+                minify: false
+            });
+
+            const content = "export const test = 'value';";
+            const outputFile = path.join(nestedPath, "test.ts");
+            
+            await writer.writeTypeScriptFile(content, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+        });
+
+        it("should handle empty content", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const outputFile = path.join(testDir, "empty.ts");
+            await writer.writeTypeScriptFile("", outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+            
+            const content = await fs.promises.readFile(outputFile, 'utf-8');
+            expect(content).toBe("");
+        });
+    });
+
+    describe("cleanOutputDirectory", () => {
+        it("should remove TypeScript and JSON files", async () => {
+            await fs.promises.mkdir(testDir, { recursive: true });
+            
+            // Create various files
+            await fs.promises.writeFile(path.join(testDir, "schema.json"), "{}");
+            await fs.promises.writeFile(path.join(testDir, "types.ts"), "export interface Test {}");
+            await fs.promises.writeFile(path.join(testDir, "readme.md"), "# Test");
+            await fs.promises.writeFile(path.join(testDir, "config.yaml"), "test: value");
+
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            await writer.cleanOutputDirectory();
+
+            // Should remove .ts and .json files
+            expect(fs.existsSync(path.join(testDir, "schema.json"))).toBe(false);
+            expect(fs.existsSync(path.join(testDir, "types.ts"))).toBe(false);
+            
+            // Should keep other files
+            expect(fs.existsSync(path.join(testDir, "readme.md"))).toBe(true);
+            expect(fs.existsSync(path.join(testDir, "config.yaml"))).toBe(true);
+        });
+
+        it("should handle non-existent directory", async () => {
+            const writer = new SchemaWriter({
+                outputPath: path.join(testDir, "nonexistent"),
+                minify: false
+            });
+
+            // Should not throw
+            await expect(writer.cleanOutputDirectory()).resolves.not.toThrow();
+        });
+
+        it("should not remove subdirectories", async () => {
+            await fs.promises.mkdir(path.join(testDir, "subdir"), { recursive: true });
+            await fs.promises.writeFile(path.join(testDir, "subdir", "file.ts"), "test");
+            await fs.promises.writeFile(path.join(testDir, "main.ts"), "test");
+
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            await writer.cleanOutputDirectory();
+
+            // Should remove file in root
+            expect(fs.existsSync(path.join(testDir, "main.ts"))).toBe(false);
+            
+            // Should keep subdirectory and its contents
+            expect(fs.existsSync(path.join(testDir, "subdir"))).toBe(true);
+            expect(fs.existsSync(path.join(testDir, "subdir", "file.ts"))).toBe(true);
+        });
+
+        it("should handle permission errors gracefully", async () => {
+            // Skip this test as it's environment dependent
+            // Real permission errors would be caught by the try-catch in SchemaWriter
+        });
+    });
+
+    describe("edge cases", () => {
+        it("should handle large files", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            // Create a large schema
+            const largeSchema: any = {
+                $schema: "http://json-schema.org/draft-07/schema#",
+                definitions: {}
+            };
+
+            // Add many definitions
+            for (let i = 0; i < 1000; i++) {
+                largeSchema.definitions[`Interface${i}`] = {
+                    type: "object",
+                    properties: {
+                        id: { type: "string" },
+                        name: { type: "string" },
+                        value: { type: "number" }
+                    }
+                };
+            }
+
+            const outputFile = path.join(testDir, "large-schema.json");
+            await writer.writeJsonSchema(largeSchema, outputFile);
+
+            expect(fs.existsSync(outputFile)).toBe(true);
+            
+            const stats = await fs.promises.stat(outputFile);
+            expect(stats.size).toBeGreaterThan(1000); // Should be reasonably large
+        });
+
+        it("should handle unicode content", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const unicodeContent = `export interface IUser {
+    // Unicode: café, naïve, résumé
+    name: string; // 中文注释
+    emoji: "👨‍💻" | "🚀" | "💡";
+}`;
+
+            const outputFile = path.join(testDir, "unicode.ts");
+            await writer.writeTypeScriptFile(unicodeContent, outputFile);
+
+            const content = await fs.promises.readFile(outputFile, 'utf-8');
+            expect(content).toBe(unicodeContent);
+        });
+
+        it("should overwrite existing files", async () => {
+            const writer = new SchemaWriter({
+                outputPath: testDir,
+                minify: false
+            });
+
+            const outputFile = path.join(testDir, "overwrite.ts");
+            
+            // Write first content
+            await writer.writeTypeScriptFile("const first = 1;", outputFile);
+            const firstContent = await fs.promises.readFile(outputFile, 'utf-8');
+            expect(firstContent).toBe("const first = 1;");
+            
+            // Overwrite with second content
+            await writer.writeTypeScriptFile("const second = 2;", outputFile);
+            const secondContent = await fs.promises.readFile(outputFile, 'utf-8');
+            expect(secondContent).toBe("const second = 2;");
+        });
+    });
+});

package/src/services/SchemaWriter.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { Schema } from "ts-json-schema-generator";
+import { CodeGenerationError } from "../errors";
+
+export interface SchemaWriterOptions {
+    outputPath: string;
+    minify?: boolean;
+}
+
+export class SchemaWriter {
+    constructor(private options: SchemaWriterOptions) {}
+
+    public async writeJsonSchema(
+        schema: Schema,
+        outputFile: string
+    ): Promise<void> {
+        try {
+            await this.ensureOutputPath();
+            
+            const content = this.options.minify
+                ? JSON.stringify(schema)
+                : JSON.stringify(schema, null, 4);
+                
+            await fs.promises.writeFile(outputFile, content, 'utf-8');
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to write JSON schema: ${error instanceof Error ? error.message : String(error)}`,
+                outputFile
+            );
+        }
+    }
+
+    public async writeTypeScriptFile(
+        content: string,
+        outputFile: string
+    ): Promise<void> {
+        try {
+            await this.ensureOutputPath();
+            await fs.promises.writeFile(outputFile, content, 'utf-8');
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to write TypeScript file: ${error instanceof Error ? error.message : String(error)}`,
+                outputFile
+            );
+        }
+    }
+
+    private async ensureOutputPath(): Promise<void> {
+        if (!fs.existsSync(this.options.outputPath)) {
+            await fs.promises.mkdir(this.options.outputPath, { recursive: true });
+        }
+    }
+
+    public async cleanOutputDirectory(): Promise<void> {
+        try {
+            if (fs.existsSync(this.options.outputPath)) {
+                const files = await fs.promises.readdir(this.options.outputPath);
+                
+                for (const file of files) {
+                    const filePath = path.join(this.options.outputPath, file);
+                    const stat = await fs.promises.stat(filePath);
+                    
+                    if (stat.isFile() && (file.endsWith('.ts') || file.endsWith('.json'))) {
+                        await fs.promises.unlink(filePath);
+                    }
+                }
+            }
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to clean output directory: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+}