@atomic-ehr/codegen 0.0.3-canary.20251204113111.bf83c83 → 0.0.3-canary.20251204134016.a4491f8

package/dist/index.js

@@ -8,6 +8,7 @@ import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as fhirschema from '@atomic-ehr/fhirschema';
 import { isStructureDefinition } from '@atomic-ehr/fhirschema';
 import * as YAML from 'yaml';
+import assert from 'assert';
 import pc from 'picocolors';
 
 // src/api/builder.ts
@@ -221,6 +222,9 @@ var isPrimitiveIdentifier = (id) => {
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
+var isComplexTypeIdentifier = (id) => {
+  return id?.kind === "complex-type";
+};
 var isProfileIdentifier = (id) => {
   return id?.kind === "profile";
 };
@@ -256,12 +260,6 @@ var isChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices !== void 0;
 };
-var isValueSet = (res) => {
-  return res?.resourceType === "ValueSet";
-};
-var isCodeSystem = (res) => {
-  return res?.resourceType === "CodeSystem";
-};
 var enrichValueSet = (vs, packageMeta) => {
   if (!vs.url) throw new Error("ValueSet must have a URL");
   if (!vs.name) throw new Error("ValueSet must have a name");
@@ -591,6 +589,18 @@ var CSharp = class extends Writer {
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
+
+// src/fhir-types/hl7-fhir-r4-core/CodeSystem.ts
+var isCodeSystem = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "CodeSystem";
+};
+
+// src/fhir-types/hl7-fhir-r4-core/ValueSet.ts
+var isValueSet = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "ValueSet";
+};
+
+// src/typeschema/register.ts
 var readPackageDependencies = async (manager, packageMeta) => {
   const packageJSON = await manager.packageJson(packageMeta.name);
   const dependencies = packageJSON.dependencies;
@@ -739,7 +749,22 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
     resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
     resolveElementSnapshot,
     getAllElementKeys,
-    resolver
+    resolver,
+    resolutionTree: () => {
+      const res = {};
+      for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
+        const pkgName = pkgIndex.pkg.name;
+        res[pkgName] = {};
+        for (const [surl, resolutions] of Object.entries(pkgIndex.canonicalResolution)) {
+          const url = surl;
+          res[pkgName][url] = [];
+          for (const resolution of resolutions) {
+            res[pkgName][url].push({ deep: resolution.deep, pkg: resolution.pkg });
+          }
+        }
+      }
+      return res;
+    }
   };
 };
 var resolveFsElementGenealogy = (genealogy, path) => {
@@ -1038,7 +1063,16 @@ function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
   return extractValueSetConcepts(register, valueSet);
 }
 function extractValueSetConcepts(register, valueSet, _logger) {
-  if (valueSet.expansion?.contains) return valueSet.expansion.contains;
+  if (valueSet.expansion?.contains) {
+    return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
+      assert(item.code);
+      return {
+        code: item.code,
+        display: item.display,
+        system: item.system
+      };
+    });
+  }
   const concepts = [];
   if (valueSet.compose?.include) {
     for (const include of valueSet.compose.include) {
@@ -1296,7 +1330,7 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
   schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
   return schema;
 };
-var treeShake = (tsIndex, treeShake2, logger) => {
+var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
   const focusedSchemas = [];
   for (const [pkgId, requires] of Object.entries(treeShake2)) {
     for (const [url, rule] of Object.entries(requires)) {
@@ -1333,7 +1367,7 @@ var treeShake = (tsIndex, treeShake2, logger) => {
     return collectDeps(newSchemas, acc);
   };
   const shaked = collectDeps(focusedSchemas, {});
-  return mkTypeSchemaIndex(shaked, logger);
+  return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
 };
 var resourceRelatives = (schemas) => {
   const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
@@ -1362,7 +1396,7 @@ var resourceRelatives = (schemas) => {
   }
   return allPairs;
 };
-var mkTypeSchemaIndex = (schemas, logger) => {
+var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
   const index = {};
   const append = (schema) => {
     const url = schema.identifier.url;
@@ -1381,7 +1415,15 @@ var mkTypeSchemaIndex = (schemas, logger) => {
   }
   const relations = resourceRelatives(schemas);
   const resolve3 = (id) => index[id.url]?.[id.package];
-  const resolveByUrl = (pkgName, url) => index[url]?.[pkgName];
+  const resolveByUrl = (pkgName, url) => {
+    if (resolutionTree) {
+      const resolution = resolutionTree[pkgName]?.[url]?.[0];
+      if (resolution) {
+        return index[url]?.[resolution.pkg.name];
+      }
+    }
+    return index[url]?.[pkgName];
+  };
   const resourceChildren = (id) => {
     return relations.filter((relative) => relative.parent.name === id.name).map((relative) => relative.child);
   };
@@ -1696,6 +1738,9 @@ var tsModuleName = (id) => {
 var tsModuleFileName = (id) => {
   return `${tsModuleName(id)}.ts`;
 };
+var tsModulePath = (id) => {
+  return `${tsFhirPackageDir(id.package)}/${tsModuleName(id)}`;
+};
 var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   const localName = extractNameFromCanonical(canonical, dropFragment);
@@ -1758,20 +1803,22 @@ var TypeScript = class extends Writer {
       }
     });
   }
-  generateDependenciesImports(schema) {
+  generateDependenciesImports(tsIndex, schema) {
     if (schema.dependencies) {
       const imports = [];
       const skipped = [];
       for (const dep of schema.dependencies) {
         if (["complex-type", "resource", "logical"].includes(dep.kind)) {
           imports.push({
-            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+            tsPackage: `../${tsModulePath(dep)}`,
             name: uppercaseFirstLetter(dep.name),
             dep
           });
         } else if (isNestedIdentifier(dep)) {
+          const ndep = { ...dep };
+          ndep.name = canonicalToName2(dep.url);
           imports.push({
-            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName2(dep.url) ?? "")}`,
+            tsPackage: `../${tsModulePath(ndep)}`,
             name: tsResourceName(dep),
             dep
           });
@@ -1788,11 +1835,17 @@ var TypeScript = class extends Writer {
         this.debugComment("skip:", dep);
       }
       this.line();
+      if (this.withPrimitiveTypeExtension(schema) && schema.identifier.name !== "Element" && schema.dependencies.find((e) => e.name === "Element") === void 0) {
+        const elementUrl = "http://hl7.org/fhir/StructureDefinition/Element";
+        const element = tsIndex.resolveByUrl(schema.identifier.package, elementUrl);
+        if (!element) throw new Error(`'${elementUrl}' not found for ${schema.identifier.package}.`);
+        this.tsImportType(`../${tsModulePath(element.identifier)}`, "Element");
+      }
     }
   }
   generateComplexTypeReexports(schema) {
-    const complexTypeDeps = schema.dependencies?.filter((dep) => ["complex-type"].includes(dep.kind)).map((dep) => ({
-      tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+    const complexTypeDeps = schema.dependencies?.filter(isComplexTypeIdentifier).map((dep) => ({
+      tsPackage: `../${tsModulePath(dep)}`,
       name: uppercaseFirstLetter(dep.name)
     }));
     if (complexTypeDeps && complexTypeDeps.length > 0) {
@@ -1802,11 +1855,9 @@ var TypeScript = class extends Writer {
       this.line();
     }
   }
-  addFieldExtension(fieldName, field) {
-    if (field.type.kind === "primitive-type") {
-      const extFieldName = tsFieldName(`_${fieldName}`);
-      this.lineSM(`${extFieldName}?: Element`);
-    }
+  addFieldExtension(fieldName) {
+    const extFieldName = tsFieldName(`_${fieldName}`);
+    this.lineSM(`${extFieldName}?: Element`);
   }
   generateType(tsIndex, schema) {
     let name;
@@ -1858,12 +1909,23 @@ var TypeScript = class extends Writer {
         const optionalSymbol = field.required ? "" : "?";
         const arraySymbol = field.array ? "[]" : "";
         this.lineSM(`${tsName}${optionalSymbol}: ${tsType}${arraySymbol}`);
-        if (["resource", "complex-type"].includes(schema.identifier.kind)) {
-          this.addFieldExtension(fieldName, field);
+        if (this.withPrimitiveTypeExtension(schema)) {
+          if (isPrimitiveIdentifier(field.type)) {
+            this.addFieldExtension(fieldName);
+          }
         }
       }
     });
   }
+  withPrimitiveTypeExtension(schema) {
+    if (!this.opts.primitiveTypeExtension) return false;
+    if (!isSpecializationTypeSchema(schema)) return false;
+    for (const field of Object.values(schema.fields ?? {})) {
+      if (isChoiceDeclarationField(field)) continue;
+      if (isPrimitiveIdentifier(field.type)) return true;
+    }
+    return false;
+  }
   generateResourceTypePredicate(schema) {
     if (!isResourceTypeSchema(schema) && !isLogicalTypeSchema(schema)) return;
     const name = tsResourceName(schema.identifier);
@@ -2035,7 +2097,7 @@ var TypeScript = class extends Writer {
     this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
       this.generateDisclaimer();
       if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
-        this.generateDependenciesImports(schema);
+        this.generateDependenciesImports(tsIndex, schema);
         this.generateComplexTypeReexports(schema);
         this.generateNestedTypes(tsIndex, schema);
         this.comment("CanonicalURL:", schema.identifier.url);
@@ -2043,7 +2105,7 @@ var TypeScript = class extends Writer {
         this.generateResourceTypePredicate(schema);
       } else if (isProfileTypeSchema(schema)) {
         const flatProfile = tsIndex.flatProfile(schema);
-        this.generateDependenciesImports(flatProfile);
+        this.generateDependenciesImports(tsIndex, flatProfile);
         this.comment("CanonicalURL:", schema.identifier.url);
         this.generateProfileType(tsIndex, flatProfile);
         this.generateAttachProfile(flatProfile);
@@ -2212,7 +2274,8 @@ var APIBuilder = class {
     };
     const defaultTsOpts = {
       ...defaultWriterOpts,
-      openResourceTypeSet: false
+      openResourceTypeSet: false,
+      primitiveTypeExtension: true
     };
     const opts = {
       ...defaultTsOpts,
@@ -2308,8 +2371,12 @@ var APIBuilder = class {
       });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await tryWriteTypeSchema(typeSchemas, this.options, this.logger);
-      let tsIndex = mkTypeSchemaIndex(typeSchemas, this.logger);
-      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, this.logger);
+      const tsIndexOpts = {
+        resolutionTree: register.resolutionTree(),
+        logger: this.logger
+      };
+      let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
+      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, tsIndexOpts);
       if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
       this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result, tsIndex);