ts-runtime-validation 1.7.0 → 1.8.1

package/src/SchemaGenerator.integration.test.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { SchemaGenerator } from "./SchemaGenerator";
 import { ICommandOptions } from "./ICommandOptions";
 
-const testDir = path.resolve(__dirname, "./test-tmp/integration");
+const testDir = path.resolve(__dirname, "../.test-tmp/integration");
 
 const createTestFile = async (filePath: string, content: string) => {
     const fullPath = path.resolve(testDir, filePath);
@@ -396,8 +396,8 @@ describe("SchemaGenerator Integration Tests", () => {
             const endTime = Date.now();
             const duration = endTime - startTime;
             
-            // Should complete reasonably quickly (less than 10 seconds)
-            expect(duration).toBeLessThan(10000);
+            // Should complete reasonably quickly (less than 20 seconds)
+            expect(duration).toBeLessThan(20000);
             
             // Verify all files were processed
             const schemaFile = path.join(testDir, "output", "validation.schema.json");

package/src/SchemaGenerator.test.ts

@@ -122,4 +122,115 @@ describe("SchemaGenerator", () => {
         };
         expect(result).toStrictEqual(expected);
     });
+
+    test("it should sort definitions alphabetically in the generated schema", async () => {
+        // Create test directory and files
+        const testDir = path.resolve(__dirname, "./test/alphabetical-sorting");
+        
+        // Ensure test directory exists
+        fs.mkdirSync(testDir, { recursive: true });
+        
+        // Create test file with unsorted type definitions
+        const testFilePath = path.join(testDir, "types.jsonschema.ts");
+        fs.writeFileSync(testFilePath, `
+            export interface ZebraType {
+                id: string;
+            }
+            
+            export interface AppleType {
+                name: string;
+            }
+            
+            export interface MiddleType {
+                value: number;
+            }
+            
+            export interface BananaType {
+                flag: boolean;
+            }
+        `);
+        
+        try {
+            const options = getGeneratorConfig("alphabetical-sorting");
+            const generator = new SchemaGenerator(options);
+            await generator.Generate();
+            
+            const rawFile = fs.readFileSync(getOutputSchemaPath("alphabetical-sorting")).toString();
+            const result = JSON.parse(rawFile);
+            
+            // Check that definitions are sorted alphabetically
+            const definitionKeys = Object.keys(result.definitions);
+            const sortedKeys = [...definitionKeys].sort();
+            
+            expect(definitionKeys).toEqual(sortedKeys);
+            expect(definitionKeys).toEqual(['AppleType', 'BananaType', 'MiddleType', 'ZebraType']);
+        } finally {
+            // Clean up test directory
+            if (fs.existsSync(testDir)) {
+                fs.rmSync(testDir, { recursive: true });
+            }
+        }
+    });
+
+    test("it should sort properties alphabetically in generated TypeScript helpers", async () => {
+        // Create test directory and files
+        const testDir = path.resolve(__dirname, "./test/alphabetical-helpers");
+        const outputDir = path.resolve(__dirname, "./test/output/alphabetical-helpers");
+        
+        // Ensure test directory exists
+        fs.mkdirSync(testDir, { recursive: true });
+        
+        // Create test file with unsorted type definitions
+        const testFilePath = path.join(testDir, "types.jsonschema.ts");
+        fs.writeFileSync(testFilePath, `
+            export type ZebraType = string;
+            export type AppleType = number;
+            export type MiddleType = boolean;
+            export type BananaType = object;
+        `);
+        
+        try {
+            const options = {
+                ...getGeneratorConfig("alphabetical-helpers"),
+                helpers: true
+            };
+            const generator = new SchemaGenerator(options);
+            await generator.Generate();
+            
+            // Check SchemaDefinition.ts for sorted imports and properties
+            const schemaDefPath = path.resolve(outputDir, "SchemaDefinition.ts");
+            if (fs.existsSync(schemaDefPath)) {
+                const schemaDefContent = fs.readFileSync(schemaDefPath, 'utf-8');
+                
+                // Extract type names from the schemas object (looking only at the schemas constant)
+                const schemasMatch = schemaDefContent.match(/export const schemas[^{]*{([\s\S]*?)}/);
+                let schemaKeys: string[] = [];
+                if (schemasMatch) {
+                    const schemaLines = schemasMatch[1].split('\n').filter(line => line.includes('#/definitions/'));
+                    schemaKeys = schemaLines.map(line => {
+                        const match = line.match(/\["#\/definitions\/([^"]+)"\]/);
+                        return match ? match[1] : null;
+                    }).filter(Boolean) as string[];
+                }
+                
+                const sortedSchemaKeys = [...schemaKeys].sort();
+                
+                expect(schemaKeys).toEqual(sortedSchemaKeys);
+                expect(schemaKeys).toEqual(['AppleType', 'BananaType', 'MiddleType', 'ZebraType']);
+                
+                // Check that imports are sorted
+                const importMatch = schemaDefContent.match(/import\s+{\s*([^}]+)\s*}/);
+                if (importMatch) {
+                    const imports = importMatch[1].split(',').map(s => s.trim());
+                    const sortedImports = [...imports].sort();
+                    expect(imports).toEqual(sortedImports);
+                }
+            }
+        } finally {
+            // Clean up test directory
+            if (fs.existsSync(testDir)) {
+                fs.rmSync(testDir, { recursive: true });
+            }
+        }
+    });
 });

