@atomic-ehr/codegen 0.0.1-canary.20251008092936.b434b77 → 0.0.1-canary.20251008162621.549c5d8

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,9 +1409,28 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
+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";
+};
+var isProfileTypeSchema = (schema) => {
+  return schema?.identifier.kind === "profile";
+};
 function isBindingSchema(schema) {
-  return schema.identifier.kind === "binding";
+  return schema?.identifier.kind === "binding";
 }
+var isNotChoiceDeclarationField = (field) => {
+  if (!field) return false;
+  return field.choices === void 0;
+};
 
 // src/typeschema/register.ts
 var registerFromManager = async (manager, logger) => {
@@ -2051,7 +2070,11 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
     uniqDeps[dep.url] = dep;
   }
   const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-  const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
+  const result = Object.values(uniqDeps).filter((e) => {
+    if (isProfileIdentifier(identifier)) return true;
+    if (!isNestedIdentifier(e)) return true;
+    return !localNestedTypeUrls.has(e.url);
+  }).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
 function transformFhirSchemaResource(register, fhirSchema, logger) {
@@ -5018,6 +5041,7 @@ var Writer = class extends FileSystemWriter {
     if (tokens.length === 0) {
       this.write("\n");
     } else {
+      this.writeIndent();
       this.write(`${tokens.join(" ")}
 `);
     }
@@ -5056,6 +5080,11 @@ var Writer = class extends FileSystemWriter {
     this.disclaimer().forEach((e) => this.comment(e));
     this.line();
   }
+  indentBlock(gencontent) {
+    this.indent();
+    gencontent();
+    this.deindent();
+  }
   curlyBlock(tokens, gencontent, endTokens) {
     this.line(`${tokens.filter(Boolean).join(" ")} {`);
     this.indent();
@@ -5089,11 +5118,7 @@ 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 collectProfiles = (tss) => tss.filter(isProfileTypeSchema);
 var resourceRelatives = (schemas) => {
   const regularSchemas = collectResources(schemas);
   const directPairs = [];
@@ -5121,8 +5146,95 @@ 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: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
+      }
+      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
+    };
+  };
+  const isWithMetaField = (profile) => {
+    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
+      console.log(schema.fields?.meta);
+      return schema.fields?.meta !== void 0;
+    });
+  };
+  return {
+    schemaIndex: index,
+    relations,
+    resolve: resolve2,
+    resourceChildren,
+    hierarchy,
+    findLastSpecialization,
+    flatProfile,
+    isWithMetaField
+  };
 };
 
 // src/api/writer-generator/typescript.ts
