@atomic-ehr/fhirpath 0.0.2 → 0.0.3-canary.2be66fb.20250905161900

package/src/operations/equivalent-operator.ts

@@ -1,64 +1,23 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box } from '../interpreter/boxing';
+import { collectionsEquivalent } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  // Empty collections are equivalent
-  if (left.length === 0 && right.length === 0) {
-    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // Different sizes are not equivalent
-  if (left.length !== right.length) {
-    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // For single items, check type-specific equivalence
-  if (left.length === 1 && right.length === 1) {
-    const boxedl = left[0];
-  if (!boxedl) return { value: [], context };
-  const l = unbox(boxedl);
-    const boxedr = right[0];
-  if (!boxedr) return { value: [], context };
-  const r = unbox(boxedr);
-    
-    // String equivalence: case-insensitive with normalized whitespace
-    if (typeof l === 'string' && typeof r === 'string') {
-      const normalizeString = (s: string) => s.trim().toLowerCase().replace(/\s+/g, ' ');
-      return { value: [box(normalizeString(l) === normalizeString(r), { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // Number equivalence (for Integer and Decimal)
-    if (typeof l === 'number' && typeof r === 'number') {
-      // For decimals with different precision, round to least precise
-      // This is a simplified implementation
-      return { value: [box(Math.abs(l - r) < Number.EPSILON, { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // Boolean equivalence
-    if (typeof l === 'boolean' && typeof r === 'boolean') {
-      return { value: [box(l === r, { type: 'Boolean', singleton: true })], context };
-    }
-    
-    // For complex types and other cases, use equality for now
-    // TODO: Implement full equivalence logic for Date/DateTime/Time and complex types
-    return { value: [box(l === r, { type: 'Boolean', singleton: true })], context };
-  }
+  // Use the new collectionsEquivalent function from comparison.ts
+  const result = collectionsEquivalent(left, right);
   
-  // For multiple items, comparison is order-independent
-  // Create sorted copies for comparison
-  // TODO: Implement proper order-independent comparison with recursive equivalence
-  const leftSorted = [...left].sort();
-  const rightSorted = [...right].sort();
-  
-  for (let i = 0; i < leftSorted.length; i++) {
-    if (leftSorted[i] !== rightSorted[i]) {
-      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
-    }
+  // null result means incomparable - return empty collection
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  // Return boolean result
+  return {
+    value: [box(result, { type: 'Boolean', singleton: true })],
+    context
+  };
 };
 
 export const equivalentOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -67,6 +26,7 @@ export const equivalentOperator: OperatorDefinition & { evaluate: OperationEvalu
   category: ['equality'],
   precedence: PRECEDENCE.EQUALITY,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Empty collections are valid operands for equivalence
   description: 'Returns true if the collections are the same. For single items: strings are compared case-insensitive with normalized whitespace, decimals are rounded to least precision, dates with different precision return false. For collections: order-independent comparison. Empty ~ empty returns true (unlike =)',
   examples: [
     "'abc' ~ 'ABC'",

package/src/operations/exclude-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length !== 1) {
@@ -44,6 +44,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const excludeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'exclude',
+  doesNotPropagateEmpty: true,  // exclude with empty argument returns the original collection
   category: ['collection'],
   description: 'Returns the set of elements that are not in the other collection. Duplicate items will not be eliminated by this function, and order will be preserved.',
   examples: [

package/src/operations/exists-function.ts

@@ -1,8 +1,8 @@
 import type { FunctionDefinition } from '../types';
 import { Errors } from '../errors';
-import { RuntimeContextManager } from '../interpreter';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
 import { type FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // No arguments - just check if input is not empty
@@ -42,6 +42,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const existsFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'exists',
+  doesNotPropagateEmpty: true,
   category: ['collection', 'logical'],
   description: 'Returns true if the collection has any items, or if any item satisfies the condition',
   examples: ['Patient.name.exists()', 'Patient.name.exists(use = "official")'],
@@ -55,4 +56,4 @@ export const existsFunction: FunctionDefinition & { evaluate: FunctionEvaluator
     result: { type: 'Boolean', singleton: true },
   }],
   evaluate
-};
+};

package/src/operations/extension-function.ts

@@ -0,0 +1,84 @@
+import type { FunctionDefinition, FunctionEvaluator, ASTNode, RuntimeContext, NodeEvaluator } from '../types';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { Errors } from '../errors';
+
+const extensionEvaluator: FunctionEvaluator = async (
+  input: FHIRPathValue[], 
+  context: RuntimeContext, 
+  args: ASTNode[],
+  evaluator: NodeEvaluator
+) => {
+  // extension() function takes one argument - the URL to match
+  if (args.length !== 1) {
+    throw Errors.invalidOperation('extension() requires exactly one argument');
+  }
+  
+  // Evaluate the URL argument
+  const urlResult = await evaluator(args[0]!, input, context);
+  if (urlResult.value.length !== 1) {
+    throw Errors.invalidOperation('extension() URL argument must be a single value');
+  }
+  
+  const urlToMatch = unbox(urlResult.value[0]);
+  if (typeof urlToMatch !== 'string') {
+    throw Errors.invalidOperation('extension() URL argument must be a string');
+  }
+  
+  const results: FHIRPathValue[] = [];
+  
+  // For each input item, look for extensions
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
+    
+    // First check if this is a primitive value with extensions in primitiveElement
+    if (boxedItem.primitiveElement?.extension) {
+      const extensions = boxedItem.primitiveElement.extension;
+      for (const ext of extensions) {
+        if (ext && typeof ext === 'object' && 'url' in ext && ext.url === urlToMatch) {
+          const boxedExt = box(ext, { type: 'Extension' as any, singleton: true });
+          results.push(boxedExt);
+        }
+      }
+    }
+    
+    // Then check for direct extension property on complex types
+    if (item && typeof item === 'object' && 'extension' in item) {
+      const extensions = (item as any).extension;
+      if (Array.isArray(extensions)) {
+        for (const ext of extensions) {
+          if (ext && typeof ext === 'object' && 'url' in ext && ext.url === urlToMatch) {
+            const boxedExt = box(ext, { type: 'Extension' as any, singleton: true });
+            results.push(boxedExt);
+          }
+        }
+      }
+    }
+  }
+  
+  return { value: results, context };
+};
+
+export const extensionFunction: FunctionDefinition & { evaluate: typeof extensionEvaluator } = {
+  name: 'extension',
+  category: ['navigation'],
+  description: 'Returns extensions matching the specified URL',
+  examples: [
+    "Patient.birthDate.extension('http://hl7.org/fhir/StructureDefinition/patient-birthTime')",
+    "Observation.extension('http://example.com/fhir/StructureDefinition/patient-age')"
+  ],
+  signatures: [
+    {
+      name: 'extension-by-url',
+      parameters: [{ 
+        name: 'url', 
+        type: { type: 'String', singleton: true },
+        expression: true
+      }],
+      input: { type: 'Any', singleton: false },
+      result: { type: 'Extension' as any, singleton: false }
+    }
+  ],
+  doesNotPropagateEmpty: false,
+  evaluate: extensionEvaluator
+};

package/src/operations/first-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition } from '../types';
 import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (input.length > 0) {

package/src/operations/floor-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // floor() takes no arguments

package/src/operations/greater-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,14 +16,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result > 0, { type: 'Boolean', singleton: true })] : [], context };
+  const comparisonResult = compare(l, r);
+  
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) > (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'greater', { type: 'Boolean', singleton: true })], context };
 };
 
 export const greaterOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/greater-or-equal-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,14 +16,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result >= 0, { type: 'Boolean', singleton: true })] : [], context };
+  const comparisonResult = compare(l, r);
+  
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) >= (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'greater' || comparisonResult.kind === 'equal', { type: 'Boolean', singleton: true })], context };
 };
 
 export const greaterOrEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/highBoundary-function.ts

