@atomic-ehr/codegen 0.0.2-canary.20251119144634.930498f → 0.0.2-canary.20251120135224.f98eeb8

package/dist/index.js

@@ -1456,7 +1456,6 @@ var mkTypeSchemaIndex = (schemas, logger) => {
         logical: {}
       };
       for (const schema of shemas) {
-        schema.identifier;
         tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
       }
     }
@@ -1606,327 +1605,6 @@ function createLogger(options = {}) {
   return new CodegenLogger(options);
 }
 
-// src/typeschema/generator.ts
-var TypeSchemaGenerator = class {
-  manager;
-  options;
-  logger;
-  constructor(options = {}) {
-    this.options = { verbose: false, ...options };
-    this.manager = options.manager || CanonicalManager({ packages: [], workingDir: "tmp/fhir" });
-    this.logger = options.logger || createLogger({
-      verbose: this.options.verbose,
-      prefix: "TypeSchema"
-    });
-  }
-  async registerFromPackageMetas(packageMetas) {
-    const packageNames = packageMetas.map(packageMetaToFhir);
-    this.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
-    await this.manager.init();
-    return registerFromManager(this.manager, { focusedPackages: packageMetas });
-  }
-  generateFhirSchemas(structureDefinitions) {
-    this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
-    const fhirSchemas = [];
-    let convertedCount = 0;
-    let failedCount = 0;
-    for (const sd of structureDefinitions) {
-      try {
-        const fhirSchema = fhirschema.translate(sd);
-        fhirSchemas.push(fhirSchema);
-        convertedCount++;
-        this.logger?.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
-      } catch (error) {
-        failedCount++;
-        this.logger?.warn(
-          `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    this.logger?.success(
-      `FHIR Schema conversion completed: ${convertedCount}/${structureDefinitions.length} successful, ${failedCount} failed`
-    );
-    return fhirSchemas;
-  }
-  async generateValueSetSchemas(valueSets, logger) {
-    if (valueSets.length > 0) {
-      this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
-    }
-    const register = await registerFromManager(this.manager, { logger: this.logger });
-    const valueSetSchemas = [];
-    if (valueSets.length > 0) {
-      this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
-      let valueSetConvertedCount = 0;
-      let valueSetFailedCount = 0;
-      for (const vs of valueSets) {
-        try {
-          const valueSetSchema = await transformValueSet(register, vs, logger);
-          if (valueSetSchema) {
-            valueSetSchemas.push(valueSetSchema);
-            valueSetConvertedCount++;
-            this.logger?.debug(`Converted ValueSet: ${vs.name || vs.id}`);
-          }
-        } catch (error) {
-          valueSetFailedCount++;
-          this.logger?.warn(
-            `Failed to convert ValueSet ${vs.name || vs.id}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      this.logger?.success(
-        `ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`
-      );
-    }
-    return valueSetSchemas;
-  }
-  async generateFromPackage(packageName, packageVersion, logger) {
-    const packageInfo = {
-      name: packageName,
-      version: packageVersion || "latest"
-    };
-    const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs4) => await transformFhirSchema(register, fs4, logger)))).flat();
-    const allSchemas = [...fhirSchemas, ...valueSets];
-    return allSchemas;
-  }
-};
-var TypeSchemaParser = class {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      format: "auto",
-      validate: true,
-      strict: false,
-      ...options
-    };
-  }
-  /**
-   * Parse TypeSchema from file
-   */
-  async parseFromFile(filePath) {
-    const content = await readFile(filePath, "utf-8");
-    const format = this.options.format === "auto" ? this.detectFormat(content, filePath) : this.options.format;
-    return this.parseFromString(content, format);
-  }
-  /**
-   * Parse TypeSchema from string content
-   */
-  async parseFromString(content, format) {
-    const actualFormat = format || this.detectFormat(content);
-    let schemas;
-    if (actualFormat === "ndjson") {
-      schemas = this.parseNDJSON(content);
-    } else {
-      schemas = this.parseJSON(content);
-    }
-    if (this.options.validate) {
-      this.validateSchemas(schemas);
-    }
-    return schemas;
-  }
-  /**
-   * Parse multiple TypeSchema files
-   */
-  async parseFromFiles(filePaths) {
-    const allSchemas = [];
-    for (const filePath of filePaths) {
-      const schemas = await this.parseFromFile(filePath);
-      allSchemas.push(...schemas);
-    }
-    return allSchemas;
-  }
-  /**
-   * Parse a single TypeSchema object
-   */
-  parseSchema(schemaData) {
-    if (!schemaData.identifier) {
-      throw new Error("TypeSchema must have an identifier");
-    }
-    if (!this.isValidIdentifier(schemaData.identifier)) {
-      throw new Error("TypeSchema identifier is invalid");
-    }
-    return schemaData;
-  }
-  /**
-   * Find schemas by identifier
-   */
-  findByIdentifier(schemas, identifier) {
-    return schemas.filter((schema) => this.matchesIdentifier(schema.identifier, identifier));
-  }
-  /**
-   * Find schema by URL
-   */
-  findByUrl(schemas, url) {
-    return schemas.find((schema) => schema.identifier.url === url);
-  }
-  /**
-   * Find schemas by kind
-   */
-  findByKind(schemas, kind) {
-    return schemas.filter((schema) => schema.identifier.kind === kind);
-  }
-  /**
-   * Find schemas by package
-   */
-  findByPackage(schemas, packageName) {
-    return schemas.filter((schema) => schema.identifier.package === packageName);
-  }
-  /**
-   * Get all dependencies from a schema
-   */
-  // getDependencies(schema: TypeSchema): Identifier[] {
-  //   const dependencies: Identifier[] = [];
-  //   // Add base dependency
-  //   if ("base" in schema && schema.base) {
-  //     dependencies.push(schema.base);
-  //   }
-  //   // Add explicit dependencies
-  //   if ("dependencies" in schema && schema.dependencies) {
-  //     dependencies.push(...schema.dependencies);
-  //   }
-  //   // Add field type dependencies
-  //   if ("fields" in schema && schema.fields) {
-  //     for (const field of Object.values(schema.fields)) {
-  //       if ("type" in field && field.type) {
-  //         dependencies.push(field.type);
-  //       }
-  //       if ("binding" in field && field.binding) {
-  //         dependencies.push(field.binding);
-  //       }
-  //       if ("reference" in field && field.reference) {
-  //         dependencies.push(...field.reference);
-  //       }
-  //     }
-  //   }
-  //   if ("nested" in schema && schema.nested) {
-  //     for (const nested of schema.nested) {
-  //       dependencies.push(nested.identifier);
-  //       dependencies.push(nested.base);
-  //       for (const field of Object.values(nested.fields)) {
-  //         if ("type" in field && field.type) {
-  //           dependencies.push(field.type);
-  //         }
-  //         if ("binding" in field && field.binding) {
-  //           dependencies.push(field.binding);
-  //         }
-  //         if ("reference" in field && field.reference) {
-  //           dependencies.push(...field.reference);
-  //         }
-  //       }
-  //     }
-  //   }
-  //   // Add binding dependencies
-  //   if ("valueset" in schema) {
-  //     const bindingSchema = schema as any;
-  //     dependencies.push(bindingSchema.valueset);
-  //     if (bindingSchema.type) {
-  //       dependencies.push(bindingSchema.type);
-  //     }
-  //   }
-  //   // Remove duplicates
-  //   return this.deduplicateDependencies(dependencies);
-  // }
-  /**
-   * Resolve schema dependencies
-   */
-  // resolveDependencies(
-  //   schemas: TypeSchema[],
-  //   targetSchema: TypeSchema,
-  // ): TypeSchema[] {
-  //   const dependencies = this.getDependencies(targetSchema);
-  //   const resolved: TypeSchema[] = [];
-  //   for (const dep of dependencies) {
-  //     const depSchema = this.findByUrl(schemas, dep.url);
-  //     if (depSchema) {
-  //       resolved.push(depSchema);
-  //     }
-  //   }
-  //   return resolved;
-  // }
-  /**
-   * Detect format from content or filename
-   */
-  detectFormat(content, filename) {
-    if (filename) {
-      if (filename.endsWith(".ndjson")) return "ndjson";
-      if (filename.endsWith(".json")) return "json";
-    }
-    const trimmed = content.trim();
-    if (trimmed.includes("\n")) {
-      const lines = trimmed.split("\n").filter((line) => line.trim());
-      if (lines.length > 1) {
-        try {
-          if (lines[0]) {
-            JSON.parse(lines[0]);
-          }
-          return "ndjson";
-        } catch {
-        }
-      }
-    }
-    return "json";
-  }
-  /**
-   * Parse NDJSON format
-   */
-  parseNDJSON(content) {
-    const schemas = [];
-    const lines = content.split("\n").filter((line) => line.trim());
-    for (const line of lines) {
-      try {
-        const parsed = JSON.parse(line);
-        schemas.push(this.parseSchema(parsed));
-      } catch (error) {
-        if (this.options.strict) {
-          throw new Error(`Failed to parse NDJSON line: ${error}`);
-        }
-      }
-    }
-    return schemas;
-  }
-  /**
-   * Parse JSON format
-   */
-  parseJSON(content) {
-    try {
-      const parsed = JSON.parse(content);
-      if (Array.isArray(parsed)) {
-        return parsed.map((item) => this.parseSchema(item));
-      } else {
-        return [this.parseSchema(parsed)];
-      }
-    } catch (error) {
-      throw new Error(`Failed to parse JSON: ${error}`);
-    }
-  }
-  /**
-   * Validate schemas
-   */
-  validateSchemas(schemas) {
-    for (const schema of schemas) {
-      if (!schema.identifier) {
-        throw new Error("Schema missing identifier");
-      }
-      if (!this.isValidIdentifier(schema.identifier)) {
-        throw new Error(`Invalid identifier in schema: ${JSON.stringify(schema.identifier)}`);
-      }
-    }
-  }
-  /**
-   * Validate identifier structure
-   */
-  isValidIdentifier(identifier) {
-    return typeof identifier === "object" && identifier !== null && typeof identifier.kind === "string" && typeof identifier.package === "string" && typeof identifier.version === "string" && typeof identifier.name === "string" && typeof identifier.url === "string";
-  }
-  /**
-   * Check if identifier matches criteria
-   */
-  matchesIdentifier(identifier, criteria) {
-    return (!criteria.kind || identifier.kind === criteria.kind) && (!criteria.package || identifier.package === criteria.package) && (!criteria.version || identifier.version === criteria.version) && (!criteria.name || identifier.name === criteria.name) && (!criteria.url || identifier.url === criteria.url);
-  }
-};
-
 // src/typeschema/index.ts
 var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
 var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
