@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

package/dist/config.js

@@ -1,591 +0,0 @@
-/**
- * New Config Schema for High-Level API
- *
- * Simple configuration system compatible ONLY with the new high-level APIBuilder.
- * All legacy config functionality has been removed.
- */
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-/**
- * Default configuration values
- */
-export const DEFAULT_CONFIG = {
-    outputDir: "./generated",
-    verbose: false,
-    overwrite: true,
-    validate: true,
-    cache: true,
-    typescript: {
-        moduleFormat: "esm",
-        generateIndex: true,
-        includeDocuments: false,
-        namingConvention: "PascalCase",
-        strictMode: true,
-        includeProfiles: true,
-        includeExtensions: false,
-        includeCodeSystems: false,
-        includeOperations: false,
-        generateValueSets: false,
-        valueSetDirectory: "valuesets",
-        valueSetMode: "required-only",
-        valueSetStrengths: ["required"],
-        includeValueSetHelpers: false,
-        fhirVersion: "R4",
-        resourceTypes: [],
-        maxDepth: 10,
-        // Profile generation defaults
-        profileOptions: {
-            generateKind: "interface",
-            includeConstraints: true,
-            includeDocumentation: true,
-            strictMode: false,
-            subfolder: "profiles",
-        },
-        // Builder generation defaults
-        generateBuilders: false,
-        builderOptions: {
-            includeValidation: true,
-            includeFactoryMethods: true,
-            includeInterfaces: true,
-            generateNestedBuilders: true,
-            includeHelperMethods: true,
-            supportPartialBuild: true,
-            includeJSDoc: true,
-            generateFactories: true,
-            includeTypeGuards: true,
-            handleChoiceTypes: true,
-            generateArrayHelpers: true,
-        },
-        // Validator generation defaults
-        validatorOptions: {
-            includeCardinality: true,
-            includeTypes: true,
-            includeConstraints: true,
-            includeInvariants: false,
-            validateRequired: true,
-            allowAdditional: false,
-            strictValidation: false,
-            collectMetrics: false,
-            generateAssertions: true,
-            generatePartialValidators: true,
-            optimizePerformance: true,
-            includeJSDoc: true,
-            generateCompositeValidators: true,
-        },
-        // Type guard generation defaults
-        guardOptions: {
-            includeRuntimeValidation: true,
-            includeErrorMessages: true,
-            treeShakeable: true,
-            targetTSVersion: "5.0",
-            strictGuards: false,
-            includeNullChecks: true,
-            verbose: false,
-        },
-    },
-    typeSchema: {
-        enablePersistence: true,
-        cacheDir: ".typeschema-cache",
-        maxAge: 24 * 60 * 60 * 1000, // 24 hours in milliseconds
-        validateCached: true,
-        forceRegenerate: false,
-        shareCache: true,
-        cacheKeyPrefix: "",
-        treeshake: [],
-        singleFile: false,
-        profiles: {
-            autoDetect: true,
-        },
-    },
-    packages: [],
-    files: [],
-    $schema: "",
-};
-/**
- * Configuration file names to search for
- */
-export const CONFIG_FILE_NAMES = [
-    "atomic-codegen.config.ts",
-    "atomic-codegen.config",
-    "atomic-codegen.config.json",
-    ".atomic-codegenrc",
-    "atomic-codegen.json",
-    ".atomic-codegen.json",
-    "codegen.config.json",
-    "codegen.json",
-];
-/**
- * Simple configuration validator
- */
-export class ConfigValidator {
-    /**
-     * Validate a configuration object
-     */
-    validate(config) {
-        const result = {
-            valid: true,
-            errors: [],
-            warnings: [],
-        };
-        if (!config || typeof config !== "object") {
-            result.valid = false;
-            result.errors.push({
-                path: "root",
-                message: "Configuration must be an object",
-                value: config,
-            });
-            return result;
-        }
-        const cfg = config;
-        // Validate outputDir
-        if (cfg.outputDir !== undefined && typeof cfg.outputDir !== "string") {
-            result.errors.push({
-                path: "outputDir",
-                message: "outputDir must be a string",
-                value: cfg.outputDir,
-            });
-        }
-        // Validate boolean fields
-        const booleanFields = ["verbose", "overwrite", "validate", "cache"];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                result.errors.push({
-                    path: field,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        // Validate typescript config
-        if (cfg.typescript !== undefined) {
-            const tsErrors = this.validateTypeScriptConfig(cfg.typescript);
-            result.errors.push(...tsErrors);
-        }
-        // Validate typeSchema config
-        if (cfg.typeSchema !== undefined) {
-            const tsErrors = this.validateTypeSchemaConfig(cfg.typeSchema);
-            result.errors.push(...tsErrors);
-        }
-        // Validate packages array
-        if (cfg.packages !== undefined) {
-            if (!Array.isArray(cfg.packages)) {
-                result.errors.push({
-                    path: "packages",
-                    message: "packages must be an array",
-                    value: cfg.packages,
-                });
-            }
-            else {
-                cfg.packages.forEach((pkg, index) => {
-                    if (typeof pkg !== "string") {
-                        result.errors.push({
-                            path: `packages[${index}]`,
-                            message: "package name must be a string",
-                            value: pkg,
-                        });
-                    }
-                });
-            }
-        }
-        // Validate files array
-        if (cfg.files !== undefined) {
-            if (!Array.isArray(cfg.files)) {
-                result.errors.push({
-                    path: "files",
-                    message: "files must be an array",
-                    value: cfg.files,
-                });
-            }
-            else {
-                cfg.files.forEach((file, index) => {
-                    if (typeof file !== "string") {
-                        result.errors.push({
-                            path: `files[${index}]`,
-                            message: "file path must be a string",
-                            value: file,
-                        });
-                    }
-                });
-            }
-        }
-        result.valid = result.errors.length === 0;
-        if (result.valid) {
-            result.config = cfg;
-        }
-        return result;
-    }
-    validateTypeScriptConfig(config) {
-        const errors = [];
-        if (typeof config !== "object" || config === null) {
-            errors.push({
-                path: "typescript",
-                message: "typescript config must be an object",
-                value: config,
-            });
-            return errors;
-        }
-        const cfg = config;
-        // Validate moduleFormat
-        if (cfg.moduleFormat !== undefined) {
-            if (!["esm", "cjs"].includes(cfg.moduleFormat)) {
-                errors.push({
-                    path: "typescript.moduleFormat",
-                    message: 'moduleFormat must be "esm" or "cjs"',
-                    value: cfg.moduleFormat,
-                });
-            }
-        }
-        // Validate namingConvention
-        if (cfg.namingConvention !== undefined) {
-            if (!["PascalCase", "camelCase"].includes(cfg.namingConvention)) {
-                errors.push({
-                    path: "typescript.namingConvention",
-                    message: 'namingConvention must be "PascalCase" or "camelCase"',
-                    value: cfg.namingConvention,
-                });
-            }
-        }
-        // Validate boolean fields
-        const booleanFields = [
-            "generateIndex",
-            "includeDocuments",
-            "strictMode",
-            "includeProfiles",
-            "includeExtensions",
-            "includeCodeSystems",
-            "includeOperations",
-            "generateValueSets",
-            "includeValueSetHelpers",
-        ];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                errors.push({
-                    path: `typescript.${field}`,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        // Validate validatorOptions
-        if (cfg.validatorOptions !== undefined) {
-            const validatorErrors = this.validateValidatorOptions(cfg.validatorOptions);
-            errors.push(...validatorErrors);
-        }
-        // Validate guardOptions
-        if (cfg.guardOptions !== undefined) {
-            const guardErrors = this.validateGuardOptions(cfg.guardOptions);
-            errors.push(...guardErrors);
-        }
-        // Validate profileOptions
-        if (cfg.profileOptions !== undefined) {
-            const profileErrors = this.validateProfileOptions(cfg.profileOptions);
-            errors.push(...profileErrors);
-        }
-        return errors;
-    }
-    validateValidatorOptions(config) {
-        const errors = [];
-        if (typeof config !== "object" || config === null) {
-            errors.push({
-                path: "typescript.validatorOptions",
-                message: "validatorOptions must be an object",
-                value: config,
-            });
-            return errors;
-        }
-        const cfg = config;
-        // Validate boolean fields
-        const booleanFields = [
-            "includeCardinality",
-            "includeTypes",
-            "includeConstraints",
-            "includeInvariants",
-            "validateRequired",
-            "allowAdditional",
-            "strictValidation",
-            "collectMetrics",
-            "generateAssertions",
-            "generatePartialValidators",
-            "optimizePerformance",
-            "includeJSDoc",
-            "generateCompositeValidators",
-        ];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                errors.push({
-                    path: `typescript.validatorOptions.${field}`,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        return errors;
-    }
-    validateGuardOptions(config) {
-        const errors = [];
-        if (typeof config !== "object" || config === null) {
-            errors.push({
-                path: "typescript.guardOptions",
-                message: "guardOptions must be an object",
-                value: config,
-            });
-            return errors;
-        }
-        const cfg = config;
-        // Validate targetTSVersion
-        if (cfg.targetTSVersion !== undefined) {
-            if (!["3.8", "4.0", "4.5", "5.0"].includes(cfg.targetTSVersion)) {
-                errors.push({
-                    path: "typescript.guardOptions.targetTSVersion",
-                    message: 'targetTSVersion must be one of: "3.8", "4.0", "4.5", "5.0"',
-                    value: cfg.targetTSVersion,
-                });
-            }
-        }
-        // Validate boolean fields
-        const booleanFields = [
-            "includeRuntimeValidation",
-            "includeErrorMessages",
-            "treeShakeable",
-            "strictGuards",
-            "includeNullChecks",
-            "verbose",
-        ];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                errors.push({
-                    path: `typescript.guardOptions.${field}`,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        return errors;
-    }
-    validateProfileOptions(config) {
-        const errors = [];
-        if (typeof config !== "object" || config === null) {
-            errors.push({
-                path: "typescript.profileOptions",
-                message: "profileOptions must be an object",
-                value: config,
-            });
-            return errors;
-        }
-        const cfg = config;
-        // Validate generateKind
-        if (cfg.generateKind !== undefined) {
-            if (!["interface", "type", "both"].includes(cfg.generateKind)) {
-                errors.push({
-                    path: "typescript.profileOptions.generateKind",
-                    message: 'generateKind must be "interface", "type", or "both"',
-                    value: cfg.generateKind,
-                });
-            }
-        }
-        // Validate subfolder
-        if (cfg.subfolder !== undefined && typeof cfg.subfolder !== "string") {
-            errors.push({
-                path: "typescript.profileOptions.subfolder",
-                message: "subfolder must be a string",
-                value: cfg.subfolder,
-            });
-        }
-        // Validate boolean fields
-        const booleanFields = ["includeConstraints", "includeDocumentation", "strictMode"];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                errors.push({
-                    path: `typescript.profileOptions.${field}`,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        return errors;
-    }
-    validateTypeSchemaConfig(config) {
-        const errors = [];
-        if (typeof config !== "object" || config === null) {
-            errors.push({
-                path: "typeSchema",
-                message: "typeSchema config must be an object",
-                value: config,
-            });
-            return errors;
-        }
-        const cfg = config;
-        // Validate boolean fields
-        const booleanFields = ["enablePersistence", "validateCached", "forceRegenerate", "shareCache"];
-        for (const field of booleanFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
-                errors.push({
-                    path: `typeSchema.${field}`,
-                    message: `${field} must be a boolean`,
-                    value: cfg[field],
-                });
-            }
-        }
-        // Validate string fields
-        const stringFields = ["cacheDir", "cacheKeyPrefix"];
-        for (const field of stringFields) {
-            if (cfg[field] !== undefined && typeof cfg[field] !== "string") {
-                errors.push({
-                    path: `typeSchema.${field}`,
-                    message: `${field} must be a string`,
-                    value: cfg[field],
-                });
-            }
-        }
-        // Validate maxAge
-        if (cfg.maxAge !== undefined) {
-            if (typeof cfg.maxAge !== "number" || cfg.maxAge <= 0) {
-                errors.push({
-                    path: "typeSchema.maxAge",
-                    message: "maxAge must be a positive number",
-                    value: cfg.maxAge,
-                });
-            }
-        }
-        // Validate profiles
-        if (cfg.profiles !== undefined) {
-            if (typeof cfg.profiles !== "object" || cfg.profiles === null) {
-                errors.push({
-                    path: "typeSchema.profiles",
-                    message: "profiles must be an object",
-                    value: cfg.profiles,
-                });
-            }
-            else {
-                const profiles = cfg.profiles;
-                // Validate autoDetect
-                if (profiles.autoDetect !== undefined && typeof profiles.autoDetect !== "boolean") {
-                    errors.push({
-                        path: "typeSchema.profiles.autoDetect",
-                        message: "autoDetect must be a boolean",
-                        value: profiles.autoDetect,
-                    });
-                }
-            }
-        }
-        return errors;
-    }
-}
-/**
- * Configuration loader with autoloading capabilities
- */
-export class ConfigLoader {
-    validator = new ConfigValidator();
-    /**
-     * Auto-load configuration from the current working directory
-     */
-    async autoload(workingDir = process.cwd()) {
-        const configPath = await this.findConfigFile(workingDir);
-        if (configPath) {
-            return this.loadFromFile(configPath);
-        }
-        // Return default config if no file found
-        return { ...DEFAULT_CONFIG };
-    }
-    /**
-     * Load configuration from a specific file
-     */
-    async loadFromFile(filePath) {
-        try {
-            let config;
-            if (filePath.endsWith(".ts") || filePath.endsWith("")) {
-                // Use dynamic import for TypeScript/JavaScript files
-                const absolutePath = resolve(filePath);
-                const importResult = await import(absolutePath);
-                config = importResult.default || importResult;
-            }
-            else {
-                // JSON files
-                const content = await readFile(filePath, "utf-8");
-                config = JSON.parse(content);
-            }
-            const validation = this.validator.validate(config);
-            if (!validation.valid) {
-                const errorMessages = validation.errors.map((e) => `${e.path}: ${e.message}`).join("\n");
-                throw new Error(`Configuration validation failed:\n${errorMessages}`);
-            }
-            // Merge with defaults
-            return this.mergeWithDefaults(validation.config);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Find configuration file in the given directory
-     */
-    async findConfigFile(startDir) {
-        for (const fileName of CONFIG_FILE_NAMES) {
-            const configPath = resolve(startDir, fileName);
-            if (existsSync(configPath)) {
-                return configPath;
-            }
-        }
-        return null;
-    }
-    /**
-     * Merge user config with defaults
-     */
-    mergeWithDefaults(userConfig) {
-        const merged = {
-            ...DEFAULT_CONFIG,
-            ...userConfig,
-            typescript: {
-                ...DEFAULT_CONFIG.typescript,
-                ...userConfig.typescript,
-            },
-        };
-        return merged;
-    }
-}
-/**
- * Global config loader instance
- */
-export const configLoader = new ConfigLoader();
-/**
- * Convenience function to auto-load configuration
- */
-export async function loadConfig(workingDir) {
-    return configLoader.autoload(workingDir);
-}
-/**
- * Type guard to check if an object is a valid Config
- */
-export function isConfig(obj) {
-    const validator = new ConfigValidator();
-    const result = validator.validate(obj);
-    return result.valid;
-}
-/**
- * Define configuration with type safety and IntelliSense support.
- * Similar to Vite's defineConfig function pattern.
- *
- * @example
- * ```typescript
- * import { defineConfig } from "@atomic-ehr/codegen";
- *
- * export default defineConfig({
- *   outputDir: "./generated",
- *   packages: [
- *     "hl7.fhir.r4.core@4.0.1",
- *     "hl7.fhir.us.core@6.1.0"
- *   ],
- *   typescript: {
- *     generateIndex: true,
- *     strictMode: true
- *   }
- * });
- * ```
- */
-export function defineConfig(config) {
-    return config;
-}