@atomic-ehr/codegen 0.0.1-canary.20251013100511.ff2ef29 → 0.0.1-canary.20251014085150.f19c2e1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as FS from '@atomic-ehr/fhirschema';
-import { FHIRSchema, StructureDefinition } from '@atomic-ehr/fhirschema';
+import { FHIRSchema, StructureDefinition, FHIRSchemaElement } from '@atomic-ehr/fhirschema';
 
 /**
  * CodeGen Logger
@@ -315,6 +315,8 @@ type Register = {
     resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
     complexTypeDict(): Record<string, RichFHIRSchema>;
     resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
+    resolveElementSnapshot(fhirSchema: RichFHIRSchema, path: string[]): FHIRSchemaElement;
+    getAllElementKeys(elems: Record<string, FHIRSchemaElement>): string[];
 } & ReturnType<typeof CanonicalManager>;
 
 /**

package/dist/index.js

@@ -1,11 +1,11 @@
-import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import * as fhirschema from '@atomic-ehr/fhirschema';
 import * as fs from 'fs';
 import { existsSync, mkdirSync } from 'fs';
 import * as afs from 'fs/promises';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
 import * as Path2 from 'path';
 import { join, resolve, dirname, relative } from 'path';
+import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import * as fhirschema from '@atomic-ehr/fhirschema';
 import pc from 'picocolors';
 
 var __defProp = Object.defineProperty;
@@ -1446,122 +1446,6 @@ var isChoiceDeclarationField = (field) => {
   return field.choices !== void 0;
 };
 
-// src/typeschema/register.ts
-var registerFromManager = async (manager, logger) => {
-  const packages = await manager.packages();
-  const flatRawIndex = {};
-  const indexByPackages = [];
-  for (const pkg of packages) {
-    const resources = await manager.search({ package: pkg });
-    const perPackageIndex = {};
-    for (const resource of resources) {
-      const url = resource.url;
-      if (!url) continue;
-      if (perPackageIndex[url]) throw new Error(`Duplicate resource URL: ${url}`);
-      perPackageIndex[url] = resource;
-      if (flatRawIndex[url]) throw new Error(`Duplicate resource URL: ${url}`);
-      flatRawIndex[url] = resource;
-    }
-    indexByPackages.push({
-      package_meta: pkg,
-      index: perPackageIndex
-    });
-  }
-  const sdIndex = {};
-  const vsIndex = {};
-  const fsIndex = {};
-  const specNameToCanonical = {};
-  for (const resourcesByPackage of indexByPackages) {
-    const packageMeta = resourcesByPackage.package_meta;
-    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
-      const url = surl;
-      if (resource.resourceType === "StructureDefinition") {
-        const sd = resource;
-        sdIndex[url] = sd;
-        const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
-        fsIndex[rfs.url] = rfs;
-        if (rfs.derivation === void 0 || rfs.derivation === "specialization") {
-          if (specNameToCanonical[rfs.name]) {
-            const info = {
-              old: specNameToCanonical[rfs.name],
-              oldDerivation: flatRawIndex[specNameToCanonical[rfs.name]].derivation,
-              new: rfs.url,
-              newDerivation: rfs.derivation
-            };
-            throw new Error(`Duplicate name ${rfs.name} ${JSON.stringify(info, void 0, 2)}`);
-          }
-          specNameToCanonical[rfs.name] = rfs.url;
-        }
-      }
-      if (resource.resourceType === "ValueSet") {
-        if (!resource.package_meta) {
-          resource.package_meta = packageMeta;
-        }
-        vsIndex[resource.url] = resource;
-      }
-    }
-    logger?.success(
-      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${Object.keys(fsIndex).length} successful`
-    );
-  }
-  const complexTypes = {};
-  for (const fs3 of Object.values(fsIndex)) {
-    if (fs3.kind === "complex-type") {
-      complexTypes[fs3.url] = fs3;
-    }
-  }
-  const resolveFsGenealogy = (canonicalUrl) => {
-    let fs3 = fsIndex[canonicalUrl];
-    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    const genealogy = [fs3];
-    while (fs3?.base) {
-      fs3 = fsIndex[fs3.base] || fsIndex[specNameToCanonical[fs3.base]];
-      genealogy.push(fs3);
-      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    }
-    return genealogy;
-  };
-  const resolveFsSpecializations = (canonicalUrl) => {
-    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
-  };
-  return {
-    ...manager,
-    appendFs(fs3) {
-      const rfs = enrichFHIRSchema(fs3);
-      fsIndex[rfs.url] = rfs;
-      specNameToCanonical[rfs.name] = rfs.url;
-    },
-    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
-    resolveFsGenealogy,
-    resolveFsSpecializations,
-    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
-    allSd: () => Object.values(sdIndex),
-    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
-    allFs: () => Object.values(fsIndex),
-    allVs: () => Object.values(vsIndex),
-    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
-    complexTypeDict: () => complexTypes,
-    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl]
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs3) => {
-    if (!fs3.elements) return void 0;
-    let elem = fs3.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
-};
-function fsElementSnapshot(genealogy) {
-  const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
-  snapshot.elements = void 0;
-  return snapshot;
-}
-
 // src/typeschema/core/identifier.ts
 function dropVersionFromUrl(url) {
   const baseUrl = url.split("|")[0];
@@ -1661,12 +1545,13 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
 }
 function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
   const fields = {};
-  for (const [key, element] of Object.entries(elements)) {
+  for (const [key, _element] of Object.entries(elements)) {
     const path = [...parentPath, key];
-    if (isNestedElement(element)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, element, logger);
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
+    if (isNestedElement(elemSnapshot)) {
+      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element, logger);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -1759,7 +1644,7 @@ var buildReferences = (element, register, _packageInfo) => {
     return mkIdentifier(fs3);
   });
 };
-function buildFieldType(register, fhirSchema, element, logger) {
+function buildFieldType(register, fhirSchema, path, element, logger) {
   if (element.elementReference) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
     return mkNestedIdentifier(register, fhirSchema, refPath, logger);
@@ -1772,10 +1657,12 @@ function buildFieldType(register, fhirSchema, element, logger) {
     return void 0;
   } else if (fhirSchema.derivation === "constraint") {
     return void 0;
-  } else
-    throw new Error(
-      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}): ${JSON.stringify(element, void 0, 2)}`
+  } else {
+    logger?.error(
+      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}) at '${path.join(".")}': ${JSON.stringify(element, void 0, 2)}`
     );
+    throw new Error(`Unrecognized element type`);
+  }
 }
 var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
@@ -1787,7 +1674,7 @@ var mkField = (register, fhirSchema, path, element, logger) => {
     }
   }
   return {
-    type: buildFieldType(register, fhirSchema, element, logger),
+    type: buildFieldType(register, fhirSchema, path, element, logger),
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
     reference: buildReferences(element, register, fhirSchema.package_meta),
@@ -1882,7 +1769,7 @@ function buildEnum(register, element, logger) {
 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, logger);
+  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
   const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
   const dependencies = [];
   if (fieldType) {
@@ -1936,26 +1823,10 @@ function collectBindingSchemas(register, fhirSchema, logger) {
 // src/typeschema/core/transformer.ts
 function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
-  const geneology = register.resolveFsGenealogy(fhirSchema.url);
-  const elems = {};
-  for (const [key, elem] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    const elemGeneology = resolveFsElementGenealogy(geneology, path);
-    const elemSnapshot = fsElementSnapshot(elemGeneology);
-    elems[key] = { elem, elemSnapshot, path };
-  }
-  for (const [_key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
-    for (const choiceKey of elem?.choices || []) {
-      if (!elems[choiceKey]) {
-        const path2 = [...parentPath, choiceKey];
-        const elemGeneology = resolveFsElementGenealogy(geneology, path2);
-        const elemSnapshot2 = fsElementSnapshot(elemGeneology);
-        elems[choiceKey] = { elem: void 0, elemSnapshot: elemSnapshot2, path: path2 };
-      }
-    }
-  }
   const fields = {};
-  for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
+  for (const key of register.getAllElementKeys(elements)) {
+    const path = [...parentPath, key];
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
@@ -2465,6 +2336,175 @@ new CodegenLogger();
 function createLogger(options = {}) {
   return new CodegenLogger(options);
 }
+var registerFromManager = async (manager, conf) => {
+  const packageNameResolver = conf?.packageNameResolver ?? ["hl7.fhir.r5.core", "hl7.cda.uv.core"];
+  const logger = conf?.logger;
+  const flatRawIndex = {};
+  const canonicalToPackages = {};
+  const resourceTypes = /* @__PURE__ */ new Set(["StructureDefinition", "ValueSet", "CodeSystem"]);
+  for (const res of await manager.search({})) {
+    const rawUrl = res.url;
+    if (!rawUrl) continue;
+    if (!resourceTypes.has(res.resourceType)) continue;
+    const url = rawUrl;
+    const pkg = (await manager.resolveEntry(url)).package;
+    if (!pkg) throw new Error(`Can't resolve package for ${url}`);
+    if (!canonicalToPackages[url]) canonicalToPackages[url] = [];
+    canonicalToPackages[url].push(pkg);
+    flatRawIndex[url] = res;
+  }
+  const collisions = Object.entries(canonicalToPackages).filter(([_, e]) => e.length > 1).map(([url, pkgs]) => `${url}: ${pkgs.map((p) => `${p.name}@${p.version}`).join(", ")}`).join("\n");
+  logger?.warn(`Duplicated canonicals: ${collisions}`);
+  const packageToResources = {};
+  const packageToPackageMeta = {};
+  for (const [url, _pkgs] of Object.entries(canonicalToPackages)) {
+    const pkg = (await manager.resolveEntry(url)).package;
+    if (!pkg) throw new Error(`Can't find package for ${url}`);
+    const pkgId = packageMetaToFhir(pkg);
+    packageToPackageMeta[pkgId] = pkg;
+    const res = await manager.resolve(url);
+    if (!packageToResources[pkgId]) {
+      packageToResources[pkgId] = {};
+    }
+    const index = packageToResources[pkgId];
+    if (!index) throw new Error(`Can't find index for ${pkg.name}@${pkg.version}`);
+    index[url] = res;
+  }
+  const indexByPackages = [];
+  for (const [pkgId, index] of Object.entries(packageToResources)) {
+    indexByPackages.push({
+      package_meta: packageToPackageMeta[pkgId],
+      index
+    });
+  }
+  const sdIndex = {};
+  const vsIndex = {};
+  const fsIndex = {};
+  for (const resourcesByPackage of indexByPackages) {
+    const packageMeta = resourcesByPackage.package_meta;
+    let counter = 0;
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' begins...`);
+    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
+      const url = surl;
+      if (resource.resourceType === "StructureDefinition") {
+        const sd = resource;
+        sdIndex[url] = sd;
+        const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
+        counter++;
+        fsIndex[rfs.url] = rfs;
+      }
+      if (resource.resourceType === "ValueSet") {
+        if (!resource.package_meta) {
+          resource.package_meta = packageMeta;
+        }
+        vsIndex[resource.url] = resource;
+      }
+    }
+    logger?.success(
+      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${counter} successful`
+    );
+  }
+  const specNameToCanonicals = {};
+  for (const rfs of Object.values(fsIndex)) {
+    if (rfs.derivation === "constraint") continue;
+    const name = rfs.name;
+    if (!specNameToCanonicals[name]) specNameToCanonicals[name] = {};
+    specNameToCanonicals[name][rfs.package_meta.name] = rfs.url;
+  }
+  const specNameToCanonical = {};
+  for (const [sname, canonicals] of Object.entries(specNameToCanonicals)) {
+    const name = sname;
+    const canonicalValues = Object.values(canonicals);
+    if (canonicalValues.length === 1) {
+      const url = canonicalValues[0];
+      specNameToCanonical[name] = url;
+    } else {
+      for (const pname of packageNameResolver) {
+        if (canonicals[pname]) {
+          specNameToCanonical[name] = canonicals[pname];
+          break;
+        }
+      }
+      if (specNameToCanonical[name] === void 0) throw new Error(`No canonical URL found for ${name}`);
+    }
+  }
+  const complexTypes = {};
+  for (const fs3 of Object.values(fsIndex)) {
+    if (fs3.kind === "complex-type") {
+      complexTypes[fs3.url] = fs3;
+    }
+  }
+  const resolveFsGenealogy = (canonicalUrl) => {
+    let fs3 = fsIndex[canonicalUrl];
+    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs3];
+    while (fs3?.base) {
+      fs3 = fsIndex[fs3.base] || fsIndex[specNameToCanonical[fs3.base]];
+      genealogy.push(fs3);
+      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    }
+    return genealogy;
+  };
+  const resolveFsSpecializations = (canonicalUrl) => {
+    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
+  };
+  const resolveElementSnapshot = (fhirSchema, path) => {
+    const geneology = resolveFsGenealogy(fhirSchema.url);
+    const elemGeneology = resolveFsElementGenealogy(geneology, path);
+    const elemSnapshot = fsElementSnapshot(elemGeneology);
+    return elemSnapshot;
+  };
+  const getAllElementKeys = (elems) => {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, elem] of Object.entries(elems)) {
+      keys.add(key);
+      for (const choiceKey of elem?.choices || []) {
+        if (!elems[choiceKey]) {
+          keys.add(choiceKey);
+        }
+      }
+    }
+    return Array.from(keys);
+  };
+  return {
+    ...manager,
+    appendFs(fs3) {
+      const rfs = enrichFHIRSchema(fs3);
+      fsIndex[rfs.url] = rfs;
+      specNameToCanonical[rfs.name] = rfs.url;
+    },
+    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
+    resolveFsGenealogy,
+    resolveFsSpecializations,
+    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
+    allSd: () => Object.values(sdIndex),
+    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
+    allFs: () => Object.values(fsIndex),
+    allVs: () => Object.values(vsIndex),
+    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
+    complexTypeDict: () => complexTypes,
+    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl],
+    resolveElementSnapshot,
+    getAllElementKeys
+  };
+};
+var resolveFsElementGenealogy = (genealogy, path) => {
+  const [top, ...rest] = path;
+  if (top === void 0) return [];
+  return genealogy.map((fs3) => {
+    if (!fs3.elements) return void 0;
+    let elem = fs3.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
+    }
+    return elem;
+  }).filter((elem) => elem !== void 0);
+};
+function fsElementSnapshot(genealogy) {
+  const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
+  snapshot.elements = void 0;
+  return snapshot;
+}
 
 // src/typeschema/generator.ts
 var TypeSchemaGenerator = class {
@@ -2522,7 +2562,7 @@ var TypeSchemaGenerator = class {
     if (valueSets.length > 0) {
       this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager, logger);
+    const register = await registerFromManager(this.manager, { logger: this.logger });
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -3015,7 +3055,7 @@ var resourceRelatives = (schemas) => {
   }
   return allPairs;
 };
-var mkTypeSchemaIndex = (schemas) => {
+var mkTypeSchemaIndex = (schemas, logger) => {
   const index = {};
   const append = (schema) => {
     const url = schema.identifier.url;
@@ -3036,7 +3076,7 @@ var mkTypeSchemaIndex = (schemas) => {
   const resourceChildren = (id) => {
     return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
   };
-  const hierarchy = (schema) => {
+  const tryHierarchy = (schema) => {
     const res = [];
     let cur = schema;
     while (cur) {
@@ -3045,18 +3085,23 @@ var mkTypeSchemaIndex = (schemas) => {
       if (base === void 0) break;
       const resolved = resolve2(base);
       if (!resolved) {
-        throw new Error(
-          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
-        );
+        return void 0;
       }
       cur = resolved;
     }
     return res;
   };
+  const hierarchy = (schema) => {
+    const genealogy = tryHierarchy(schema);
+    if (genealogy === void 0) {
+      throw new Error(`Failed to resolve base type: ${schema.identifier.url} (${schema.identifier.kind})`);
+    }
+    return genealogy;
+  };
   const findLastSpecialization = (schema) => {
     const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
     if (!nonConstraintSchema) {
-      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+      throw new Error(`No non-constraint schema found in hierarchy for: ${schema.identifier.name}`);
     }
     return nonConstraintSchema;
   };
@@ -3096,7 +3141,9 @@ var mkTypeSchemaIndex = (schemas) => {
     };
   };
   const isWithMetaField = (profile) => {
-    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
+    const genealogy = tryHierarchy(profile);
+    if (!genealogy) return false;
+    return genealogy.filter(isSpecializationTypeSchema).some((schema) => {
       return schema.fields?.meta !== void 0;
     });
   };
@@ -3109,6 +3156,7 @@ var mkTypeSchemaIndex = (schemas) => {
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     resolve: resolve2,
     resourceChildren,
+    tryHierarchy,
     hierarchy,
     findLastSpecialization,
     findLastSpecializationByIdentifier,
@@ -5868,7 +5916,7 @@ var APIBuilder = class {
         workingDir: "tmp/fhir"
       });
       await manager.init();
-      const register = await registerFromManager(manager, this.logger);
+      const register = await registerFromManager(manager, { logger: this.logger });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await this.tryWriteTypeSchema(typeSchemas);
       this.logger.debug(`Executing ${this.generators.size} generators`);