package/src/cli.test.ts

@@ -0,0 +1,130 @@
+import { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+
+describe("CLI Arguments", () => {
+    const cliPath = path.join(__dirname, "..", "dist", "index.js");
+    const testOutputPath = path.join(__dirname, "../.test-tmp/cli-output");
+    
+    beforeEach(() => {
+        if (fs.existsSync(testOutputPath)) {
+            fs.rmSync(testOutputPath, { recursive: true, force: true });
+        }
+    });
+    
+    afterEach(() => {
+        if (fs.existsSync(testOutputPath)) {
+            fs.rmSync(testOutputPath, { recursive: true, force: true });
+        }
+    });
+    
+    const runCLI = (args: string[]): Promise<{ code: number; stdout: string; stderr: string }> => {
+        return new Promise((resolve) => {
+            const proc = spawn("node", [cliPath, ...args]);
+            let stdout = "";
+            let stderr = "";
+            
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            
+            proc.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            
+            proc.on("close", (code) => {
+                resolve({ code: code || 0, stdout, stderr });
+            });
+        });
+    };
+    
+    it("should accept glob pattern with --glob parameter", async () => {
+        const result = await runCLI([
+            "--glob", "test/basic-scenario/*.jsonschema.ts",
+            "--rootPath", path.join(__dirname),
+            "--output", "../.test-tmp/cli-output"
+        ]);
+        
+        expect(result.code).toBe(0);
+        expect(fs.existsSync(testOutputPath)).toBe(true);
+        
+        // Check that files were generated
+        const generatedFiles = fs.readdirSync(testOutputPath);
+        expect(generatedFiles).toContain("validation.schema.json");
+        expect(generatedFiles).toContain("SchemaDefinition.ts");
+        expect(generatedFiles).toContain("ValidationType.ts");
+        expect(generatedFiles).toContain("isValidSchema.ts");
+    });
+    
+    it("should use default glob pattern when --glob is not provided", async () => {
+        // Create test files matching the default pattern
+        const testDir = path.join(__dirname, "test-default-glob");
+        const testFile1 = path.join(testDir, "test.jsonschema.ts");
+        const testFile2 = path.join(testDir, "test2.jsonschema.tsx");
+        
+        if (!fs.existsSync(testDir)) {
+            fs.mkdirSync(testDir, { recursive: true });
+        }
+        
+        fs.writeFileSync(testFile1, "export interface TestInterface { test: string; }");
+        fs.writeFileSync(testFile2, "export interface TestInterface2 { test2: number; }");
+        
+        try {
+            const result = await runCLI([
+                "--rootPath", testDir,
+                "--output", path.join("..", "../.test-tmp/cli-output")
+            ]);
+            
+            expect(result.code).toBe(0);
+            expect(fs.existsSync(testOutputPath)).toBe(true);
+        } finally {
+            // Clean up test files and directory
+            if (fs.existsSync(testDir)) {
+                fs.rmSync(testDir, { recursive: true, force: true });
+            }
+        }
+    });
+    
+    it("should accept all supported CLI options", async () => {
+        const result = await runCLI([
+            "--glob", "test/basic-scenario/*.jsonschema.ts",
+            "--rootPath", path.join(__dirname),
+            "--output", "../.test-tmp/cli-output",
+            "--additionalProperties",
+            "--verbose",
+            "--progress",
+            "--minify",
+            "--cache",
+            "--tree-shaking",
+            "--lazy-load"
+        ]);
+        
+        expect(result.code).toBe(0);
+        // With verbose flag, we should see output
+        expect(result.stdout).toContain("Found");
+    });
+    
+    it("should handle parallel processing flags correctly", async () => {
+        // Test with parallel disabled
+        const result = await runCLI([
+            "--glob", "test/basic-scenario/*.jsonschema.ts",
+            "--rootPath", path.join(__dirname),
+            "--output", "../.test-tmp/cli-output",
+            "--no-parallel"
+        ]);
+        
+        expect(result.code).toBe(0);
+        expect(fs.existsSync(testOutputPath)).toBe(true);
+    });
+    
+    it("should error gracefully when no matching files are found", async () => {
+        const result = await runCLI([
+            "--glob", "nonexistent/*.jsonschema.ts",
+            "--rootPath", path.join(__dirname),
+            "--output", "../.test-tmp/cli-output"
+        ]);
+        
+        expect(result.code).not.toBe(0);
+        expect(result.stderr).toContain("No files found");
+    });
+});

package/src/index.ts

@@ -11,7 +11,7 @@ const defaultOutputFolder = "./.ts-runtime-validation";
 const defaultTsconfig = "";
 
 program.option(
-    "--glob",
+    "--glob <glob>",
     `Glob file path of typescript files to generate ts-interface -> json-schema validations - default: ${defaultGlobPattern}`,
     defaultGlobPattern
 );

package/src/services/CodeGenerator.ts

@@ -98,7 +98,10 @@ export class CodeGenerator {
         const readerProject = new Project(defaultTsMorphProjectSettings);
         const typeInfos: TypeInfo[] = [];
         
-        schemaMap.forEach((schema, filePath) => {
+        // Sort schema map entries by file path for consistent processing order
+        const sortedEntries = [...schemaMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+        
+        for (const [filePath, schema] of sortedEntries) {
             const dir = path.dirname(filePath);
             const fileWithoutExtension = path.parse(filePath).name;
             const relativeFilePath = path.relative(this.options.outputPath, dir);
@@ -107,7 +110,8 @@ export class CodeGenerator {
             
             const readerSourceFile = readerProject.addSourceFileAtPath(filePath);
             
-            Object.keys(defs).forEach((symbol) => {
+            // Sort definition keys alphabetically
+            Object.keys(defs).sort().forEach((symbol) => {
                 const typeAlias = readerSourceFile.getTypeAlias(symbol);
                 const typeInterface = readerSourceFile.getInterface(symbol);
                 
@@ -119,9 +123,10 @@ export class CodeGenerator {
                     });
                 }
             });
-        });
+        }
         
-        return typeInfos;
+        // Sort typeInfos alphabetically by symbol
+        return typeInfos.sort((a, b) => a.symbol.localeCompare(b.symbol));
     }
 
     private async writeSchemaDefinitionFile(
@@ -145,7 +150,8 @@ export class CodeGenerator {
                     type: "Record<keyof ISchema, string>",
                     initializer: (writer: CodeBlockWriter) => {
                         writer.writeLine(`{`);
-                        typeInfos.forEach(({ symbol }) => {
+                        // Sort by symbol for consistent output
+                        [...typeInfos].sort((a, b) => a.symbol.localeCompare(b.symbol)).forEach(({ symbol }) => {
                             writer.writeLine(`["#/definitions/${symbol}"] : "${symbol}",`);
                         });
                         writer.writeLine(`}`);
@@ -158,7 +164,7 @@ export class CodeGenerator {
             kind: StructureKind.Interface,
             name: "ISchema",
             isExported: true,
-            properties: typeInfos.map(({ symbol }) => ({
+            properties: [...typeInfos].sort((a, b) => a.symbol.localeCompare(b.symbol)).map(({ symbol }) => ({
                 name: `readonly ["#/definitions/${symbol}"]`,
                 type: symbol
             })),
@@ -176,7 +182,10 @@ export class CodeGenerator {
             importMap.set(importPath, existing);
         });
         
-        importMap.forEach((symbols, importPath) => {
+        // Sort import paths and symbols alphabetically
+        const sortedImportPaths = Array.from(importMap.keys()).sort();
+        sortedImportPaths.forEach((importPath) => {
+            const symbols = importMap.get(importPath)!.sort();
             sourceFile.addImportDeclaration({
                 namedImports: symbols,
                 moduleSpecifier: importPath
@@ -193,7 +202,10 @@ export class CodeGenerator {
             importMap.set(importPath, existing);
         });
         
-        importMap.forEach((symbols, importPath) => {
+        // Sort import paths and symbols alphabetically
+        const sortedImportPaths = Array.from(importMap.keys()).sort();
+        sortedImportPaths.forEach((importPath) => {
+            const symbols = importMap.get(importPath)!.sort();
             sourceFile.addImportDeclaration({
                 namedImports: symbols,
                 moduleSpecifier: importPath
@@ -306,13 +318,19 @@ export class CodeGenerator {
         const sourceFile = this.project.createSourceFile(outputFile, {}, defaultCreateFileOptions);
         
         const importMap = new Map<string, string[]>();
-        typeInfos.forEach(({ symbol, importPath }) => {
+        // Sort typeInfos for consistent processing
+        const sortedTypeInfos = [...typeInfos].sort((a, b) => a.symbol.localeCompare(b.symbol));
+        
+        sortedTypeInfos.forEach(({ symbol, importPath }) => {
             const existing = importMap.get(importPath) || [];
             existing.push(symbol);
             importMap.set(importPath, existing);
         });
         
-        importMap.forEach((symbols, importPath) => {
+        // Sort import paths and symbols alphabetically
+        const sortedImportPaths = Array.from(importMap.keys()).sort();
+        sortedImportPaths.forEach((importPath) => {
+            const symbols = importMap.get(importPath)!.sort();
             const declaration = sourceFile.addImportDeclaration({
                 moduleSpecifier: importPath
             });
@@ -325,7 +343,7 @@ export class CodeGenerator {
         });
         
         if (this.options.treeShaking) {
-            typeInfos.forEach(({ symbol }) => {
+            sortedTypeInfos.forEach(({ symbol }) => {
                 sourceFile.addTypeAlias({
                     name: symbol,
                     type: `_${symbol}`,
@@ -338,7 +356,7 @@ export class CodeGenerator {
                 isExported: true,
             });
             
-            typeInfos.forEach(({ symbol }) => {
+            sortedTypeInfos.forEach(({ symbol }) => {
                 namespace.addTypeAlias({
                     name: symbol,
                     type: `_${symbol}`,

package/src/services/FileDiscovery.test.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { FileDiscovery } from "./FileDiscovery";
 import { FileDiscoveryError } from "../errors";
 
-const testDir = path.resolve(__dirname, "../test-tmp/file-discovery");
+const testDir = path.resolve(__dirname, "../../.test-tmp/file-discovery");
 const cacheDir = path.resolve(testDir, ".cache");
 
 const createTestFile = async (filePath: string, content: string = "test content") => {

package/src/services/FileDiscovery.ts

@@ -54,9 +54,12 @@ export class FileDiscovery {
                 );
             }
 
+            // Sort files alphabetically to ensure consistent ordering
+            const sortedFiles = [...files].sort();
+
             return this.options.cacheEnabled 
-                ? await this.enrichWithCacheInfo(files)
-                : files.map(path => ({ path }));
+                ? await this.enrichWithCacheInfo(sortedFiles)
+                : sortedFiles.map(path => ({ path }));
         } catch (error) {
             if (error instanceof FileDiscoveryError) {
                 throw error;

package/src/services/SchemaProcessor.test.ts

@@ -4,7 +4,7 @@ import { SchemaProcessor } from "./SchemaProcessor";
 import { FileInfo } from "./FileDiscovery";
 import { DuplicateSymbolError } from "../errors";
 
-const testDir = path.resolve(__dirname, "../test-tmp/schema-processor");
+const testDir = path.resolve(__dirname, "../../.test-tmp/schema-processor");
 
 const createTestFile = async (filePath: string, content: string) => {
     const fullPath = path.resolve(testDir, filePath);
@@ -340,6 +340,78 @@ describe("SchemaProcessor", () => {
             expect(mergedSchema.$schema).toBe("http://json-schema.org/draft-07/schema#");
             expect(mergedSchema.definitions).toEqual({});
         });
+
+        it("should sort definitions alphabetically in merged schema", async () => {
+            const file1 = await createTestFile("types1.jsonschema.ts", `
+                export interface ZebraType {
+                    id: string;
+                }
+                export interface AppleType {
+                    name: string;
+                }
+            `);
+
+            const file2 = await createTestFile("types2.jsonschema.ts", `
+                export interface MiddleType {
+                    value: number;
+                }
+                export interface BananaType {
+                    flag: boolean;
+                }
+            `);
+
+            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);
+
+            const definitionKeys = Object.keys(mergedSchema.definitions || {});
+            const sortedKeys = [...definitionKeys].sort();
+
+            expect(definitionKeys).toEqual(sortedKeys);
+            expect(definitionKeys).toEqual(['AppleType', 'BananaType', 'MiddleType', 'ZebraType']);
+        });
+
+        it("should maintain alphabetical order for definitions with numbers and special characters", async () => {
+            const file1 = await createTestFile("special.jsonschema.ts", `
+                export interface Type1 {
+                    id: string;
+                }
+                export interface TypeA {
+                    name: string;
+                }
+                export interface Type10 {
+                    value: number;
+                }
+                export interface Type2 {
+                    flag: boolean;
+                }
+            `);
+
+            const processor = new SchemaProcessor({
+                additionalProperties: false,
+                parallel: false
+            });
+
+            const files: FileInfo[] = [{ path: file1 }];
+            const schemaMap = await processor.processFiles(files);
+            const mergedSchema = processor.mergeSchemas(schemaMap);
+
+            const definitionKeys = Object.keys(mergedSchema.definitions || {});
+            const sortedKeys = [...definitionKeys].sort();
+
+            expect(definitionKeys).toEqual(sortedKeys);
+            // Natural alphabetical order: numbers before letters
+            expect(definitionKeys).toEqual(['Type1', 'Type10', 'Type2', 'TypeA']);
+        });
     });
 
     describe("error handling", () => {

package/src/services/SchemaProcessor.ts

@@ -27,9 +27,12 @@ export class SchemaProcessor {
             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(files)
-            : await this.processSequentially(files);
+            ? await this.processInParallel(sortedFiles)
+            : await this.processSequentially(sortedFiles);
 
         return this.consolidateSchemas(results);
     }
@@ -38,6 +41,7 @@ export class SchemaProcessor {
         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;
@@ -106,7 +110,10 @@ export class SchemaProcessor {
         const schemaMap = new Map<string, Schema>();
         const errors: Error[] = [];
         
-        for (const result of results) {
+        // 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;
@@ -128,10 +135,14 @@ export class SchemaProcessor {
     public validateSchemaCompatibility(schemaMap: Map<string, Schema>): void {
         const definitions: { [id: string]: any } = {};
         
-        schemaMap.forEach((fileSchema, filePath) => {
+        // 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 ?? {};
             
-            Object.keys(defs).forEach((key) => {
+            // Sort definition keys for consistent processing
+            Object.keys(defs).sort().forEach((key) => {
                 if (definitions[key] !== undefined) {
                     try {
                         assert.deepEqual(definitions[key], defs[key]);
@@ -147,27 +158,37 @@ export class SchemaProcessor {
                 }
                 definitions[key] = defs[key];
             });
-        });
+        }
     }
 
     public mergeSchemas(schemaMap: Map<string, Schema>): Schema {
         const definitions: { [id: string]: Schema } = {};
         let schemaVersion = "";
         
-        schemaMap.forEach((fileSchema) => {
+        // 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 ?? {};
-            Object.keys(defs).forEach((key) => {
+            // 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,
+            definitions: sortedDefinitions,
         };
     }
 }

package/src/services/SchemaWriter.test.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { SchemaWriter } from "./SchemaWriter";
 import { CodeGenerationError } from "../errors";
 
-const testDir = path.resolve(__dirname, "../test-tmp/schema-writer");
+const testDir = path.resolve(__dirname, "../../.test-tmp/schema-writer");
 
 const cleanup = async () => {
     if (fs.existsSync(testDir)) {

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(yarn test)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/dist/test/output/duplicate-symbols-identitcal-implementation/ValidationType.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ValidationType.js.map

package/dist/test/output/duplicate-symbols-identitcal-implementation/ValidationType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ValidationType.js","sourceRoot":"","sources":["../../../../src/test/output/duplicate-symbols-identitcal-implementation/ValidationType.ts"],"names":[],"mappings":""}