@@ -5153,6 +5265,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) => {
@@ -5184,10 +5297,12 @@ var tsResourceName = (id) => {
 };
 var tsFieldName = (n) => normalizeTsName(n);
 var normalizeTsName = (n) => {
+  const tsKeywords = /* @__PURE__ */ new Set(["abstract", "any", "as", "async", "await", "boolean", "bigint", "break", "case", "catch", "class", "const", "constructor", "continue", "debugger", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "extern", "false", "finally", "for", "function", "from", "get", "goto", "if", "implements", "import", "in", "infer", "instanceof", "interface", "keyof", "let", "module", "namespace", "never", "new", "null", "number", "object", "of", "override", "private", "protected", "public", "readonly", "return", "satisfies", "set", "static", "string", "super", "switch", "this", "throw", "true", "try", "type", "typeof", "unknown", "var", "void", "while"]);
+  if (tsKeywords.has(n)) n = `${n}_`;
   return n.replace(/[- ]/g, "_");
 };
 var TypeScript = class extends Writer {
-  resourceRelatives = [];
+  tsIndex = mkTypeSchemaIndex([]);
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
@@ -5209,19 +5324,30 @@ var TypeScript = class extends Writer {
   }
   generateDependenciesImports(schema) {
     if (schema.dependencies) {
-      const deps = [
-        ...schema.dependencies.filter((dep) => ["complex-type", "resource", "logical"].includes(dep.kind)).map((dep) => ({
-          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
-          name: uppercaseFirstLetter(dep.name)
-        })),
-        ...schema.dependencies.filter((dep) => ["nested"].includes(dep.kind)).map((dep) => ({
-          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
-          name: tsResourceName(dep)
-        }))
-      ].sort((a, b) => a.name.localeCompare(b.name));
-      for (const dep of deps) {
+      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)}`,
+            name: uppercaseFirstLetter(dep.name)
+          });
+        } else if (isNestedIdentifier(dep)) {
+          imports.push({
+            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+            name: tsResourceName(dep)
+          });
+        } else {
+          skipped.push(dep);
+        }
+      }
+      imports.sort((a, b) => a.name.localeCompare(b.name));
+      for (const dep of imports) {
         this.tsImportType(dep.tsPackage, dep.name);
       }
+      for (const dep of skipped) {
+        this.debugComment("skip:", dep);
+      }
       this.line();
     }
   }
@@ -5258,39 +5384,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 (!isNotChoiceDeclarationField(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,27 +5427,175 @@ var TypeScript = class extends Writer {
       }
     }
   }
+  generateProfileType(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}"`);
+      this.line();
+      if (!isFhirSchemaBased(schema)) return;
+      for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
+        if (!isNotChoiceDeclarationField(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 (!isSpecializationTypeSchema(specialization))
+            throw new Error(`Invalid specialization for ${schema.identifier}`);
+          const sField = specialization.fields?.[fieldName];
+          if (sField === void 0 || !isNotChoiceDeclarationField(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();
+  }
+  generateAttachProfile(flatProfile) {
+    const tsBaseResourceName = tsResourceName(flatProfile.base);
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
+      return field && isNotChoiceDeclarationField(field) && field.type !== void 0;
+    }).map(([fieldName]) => tsFieldName(fieldName));
+    this.curlyBlock(
+      [
+        `export const attach_${tsProfileName} =`,
+        `(resource: ${tsBaseResourceName}, profile: ${tsProfileName}): ${tsBaseResourceName}`,
+        "=>"
+      ],
+      () => {
+        this.curlyBlock(["return"], () => {
+          this.line("...resource,");
+          this.curlyBlock(["meta:"], () => {
+            this.line(`profile: ['${flatProfile.identifier.url}']`);
+          }, [","]);
+          profileFields.forEach((fieldName) => {
+            this.line(`${fieldName}:`, `profile.${fieldName},`);
+          });
+        });
+      }
+    );
+    this.line();
+  }
+  generateExtractProfile(flatProfile) {
+    const tsBaseResourceName = tsResourceName(flatProfile.base);
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
+      return isNotChoiceDeclarationField(field) && field.type !== void 0;
+    }).map(([fieldName]) => fieldName);
+    const specialization = this.tsIndex.resolve(this.tsIndex.findLastSpecialization(flatProfile.identifier));
+    if (!isSpecializationTypeSchema(specialization))
+      throw new Error(`Specialization not found for ${flatProfile.identifier.url}`);
+    const shouldCast = {};
+    this.curlyBlock(
+      [
+        `export const extract_${tsBaseResourceName} =`,
+        `(resource: ${tsBaseResourceName}): ${tsProfileName}`,
+        "=>"
+      ],
+      () => {
+        profileFields.forEach((fieldName) => {
+          const tsField = tsFieldName(fieldName);
+          const pField = flatProfile.fields?.[fieldName];
+          const rField = specialization.fields?.[fieldName];
+          if (!isNotChoiceDeclarationField(pField) || !isNotChoiceDeclarationField(rField)) return;
+          if (pField.required && !rField.required) {
+            this.curlyBlock(
+              [`if (resource.${tsField} === undefined)`],
+              () => this.lineSM(
+                `throw new Error("'${tsField}' is required for ${flatProfile.identifier.url}")`
+              )
+            );
+          }
+          const pRefs = pField?.reference?.map((ref) => ref.name);
+          const rRefs = rField?.reference?.map((ref) => ref.name);
+          if (pRefs && rRefs && pRefs.length !== rRefs.length) {
+            const predName = `reference_pred_${tsField}`;
+            this.curlyBlock(["const", predName, "=", "(ref?: Reference)", "=>"], () => {
+              this.line("return !ref");
+              this.indentBlock(() => {
+                rRefs.forEach((ref) => {
+                  this.line(`|| ref.reference?.startsWith('${ref}/')`);
+                });
+                this.line(";");
+              });
+            });
+            let cond = !pField?.required ? `!resource.${tsField} || ` : "";
+            if (pField.array) {
+              cond += `resource.${tsField}.every( (ref) => ${predName}(ref) )`;
+            } else {
+              cond += `${predName}(resource.${tsField})`;
+            }
+            this.curlyBlock(["if (", cond, ")"], () => {
+              this.lineSM(
+                `throw new Error("'${fieldName}' has different references in profile and specialization")`
+              );
+            });
+            this.line();
+            shouldCast[fieldName] = true;
+          }
+        });
+        this.curlyBlock(["return"], () => {
+          this.line(`__profileUrl: '${flatProfile.identifier.url}',`);
+          profileFields.forEach((fieldName) => {
+            const tsField = tsFieldName(fieldName);
+            if (shouldCast[fieldName]) {
+              this.line(`${tsField}:`, `resource.${tsField} as ${tsProfileName}['${tsField}'],`);
+            } else {
+              this.line(`${tsField}:`, `resource.${tsField},`);
+            }
+          });
+        });
+      }
+    );
+  }
   generateResourceModule(schema) {
     this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
       this.generateDisclaimer();
-      if (["complex-type", "resource", "logical", "nested"].includes(schema.identifier.kind)) {
+      if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
         this.generateDependenciesImports(schema);
         this.generateComplexTypeReexports(schema);
         this.generateNestedTypes(schema);
         this.generateType(schema);
-      } else {
-        throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
-      }
+      } else if (isProfileTypeSchema(schema)) {
+        const flatProfile = this.tsIndex.flatProfile(schema);
+        this.generateDependenciesImports(flatProfile);
+        this.generateProfileType(flatProfile);
+        this.generateAttachProfile(flatProfile);
+        this.generateExtractProfile(flatProfile);
+      } else throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
     });
   }
   generate(schemas) {
+    this.tsIndex = mkTypeSchemaIndex(schemas);
     const typesToGenerate = [
       ...collectComplexTypes(schemas),
-      ...collectResources(schemas)
-      // ...collectLogicalModels(typeSchemas),
-      // ...collectProfiles(typeSchemas),
+      ...collectResources(schemas),
+      // ...collectLogicalModels(schemas),
+      ...collectProfiles(schemas).filter((p) => this.tsIndex.isWithMetaField(p))
     ];
-    this.resourceRelatives = resourceRelatives(typesToGenerate);
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {