@atomic-ehr/fhirpath 0.0.5 → 0.1.0-canary.20260203155750.e52d2f6

package/dist/index.node.d.ts

@@ -1,5 +1,5 @@
-import { F as FHIRModelProviderBase, R as Resource } from './model-provider.common-oir-zg7r.js';
-export { q as ASTMetadata, i as ASTNode, h as AnalysisResult, A as Analyzer, N as AnyCursorNode, w as CompletionItem, C as CompletionKind, x as CompletionOptions, J as CursorArgumentNode, y as CursorContext, H as CursorIdentifierNode, K as CursorIndexNode, B as CursorNode, G as CursorOperatorNode, L as CursorTypeNode, f as Diagnostic, D as DiagnosticSeverity, u as ErrorCodes, t as Errors, E as EvaluateOptions, l as EvaluationResult, a as FHIRModelContext, s as FHIRPathError, k as FunctionDefinition, n as InspectOptions, o as InspectResult, I as Interpreter, M as ModelTypeProvider, O as OperatorDefinition, d as ParseResult, P as Parser, c as Registry, T as TypeInfo, j as TypeName, b as analyze, e as evaluate, g as getVersion, m as inspect, z as isCursorNode, p as parse, v as provideCompletions, r as registry } from './model-provider.common-oir-zg7r.js';
+import { F as FHIRModelProviderBase, R as Resource } from './model-provider.common-BULsr92N.js';
+export { q as ASTMetadata, i as ASTNode, h as AnalysisResult, A as Analyzer, N as AnyCursorNode, w as CompletionItem, C as CompletionKind, x as CompletionOptions, J as CursorArgumentNode, y as CursorContext, H as CursorIdentifierNode, K as CursorIndexNode, B as CursorNode, G as CursorOperatorNode, L as CursorTypeNode, f as Diagnostic, D as DiagnosticSeverity, u as ErrorCodes, t as Errors, E as EvaluateOptions, l as EvaluationResult, a as FHIRModelContext, s as FHIRPathError, k as FunctionDefinition, n as InspectOptions, o as InspectResult, I as Interpreter, M as ModelTypeProvider, O as OperatorDefinition, d as ParseResult, P as Parser, c as Registry, T as TypeInfo, j as TypeName, b as analyze, e as evaluate, g as getVersion, m as inspect, z as isCursorNode, p as parse, v as provideCompletions, r as registry } from './model-provider.common-BULsr92N.js';
 import '@atomic-ehr/fhirschema';
 
 interface FHIRModelProviderConfig {
@@ -14,7 +14,7 @@ declare class FHIRModelProvider extends FHIRModelProviderBase {
     private config;
     private canonicalManager;
     prepare(): Promise<void>;
-    resolve(canonicalUrl: string): Promise<Resource>;
+    resolve(typeName: string): Promise<Resource>;
     search(params: {
         kind: 'primitive-type' | 'complex-type' | 'resource';
     }): Promise<Resource[]>;

package/dist/index.node.js

@@ -2268,6 +2268,8 @@ __export(operations_exports, {
   extensionFunction: () => extensionFunction,
   firstFunction: () => firstFunction,
   floorFunction: () => floorFunction,
+  getReferenceKeyFunction: () => getReferenceKeyFunction,
+  getResourceKeyFunction: () => getResourceKeyFunction,
   greaterOperator: () => greaterOperator,
   greaterOrEqualOperator: () => greaterOrEqualOperator,
   hasValueFunction: () => hasValueFunction,
@@ -11582,6 +11584,133 @@ var expFunction = {
   evaluate: evaluate105
 };
 
+// src/operations/getResourceKey-function.ts
+var evaluate106 = async (input, context, args, evaluator) => {
+  const results = [];
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
+    if (item && typeof item === "object") {
+      if ("id" in item && item.id !== void 0) {
+        results.push(box(String(item.id), { type: "String", singleton: true }));
+      }
+    }
+  }
+  return { value: results, context };
+};
+var getResourceKeyFunction = {
+  name: "getResourceKey",
+  category: ["SQL on FHIR", "navigation"],
+  description: "Returns a unique key identifying this resource for use in database joins. The returned value can be used with getReferenceKey() to join resources. This is typically the resource id, but the exact format is implementation-dependent.",
+  examples: [
+    "getResourceKey()",
+    "Patient.getResourceKey()"
+  ],
+  signatures: [{
+    name: "getResourceKey",
+    input: { type: "Any", singleton: false, name: "Resource" },
+    parameters: [],
+    result: { type: "String", singleton: false }
+  }],
+  evaluate: evaluate106
+};
+
+// src/operations/getReferenceKey-function.ts
+init_errors();
+init_types();
+function parseReference(reference) {
+  if (!reference) return null;
+  if (reference.startsWith("urn:")) {
+    return { id: reference };
+  }
+  if (reference.includes("://")) {
+    const url = reference.split("?")[0];
+    const segments = url.split("/").filter((s) => s);
+    if (segments.length >= 2) {
+      const id = segments[segments.length - 1];
+      const resourceType = segments[segments.length - 2];
+      return { resourceType, id };
+    }
+    return null;
+  }
+  const parts = reference.split("/");
+  if (parts.length === 2) {
+    return { resourceType: parts[0], id: parts[1] };
+  }
+  if (reference.startsWith("#")) {
+    return { id: reference.substring(1) };
+  }
+  return null;
+}
+function extractTypeName(typeArg) {
+  if (isIdentifierNode(typeArg)) {
+    return typeArg.name;
+  } else if (isFunctionNode(typeArg) && isIdentifierNode(typeArg.name)) {
+    return typeArg.name.name;
+  }
+  throw Errors.invalidOperation(`getReferenceKey() requires a type name as argument, got ${typeArg.type}`);
+}
+var evaluate107 = async (input, context, args, evaluator) => {
+  let targetResourceType;
+  if (args.length > 0) {
+    targetResourceType = extractTypeName(args[0]);
+  }
+  const results = [];
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    let referenceString;
+    if ("reference" in item && typeof item.reference === "string") {
+      referenceString = item.reference;
+    } else if (typeof item === "string") {
+      referenceString = item;
+    }
+    if (!referenceString) {
+      continue;
+    }
+    const parsed = parseReference(referenceString);
+    if (!parsed || !parsed.id) {
+      continue;
+    }
+    if (targetResourceType) {
+      if (!parsed.resourceType || parsed.resourceType !== targetResourceType) {
+        continue;
+      }
+    }
+    results.push(box(parsed.id, { type: "String", singleton: true }));
+  }
+  return { value: results, context };
+};
+var getReferenceKeyFunction = {
+  name: "getReferenceKey",
+  category: ["SQL on FHIR", "navigation"],
+  description: "Returns a foreign key from a Reference element for joining to another resource. The returned value equals getResourceKey() on the referenced resource. If resourceType is provided, returns empty if the reference is not of that type.",
+  examples: [
+    "subject.getReferenceKey()",
+    "subject.getReferenceKey(Patient)",
+    "Observation.subject.getReferenceKey(Patient)"
+  ],
+  signatures: [
+    {
+      name: "getReferenceKey",
+      input: { type: "Any", singleton: false, name: "Reference" },
+      parameters: [
+        {
+          name: "resourceType",
+          type: { type: "Any", singleton: true },
+          optional: true,
+          expression: true,
+          typeReference: true
+          // Expects a type name like Patient, Observation
+        }
+      ],
+      result: { type: "String", singleton: false }
+    }
+  ],
+  evaluate: evaluate107
+};
+
 // src/registry.ts
 var Registry = class {
   constructor() {
@@ -13065,11 +13194,11 @@ function specificity(actual, required) {
   if (numeric.has(actual.type) && numeric.has(required.type)) return 2;
   return 1;
 }
-function matchFunctionSignature(input, args, def) {
+function matchFunctionSignature(input, args, def, resourceTypes) {
   if (!def || !def.signatures || def.signatures.length === 0) return void 0;
   let best;
   for (const sig of def.signatures) {
-    if (sig.input && !isFunctionTypeCompatible(input, sig.input)) {
+    if (sig.input && !isFunctionTypeCompatible(input, sig.input, resourceTypes)) {
       continue;
     }
     let ok = true;
@@ -13106,8 +13235,16 @@ function matchFunctionSignature(input, args, def) {
   }
   return best?.sig;
 }
-function isFunctionTypeCompatible(actual, expected) {
+function isFunctionTypeCompatible(actual, expected, resourceTypes) {
   if (expected.singleton && !actual.singleton) return false;
+  if (expected.name && actual.name) {
+    if (expected.name === "Resource") {
+      if (actual.name === "Resource") return true;
+      if (resourceTypes) return resourceTypes.has(actual.name);
+      return true;
+    }
+    if (expected.name !== actual.name) return false;
+  }
   if (expected.type === "Any") return true;
   if (actual.type === expected.type) return true;
   if (expected.type === "Decimal" && actual.type === "Integer") return true;
@@ -13214,6 +13351,7 @@ function checkParamTypes(sig, argTypes, nodes, opts) {
 init_errors();
 var Analyzer = class _Analyzer {
   constructor(modelProvider) {
+    this.resourceTypesCache = null;
     this.cursorMode = false;
     this.stoppedAtCursor = false;
     this.modelProvider = modelProvider;
@@ -13559,7 +13697,12 @@ var Analyzer = class _Analyzer {
     const diagnostics = [];
     let match = null;
     if (!hasArityError && funcDef.signatures && funcDef.signatures.length > 0) {
-      match = matchFunctionSignature(actualInput, argTypes, funcDef) || null;
+      match = matchFunctionSignature(
+        actualInput,
+        argTypes,
+        funcDef,
+        this.resourceTypesCache ?? void 0
+      ) || null;
       if (!match) {
         const inputIsEmpty = isEmptyCollection(actualInput);
         if (inputIsEmpty && !funcDef.doesNotPropagateEmpty) {
@@ -13582,7 +13725,11 @@ var Analyzer = class _Analyzer {
               const expectedInput = sig.input;
               const singletonMatch = !expectedInput.singleton || actualInput.singleton === true;
               const typeMatch = expectedInput.type === "Any" || actualInput.type === "Any" || expectedInput.type === actualInput.type || expectedInput.type === "Decimal" && actualInput.type === "Integer";
-              inputMatches = singletonMatch && typeMatch;
+              let nameMatch = !expectedInput.name || !actualInput.name || expectedInput.name === actualInput.name;
+              if (expectedInput.name === "Resource" && actualInput.name) {
+                nameMatch = actualInput.name === "Resource" || (this.resourceTypesCache?.has(actualInput.name) ?? true);
+              }
+              inputMatches = singletonMatch && typeMatch && nameMatch;
             }
             if (inputMatches) {
               inputMatchingSignature = sig;
@@ -13598,7 +13745,8 @@ var Analyzer = class _Analyzer {
               })
             );
           } else {
-            const actualTypeStr = actualInput.singleton ? actualInput.type : `${actualInput.type}[]`;
+            const actualTypeName = actualInput.name || actualInput.type;
+            const actualTypeStr = actualInput.singleton ? actualTypeName : `${actualTypeName}[]`;
             const hasSingletonSignature = funcDef.signatures.some((sig) => sig.input?.singleton && sig.input.type === actualInput.type);
             const permissive = ["anyFalse", "anyTrue"];
             if (hasSingletonSignature && !actualInput.singleton) {
@@ -13610,7 +13758,11 @@ var Analyzer = class _Analyzer {
                 )
               );
             } else if (!permissive.includes(functionName)) {
-              const expectedTypes = funcDef.signatures.map((sig) => sig.input ? sig.input.singleton ? sig.input.type : `${sig.input.type}[]` : "Any").filter((v, i, a) => a.indexOf(v) === i).join(" or ");
+              const expectedTypes = funcDef.signatures.map((sig) => {
+                if (!sig.input) return "Any";
+                const name = sig.input.name || sig.input.type;
+                return sig.input.singleton ? name : `${name}[]`;
+              }).filter((v, i, a) => a.indexOf(v) === i).join(" or ");
               diagnostics.push(
                 this.createError(
                   node,
@@ -14022,6 +14174,10 @@ var Analyzer = class _Analyzer {
     this.cursorMode = options?.cursorMode ?? false;
     this.stoppedAtCursor = false;
     this.cursorContext = void 0;
+    if (this.modelProvider && this.resourceTypesCache === null) {
+      const list = await this.modelProvider.getResourceTypes();
+      this.resourceTypesCache = new Set(list);
+    }
     const systemVars = /* @__PURE__ */ new Map();
     systemVars.set("$this", inputType || { type: "Any", singleton: false });
     systemVars.set("$index", { type: "Integer", singleton: true });
@@ -14938,10 +15094,33 @@ async function provideCompletions(expression, cursorPosition, options = {}) {
     return [];
   }
 }
-function isFunctionApplicable(funcDef, typeInfo) {
+async function isFunctionApplicable(funcDef, typeInfo, modelProvider) {
   if (!typeInfo || !typeInfo.type) return true;
   const typeForRegistry = typeInfo.singleton === false ? `${typeInfo.type}[]` : typeInfo.type;
-  return registry.isFunctionApplicableToType(funcDef.name, typeForRegistry);
+  if (!registry.isFunctionApplicableToType(funcDef.name, typeForRegistry)) {
+    return false;
+  }
+  if (funcDef.signatures) {
+    const hasNameConstraint = funcDef.signatures.some(
+      (sig) => sig.input && sig.input.name
+    );
+    if (hasNameConstraint && typeInfo.name) {
+      const resourceTypes = modelProvider ? await modelProvider.getResourceTypes() : [];
+      const nameMatches = funcDef.signatures.some((sig) => {
+        if (!sig.input?.name) return true;
+        if (sig.input.name === typeInfo.name) return true;
+        if (sig.input.name === "Resource") {
+          const name = typeInfo.name;
+          return name === "Resource" || name !== void 0 && resourceTypes.includes(name);
+        }
+        return false;
+      });
+      if (!nameMatches) {
+        return false;
+      }
+    }
+  }
+  return true;
 }
 function isOperatorApplicable(opDef, typeInfo) {
   if (!typeInfo || !typeInfo.type) return true;
@@ -14985,7 +15164,7 @@ async function getIdentifierCompletions(typeBeforeCursor, modelProvider) {
   for (const name of functionNames) {
     const funcDef = registry.getFunction(name);
     if (funcDef) {
-      const isApplicable = !typeBeforeCursor || isFunctionApplicable(funcDef, typeBeforeCursor);
+      const isApplicable = !typeBeforeCursor || await isFunctionApplicable(funcDef, typeBeforeCursor, modelProvider);
       if (isApplicable) {
         const hasParams = funcDef.signatures?.some((sig) => (sig.parameters?.length ?? 0) > 0) ?? false;
         const funcDescription = funcDef.description || `FHIRPath ${name} function`;
@@ -15002,7 +15181,7 @@ async function getIdentifierCompletions(typeBeforeCursor, modelProvider) {
     const typeForRegistry = typeBeforeCursor.singleton === false ? `${typeBeforeCursor.type}[]` : typeBeforeCursor.type;
     const typeFunctions = registry.getFunctionsForType(typeForRegistry);
     for (const func of typeFunctions) {
-      if (!completions.some((c) => c.label === func.name)) {
+      if (!completions.some((c) => c.label === func.name) && await isFunctionApplicable(func, typeBeforeCursor, modelProvider)) {
         const hasParams = func.signatures?.some((sig) => (sig.parameters?.length ?? 0) > 0) ?? false;
         completions.push({
           label: func.name,
@@ -15245,7 +15424,7 @@ function rankCompletions(completions) {
 }
 
 // src/index.common.ts
-async function evaluate106(expression, options = {}) {
+async function evaluate108(expression, options = {}) {
   const interpreter = new Interpreter(void 0, options.modelProvider);
   return interpreter.evaluateExpression(expression, {
     input: options.input,
@@ -15265,7 +15444,7 @@ async function analyze(expression, options = {}) {
   return analysisResult;
 }
 function getVersion() {
-  return "0.0.5";
+  return "0.1.0-canary.20260203155750.e52d2f6";
 }
 var FHIRModelProviderBase = class _FHIRModelProviderBase {
   constructor() {
@@ -15347,23 +15526,19 @@ var FHIRModelProviderBase = class _FHIRModelProviderBase {
       this.initialized = true;
     }
   }
-  async resolve(_canonicalUrl) {
+  async resolve(_typeName) {
     throw new Error("Resolve not implemented.");
   }
   async search(_params) {
     throw new Error("Search not implemented.");
   }
-  buildCanonicalUrl(typeName) {
-    return `http://hl7.org/fhir/StructureDefinition/${typeName}`;
-  }
   // Public method to get schema with automatic caching
   async getSchema(typeName) {
     if (this.schemaCache.has(typeName)) {
       return this.schemaCache.get(typeName);
     }
     try {
-      const canonicalUrl = this.buildCanonicalUrl(typeName);
-      const resource = await this.resolve(canonicalUrl);
+      const resource = await this.resolve(typeName);
       if (!resource || resource.resourceType !== "StructureDefinition") {
         return void 0;
       }
@@ -15752,14 +15927,16 @@ var FHIRModelProvider = class extends FHIRModelProviderBase {
   async prepare() {
     await this.canonicalManager.init();
   }
-  async resolve(canonicalUrl) {
-    return await this.canonicalManager.resolve(canonicalUrl);
+  async resolve(typeName) {
+    return await this.canonicalManager.resolve(
+      `http://hl7.org/fhir/StructureDefinition/${typeName}`
+    );
   }
   async search(params) {
     return await this.canonicalManager.search(params);
   }
 };
 
-export { Analyzer, CompletionKind, CursorContext, DiagnosticSeverity, ErrorCodes, Errors, FHIRModelProvider, FHIRPathError, Interpreter, Parser, Registry, analyze, evaluate106 as evaluate, getVersion, inspect, isCursorNode, parse, provideCompletions, registry };
+export { Analyzer, CompletionKind, CursorContext, DiagnosticSeverity, ErrorCodes, Errors, FHIRModelProvider, FHIRPathError, Interpreter, Parser, Registry, analyze, evaluate108 as evaluate, getVersion, inspect, isCursorNode, parse, provideCompletions, registry };
 //# sourceMappingURL=index.node.js.map
 //# sourceMappingURL=index.node.js.map