ts-runtime-validation 1.6.16 → 1.8.0

package/src/services/CodeGenerator.ts

@@ -0,0 +1,370 @@
+import {
+    Project,
+    IndentationText,
+    NewLineKind,
+    QuoteKind,
+    StructureKind,
+    VariableDeclarationKind,
+    CodeBlockWriter,
+    ProjectOptions,
+    SourceFileCreateOptions,
+} from "ts-morph";
+import { Schema } from "ts-json-schema-generator";
+import path from "path";
+import { getPosixPath } from "../getPosixPath";
+import { CodeGenerationError } from "../errors";
+
+export interface CodeGeneratorOptions {
+    outputPath: string;
+    minify?: boolean;
+    treeShaking?: boolean;
+    lazyLoad?: boolean;
+}
+
+interface TypeInfo {
+    symbol: string;
+    importPath: string;
+    isInterface: boolean;
+}
+
+const defaultTsMorphProjectSettings: ProjectOptions = {
+    manipulationSettings: {
+        indentationText: IndentationText.FourSpaces,
+        newLineKind: NewLineKind.LineFeed,
+        quoteKind: QuoteKind.Double,
+        usePrefixAndSuffixTextForRename: false,
+        useTrailingCommas: true,
+    },
+};
+
+const defaultCreateFileOptions: SourceFileCreateOptions = {
+    overwrite: true,
+};
+
+export class CodeGenerator {
+    private project: Project;
+    
+    constructor(private options: CodeGeneratorOptions) {
+        this.project = new Project(defaultTsMorphProjectSettings);
+    }
+
+    public async generateSchemaDefinition(
+        schemaMap: Map<string, Schema>,
+        outputFile: string
+    ): Promise<void> {
+        try {
+            const typeInfos = this.extractTypeInfo(schemaMap);
+            await this.writeSchemaDefinitionFile(typeInfos, outputFile);
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to generate schema definition: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
+    public async generateValidatorFunction(outputFile: string): Promise<void> {
+        try {
+            const sourceFile = this.project.createSourceFile(outputFile, {}, defaultCreateFileOptions);
+            
+            if (this.options.lazyLoad) {
+                this.generateLazyValidator(sourceFile);
+            } else {
+                this.generateStandardValidator(sourceFile);
+            }
+            
+            await this.project.save();
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to generate validator function: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
+    public async generateValidationTypes(
+        schemaMap: Map<string, Schema>,
+        outputFile: string
+    ): Promise<void> {
+        try {
+            const typeInfos = this.extractTypeInfo(schemaMap);
+            await this.writeValidationTypesFile(typeInfos, outputFile);
+        } catch (error) {
+            throw new CodeGenerationError(
+                `Failed to generate validation types: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
+    private extractTypeInfo(schemaMap: Map<string, Schema>): TypeInfo[] {
+        const readerProject = new Project(defaultTsMorphProjectSettings);
+        const typeInfos: TypeInfo[] = [];
+        
+        // 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);
+            const relativeImportPath = `${relativeFilePath}/${fileWithoutExtension}`;
+            const defs = schema.definitions ?? {};
+            
+            const readerSourceFile = readerProject.addSourceFileAtPath(filePath);
+            
+            // Sort definition keys alphabetically
+            Object.keys(defs).sort().forEach((symbol) => {
+                const typeAlias = readerSourceFile.getTypeAlias(symbol);
+                const typeInterface = readerSourceFile.getInterface(symbol);
+                
+                if (typeAlias || typeInterface) {
+                    typeInfos.push({
+                        symbol,
+                        importPath: getPosixPath(relativeImportPath),
+                        isInterface: !!typeInterface
+                    });
+                }
+            });
+        }
+        
+        // Sort typeInfos alphabetically by symbol
+        return typeInfos.sort((a, b) => a.symbol.localeCompare(b.symbol));
+    }
+
+    private async writeSchemaDefinitionFile(
+        typeInfos: TypeInfo[],
+        outputFile: string
+    ): Promise<void> {
+        const sourceFile = this.project.createSourceFile(outputFile, {}, defaultCreateFileOptions);
+        
+        if (this.options.treeShaking) {
+            this.generateTreeShakingImports(sourceFile, typeInfos);
+        } else {
+            this.generateStandardImports(sourceFile, typeInfos);
+        }
+        
+        sourceFile.addVariableStatement({
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "schemas",
+                    type: "Record<keyof ISchema, string>",
+                    initializer: (writer: CodeBlockWriter) => {
+                        writer.writeLine(`{`);
+                        // Sort by symbol for consistent output
+                        [...typeInfos].sort((a, b) => a.symbol.localeCompare(b.symbol)).forEach(({ symbol }) => {
+                            writer.writeLine(`["#/definitions/${symbol}"] : "${symbol}",`);
+                        });
+                        writer.writeLine(`}`);
+                    },
+                },
+            ],
+        });
+        
+        sourceFile.addInterface({
+            kind: StructureKind.Interface,
+            name: "ISchema",
+            isExported: true,
+            properties: [...typeInfos].sort((a, b) => a.symbol.localeCompare(b.symbol)).map(({ symbol }) => ({
+                name: `readonly ["#/definitions/${symbol}"]`,
+                type: symbol
+            })),
+        });
+        
+        await this.project.save();
+    }
+
+    private generateTreeShakingImports(sourceFile: any, typeInfos: TypeInfo[]): void {
+        const importMap = new Map<string, string[]>();
+        
+        typeInfos.forEach(({ symbol, importPath }) => {
+            const existing = importMap.get(importPath) || [];
+            existing.push(symbol);
+            importMap.set(importPath, existing);
+        });
+        
+        // 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
+            });
+        });
+    }
+
+    private generateStandardImports(sourceFile: any, typeInfos: TypeInfo[]): void {
+        const importMap = new Map<string, string[]>();
+        
+        typeInfos.forEach(({ symbol, importPath }) => {
+            const existing = importMap.get(importPath) || [];
+            existing.push(symbol);
+            importMap.set(importPath, existing);
+        });
+        
+        // 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
+            });
+        });
+    }
+
+    private generateLazyValidator(sourceFile: any): void {
+        sourceFile.addImportDeclaration({
+            namespaceImport: "schema",
+            moduleSpecifier: "./validation.schema.json"
+        });
+        sourceFile.addImportDeclaration({
+            namedImports: ["ISchema", "schemas"],
+            moduleSpecifier: "./SchemaDefinition"
+        });
+        
+        sourceFile.addVariableStatement({
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Let,
+            declarations: [
+                {
+                    name: "validator",
+                    type: "any",
+                    initializer: "null"
+                }
+            ]
+        });
+        
+        sourceFile.addFunction({
+            name: "getValidator",
+            isExported: false,
+            statements: (writer: CodeBlockWriter) => {
+                writer.writeLine(`if (!validator) {`);
+                writer.writeLine(`    const Ajv = require("ajv");`);
+                writer.writeLine(`    validator = new Ajv({ allErrors: true });`);
+                writer.writeLine(`    validator.compile(schema);`);
+                writer.writeLine(`}`);
+                writer.writeLine(`return validator;`);
+            }
+        });
+        
+        sourceFile.addVariableStatement({
+            declarationKind: VariableDeclarationKind.Const,
+            isExported: true,
+            declarations: [
+                {
+                    name: "isValidSchema",
+                    initializer: (writer: CodeBlockWriter) => {
+                        writer.writeLine(`<T extends keyof typeof schemas>(data: unknown, schemaKeyRef: T): data is ISchema[T] => {`);
+                        writer.writeLine(`const v = getValidator();`);
+                        writer.writeLine(`v.validate(schemaKeyRef as string, data);`);
+                        writer.writeLine(`return Boolean(v.errors) === false;`);
+                        writer.writeLine(`}`);
+                    },
+                },
+            ],
+        });
+    }
+
+    private generateStandardValidator(sourceFile: any): void {
+        sourceFile.addImportDeclaration({
+            namespaceImport: "schema",
+            moduleSpecifier: "./validation.schema.json"
+        });
+        sourceFile.addImportDeclaration({
+            defaultImport: "Ajv",
+            moduleSpecifier: "ajv"
+        });
+        sourceFile.addImportDeclaration({
+            namedImports: ["ISchema", "schemas"],
+            moduleSpecifier: "./SchemaDefinition"
+        });
+        
+        sourceFile.addVariableStatement({
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "validator",
+                    initializer: (writer: CodeBlockWriter) => {
+                        writer.writeLine(`new Ajv({ allErrors: true });`);
+                        writer.writeLine(`validator.compile(schema)`);
+                    },
+                },
+            ],
+        });
+        
+        sourceFile.addVariableStatement({
+            declarationKind: VariableDeclarationKind.Const,
+            isExported: true,
+            declarations: [
+                {
+                    name: "isValidSchema",
+                    initializer: (writer: CodeBlockWriter) => {
+                        writer.writeLine(`<T extends keyof typeof schemas>(data: unknown, schemaKeyRef: T): data is ISchema[T] => {`);
+                        writer.writeLine(`validator.validate(schemaKeyRef as string, data);`);
+                        writer.writeLine(`return Boolean(validator.errors) === false;`);
+                        writer.writeLine(`}`);
+                    },
+                },
+            ],
+        });
+    }
+
+    private async writeValidationTypesFile(
+        typeInfos: TypeInfo[],
+        outputFile: string
+    ): Promise<void> {
+        const sourceFile = this.project.createSourceFile(outputFile, {}, defaultCreateFileOptions);
+        
+        const importMap = new Map<string, string[]>();
+        // 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);
+        });
+        
+        // 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
+            });
+            symbols.forEach((symbol) => {
+                declaration.addNamedImport({
+                    name: symbol,
+                    alias: `_${symbol}`
+                });
+            });
+        });
+        
+        if (this.options.treeShaking) {
+            sortedTypeInfos.forEach(({ symbol }) => {
+                sourceFile.addTypeAlias({
+                    name: symbol,
+                    type: `_${symbol}`,
+                    isExported: true
+                });
+            });
+        } else {
+            const namespace = sourceFile.addModule({
+                name: "ValidationType",
+                isExported: true,
+            });
+            
+            sortedTypeInfos.forEach(({ symbol }) => {
+                namespace.addTypeAlias({
+                    name: symbol,
+                    type: `_${symbol}`,
+                    isExported: true
+                });
+            });
+        }
+        
+        await this.project.save();
+    }
+}

package/src/services/FileDiscovery.test.ts

@@ -0,0 +1,216 @@
+import fs from "fs";
+import path from "path";
+import { FileDiscovery } from "./FileDiscovery";
+import { FileDiscoveryError } from "../errors";
+
+const testDir = path.resolve(__dirname, "../../.test-tmp/file-discovery");
+const cacheDir = path.resolve(testDir, ".cache");
+
+const createTestFile = async (filePath: string, content: string = "test content") => {
+    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("FileDiscovery", () => {
+    describe("discoverFiles", () => {
+        it("should find files matching glob pattern", async () => {
+            await createTestFile("types/user.jsonschema.ts", "export interface User {}");
+            await createTestFile("types/product.jsonschema.ts", "export interface Product {}");
+            await createTestFile("types/order.ts", "export interface Order {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files = await discovery.discoverFiles();
+
+            expect(files).toHaveLength(2);
+            expect(files.map(f => path.basename(f.path))).toEqual(
+                expect.arrayContaining(["user.jsonschema.ts", "product.jsonschema.ts"])
+            );
+        });
+
+        it("should handle nested directory patterns", async () => {
+            await createTestFile("api/v1/user.jsonschema.ts", "export interface User {}");
+            await createTestFile("api/v2/product.jsonschema.ts", "export interface Product {}");
+            await createTestFile("utils/helper.ts", "export const helper = () => {}");
+
+            const discovery = new FileDiscovery({
+                glob: "**/*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files = await discovery.discoverFiles();
+
+            expect(files).toHaveLength(2);
+            expect(files.every(f => f.path.includes(".jsonschema.ts"))).toBe(true);
+        });
+
+        it("should throw error when no files found", async () => {
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            await expect(discovery.discoverFiles()).rejects.toThrow(FileDiscoveryError);
+        });
+
+        it("should throw error for invalid directory", async () => {
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: "/nonexistent/path"
+            });
+
+            await expect(discovery.discoverFiles()).rejects.toThrow(FileDiscoveryError);
+        });
+    });
+
+    describe("caching", () => {
+        it("should generate file hashes when caching enabled", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            const files = await discovery.discoverFiles();
+
+            expect(files).toHaveLength(1);
+            expect(files[0].hash).toBeDefined();
+            expect(files[0].lastModified).toBeDefined();
+            expect(typeof files[0].hash).toBe("string");
+        });
+
+        it("should save and load cache correctly", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            // First run - should create cache
+            const files1 = await discovery.discoverFiles();
+            expect(fs.existsSync(path.join(cacheDir, "file-hashes.json"))).toBe(true);
+
+            // Second run - should load from cache
+            const discovery2 = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            const files2 = await discovery2.discoverFiles();
+            expect(files1[0].hash).toBe(files2[0].hash);
+        });
+
+        it("should detect file changes", async () => {
+            const filePath = await createTestFile("user.jsonschema.ts", "export interface User {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            const files1 = await discovery.discoverFiles();
+            const originalHash = files1[0].hash!;
+
+            // Modify file
+            await fs.promises.writeFile(filePath, "export interface User { name: string; }");
+
+            const files2 = await discovery.discoverFiles();
+            const newHash = files2[0].hash!;
+
+            expect(discovery.hasFileChanged(filePath, originalHash)).toBe(true);
+            expect(originalHash).not.toBe(newHash);
+        });
+
+        it("should clear cache correctly", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            await discovery.discoverFiles();
+            expect(fs.existsSync(path.join(cacheDir, "file-hashes.json"))).toBe(true);
+
+            discovery.clearCache();
+            expect(fs.existsSync(path.join(cacheDir, "file-hashes.json"))).toBe(false);
+        });
+
+        it("should handle corrupted cache gracefully", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+            
+            // Create corrupted cache file
+            await fs.promises.mkdir(cacheDir, { recursive: true });
+            await fs.promises.writeFile(path.join(cacheDir, "file-hashes.json"), "invalid json");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir,
+                cacheEnabled: true,
+                cachePath: cacheDir
+            });
+
+            // Should not throw error and should work normally
+            const files = await discovery.discoverFiles();
+            expect(files).toHaveLength(1);
+        });
+    });
+
+    describe("file patterns", () => {
+        it("should support multiple extensions", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+            await createTestFile("product.jsonschema.tsx", "export interface Product {}");
+            await createTestFile("order.types.ts", "export interface Order {}");
+
+            const discovery = new FileDiscovery({
+                glob: "*.{jsonschema.ts,jsonschema.tsx}",
+                rootPath: testDir
+            });
+
+            const files = await discovery.discoverFiles();
+            expect(files).toHaveLength(2);
+        });
+
+        it("should exclude files not matching pattern", async () => {
+            await createTestFile("user.jsonschema.ts", "export interface User {}");
+            await createTestFile("user.test.ts", "test file");
+            await createTestFile("user.spec.ts", "spec file");
+            await createTestFile("README.md", "readme");
+
+            const discovery = new FileDiscovery({
+                glob: "*.jsonschema.ts",
+                rootPath: testDir
+            });
+
+            const files = await discovery.discoverFiles();
+            expect(files).toHaveLength(1);
+            expect(files[0].path).toContain("user.jsonschema.ts");
+        });
+    });
+});