@atomic-ehr/codegen 0.0.1-canary.20250821160126.c552195 → 0.0.1-canary.20250822150706.c3b8669

package/dist/config.js

@@ -0,0 +1,703 @@
+/**
+ * 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,
+    restClient: {
+        clientName: "FHIRClient",
+        includeValidation: false,
+        includeErrorHandling: true,
+        includeRequestInterceptors: false,
+        baseUrlOverride: "",
+        enhancedSearch: false,
+        chainedSearchBuilder: false,
+        searchAutocomplete: true,
+        generateValueSetEnums: true,
+        includeUtilities: true,
+        generateValidators: false,
+        useCanonicalManager: true,
+        defaultTimeout: 30000,
+        defaultRetries: 0,
+        includeDocumentation: true,
+        generateExamples: false,
+    },
+    typescript: {
+        moduleFormat: "esm",
+        generateIndex: true,
+        includeDocuments: false,
+        namingConvention: "PascalCase",
+        strictMode: true,
+        includeProfiles: true,
+        includeExtensions: false,
+        includeValueSets: true,
+        includeCodeSystems: false,
+        includeOperations: 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.js",
+    "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 restClient config
+        if (cfg.restClient !== undefined) {
+            const rcErrors = this.validateRestClientConfig(cfg.restClient);
+            result.errors.push(...rcErrors);
+        }
+        // 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",
+        ];
+        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;
+    }
+    validateRestClientConfig(config) {
+        const errors = [];
+        if (typeof config !== "object" || config === null) {
+            errors.push({
+                path: "restClient",
+                message: "restClient config must be an object",
+                value: config,
+            });
+            return errors;
+        }
+        const cfg = config;
+        // Validate clientName
+        if (cfg.clientName !== undefined && typeof cfg.clientName !== "string") {
+            errors.push({
+                path: "restClient.clientName",
+                message: "clientName must be a string",
+                value: cfg.clientName,
+            });
+        }
+        // Validate baseUrlOverride
+        if (cfg.baseUrlOverride !== undefined &&
+            typeof cfg.baseUrlOverride !== "string") {
+            errors.push({
+                path: "restClient.baseUrlOverride",
+                message: "baseUrlOverride must be a string",
+                value: cfg.baseUrlOverride,
+            });
+        }
+        // Validate timeout
+        if (cfg.defaultTimeout !== undefined) {
+            if (typeof cfg.defaultTimeout !== "number" || cfg.defaultTimeout <= 0) {
+                errors.push({
+                    path: "restClient.defaultTimeout",
+                    message: "defaultTimeout must be a positive number",
+                    value: cfg.defaultTimeout,
+                });
+            }
+        }
+        // Validate retries
+        if (cfg.defaultRetries !== undefined) {
+            if (typeof cfg.defaultRetries !== "number" || cfg.defaultRetries < 0) {
+                errors.push({
+                    path: "restClient.defaultRetries",
+                    message: "defaultRetries must be a non-negative number",
+                    value: cfg.defaultRetries,
+                });
+            }
+        }
+        // Validate boolean fields
+        const booleanFields = [
+            "includeValidation",
+            "includeErrorHandling",
+            "includeRequestInterceptors",
+            "enhancedSearch",
+            "chainedSearchBuilder",
+            "searchAutocomplete",
+            "generateValueSetEnums",
+            "includeUtilities",
+            "generateValidators",
+            "useCanonicalManager",
+            "includeDocumentation",
+            "generateExamples",
+        ];
+        for (const field of booleanFields) {
+            if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+                errors.push({
+                    path: `restClient.${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(".js")) {
+                // 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,
+            },
+        };
+        // Only include restClient if it was explicitly defined in user config
+        if (userConfig.restClient !== undefined) {
+            merged.restClient = {
+                ...DEFAULT_CONFIG.restClient,
+                ...userConfig.restClient,
+            };
+        }
+        else {
+            // Remove restClient from merged config if not defined in user config
+            delete merged.restClient;
+        }
+        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;
+}

package/dist/index.d.ts

@@ -78,6 +78,6 @@
  * @author Atomic EHR Team
  * @since 0.0.1
  */
-export * from "./api";
-export * from "./config";
+export * from "./api/index.js";
+export * from "./config.js";
 //# sourceMappingURL=index.d.ts.map