@atomic-ehr/codegen 0.0.1-canary.20251007145120.703d8ab → 0.0.1-canary.20251007214454.7cafa75

package/dist/index.d.ts

@@ -3,12 +3,9 @@ import * as FS from '@atomic-ehr/fhirschema';
 import { FHIRSchema, StructureDefinition } from '@atomic-ehr/fhirschema';
 
 /**
- * Structured Logging System for Atomic Codegen
+ * CodeGen Logger
  *
- * Provides configurable logging with levels, structured output, and context
- */
-/**
- * Log levels in order of severity
+ * Clean, colorful logging designed for code generation tools
  */
 declare enum LogLevel {
     DEBUG = 0,
@@ -17,13 +14,6 @@ declare enum LogLevel {
     ERROR = 3,
     SILENT = 4
 }
-
-/**
- * CodeGen Logger
- *
- * Clean, colorful logging designed for code generation tools
- */
-
 interface LogOptions {
     prefix?: string;
     timestamp?: boolean;

package/dist/index.js

@@ -1414,7 +1414,7 @@ function isBindingSchema(schema) {
 }
 
 // src/typeschema/register.ts
-var registerFromManager = async (manager, logger2) => {
+var registerFromManager = async (manager, logger) => {
   const packages = await manager.packages();
   const flatRawIndex = {};
   const indexByPackages = [];
@@ -1450,7 +1450,7 @@ var registerFromManager = async (manager, logger2) => {
           nameToCanonical[rfs.name] = rfs.url;
           fsSuccess++;
         } catch (error) {
-          logger2?.warn(
+          logger?.warn(
             `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
           );
           fsFailed++;
@@ -1463,7 +1463,7 @@ var registerFromManager = async (manager, logger2) => {
         vsIndex[resource.url] = resource;
       }
     }
-    logger2?.success(
+    logger?.success(
       `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
   }
@@ -1596,7 +1596,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 }
 
 // src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema, logger2) {
+async function transformProfile(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind !== "profile") {
     throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -1628,7 +1628,7 @@ async function transformProfile(register, fhirSchema, logger2) {
     profileSchema.metadata = metadata;
   }
   if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
     if (fields && Object.keys(fields).length > 0) {
       profileSchema.fields = fields;
     }
@@ -1825,13 +1825,13 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element, logger2) => {
+var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element, logger2);
+      enumValues = buildEnum(register, element, logger);
     }
   }
   return {
@@ -1864,7 +1864,7 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl, logger2) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
@@ -1909,7 +1909,7 @@ function extractValueSetConcepts(register, valueSet, _logger) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element, logger2) {
+function buildEnum(register, element, logger) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -1920,14 +1920,14 @@ function buildEnum(register, element, logger2) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    logger2?.dry_warn(
+    logger?.dry_warn(
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element, logger2) {
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, element);
@@ -1937,7 +1937,7 @@ function generateBindingSchema(register, fhirSchema, path, element, logger2) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element, logger2);
+  const enumValues = buildEnum(register, element, logger);
   return {
     identifier,
     type: fieldType,
@@ -1947,7 +1947,7 @@ function generateBindingSchema(register, fhirSchema, path, element, logger2) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema, logger2) {
+function collectBindingSchemas(register, fhirSchema, logger) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -1958,7 +1958,7 @@ function collectBindingSchemas(register, fhirSchema, logger2) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element, logger2);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
         if (binding) {
           bindings.push(binding);
         }
@@ -1995,19 +1995,19 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
   }
   return nested;
 }
-function transformNestedElements(fhirSchema, parentPath, elements, register, logger2) {
+function transformNestedElements(fhirSchema, parentPath, elements, register, logger) {
   const fields = {};
   for (const [key, element] of Object.entries(elements)) {
     const path = [...parentPath, key];
     if (isNestedElement(element)) {
       fields[key] = mkNestedField(register, fhirSchema, path, element);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element, logger2);
+      fields[key] = mkField(register, fhirSchema, path, element, logger);
     }
   }
   return fields;
 }
-function mkNestedTypes(register, fhirSchema, logger2) {
+function mkNestedTypes(register, fhirSchema, logger) {
   if (!fhirSchema.elements) return void 0;
   const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
   const actualNested = nestedElements.filter(
@@ -2034,7 +2034,7 @@ function mkNestedTypes(register, fhirSchema, logger2) {
         url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
       };
     }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger2);
+    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger);
     const nestedType = {
       identifier,
       base,
@@ -2064,7 +2064,7 @@ function extractNestedDependencies(nestedTypes) {
 }
 
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements, logger2) {
+function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2089,7 +2089,7 @@ function mkFields(register, fhirSchema, parentPath, elements, logger2) {
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger2);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -2134,7 +2134,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet, logger2) {
+async function transformValueSet(register, valueSet, logger) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2145,7 +2145,7 @@ async function transformValueSet(register, valueSet, logger2) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, logger2) {
+async function transformExtension(fhirSchema, register, logger) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2182,13 +2182,13 @@ async function transformExtension(fhirSchema, register, logger2) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema, logger2);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2215,7 +2215,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
   const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
-function transformFhirSchemaResource(register, fhirSchema, logger2) {
+function transformFhirSchemaResource(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
@@ -2225,8 +2225,8 @@ function transformFhirSchemaResource(register, fhirSchema, logger2) {
     }
     base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
-  const nested = mkNestedTypes(register, fhirSchema, logger2);
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const nested = mkNestedTypes(register, fhirSchema, logger);
   const dependencies = extractDependencies(identifier, base, fields, nested);
   const typeSchema = {
     identifier,
@@ -2236,27 +2236,27 @@ function transformFhirSchemaResource(register, fhirSchema, logger2) {
     description: fhirSchema.description,
     dependencies
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
   return [typeSchema, ...bindingSchemas];
 }
-async function transformFhirSchema(register, fhirSchema, logger2) {
+async function transformFhirSchema(register, fhirSchema, logger) {
   const results = [];
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema, logger2);
+    const profileSchema = await transformProfile(register, fhirSchema, logger);
     results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
     results.push(...bindingSchemas);
     return results;
   }
   if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, logger2);
+    const extensionSchema = await transformExtension(fhirSchema, register, logger);
     if (extensionSchema) {
       results.push(extensionSchema);
     }
     return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema, logger2);
+  return transformFhirSchemaResource(register, fhirSchema, logger);
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2476,224 +2476,6 @@ var TypeSchemaCache = class {
     }
   }
 };
-
-// src/logger.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
-  return LogLevel2;
-})(LogLevel || {});
-var ConsoleOutput = class {
-  constructor(useStderr = false) {
-    this.useStderr = useStderr;
-  }
-  write(entry, formatted) {
-    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
-    output(formatted);
-  }
-};
-var Logger = class _Logger {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      level: 1 /* INFO */,
-      format: "pretty",
-      includeTimestamp: true,
-      includeContext: true,
-      colorize: true,
-      outputs: [new ConsoleOutput()],
-      ...config
-    };
-  }
-  /**
-   * Update logger configuration
-   */
-  configure(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * Check if a log level should be output
-   */
-  shouldLog(level) {
-    return level >= this.config.level;
-  }
-  /**
-   * Create a log entry
-   */
-  createEntry(level, message, context, error, operation) {
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      levelName: LogLevel[level],
-      message,
-      component: this.config.component
-    };
-    if (context && this.config.includeContext) {
-      entry.context = context;
-    }
-    if (operation) {
-      entry.operation = operation;
-    }
-    if (error) {
-      entry.error = {
-        name: error.name,
-        message: error.message,
-        stack: error.stack
-      };
-    }
-    return entry;
-  }
-  /**
-   * Format log entry for output
-   */
-  formatEntry(entry) {
-    switch (this.config.format) {
-      case "json":
-        return JSON.stringify(entry);
-      case "compact":
-        return this.formatCompact(entry);
-      default:
-        return this.formatPretty(entry);
-    }
-  }
-  /**
-   * Format entry in compact format
-   */
-  formatCompact(entry) {
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName, entry.level);
-    return `${timestamp}${level} ${component}${operation}${entry.message}`;
-  }
-  /**
-   * Format entry in pretty format
-   */
-  formatPretty(entry) {
-    let formatted = "";
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
-    formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
-    if (entry.context && Object.keys(entry.context).length > 0) {
-      formatted += `
-  Context: ${JSON.stringify(entry.context, null, 2).split("\n").join("\n  ")}`;
-    }
-    if (entry.error) {
-      formatted += `
-  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
-      if (entry.error.context && Object.keys(entry.error.context).length > 0) {
-        formatted += `
-  Error Context: ${JSON.stringify(entry.error.context, null, 2).split("\n").join("\n  ")}`;
-      }
-      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
-        formatted += `
-  Suggestions:
-${entry.error.suggestions.map((s) => `    \u2022 ${s}`).join("\n")}`;
-      }
-      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
-        formatted += `
-  Stack: ${entry.error.stack.split("\n").join("\n  ")}`;
-      }
-    }
-    return formatted;
-  }
-  /**
-   * Colorize log level if enabled
-   */
-  colorizeLevel(levelName, level) {
-    if (!this.config.colorize) {
-      return levelName;
-    }
-    const colors = {
-      [0 /* DEBUG */]: "\x1B[36m",
-      // Cyan
-      [1 /* INFO */]: "\x1B[32m",
-      // Green
-      [2 /* WARN */]: "\x1B[33m",
-      // Yellow
-      [3 /* ERROR */]: "\x1B[31m"
-      // Red
-    };
-    const reset = "\x1B[0m";
-    const color = colors[level] || "";
-    return `${color}${levelName}${reset}`;
-  }
-  /**
-   * Write log entry to all outputs
-   */
-  async writeEntry(entry) {
-    if (!this.shouldLog(entry.level)) {
-      return;
-    }
-    const formatted = this.formatEntry(entry);
-    for (const output of this.config.outputs) {
-      try {
-        await output.write(entry, formatted);
-      } catch (error) {
-        console.error("Logger output failed:", error);
-        console.error(formatted);
-      }
-    }
-  }
-  /**
-   * Log debug message
-   */
-  async debug(message, context, operation) {
-    const entry = this.createEntry(0 /* DEBUG */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log info message
-   */
-  async info(message, context, operation) {
-    const entry = this.createEntry(1 /* INFO */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log warning message
-   */
-  async warn(message, context, operation) {
-    const entry = this.createEntry(2 /* WARN */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log error message
-   */
-  async error(message, error, context, operation) {
-    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Create a child logger with additional context
-   */
-  child(component, context) {
-    const childLogger = new _Logger({
-      ...this.config,
-      component: this.config.component ? `${this.config.component}.${component}` : component
-    });
-    if (context) {
-      const originalMethods = {
-        debug: childLogger.debug.bind(childLogger),
-        info: childLogger.info.bind(childLogger),
-        warn: childLogger.warn.bind(childLogger),
-        error: childLogger.error.bind(childLogger)
-      };
-      childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
-      childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
-      childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
-      childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
-    }
-    return childLogger;
-  }
-};
-new Logger();
-
-// src/utils/codegen-logger.ts
 var CodegenLogger = class _CodegenLogger {
   options;
   dryWarnSet = /* @__PURE__ */ new Set();
@@ -2869,11 +2651,11 @@ var TypeSchemaGenerator = class {
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets, logger2) {
+  async generateValueSetSchemas(valueSets, logger) {
     if (valueSets.length > 0) {
       this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager, logger2);
+    const register = await registerFromManager(this.manager, logger);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -2881,7 +2663,7 @@ var TypeSchemaGenerator = class {
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(register, vs, logger2);
+          const valueSetSchema = await transformValueSet(register, vs, logger);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
@@ -2900,7 +2682,7 @@ var TypeSchemaGenerator = class {
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion, logger2) {
+  async generateFromPackage(packageName, packageVersion, logger) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
@@ -2916,8 +2698,8 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger2);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger2)))).flat();
+    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -3286,10 +3068,10 @@ var TypeSchemaParser = class {
 };
 
 // src/typeschema/index.ts
-var generateTypeSchemas = async (register, logger2) => {
+var generateTypeSchemas = async (register, logger) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger2));
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
   }
   for (const vsSchema of register.allVs()) {
     fhirSchemas.push(await transformValueSet(register, vsSchema));