@atomic-ehr/codegen 0.0.1-canary.20251008121245.8324bc2 → 0.0.1-canary.20251008162621.549c5d8

package/dist/index.js

@@ -1409,21 +1409,28 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
-var isFhirSchemaBased = (schema) => {
-  return schema.identifier.kind !== "value-set";
+var isNestedIdentifier = (id) => {
+  return id?.kind === "nested";
 };
-var isSpecialization = (schema) => {
-  return schema.identifier.kind === "resource" || schema.identifier.kind === "complex-type" || schema.identifier.kind === "logical";
+var isProfileIdentifier = (id) => {
+  return id?.kind === "profile";
 };
-var isProfile = (schema) => {
-  return schema.identifier.kind === "profile";
+var isFhirSchemaBased = (schema) => {
+  return schema?.identifier.kind !== "value-set";
 };
-var isNotChoiceFieldDeclaration = (field) => {
-  return field.choices === void 0;
+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) => {
@@ -2063,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) {
@@ -5030,6 +5041,7 @@ var Writer = class extends FileSystemWriter {
     if (tokens.length === 0) {
       this.write("\n");
     } else {
+      this.writeIndent();
       this.write(`${tokens.join(" ")}
 `);
     }
@@ -5068,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();
@@ -5101,6 +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 collectProfiles = (tss) => tss.filter(isProfileTypeSchema);
 var resourceRelatives = (schemas) => {
   const regularSchemas = collectResources(schemas);
   const directPairs = [];
@@ -5154,7 +5172,9 @@ var mkTypeSchemaIndex = (schemas) => {
       if (base === void 0) break;
       const resolved = resolve2(base);
       if (!resolved) {
-        throw new Error(`Failed to resolve base type: ${JSON.stringify(base)}`);
+        throw new Error(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
       }
       cur = resolved;
     }
@@ -5199,6 +5219,12 @@ var mkTypeSchemaIndex = (schemas) => {
       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,
@@ -5206,7 +5232,8 @@ var mkTypeSchemaIndex = (schemas) => {
     resourceChildren,
     hierarchy,
     findLastSpecialization,
-    flatProfile
+    flatProfile,
+    isWithMetaField
   };
 };
 
@@ -5270,6 +5297,8 @@ 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 {
@@ -5295,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();
     }
   }
@@ -5350,7 +5390,7 @@ var TypeScript = class extends Writer {
       }
       const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
       for (const [fieldName, field] of fields) {
-        if (!isNotChoiceFieldDeclaration(field)) continue;
+        if (!isNotChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
         const optionalSymbol = field.required ? "" : "?";
@@ -5389,13 +5429,14 @@ var TypeScript = class extends Writer {
   }
   generateProfileType(schema) {
     const name = tsResourceName(schema.identifier);
-    this.debugComment(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 (!isNotChoiceFieldDeclaration(field)) continue;
+        if (!isNotChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, field);
         const tsName = tsFieldName(fieldName);
         let tsType;
@@ -5406,10 +5447,10 @@ var TypeScript = class extends Writer {
         } 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))
+          if (!isSpecializationTypeSchema(specialization))
             throw new Error(`Invalid specialization for ${schema.identifier}`);
           const sField = specialization.fields?.[fieldName];
-          if (sField === void 0 || !isNotChoiceFieldDeclaration(sField))
+          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) => {
@@ -5432,32 +5473,129 @@ var TypeScript = class extends Writer {
     });
     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 if (isProfile(schema)) {
+      } else if (isProfileTypeSchema(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}`);
-      }
+        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)
+      ...collectResources(schemas),
       // ...collectLogicalModels(schemas),
-      // ...collectProfiles(schemas),
+      ...collectProfiles(schemas).filter((p) => this.tsIndex.isWithMetaField(p))
     ];
-    this.tsIndex = mkTypeSchemaIndex(typesToGenerate);
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {