@atomic-ehr/codegen 0.0.1-canary.20251106152808.f4530b9 → 0.0.1-canary.20251107091824.7605d36

package/dist/index.js

@@ -1715,8 +1715,10 @@ var mkField = (register, fhirSchema, path, element, logger) => {
       enumValues = buildEnum(register, fhirSchema, element, logger);
     }
   }
+  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
+  if (!fieldType) logger?.warn(`Field type not found for ${path.join(".")}`);
   return {
-    type: buildFieldType(register, fhirSchema, path, element, logger),
+    type: fieldType,
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
     reference: buildReferences(register, fhirSchema, element),
@@ -4162,7 +4164,7 @@ var BaseGenerator = class {
    * This is the main method that orchestrates the entire generation process
    * @param schemas - Array of TypeSchema documents
    */
-  async generate(schemas) {
+  async generate({ schemas }) {
     return this.errorBoundary.withErrorBoundary(
       async () => {
         this.generationStartTime = performance.now();
@@ -4202,7 +4204,7 @@ var BaseGenerator = class {
       return result;
     };
     try {
-      const result = await this.generate(schemas);
+      const result = await this.generate({ schemas, index: null });
       result.forEach((file) => {
         const mockResult = mockWriteResults.get(file.filename);
         if (mockResult) {
@@ -5510,10 +5512,10 @@ ${nestedInterfaces}`;
   /**
    * Override generate to clean directory first
    */
-  async generate(schemas) {
+  async generate(input) {
     await this.fileManager.cleanDirectory();
     this.logger.debug("Cleaned output directory before generation");
-    return super.generate(schemas);
+    return super.generate(input);
   }
   /**
    * Run post-generation hooks - generate utility files
@@ -6077,16 +6079,12 @@ var writerToGenerator = (writerGen) => {
     });
   };
   return {
-    generate: async (schemas) => {
-      const tsIndex = mkTypeSchemaIndex(schemas);
-      if (writerGen.opts.writeTypeTree) {
-        await tsIndex.exportTree(writerGen.opts.writeTypeTree);
-      }
+    generate: async ({ index: tsIndex }) => {
       writerGen.generate(tsIndex);
       return getGeneratedFiles();
     },
     setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
-    build: async (_schemas) => getGeneratedFiles()
+    build: async (_input) => getGeneratedFiles()
   };
 };
 var normalizeFileName = (str) => {
@@ -6131,24 +6129,18 @@ var APIBuilder = class {
     this.packages.push(packageMetaToNpm({ name: packageName, version: version || "latest" }));
     return this;
   }
-  /**
-   * Load TypeSchema from files
-   */
   fromFiles(...filePaths) {
     this.logger.debug(`Loading from ${filePaths.length} TypeSchema files`);
     const operation = this.loadFromFiles(filePaths);
     this.pendingOperations.push(operation);
     return this;
   }
-  /**
-   * Load TypeSchema from TypeSchema objects
-   */
   fromSchemas(schemas) {
     this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
     this.schemas = [...this.schemas, ...schemas];
     return this;
   }
-  typescript(options = {}) {
+  typescriptDepricated(options = {}) {
     const typesOutputDir = `${this.options.outputDir}/types`;
     const generator = new TypeScriptGenerator({
       outputDir: typesOutputDir,
@@ -6173,7 +6165,7 @@ var APIBuilder = class {
     this.logger.debug(`Configured TypeScript generator (${options.moduleFormat || "esm"})`);
     return this;
   }
-  typescript2(opts) {
+  typescript(opts) {
     const writerOpts = {
       outputDir: Path4.join(this.options.outputDir, "/types"),
       tabSize: 4,
@@ -6347,8 +6339,10 @@ var APIBuilder = class {
       });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await this.tryWriteTypeSchema(typeSchemas);
+      const tsIndex = mkTypeSchemaIndex(typeSchemas);
+      if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
       this.logger.debug(`Executing ${this.generators.size} generators`);
-      await this.executeGenerators(result, typeSchemas);
+      await this.executeGenerators(result, { schemas: typeSchemas, index: tsIndex });
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
@@ -6415,11 +6409,11 @@ var APIBuilder = class {
       this.cache.setMany(schemas);
     }
   }
-  async executeGenerators(result, typeSchemas) {
+  async executeGenerators(result, input) {
     for (const [type, generator] of this.generators.entries()) {
       this.logger.info(`Generating ${type}...`);
       try {
-        const files = await generator.generate(typeSchemas);
+        const files = await generator.generate(input);
         result.filesGenerated.push(...files.map((f) => f.path || f.filename));
         this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
@@ -6452,7 +6446,7 @@ function createAPIFromConfig(config) {
     builder.fromFiles(...config.files);
   }
   if (config.typescript) {
-    builder.typescript(config.typescript);
+    builder.typescriptDepricated(config.typescript);
   }
   return builder;
 }
@@ -6460,13 +6454,13 @@ async function generateTypesFromPackage(packageName, outputDir, options = {}) {
   return createAPI({
     outputDir,
     verbose: options.verbose
-  }).fromPackage(packageName, options.version).typescript().generate();
+  }).fromPackage(packageName, options.version).typescriptDepricated().generate();
 }
 async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
   return createAPI({
     outputDir,
     verbose: options.verbose
-  }).fromFiles(...inputFiles).typescript().generate();
+  }).fromFiles(...inputFiles).typescriptDepricated().generate();
 }
 var DEFAULT_CONFIG = {
   outputDir: "./generated",