@atomic-ehr/codegen 0.0.1-canary.20251009083957.bf76104 → 0.0.1-canary.20251009095714.f3c2978

package/dist/index.js

@@ -1409,15 +1409,15 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
+var isPrimitiveIdentifier = (id) => {
+  return id?.kind === "primitive-type";
+};
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
 var isProfileIdentifier = (id) => {
   return id?.kind === "profile";
 };
-var isFhirSchemaBased = (schema) => {
-  return schema?.identifier.kind !== "value-set";
-};
 var isSpecializationTypeSchema = (schema) => {
   return schema?.identifier.kind === "resource" || schema?.identifier.kind === "complex-type" || schema?.identifier.kind === "logical";
 };
@@ -1440,6 +1440,10 @@ var isNotChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices === void 0;
 };
+var isChoiceDeclarationField = (field) => {
+  if (!field) return false;
+  return field.choices !== void 0;
+};
 
 // src/typeschema/register.ts
 var registerFromManager = async (manager, logger) => {
@@ -1619,7 +1623,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 
 // src/typeschema/core/nested-types.ts
 function mkNestedIdentifier(register, fhirSchema, path, logger) {
-  var nestedTypeOrigins = {};
+  const nestedTypeOrigins = {};
   if (fhirSchema.derivation === "constraint") {
     const specializations = register.resolveFsSpecializations(fhirSchema.url);
     const nestedTypeGenealogy = specializations.map((fs3) => mkNestedTypes(register, fs3, logger)).filter((e) => e !== void 0).flat();
@@ -3019,14 +3023,17 @@ var mkTypeSchemaIndex = (schemas) => {
     }
     return res;
   };
-  const findLastSpecialization = (id) => {
-    const schema = resolve2(id);
-    if (!schema) return id;
+  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 ${id.name}`);
+      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
     }
-    return nonConstraintSchema.identifier;
+    return nonConstraintSchema;
+  };
+  const findLastSpecializationByIdentifier = (id) => {
+    const schema = resolve2(id);
+    if (!schema) return id;
+    return findLastSpecialization(schema).identifier;
   };
   const flatProfile = (schema) => {
     const hierarchySchemas = hierarchy(schema);
@@ -3075,6 +3082,7 @@ var mkTypeSchemaIndex = (schemas) => {
     resourceChildren,
     hierarchy,
     findLastSpecialization,
+    findLastSpecializationByIdentifier,
     flatProfile,
     isWithMetaField
   };
@@ -5271,6 +5279,11 @@ var primitiveType2tsType = {
   id: "string",
   xhtml: "string"
 };
+var resolvePrimitiveType = (name) => {
+  const tsType = primitiveType2tsType[name];
+  if (tsType === void 0) throw new Error(`Unknown primitive type ${name}`);
+  return tsType;
+};
 var tsFhirPackageDir = (name) => {
   return kebabCase(name);
 };
@@ -5378,7 +5391,7 @@ var TypeScript = class extends Writer {
     }
   }
   generateType(tsIndex, schema) {
-    var name;
+    let name;
     if (schema.identifier.name === "Reference") {
       name = "Reference<T extends string = string>";
     } else if (schema.identifier.kind === "nested") {
@@ -5386,43 +5399,41 @@ var TypeScript = class extends Writer {
     } else {
       name = tsResourceName(schema.identifier);
     }
-    const parent = canonicalToName(schema.base?.url);
-    const extendsClause = parent && `extends ${parent}`;
+    let extendsClause;
+    if (schema.base) extendsClause = `extends ${canonicalToName(schema.base.url)}`;
     this.debugComment(schema.identifier);
     this.curlyBlock(["export", "interface", name, extendsClause], () => {
-      if (!schema.fields) return;
-      if (schema.identifier.kind === "resource") {
+      if (isResourceTypeSchema(schema)) {
         const possibleResourceTypes = [schema.identifier];
         possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
         this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `"${e.name}"`).join(" | ")}`);
         this.line();
       }
+      if (!schema.fields) return;
       const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
       for (const [fieldName, field] of fields) {
-        if (!isNotChoiceDeclarationField(field)) continue;
+        if (isChoiceDeclarationField(field)) continue;
+        if (field.type === void 0) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
-        const optionalSymbol = field.required ? "" : "?";
-        const arraySymbol = field.array ? "[]" : "";
-        if (field.type === void 0) continue;
-        let tsType = field.type.name;
-        if (field.type.kind === "nested") {
-          tsType = tsResourceName(field.type);
-        }
-        if (field.type.kind === "primitive-type") {
-          tsType = primitiveType2tsType[field.type.name] ?? "string";
-        }
-        if (schema.identifier.name === "Reference" && tsName === "reference") {
+        let tsType;
+        if (field.enum) {
+          tsType = field.enum.map((e) => `"${e}"`).join(" | ");
+        } else if (schema.identifier.name === "Reference" && tsName === "reference") {
           tsType = "`${T}/${string}`";
-        }
-        if (field.reference?.length) {
+        } else if (field.reference && field.reference.length > 0) {
           const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
           tsType = `Reference<${references}>`;
+        } else if (isPrimitiveIdentifier(field.type)) {
+          tsType = resolvePrimitiveType(field.type.name);
+        } else if (isNestedIdentifier(field.type)) {
+          tsType = tsResourceName(field.type);
+        } else {
+          tsType = field.type.name;
         }
-        if (field.enum) {
-          tsType = field.enum.map((e) => `"${e}"`).join(" | ");
-        }
-        this.lineSM(`${tsName}${optionalSymbol}:`, `${tsType}${arraySymbol}`);
+        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);
         }
@@ -5436,34 +5447,30 @@ var TypeScript = class extends Writer {
       }
     }
   }
