@atomic-ehr/codegen 0.0.1-canary.20251008092936.b434b77 → 0.0.1-canary.20251008121245.8324bc2

package/dist/index.d.ts

@@ -256,12 +256,6 @@ interface BindingTypeSchema {
     dependencies?: Identifier[];
 }
 type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
-interface TypeschemaGeneratorOptions {
-    verbose?: boolean;
-    logger?: CodegenLogger;
-    treeshake?: string[];
-    manager?: ReturnType<typeof CanonicalManager> | null;
-}
 type TypeschemaParserOptions = {
     format?: "auto" | "ndjson" | "json";
     validate?: boolean;
@@ -301,6 +295,12 @@ type RichValueSet = Omit<ValueSet, "name" | "url"> & {
     name?: Name;
     url?: CanonicalUrl;
 };
+interface TypeschemaGeneratorOptions {
+    verbose?: boolean;
+    logger?: CodegenLogger;
+    treeshake?: string[];
+    manager?: ReturnType<typeof CanonicalManager> | null;
+}
 
 type Register = {
     appendFs(fs: FHIRSchema): void;

package/dist/index.js

@@ -1409,6 +1409,18 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
+var isFhirSchemaBased = (schema) => {
+  return schema.identifier.kind !== "value-set";
+};
+var isSpecialization = (schema) => {
+  return schema.identifier.kind === "resource" || schema.identifier.kind === "complex-type" || schema.identifier.kind === "logical";
+};
+var isProfile = (schema) => {
+  return schema.identifier.kind === "profile";
+};
+var isNotChoiceFieldDeclaration = (field) => {
+  return field.choices === void 0;
+};
 function isBindingSchema(schema) {
   return schema.identifier.kind === "binding";
 }
@@ -5089,11 +5101,6 @@ var groupByPackages = (typeSchemas) => {
 };
 var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
 var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
-var notChoiceDeclaration = (field) => {
-  if (field.choices) return void 0;
-  if (field.choiceOf) return field;
-  return field;
-};
 var resourceRelatives = (schemas) => {
   const regularSchemas = collectResources(schemas);
   const directPairs = [];
@@ -5121,8 +5128,86 @@ var resourceRelatives = (schemas) => {
   }
   return allPairs;
 };
-var resourceChildren = (relatives, id) => {
-  return relatives.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+var mkTypeSchemaIndex = (schemas) => {
+  const index = {};
+  const append = (schema) => {
+    const url = schema.identifier.url;
+    if (!index[url]) {
+      index[url] = {};
+    }
+    index[url][schema.identifier.package] = schema;
+  };
+  for (const schema of schemas) {
+    append(schema);
+  }
+  const relations = resourceRelatives(schemas);
+  const resolve2 = (id) => index[id.url]?.[id.package];
+  const resourceChildren = (id) => {
+    return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+  };
+  const hierarchy = (schema) => {
+    const res = [];
+    let cur = schema;
+    while (cur) {
+      res.push(cur);
+      const base = cur.base;
+      if (base === void 0) break;
+      const resolved = resolve2(base);
+      if (!resolved) {
+        throw new Error(`Failed to resolve base type: ${JSON.stringify(base)}`);
+      }
+      cur = resolved;
+    }
+    return res;
+  };
+  const findLastSpecialization = (id) => {
+    const schema = resolve2(id);
+    if (!schema) return id;
+    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}`);
+    }
+    return nonConstraintSchema.identifier;
+  };
+  const flatProfile = (schema) => {
+    const hierarchySchemas = hierarchy(schema);
+    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
+    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema)
+      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+    const mergedFields = {};
+    for (const anySchema of constraintSchemas.slice().reverse()) {
+      const schema2 = anySchema;
+      if (!schema2.fields) continue;
+      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
+        if (mergedFields[fieldName]) {
+          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
+        } else {
+          mergedFields[fieldName] = { ...fieldConstraints };
+        }
+      }
+    }
+    const deps = {};
+    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
+      deps[e.url] = e;
+    }
+    const dependencies = Object.values(deps);
+    return {
+      ...schema,
+      base: nonConstraintSchema.identifier,
+      fields: mergedFields,
+      dependencies
+    };
+  };
+  return {
+    schemaIndex: index,
+    relations,
+    resolve: resolve2,
+    resourceChildren,
+    hierarchy,
+    findLastSpecialization,
+    flatProfile
+  };
 };
 
 // src/api/writer-generator/typescript.ts
@@ -5153,6 +5238,7 @@ var tsFhirPackageDir = (name) => {
   return kebabCase(name);
 };
 var tsModuleName = (id) => {
+  if (id.kind === "profile") return `${tsResourceName(id)}_profile`;
   return pascalCase(id.name);
 };
 var tsModuleFileName = (id) => {
@@ -5187,7 +5273,7 @@ var normalizeTsName = (n) => {
   return n.replace(/[- ]/g, "_");
 };
 var TypeScript = class extends Writer {
-  resourceRelatives = [];
+  tsIndex = mkTypeSchemaIndex([]);
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
@@ -5258,39 +5344,36 @@ var TypeScript = class extends Writer {
       if (!schema.fields) return;
       if (schema.identifier.kind === "resource") {
         const possibleResourceTypes = [schema.identifier];
-        possibleResourceTypes.push(...resourceChildren(this.resourceRelatives, schema.identifier));
+        possibleResourceTypes.push(...this.tsIndex.resourceChildren(schema.identifier));
         this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `"${e.name}"`).join(" | ")}`);
         this.line();
       }
       const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
-      for (const [fieldName, anyField] of fields) {
-        const field = notChoiceDeclaration(anyField);
-        if (field === void 0) continue;
+      for (const [fieldName, field] of fields) {
+        if (!isNotChoiceFieldDeclaration(field)) continue;
         this.debugComment(fieldName, ":", field);
-        const fieldNameFixed = tsFieldName(fieldName);
+        const tsName = tsFieldName(fieldName);
         const optionalSymbol = field.required ? "" : "?";
         const arraySymbol = field.array ? "[]" : "";
-        if (field.type === void 0) {
-          continue;
-        }
-        let type = field.type.name;
+        if (field.type === void 0) continue;
+        let tsType = field.type.name;
         if (field.type.kind === "nested") {
-          type = tsResourceName(field.type);
+          tsType = tsResourceName(field.type);
         }
         if (field.type.kind === "primitive-type") {
-          type = primitiveType2tsType[field.type.name] ?? "string";
+          tsType = primitiveType2tsType[field.type.name] ?? "string";
         }
-        if (schema.identifier.name === "Reference" && fieldNameFixed === "reference") {
-          type = "`${T}/${string}`";
+        if (schema.identifier.name === "Reference" && tsName === "reference") {
+          tsType = "`${T}/${string}`";
         }
         if (field.reference?.length) {
           const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
-          type = `Reference<${references}>`;
+          tsType = `Reference<${references}>`;
         }
         if (field.enum) {
-          type = field.enum.map((e) => `"${e}"`).join(" | ");
+          tsType = field.enum.map((e) => `"${e}"`).join(" | ");
         }
-        this.lineSM(`${fieldNameFixed}${optionalSymbol}:`, `${type}${arraySymbol}`);
+        this.lineSM(`${tsName}${optionalSymbol}:`, `${tsType}${arraySymbol}`);
         if (["resource", "complex-type"].includes(schema.identifier.kind)) {
           this.addFieldExtension(fieldName, field);
         }
@@ -5304,6 +5387,51 @@ var TypeScript = class extends Writer {
       }
     }
   }
+  generateProfileType(schema) {
+    const name = tsResourceName(schema.identifier);
+    this.debugComment(schema.identifier);
+    this.curlyBlock(["export", "interface", name], () => {
+      this.lineSM(`__profileUrl: "${schema.identifier.url}"`);
+      this.line();
+      if (!isFhirSchemaBased(schema)) return;
+      for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
+        if (!isNotChoiceFieldDeclaration(field)) continue;
+        this.debugComment(fieldName, field);
+        const tsName = tsFieldName(fieldName);
+        let tsType;
+        if (field.type.kind === "nested") {
+          tsType = tsResourceName(field.type);
+        } else if (field.enum) {
+          tsType = field.enum.map((e) => `'${e}'`).join(" | ");
+        } else if (field.reference && field.reference.length > 0) {
+          const specializationId = this.tsIndex.findLastSpecialization(schema.identifier);
+          const specialization = this.tsIndex.resolve(specializationId);
+          if (specialization === void 0 || !isSpecialization(specialization))
+            throw new Error(`Invalid specialization for ${schema.identifier}`);
+          const sField = specialization.fields?.[fieldName];
+          if (sField === void 0 || !isNotChoiceFieldDeclaration(sField))
+            throw new Error(`Invalid field declaration for ${fieldName}`);
+          const sRefs = (sField.reference ?? []).map((e) => e.name);
+          const references = field.reference.map((ref) => {
+            const resRef = this.tsIndex.findLastSpecialization(ref);
+            if (resRef.name !== ref.name) {
+              return `"${resRef.name}" /*${ref.name}*/`;
+            }
+            return `'${ref.name}'`;
+          }).join(" | ");
+          if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
+            tsType = `Reference<"Resource" /* ${references} */ >`;
+          } else {
+            tsType = `Reference<${references}>`;
+          }
+        } else {
+          tsType = primitiveType2tsType[field.type.name] ?? field.type.name;
+        }
+        this.lineSM(`${tsName}${!field.required ? "?" : ""}: ${tsType}${field.array ? "[]" : ""}`);
+      }
+    });
+    this.line();
+  }
   generateResourceModule(schema) {
     this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
       this.generateDisclaimer();
@@ -5312,6 +5440,11 @@ var TypeScript = class extends Writer {
         this.generateComplexTypeReexports(schema);
         this.generateNestedTypes(schema);
         this.generateType(schema);
+      } else if (isProfile(schema)) {
+        const flatProfile = this.tsIndex.flatProfile(schema);
+        this.debugComment(flatProfile.dependencies);
+        this.generateDependenciesImports(flatProfile);
+        this.generateProfileType(flatProfile);
       } else {
         throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
       }
@@ -5321,10 +5454,10 @@ var TypeScript = class extends Writer {
     const typesToGenerate = [
       ...collectComplexTypes(schemas),
       ...collectResources(schemas)
-      // ...collectLogicalModels(typeSchemas),
-      // ...collectProfiles(typeSchemas),
+      // ...collectLogicalModels(schemas),
+      // ...collectProfiles(schemas),
     ];
-    this.resourceRelatives = resourceRelatives(typesToGenerate);
+    this.tsIndex = mkTypeSchemaIndex(typesToGenerate);
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {