ts-runtime-validation 1.6.16 → 1.7.0

package/src/SchemaGenerator.ts

@@ -1,316 +1,130 @@
-import { fdir } from "fdir";
 import { ICommandOptions } from "./ICommandOptions";
-import fs from "fs";
-import picomatch from "picomatch";
 import path from "path";
-import {
-    Project,
-    IndentationText,
-    NewLineKind,
-    QuoteKind,
-    StructureKind,
-    VariableDeclarationKind,
-    CodeBlockWriter,
-    ProjectOptions,
-    SourceFileCreateOptions,
-} from "ts-morph";
-import * as tsj from "ts-json-schema-generator";
-import { Config, Schema } from "ts-json-schema-generator";
-import assert from "assert";
-import { writeLine } from "./writeLine";
-import { getPosixPath } from "./getPosixPath";
-
-const defaultTsMorphProjectSettings: ProjectOptions = {
-    manipulationSettings: {
-        indentationText: IndentationText.FourSpaces,
-        newLineKind: NewLineKind.LineFeed,
-        quoteKind: QuoteKind.Double,
-        usePrefixAndSuffixTextForRename: false,
-        useTrailingCommas: true,
-    },
-};
-
-const defaultCreateFileOptions: SourceFileCreateOptions = {
-    overwrite: true,
-};
+import { FileDiscovery } from "./services/FileDiscovery";
+import { SchemaProcessor } from "./services/SchemaProcessor";
+import { CodeGenerator } from "./services/CodeGenerator";
+import { SchemaWriter } from "./services/SchemaWriter";
+import { ProgressReporter } from "./utils/ProgressReporter";
+import { formatError, isKnownError } from "./errors";
 
 const validationSchemaFileName = "validation.schema.json";
 const schemaDefinitionFileName = "SchemaDefinition.ts";
 const validationInterfacesFile = "ValidationType.ts";