@@ -0,0 +1,120 @@
+// highBoundary() function - Returns the greatest possible value to the specified precision
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { 
+  isFHIRDate, isFHIRDateTime, isFHIRTime,
+  getDateHighBoundary, getDateTimeHighBoundary, getTimeHighBoundary 
+} from '../complex-types/temporal';
+import { getDecimalHighBoundary } from './decimal-boundaries';
+import { Errors } from '../errors';
+
+export const highBoundaryEvaluator: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // highBoundary() takes optional precision parameter
+  if (args.length > 1) {
+    throw Errors.wrongArgumentCountRange('highBoundary', 0, 1, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('highBoundary', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Get precision if provided
+  let precision: number | undefined;
+  if (args.length === 1) {
+    const precisionResult = await evaluator(args[0]!, input, context);
+    const precisionArg = precisionResult.value;
+    if (precisionArg.length === 0) {
+      return { value: [], context };
+    }
+    if (precisionArg.length > 1) {
+      throw Errors.singletonRequired('highBoundary precision', precisionArg.length);
+    }
+    const precisionValue = unbox(precisionArg[0]!);
+    if (typeof precisionValue !== 'number' || !Number.isInteger(precisionValue)) {
+      throw Errors.invalidOperandType('highBoundary precision', typeof precisionValue);
+    }
+    precision = precisionValue;
+  }
+  
+  // Handle Date
+  if (isFHIRDate(value)) {
+    const result = getDateHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'Date', singleton: true })], context };
+  }
+  
+  // Handle DateTime
+  if (isFHIRDateTime(value)) {
+    const result = getDateTimeHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+  }
+  
+  // Handle Time
+  if (isFHIRTime(value)) {
+    const result = getTimeHighBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'Time', singleton: true })], context };
+  }
+  
+  // For Decimal/Integer types
+  if (typeof value === 'number') {
+    const result = getDecimalHighBoundary(value, precision);
+    if (result === null) {
+      return { value: [], context };
+    }
+    // Determine the result type based on whether it's an integer or decimal
+    const isInteger = Number.isInteger(result);
+    return { 
+      value: [box(result, { type: isInteger ? 'Integer' : 'Decimal', singleton: true })], 
+      context 
+    };
+  }
+  
+  // Invalid type returns empty
+  return { value: [], context };
+};
+
+export const highBoundaryFunction: FunctionDefinition & { evaluate: typeof highBoundaryEvaluator } = {
+  name: 'highBoundary',
+  category: ['utility'],
+  description: 'Returns the greatest possible value of the input to the specified precision',
+  examples: [
+    '@2014.highBoundary(6)',
+    '@2014-01-01T08.highBoundary(17)',
+    '@T10:30.highBoundary(9)',
+    '1.587.highBoundary()',
+    '1.587.highBoundary(2)',
+    '1.highBoundary(0)'
+  ],
+  signatures: [
+    {
+      name: 'highBoundary',
+      input: { type: 'Any' as const, singleton: true },
+      parameters: [
+        { name: 'precision', type: { type: 'Integer' as const, singleton: true }, optional: true }
+      ],
+      result: { type: 'Any' as const, singleton: true }
+    }
+  ],
+  evaluate: highBoundaryEvaluator
+};

package/src/operations/hourOf-function.ts

@@ -0,0 +1,66 @@
+// hourOf() function - Extracts hour component from Time or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const hourOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // hourOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('hourOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('hourOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Time or DateTime
+  if (isFHIRTime(value) || isFHIRDateTime(value)) {
+    // Check if hour component is present
+    if (value.hour === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the hour as an Integer (0-23)
+    return {
+      value: [box(value.hour, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const hourOfFunction: FunctionDefinition & { evaluate: typeof hourOfEvaluator } = {
+  name: 'hourOf',
+  category: ['temporal'],
+  description: 'Returns the hour component of a Time or DateTime value (0-23)',
+  examples: [
+    '@T10:30:00.hourOf()',
+    '@2014-01-05T10:30:00.hourOf()',
+    'Patient.birthDate.hourOf()'
+  ],
+  signatures: [
+    {
+      name: 'hourOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: hourOfEvaluator
+};