ts-runtime-validation 1.6.16 → 1.7.0

package/src/services/CodeGenerator.ts

@@ -0,0 +1,352 @@
+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[] = [];
+        
+        schemaMap.forEach((schema, filePath) => {
+            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);
+            
+            Object.keys(defs).forEach((symbol) => {
+                const typeAlias = readerSourceFile.getTypeAlias(symbol);
+                const typeInterface = readerSourceFile.getInterface(symbol);
+                
+                if (typeAlias || typeInterface) {
+                    typeInfos.push({
+                        symbol,
+                        importPath: getPosixPath(relativeImportPath),
+                        isInterface: !!typeInterface
+                    });
+                }
+            });
+        });
+        
+        return typeInfos;
+    }
+
+    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(`{`);
+                        typeInfos.forEach(({ symbol }) => {
+                            writer.writeLine(`["#/definitions/${symbol}"] : "${symbol}",`);
+                        });
+                        writer.writeLine(`}`);
+                    },
+                },
+            ],
+        });
+        
+        sourceFile.addInterface({
+            kind: StructureKind.Interface,
+            name: "ISchema",
+            isExported: true,
+            properties: typeInfos.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);
+        });
+        
+        importMap.forEach((symbols, importPath) => {
+            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);
+        });
+        
+        importMap.forEach((symbols, importPath) => {
+            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[]>();
+        typeInfos.forEach(({ symbol, importPath }) => {
+            const existing = importMap.get(importPath) || [];
+            existing.push(symbol);
+            importMap.set(importPath, existing);
+        });
+        
+        importMap.forEach((symbols, importPath) => {
+            const declaration = sourceFile.addImportDeclaration({
+                moduleSpecifier: importPath
+            });
+            symbols.forEach((symbol) => {
+                declaration.addNamedImport({
+                    name: symbol,
+                    alias: `_${symbol}`
+                });
+            });
+        });
+        
+        if (this.options.treeShaking) {
+            typeInfos.forEach(({ symbol }) => {
+                sourceFile.addTypeAlias({
+                    name: symbol,
+                    type: `_${symbol}`,
+                    isExported: true
+                });
+            });
+        } else {
+            const namespace = sourceFile.addModule({
+                name: "ValidationType",
+                isExported: true,
+            });
+            
+            typeInfos.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");
+        });
+    });
+});

package/src/services/FileDiscovery.ts

@@ -0,0 +1,137 @@
+import { fdir } from "fdir";
+import picomatch from "picomatch";
+import path from "path";
+import fs from "fs";
+import crypto from "crypto";
+import { FileDiscoveryError } from "../errors";
+
+export interface FileDiscoveryOptions {
+    glob: string;
+    rootPath: string;
+    cacheEnabled?: boolean;
+    cachePath?: string;
+}
+
+export interface FileInfo {
+    path: string;
+    hash?: string;
+    lastModified?: Date;
+}
+
+export class FileDiscovery {
+    private cacheFile: string;
+    private fileCache: Map<string, string> = new Map();
+
+    constructor(private options: FileDiscoveryOptions) {
+        this.cacheFile = path.join(
+            options.cachePath || ".ts-runtime-validation-cache",
+            "file-hashes.json"
+        );
+        if (options.cacheEnabled) {
+            this.loadCache();
+        }
+    }
+
+    public async discoverFiles(): Promise<FileInfo[]> {
+        const { glob, rootPath } = this.options;
+        
+        try {
+            const api = new fdir({
+                includeBasePath: true,
+                includeDirs: false,
+                filters: [
+                    (filePath) => {
+                        return picomatch.isMatch(filePath, glob, { contains: true });
+                    },
+                ],
+            }).crawl(rootPath);
+
+            const files = await api.withPromise();
+            
+            if (files.length === 0) {
+                throw new FileDiscoveryError(
+                    `No files found matching pattern: ${glob} in ${rootPath}`
+                );
+            }
+
+            return this.options.cacheEnabled 
+                ? await this.enrichWithCacheInfo(files)
+                : files.map(path => ({ path }));
+        } catch (error) {
+            if (error instanceof FileDiscoveryError) {
+                throw error;
+            }
+            throw new FileDiscoveryError(
+                `Failed to discover files: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
+    private async enrichWithCacheInfo(files: string[]): Promise<FileInfo[]> {
+        const enrichedFiles = await Promise.all(
+            files.map(async (filePath) => {
+                const stats = await fs.promises.stat(filePath);
+                const hash = await this.getFileHash(filePath);
+                return {
+                    path: filePath,
+                    hash,
+                    lastModified: stats.mtime
+                };
+            })
+        );
+        
+        await this.saveCache(enrichedFiles);
+        return enrichedFiles;
+    }
+
+    private async getFileHash(filePath: string): Promise<string> {
+        const content = await fs.promises.readFile(filePath, 'utf-8');
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+
+    public hasFileChanged(filePath: string, currentHash: string): boolean {
+        const cachedHash = this.fileCache.get(filePath);
+        return cachedHash !== currentHash;
+    }
+
+    private loadCache(): void {
+        try {
+            if (fs.existsSync(this.cacheFile)) {
+                const cacheData = JSON.parse(
+                    fs.readFileSync(this.cacheFile, 'utf-8')
+                );
+                this.fileCache = new Map(Object.entries(cacheData));
+            }
+        } catch (error) {
+            console.warn('Failed to load cache, starting fresh');
+            this.fileCache.clear();
+        }
+    }
+
+    private async saveCache(files: FileInfo[]): Promise<void> {
+        const cacheDir = path.dirname(this.cacheFile);
+        if (!fs.existsSync(cacheDir)) {
+            await fs.promises.mkdir(cacheDir, { recursive: true });
+        }
+
+        const cacheData: Record<string, string> = {};
+        files.forEach(file => {
+            if (file.hash) {
+                cacheData[file.path] = file.hash;
+                this.fileCache.set(file.path, file.hash);
+            }
+        });
+
+        await fs.promises.writeFile(
+            this.cacheFile,
+            JSON.stringify(cacheData, null, 2)
+        );
+    }
+
+    public clearCache(): void {
+        this.fileCache.clear();
+        if (fs.existsSync(this.cacheFile)) {
+            fs.unlinkSync(this.cacheFile);
+        }
+    }
+}