@atomic-ehr/codegen 0.0.1-canary.20251009095714.f3c2978 → 0.0.1-canary.20251010120059.024c867

package/dist/index.d.ts

@@ -304,7 +304,7 @@ interface TypeschemaGeneratorOptions {
 
 type Register = {
     appendFs(fs: FHIRSchema): void;
-    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
+    ensureSpecializationCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
     resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
     resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
     resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];

package/dist/index.js

@@ -1452,23 +1452,24 @@ var registerFromManager = async (manager, logger) => {
   const indexByPackages = [];
   for (const pkg of packages) {
     const resources = await manager.search({ package: pkg });
-    const index = {};
+    const perPackageIndex = {};
     for (const resource of resources) {
       const url = resource.url;
       if (!url) continue;
-      index[url] = resource;
+      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
+      index: perPackageIndex
     });
   }
   const sdIndex = {};
   const vsIndex = {};
   const fsIndex = {};
-  const nameToCanonical = {};
-  let [fsSuccess, fsFailed] = [0, 0];
+  const specNameToCanonical = {};
   for (const resourcesByPackage of indexByPackages) {
     const packageMeta = resourcesByPackage.package_meta;
     for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
@@ -1476,16 +1477,19 @@ var registerFromManager = async (manager, logger) => {
       if (resource.resourceType === "StructureDefinition") {
         const sd = resource;
         sdIndex[url] = sd;
-        try {
-          const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
-          fsIndex[rfs.url] = rfs;
-          nameToCanonical[rfs.name] = rfs.url;
-          fsSuccess++;
-        } catch (error) {
-          logger?.warn(
-            `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
-          );
-          fsFailed++;
+        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") {
@@ -1496,7 +1500,7 @@ var registerFromManager = async (manager, logger) => {
       }
     }
     logger?.success(
-      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
+      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${Object.keys(fsIndex).length} successful`
     );
   }
   const complexTypes = {};
@@ -1510,7 +1514,7 @@ var registerFromManager = async (manager, logger) => {
     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[nameToCanonical[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}'`);
     }
@@ -1524,12 +1528,12 @@ var registerFromManager = async (manager, logger) => {
     appendFs(fs3) {
       const rfs = enrichFHIRSchema(fs3);
       fsIndex[rfs.url] = rfs;
-      nameToCanonical[rfs.name] = rfs.url;
+      specNameToCanonical[rfs.name] = rfs.url;
     },
     resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
     resolveFsGenealogy,
     resolveFsSpecializations,
-    ensureCanonicalUrl: (name) => nameToCanonical[name] || name,
+    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
     allSd: () => Object.values(sdIndex),
     resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
     allFs: () => Object.values(fsIndex),
@@ -1685,7 +1689,7 @@ function mkNestedTypes(register, fhirSchema, logger) {
       package: fhirSchema.package_meta.name,
       version: fhirSchema.package_meta.version,
       name: baseName,
-      url: register.ensureCanonicalUrl(baseName)
+      url: register.ensureSpecializationCanonicalUrl(baseName)
     };
     const fields = transformNestedElements(register, fhirSchema, path, element.elements, logger);
     const nestedType = {
@@ -1749,34 +1753,28 @@ function isExcluded(register, fhirSchema, path) {
 var buildReferences = (element, register, _packageInfo) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
-    const curl = register.ensureCanonicalUrl(ref);
+    const curl = register.ensureSpecializationCanonicalUrl(ref);
     const fs3 = register.resolveFs(curl);
     return mkIdentifier(fs3);
   });
 };
 function buildFieldType(register, fhirSchema, element, logger) {
   if (element.elementReference) {
-    const refPath = element.elementReference.filter((_, i) => i % 2 === 1).map((p) => p).filter((p) => p !== "elements");
-    if (refPath.length > 0) {
-      return mkNestedIdentifier(register, fhirSchema, refPath, logger);
-    }
-  }
-  if (element.type) {
-    const kind = element.type.match(/^[a-z]/) ? "primitive-type" : "complex-type";
-    const url = register.ensureCanonicalUrl(element.type);
+    const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
+    return mkNestedIdentifier(register, fhirSchema, refPath, logger);
+  } else if (element.type) {
+    const url = register.ensureSpecializationCanonicalUrl(element.type);
     const fieldFs = register.resolveFs(url);
-    if (!fieldFs) {
-      throw new Error(`Could not resolve field '${element.type}'`);
-    }
-    return {
-      kind,
-      package: fieldFs.package_meta.name,
-      version: fieldFs.package_meta.version,
-      name: element.type,
-      url
-    };
-  }
-  return void 0;
+    if (!fieldFs) throw new Error(`Could not resolve field '${element.type}'`);
+    return mkIdentifier(fieldFs);
+  } else if (element.choices) {
+    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)}`
+    );
 }
 var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
@@ -2094,7 +2092,7 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
-    const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
+    const baseFs = register.resolveFs(register.ensureSpecializationCanonicalUrl(fhirSchema.base));
     if (!baseFs) {
       throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
     }
@@ -2993,10 +2991,14 @@ var mkTypeSchemaIndex = (schemas) => {
   const index = {};
   const append = (schema) => {
     const url = schema.identifier.url;
-    if (!index[url]) {
-      index[url] = {};
-    }
-    index[url][schema.identifier.package] = schema;
+    const pkg = schema.identifier.package;
+    if (!index[url]) index[url] = {};
+    if (index[url][schema.identifier.package] && pkg !== "shared") {
+      const r1 = JSON.stringify(schema.identifier, void 0, 2);
+      const r2 = JSON.stringify(index[url][pkg]?.identifier, void 0, 2);
+      throw new Error(`Duplicate schema: ${r1} and ${r2}`);
+    }
+    index[url][pkg] = schema;
   };
   for (const schema of schemas) {
     append(schema);
@@ -3067,7 +3069,6 @@ var mkTypeSchemaIndex = (schemas) => {
   };
   const isWithMetaField = (profile) => {
     return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
-      console.log(schema.fields?.meta);
       return schema.fields?.meta !== void 0;
     });
   };
@@ -5444,6 +5445,7 @@ var TypeScript = class extends Writer {
     if (schema.nested) {
       for (const subtype of schema.nested) {
         this.generateType(tsIndex, subtype);
+        this.line();
       }
     }
   }
@@ -5598,10 +5600,12 @@ var TypeScript = class extends Writer {
         this.generateDependenciesImports(schema);
         this.generateComplexTypeReexports(schema);
         this.generateNestedTypes(tsIndex, schema);
+        this.comment("CanonicalURL:", schema.identifier.url);
         this.generateType(tsIndex, schema);
       } else if (isProfileTypeSchema(schema)) {
         const flatProfile = tsIndex.flatProfile(schema);
         this.generateDependenciesImports(flatProfile);
+        this.comment("CanonicalURL:", schema.identifier.url);
         this.generateProfileType(tsIndex, flatProfile);
         this.generateAttachProfile(flatProfile);
         this.generateExtractProfile(tsIndex, flatProfile);