-  generateProfileType(tsIndex, schema) {
-    const name = tsResourceName(schema.identifier);
-    this.debugComment("identifier", schema.identifier);
-    this.debugComment("base", schema.base);
-    this.curlyBlock(["export", "interface", name], () => {
-      this.lineSM(`__profileUrl: "${schema.identifier.url}"`);
+  generateProfileType(tsIndex, flatProfile) {
+    const tsName = tsResourceName(flatProfile.identifier);
+    this.debugComment("identifier", flatProfile.identifier);
+    this.debugComment("base", flatProfile.base);
+    this.curlyBlock(["export", "interface", tsName], () => {
+      this.lineSM(`__profileUrl: "${flatProfile.identifier.url}"`);
       this.line();
-      if (!isFhirSchemaBased(schema)) return;
-      for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
-        if (!isNotChoiceDeclarationField(field)) continue;
+      for (const [fieldName, field] of Object.entries(flatProfile.fields ?? {})) {
+        if (isChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, field);
-        const tsName = tsFieldName(fieldName);
+        const tsName2 = tsFieldName(fieldName);
         let tsType;
-        if (field.type.kind === "nested") {
-          tsType = tsResourceName(field.type);
-        } else if (field.enum) {
+        if (field.enum) {
           tsType = field.enum.map((e) => `'${e}'`).join(" | ");
         } else if (field.reference && field.reference.length > 0) {
-          const specializationId = tsIndex.findLastSpecialization(schema.identifier);
-          const specialization = tsIndex.resolve(specializationId);
+          const specialization = tsIndex.findLastSpecialization(flatProfile);
           if (!isSpecializationTypeSchema(specialization))
-            throw new Error(`Invalid specialization for ${schema.identifier}`);
+            throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
           const sField = specialization.fields?.[fieldName];
-          if (sField === void 0 || !isNotChoiceDeclarationField(sField))
+          if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
             throw new Error(`Invalid field declaration for ${fieldName}`);
-          const sRefs = (sField.reference ?? []).map((e) => e.name);
+          const sRefs = sField.reference.map((e) => e.name);
           const references = field.reference.map((ref) => {
-            const resRef = tsIndex.findLastSpecialization(ref);
+            const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
             if (resRef.name !== ref.name) {
               return `"${resRef.name}" /*${ref.name}*/`;
             }
@@ -5474,10 +5481,14 @@ var TypeScript = class extends Writer {
           } else {
             tsType = `Reference<${references}>`;
           }
+        } else if (isNestedIdentifier(field.type)) {
+          tsType = tsResourceName(field.type);
+        } else if (isPrimitiveIdentifier(field.type)) {
+          tsType = resolvePrimitiveType(field.type.name);
         } else {
-          tsType = primitiveType2tsType[field.type.name] ?? field.type.name;
+          tsType = field.type.name;
         }
-        this.lineSM(`${tsName}${!field.required ? "?" : ""}: ${tsType}${field.array ? "[]" : ""}`);
+        this.lineSM(`${tsName2}${!field.required ? "?" : ""}: ${tsType}${field.array ? "[]" : ""}`);
       }
     });
     this.line();
@@ -5514,7 +5525,7 @@ var TypeScript = class extends Writer {
     const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
       return isNotChoiceDeclarationField(field) && field.type !== void 0;
     }).map(([fieldName]) => fieldName);
-    const specialization = tsIndex.resolve(tsIndex.findLastSpecialization(flatProfile.identifier));
+    const specialization = tsIndex.findLastSpecialization(flatProfile);
     if (!isSpecializationTypeSchema(specialization))
       throw new Error(`Specialization not found for ${flatProfile.identifier.url}`);
     const shouldCast = {};
@@ -5876,6 +5887,7 @@ var APIBuilder = class {
         result.errors.push(
           `${type} generator failed: ${error instanceof Error ? error.message : String(error)}`
         );
+        if (this.options.throwException) throw error;
       }
     }
   }