@@ -2484,8 +2162,6 @@ var APIBuilder = class {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
-  pendingOperations = [];
-  typeSchemaGenerator;
   logger;
   packages = [];
   progressCallback;
@@ -2519,12 +2195,6 @@ var APIBuilder = class {
     this.packages.push(packageRef);
     return this;
   }
-  fromFiles(...filePaths) {
-    this.logger.debug(`Loading from ${filePaths.length} TypeSchema files`);
-    const operation = this.loadFromFiles(filePaths);
-    this.pendingOperations.push(operation);
-    return this;
-  }
   fromSchemas(schemas) {
     this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
     this.schemas = [...this.schemas, ...schemas];
@@ -2696,20 +2366,6 @@ var APIBuilder = class {
   getGenerators() {
     return Array.from(this.generators.keys());
   }
-  async loadFromFiles(filePaths) {
-    if (!this.typeSchemaGenerator) {
-      this.typeSchemaGenerator = new TypeSchemaGenerator({
-        verbose: this.options.verbose,
-        logger: this.logger.child("Schema"),
-        treeshake: this.typeSchemaConfig?.treeshake
-      });
-    }
-    const parser = new TypeSchemaParser({
-      format: "auto"
-    });
-    const schemas = await parser.parseFromFiles(filePaths);
-    this.schemas = [...this.schemas, ...schemas];
-  }
   async executeGenerators(result, input) {
     for (const [type, generator] of this.generators.entries()) {
       this.logger.info(`Generating ${type}...`);