+const isValidSchemaFileName = "isValidSchema.ts";
 
 export class SchemaGenerator {
     private outputPath = path.join(this.options.rootPath, this.options.output);
-    private jsonSchemaOutputFile = path.join(this.options.rootPath, this.options.output, validationSchemaFileName);
-    private tsSchemaDefinitionOutputFile = path.join(this.options.rootPath, this.options.output, schemaDefinitionFileName);
-    private validationTypesOutputFile = path.join(this.options.rootPath, this.options.output, validationInterfacesFile);
-    private isValidSchemaOutputFile = path.join(this.options.rootPath, this.options.output, "isValidSchema.ts");
-
-    public constructor(private options: ICommandOptions) {}
-
-    public Generate = async () => {
-        const { helpers, glob } = this.options;
-        const fileList = await this.getMatchingFiles();
-
-        console.log(`Found ${fileList.length} schema file(s)`);
-        if (fileList.length === 0) {
-            writeLine(`Aborting - no files found with glob: ${glob}`);
-            return;
-        }
-        const fileSchemas = await this.getJsonSchemasForFiles(fileList);
-
-        if (fileSchemas.size === 0) {
-            writeLine(`Aborting - no types found: ${glob}`);
-            return;
-        }
-        this.writeSchemaMapToValidationSchema(fileSchemas);
-        if (helpers === false) {
-            writeLine("Skipping helper file generation");
-            return;
-        }
-        await this.writeSchemaMapToValidationTypes(fileSchemas);
-        this.writeValidatorFunction();
-        writeLine("Writing validation types file");
-        this.writeValidationTypes(fileSchemas);
-    };
-
-    private getMatchingFiles = async () => {
-        const { glob, rootPath } = this.options;
-        const api = new fdir({
-            includeBasePath: true,
-            includeDirs: false,
-            filters: [
-                (path) => {
-                    return picomatch.isMatch(path, glob, { contains: true });
-                },
-            ],
-        }).crawl(rootPath);
-        return api.withPromise();
-    };
-
-    private getJsonSchemasForFiles = async (filesList: Array<string>) => {
-        const { additionalProperties, tsconfigPath } = this.options;
-        const schemaMap = new Map<string, Schema>();
-        const tsconfig = tsconfigPath.length > 0 ? tsconfigPath : undefined;
-        filesList.forEach((file, index) => {
-            writeLine(`\rProcessing file ${index + 1} of ${filesList.length}: ${file}`);
-            const config: Config = {
-                path: file,
-                type: "*",
-                additionalProperties,
-                encodeRefs: false,
-                sortProps: true,
-                ...(tsconfig !== null ? { tsconfig } : {}),
-            };
-
-            const schemaGenerator = tsj.createGenerator(config);
-            const fileSchemas = schemaGenerator.createSchema(config.type);
-            schemaMap.set(file, fileSchemas);
-        });
-        return schemaMap;
-    };
-
-    private getSchemaVersion = (schemaMap: Map<string, Schema>) => {
-        const firstEntry = schemaMap.values().next().value;
-        return firstEntry?.["$schema"] ?? "";
-    };
-
-    private ensureOutputPathExists = () => {
-        if (!fs.existsSync(this.outputPath)) {
-            fs.mkdirSync(this.outputPath, { recursive: true });
-        }
-    };
-
-    private writeSchemaMapToValidationSchema = (schemaMap: Map<string, Schema>) => {
-        const definitions: { [id: string]: Schema } = {};
-        schemaMap.forEach((fileSchema) => {
-            const defs = fileSchema.definitions ?? {};
-
-            Object.keys(defs).forEach((key) => {
-                if (definitions[key] !== undefined) {
-                    try {
-                        assert.deepEqual(definitions[key], defs[key]);
-                    } catch (e) {
-                        console.error(
-                            `Duplicate symbol: ${key} found with varying definitions.\nDefinition 1:\n${JSON.stringify(
-                                definitions[key],
-                                null,
-                                4
-                            )}\nDefinition 2:\n${JSON.stringify(defs[key], null, 4)}`
-                        );
-                        throw e;
-                    }
-                }
-                const schema = defs[key] as Schema;
-                definitions[key] = schema;
-            });
-        });
-        const outputBuffer: Schema = {
-            $schema: this.getSchemaVersion(schemaMap),
-            definitions,
-        };
-
-        this.ensureOutputPathExists();
-        fs.writeFileSync(this.jsonSchemaOutputFile, JSON.stringify(outputBuffer, null, 4));
-    };
-
-    private writeSchemaMapToValidationTypes = async (schemaMap: Map<string, Schema>) => {
-        const project = new Project(defaultTsMorphProjectSettings);
-        const readerProject = new Project(defaultTsMorphProjectSettings);
-
-        const symbols: Array<string> = [];
-
-        const importMap = new Map<string, Array<string>>();
-        schemaMap.forEach((schema, filePath) => {
-            const dir = path.dirname(filePath);
-            const fileWithoutExtension = path.parse(filePath).name;
-            const relativeFilePath = path.relative(this.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);
-                const hasTypeOrInterface = (typeAlias ?? typeInterface) !== undefined;
-                if (hasTypeOrInterface) {
-                    const namedImports = importMap.get(relativeImportPath) ?? [];
-                    namedImports.push(symbol);
-                    importMap.set(relativeImportPath, namedImports);
-                    symbols.push(symbol);
-                }
-            });
-        });
-
-        const sourceFile = project.createSourceFile(this.tsSchemaDefinitionOutputFile, {}, defaultCreateFileOptions);
-
-        importMap.forEach((namedImports, importPath) => {
-            sourceFile.addImportDeclaration({ namedImports, moduleSpecifier: getPosixPath(importPath) });
+    private jsonSchemaOutputFile = path.join(this.outputPath, validationSchemaFileName);
+    private tsSchemaDefinitionOutputFile = path.join(this.outputPath, schemaDefinitionFileName);
+    private validationTypesOutputFile = path.join(this.outputPath, validationInterfacesFile);
+    private isValidSchemaOutputFile = path.join(this.outputPath, isValidSchemaFileName);
+    
+    private fileDiscovery: FileDiscovery;
+    private schemaProcessor: SchemaProcessor;
+    private codeGenerator: CodeGenerator;
+    private schemaWriter: SchemaWriter;
+    private progressReporter: ProgressReporter;
+
+    public constructor(private options: ICommandOptions) {
+        this.fileDiscovery = new FileDiscovery({
+            glob: options.glob,
+            rootPath: options.rootPath,
+            cacheEnabled: options.cache || false,
+            cachePath: path.join(options.rootPath, ".ts-runtime-validation-cache")
         });
-
-        sourceFile.addVariableStatement({
-            isExported: true,
-            declarationKind: VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    name: "schemas",
-                    type: "Record<keyof ISchema, string>",
-                    initializer: (writer: CodeBlockWriter) => {
-                        writer.writeLine(`{`);
-                        symbols.forEach((symbol) => {
-                            writer.writeLine(`["#/definitions/${symbol}"] : "${symbol}",`);
-                        }),
-                            writer.writeLine(`}`);
-                    },
-                },
-            ],
+        
+        this.schemaProcessor = new SchemaProcessor({
+            additionalProperties: options.additionalProperties,
+            tsconfigPath: options.tsconfigPath || undefined,
+            parallel: options.parallel !== false,
+            verbose: options.verbose || false
         });
-
-        sourceFile.addInterface({
-            kind: StructureKind.Interface,
-            name: "ISchema",
-            isExported: true,
-            properties: symbols.map((symbol) => {
-                return { name: `readonly ["#/definitions/${symbol}"]`, type: symbol };
-            }),
+        
+        this.codeGenerator = new CodeGenerator({
+            outputPath: this.outputPath,
+            minify: options.minify || false,
+            treeShaking: options.treeShaking || false,
+            lazyLoad: options.lazyLoad || false
         });
-
-        await project.save();
-    };
-
-    private writeValidatorFunction = async () => {
-        const project = new Project(defaultTsMorphProjectSettings);
-        const sourceFile = project.createSourceFile(this.isValidSchemaOutputFile, {}, defaultCreateFileOptions);
-        sourceFile.addImportDeclaration({ namespaceImport: "schema", moduleSpecifier: `./${validationSchemaFileName}` });
-        sourceFile.addImportDeclaration({ defaultImport: "Ajv", moduleSpecifier: "ajv" });
-        sourceFile.addImportDeclaration({
-            namedImports: ["ISchema", "schemas"],
-            moduleSpecifier: `./${path.parse(schemaDefinitionFileName).name}`,
+        
+        this.schemaWriter = new SchemaWriter({
+            outputPath: this.outputPath,
+            minify: options.minify || false
         });
-        sourceFile.addVariableStatement({
-            isExported: true,
-            declarationKind: VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    name: "validator",
-                    initializer: (writer: CodeBlockWriter) => {
-                        writer.writeLine(`new Ajv({ allErrors: true });`);
-                        writer.writeLine(`validator.compile(schema)`);
-                    },
-                },
-            ],
+        
+        this.progressReporter = new ProgressReporter({
+            enabled: options.progress || false,
+            showBar: true
         });
+    }
 
-        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(`}`);
-                    },
-                },
-            ],
-        });
-        await project.save();
+    public Generate = async () => {
+        try {
+            this.progressReporter.start("Starting schema generation...");
+            
+            const { helpers } = this.options;
+            
+            // Discover files
+            this.progressReporter.update(0, "Discovering files...");
+            const files = await this.fileDiscovery.discoverFiles();
+            
+            if (this.options.verbose) {
+                console.log(`Found ${files.length} schema file(s)`);
+                files.forEach(file => console.log(`  - ${file.path}`));
+            }
+            
+            // Process schemas
+            this.progressReporter.update(1, "Processing TypeScript files...");
+            this.progressReporter.options.total = files.length + 4; // files + 4 generation steps
+            
+            const schemaMap = await this.schemaProcessor.processFiles(files);
+            
+            if (schemaMap.size === 0) {
+                console.log("No types found to generate schemas for");
+                return;
+            }
+            
+            // Validate schema compatibility
+            this.progressReporter.update(files.length + 1, "Validating schema compatibility...");
+            this.schemaProcessor.validateSchemaCompatibility(schemaMap);
+            
+            // Merge and write JSON schema
+            this.progressReporter.update(files.length + 2, "Writing JSON schema...");
+            const mergedSchema = this.schemaProcessor.mergeSchemas(schemaMap);
+            await this.schemaWriter.writeJsonSchema(mergedSchema, this.jsonSchemaOutputFile);
+            
+            if (helpers === false) {
+                this.progressReporter.complete("Schema generation completed (helpers skipped)");
+                return;
+            }
+            
+            // Generate TypeScript helpers
+            this.progressReporter.update(files.length + 3, "Generating TypeScript helpers...");
+            await Promise.all([
+                this.codeGenerator.generateSchemaDefinition(schemaMap, this.tsSchemaDefinitionOutputFile),
+                this.codeGenerator.generateValidatorFunction(this.isValidSchemaOutputFile),
+                this.codeGenerator.generateValidationTypes(schemaMap, this.validationTypesOutputFile)
+            ]);
+            
+            this.progressReporter.complete("Schema generation completed successfully");
+            
+        } catch (error) {
+            const formattedError = formatError(error, this.options.verbose || false);
+            console.error(`Schema generation failed: ${formattedError}`);
+            
+            if (!isKnownError(error) && this.options.verbose) {
+                console.error(error);
+            }
+            
+            throw error;
+        }
     };
 
-    private writeValidationTypes = async (schemaMap: Map<string, Schema>) => {
-        const project = new Project(defaultTsMorphProjectSettings);
-        const readerProject = new Project(defaultTsMorphProjectSettings);
-
-        const symbols: Array<string> = [];
-
-        const importMap = new Map<string, Array<string>>();
-        schemaMap.forEach((schema, filePath) => {
-            const dir = path.dirname(filePath);
-            const fileWithoutExtension = path.parse(filePath).name;
-            const relativeFilePath = path.relative(this.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);
-                const hasTypeOrInterface = (typeAlias ?? typeInterface) !== undefined;
-                if (hasTypeOrInterface) {
-                    const namedImports = importMap.get(relativeImportPath) ?? [];
-                    namedImports.push(symbol);
-                    importMap.set(relativeImportPath, namedImports);
-                    symbols.push(symbol);
-                }
-            });
-        });
-
-        const sourceFile = project.createSourceFile(this.validationTypesOutputFile, {}, defaultCreateFileOptions);
-
-        importMap.forEach((namedImports, importPath) => {
-            const declaration = sourceFile.addImportDeclaration({ moduleSpecifier: getPosixPath(importPath) });
-            namedImports.forEach((namedImport) => {
-                const name = namedImport.valueOf();
-                const alias = `_${name}`;
-                declaration.addNamedImport({ name, alias });
-            });
-        });
-        const namespace = sourceFile.addModule({
-            name: "ValidationType",
-            isExported: true,
-        });
-
-        importMap.forEach((namedImports) => {
-            namedImports.forEach((namedImport) => {
-                const name = namedImport.valueOf();
-                const alias = `_${name}`;
-                namespace.addTypeAlias({ name, type: alias, isExported: true });
-            });
-        });
-
-        await project.save();
-    };
+    public clearCache(): void {
+        this.fileDiscovery.clearCache();
+    }
+    
+    public async cleanOutput(): Promise<void> {
+        await this.schemaWriter.cleanOutputDirectory();
+    }
 }