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

package/src/operations/not-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 { collectionsNotEquivalent } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  // Empty collections are equivalent, so not-equivalent returns false
-  if (left.length === 0 && right.length === 0) {
-    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // Different sizes are not equivalent, so not-equivalent returns true
-  if (left.length !== right.length) {
-    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  // For single items, check type-specific non-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 non-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 non-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 non-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 inequality for now
-    // TODO: Implement full non-equivalence logic for Date/DateTime/Time and complex types
-    return { value: [box(l !== r, { type: 'Boolean', singleton: true })], context };
-  }
+  // Use the new collectionsNotEquivalent function from comparison.ts
+  const result = collectionsNotEquivalent(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(true, { type: 'Boolean', singleton: true })], context };
-    }
+  // null result means incomparable - return empty collection
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  // Return boolean result
+  return {
+    value: [box(result, { type: 'Boolean', singleton: true })],
+    context
+  };
 };
 
 export const notEquivalentOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -67,6 +26,7 @@ export const notEquivalentOperator: OperatorDefinition & { evaluate: OperationEv
   category: ['equality'],
   precedence: PRECEDENCE.EQUALITY,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Empty collections are valid operands for not-equivalence
   description: 'The converse of the equivalent operator, returning true if equivalent returns false and false if equivalent returns true. In other words, A !~ B is short-hand for (A ~ B).not()',
   examples: [
     "'abc' !~ 'ABC'",

package/src/operations/not-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) => {
   // Three-valued logic implementation
@@ -9,6 +9,11 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     return { value: [], context };
   }
   
+  // Multiple values should throw an error per XML tests
+  if (input.length > 1) {
+    throw new Error('not() can only be applied to a single item');
+  }
+  
   const boxedValue = input[0];
   if (!boxedValue) {
     return { value: [], context };
@@ -24,8 +29,10 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     return { value: [box(true, { type: 'Boolean', singleton: true })], context };
   }
   
-  // Non-boolean values return empty
-  return { value: [], context };
+  // Non-boolean values: any non-empty collection is considered truthy
+  // So not() returns false for any non-boolean value
+  // This follows the XML test suite behavior
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
 };
 
 export const notFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {

package/src/operations/ofType-function.ts

@@ -1,9 +1,8 @@
 import type { FunctionDefinition, RuntimeContext, ASTNode, TypeInfo, NodeEvaluator, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import type { FHIRPathValue } from '../boxing';
-import { unbox } from '../boxing';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { unbox } from '../interpreter/boxing';
 import { isIdentifierNode, isFunctionNode } from '../types';
-import { NodeType } from '../types';
 
 export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'ofType',
@@ -21,7 +20,8 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
       { 
         name: 'type', 
         type: { type: 'Any', singleton: true },
-        expression: true
+        expression: true,
+        typeReference: true // This parameter expects a type name
       }
     ],
     result: 'inputType'
@@ -37,10 +37,6 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
     let targetTypeName: string;
     if (isIdentifierNode(typeArg)) {
       targetTypeName = typeArg.name;
-    } else if (typeArg.type === NodeType.TypeOrIdentifier) {
-      targetTypeName = (typeArg as any).name;
-    } else if (typeArg.type === NodeType.TypeReference) {
-      targetTypeName = (typeArg as any).name;
     } else if (isFunctionNode(typeArg) && isIdentifierNode(typeArg.name)) {
       // Handle cases like ofType(Patient())
       targetTypeName = typeArg.name.name;
@@ -48,6 +44,41 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
       throw Errors.invalidOperation(`ofType() requires a type name as argument, got ${typeArg.type}`);
     }
 
+    // Validate the type name using ModelProvider if available
+    if (context.modelProvider) {
+      // Try to get the type from the model provider
+      const typeInfo = await context.modelProvider.getType(targetTypeName);
+      if (!typeInfo) {
+        // Not a valid FHIR type, check if it's a System type
+        const systemTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Quantity'];
+        const fhirPrimitiveTypes = ['boolean', 'integer', 'string', 'decimal', 'uri', 'url', 'canonical', 
+                                     'base64Binary', 'instant', 'date', 'dateTime', 'time', 'code', 'oid', 
+                                     'id', 'markdown', 'unsignedInt', 'positiveInt', 'uuid', 'xhtml'];
+        
+        if (!systemTypes.includes(targetTypeName) && !fhirPrimitiveTypes.includes(targetTypeName)) {
+          throw Errors.invalidOperation(`Unknown type: ${targetTypeName}`);
+        }
+      }
+    } else {
+      // Without ModelProvider, only allow basic System types and reject obvious invalid names
+      const systemTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time'];
+      const fhirPrimitiveTypes = ['boolean', 'integer', 'string', 'decimal', 'uri', 'url', 'canonical', 
+                                   'base64Binary', 'instant', 'date', 'dateTime', 'time', 'code', 'oid', 
+                                   'id', 'markdown', 'unsignedInt', 'positiveInt', 'uuid'];
+      
+      // If it's not a known primitive type and looks invalid, reject it
+      if (!systemTypes.includes(targetTypeName) && !fhirPrimitiveTypes.includes(targetTypeName)) {
+        // Check if it looks like a valid type name
+        if (!/^[A-Z][A-Za-z0-9]*$/.test(targetTypeName) && !/^[a-z][a-z0-9]*$/i.test(targetTypeName)) {
+          throw Errors.invalidOperation(`Invalid type name: ${targetTypeName}`);
+        }
+        // If it contains numbers but isn't a known type, it's likely invalid
+        if (/\d/.test(targetTypeName) && targetTypeName !== 'base64Binary') {
+          throw Errors.invalidOperation(`Unknown type: ${targetTypeName}`);
+        }
+      }
+    }
+
     // If we have typeInfo from the analyzer (with ModelProvider), use it
     // NOTE: This optimization is currently disabled because currentNode refers to the ofType
     // function node, not the input navigation node. The correct type checking happens below
@@ -91,9 +122,9 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
         return matchingType !== undefined;
       }
       
-      // Check if the box has type information
-      if (boxedItem.typeInfo) {
-        // If we have type info, use it for accurate filtering
+      // Check if the box has specific type information (not just "Any")
+      if (boxedItem.typeInfo && boxedItem.typeInfo.type !== 'Any') {
+        // If we have specific type info, use it for accurate filtering
         return boxedItem.typeInfo.type === targetTypeName;
       }
       
@@ -136,4 +167,4 @@ export const ofTypeFunction: FunctionDefinition & { evaluate: FunctionEvaluator
 
     return { value: actualFiltered, context };
   }
-};
+};

package/src/operations/or-operator.ts

@@ -1,7 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // Three-valued logic implementation
@@ -30,6 +30,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
 export const orOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
   symbol: 'or',
   name: 'or',
+  doesNotPropagateEmpty: true,  // Three-valued logic: true or empty = true
   category: ['logical'],
   precedence: PRECEDENCE.OR,
   associativity: 'left',

package/src/operations/plus-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { addQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { addQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -20,6 +20,69 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const l = unbox(boxedL);
   const r = unbox(boxedR);
   
+  // Check for temporal arithmetic using boxed type information
+  const leftType = boxedL?.typeInfo?.type;
+  const rightType = boxedR?.typeInfo?.type;
+  
+  if ((leftType === 'Date' || leftType === 'DateTime' || leftType === 'Time') && rightType === 'Quantity') {
+    // Left is temporal, right is quantity
+    const temporalType = leftType;
+    const temporal = l;
+    const quantity = r as QuantityValue;
+    
+    // Import temporal utilities and create TimeQuantity
+    const { createTimeQuantity, add } = await import('../complex-types/temporal');
+    
+    // Calendar duration units (allowed for temporal arithmetic)
+    const calendarUnits = ['year', 'years', 'month', 'months', 'week', 'weeks', 
+                          'day', 'days', 'hour', 'hours', 'minute', 'minutes', 
+                          'second', 'seconds', 'millisecond', 'milliseconds'];
+    
+    // Variable duration UCUM units (not allowed for temporal arithmetic - they have calendar-dependent durations)
+    const variableDurationUnits = ['a', 'mo'];
+    
+    // Fixed duration UCUM units (allowed - they map directly to calendar units)
+    const fixedDurationUnitMap: Record<string, string> = {
+      'd': 'day',
+      'wk': 'week', 
+      'h': 'hour',
+      'min': 'minute',
+      's': 'second',
+      'ms': 'millisecond'
+    };
+    
+    // Check if this is a variable duration unit (not allowed)
+    if (variableDurationUnits.includes(quantity.unit)) {
+      // Variable duration units like 'a' and 'mo' cannot be added to temporal values
+      // because they don't have fixed durations
+      const { Errors } = await import('../errors');
+      throw Errors.invalidTemporalUnit(temporalType, quantity.unit);
+    }
+    
+    // Map fixed duration UCUM units to calendar units
+    let mappedUnit = fixedDurationUnitMap[quantity.unit] || quantity.unit;
+    
+    // Check if this is a valid calendar duration unit (after mapping)
+    if (!calendarUnits.includes(mappedUnit)) {
+      // Non-time units with temporal values return empty per FHIRPath spec
+      return { value: [], context };
+    }
+    
+    const timeQuantity = createTimeQuantity(quantity.value, mappedUnit as any);
+    
+    // Use the functional add operation
+    const result = add(temporal as any, timeQuantity);
+    
+    if (temporalType === 'Date') {
+      return { value: [box(result, { type: 'Date', singleton: true })], context };
+    } else if (temporalType === 'DateTime') {
+      return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+    } else if (temporalType === 'Time') {
+      // Let the error propagate - adding calendar units to Time should throw
+      return { value: [box(result, { type: 'Time', singleton: true })], context };
+    }
+  }
+  
   // Check if both are quantities
   if (l && typeof l === 'object' && 'unit' in l && 
       r && typeof r === 'object' && 'unit' in r) {
@@ -27,8 +90,9 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: result ? [box(result, { type: 'Quantity', singleton: true })] : [], context };
   }
   
-  if (typeof l === 'string' || typeof r === 'string') {
-    return { value: [box(String(l) + String(r), { type: 'String', singleton: true })], context };
+  // String concatenation only works for string + string
+  if (typeof l === 'string' && typeof r === 'string') {
+    return { value: [box(l + r, { type: 'String', singleton: true })], context };
   }
   
   if (typeof l === 'number' && typeof r === 'number') {
@@ -39,8 +103,8 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: [box(result, typeInfo)], context };
   }
   
-  // For other types, convert to string
-  return { value: [box(String(l) + String(r), { type: 'String', singleton: true })], context };
+  // For incompatible types, return empty per FHIRPath spec
+  return { value: [], context };
 };
 
 export const plusOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/power-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) => {
   // power() takes exactly one argument (exponent)
@@ -75,14 +75,39 @@ export const powerFunction: FunctionDefinition & { evaluate: FunctionEvaluator }
     '2.5.power(2)',
     '(-1).power(0.5)'
   ],
-  signatures: [{
-
-    name: 'power',
-    input: { type: 'Decimal', singleton: true },
-    parameters: [
-      { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
-    ],
-    result: { type: 'Decimal', singleton: true }
-  }],
+  signatures: [
+    {
+      name: 'power-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'power-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'power-integer-decimal',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'power-decimal-integer',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
   evaluate
 };

package/src/operations/precision-function.ts

@@ -0,0 +1,146 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+import { getDecimalPlaces } from '../utils/decimal';
+import { isFHIRDate, isFHIRDateTime, isFHIRTime } from '../complex-types/temporal';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // Check single item in input
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (input.length > 1) {
+    throw Errors.singletonRequired('precision', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // precision() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('precision', 0, args.length);
+  }
+
+  // Handle temporal types - return precision according to FHIRPath spec
+  if (isFHIRDate(inputValue)) {
+    const date = inputValue as any;
+    // Date precision: year=4, year-month=6, year-month-day=8
+    if (date.day !== undefined) {
+      return { value: [box(8, { type: 'Integer', singleton: true })], context };
+    } else if (date.month !== undefined) {
+      return { value: [box(6, { type: 'Integer', singleton: true })], context };
+    } else {
+      return { value: [box(4, { type: 'Integer', singleton: true })], context };
+    }
+  }
+  
+  if (isFHIRDateTime(inputValue)) {
+    const dateTime = inputValue as any;
+    // DateTime precision: year=4, month=6, day=8, hour=10, minute=12, second=14, millisecond=17
+    if (dateTime.millisecond !== undefined) {
+      return { value: [box(17, { type: 'Integer', singleton: true })], context };
+    } else if (dateTime.second !== undefined) {
+      return { value: [box(14, { type: 'Integer', singleton: true })], context };
+    } else if (dateTime.minute !== undefined) {
+      return { value: [box(12, { type: 'Integer', singleton: true })], context };
+    } else if (dateTime.hour !== undefined) {
+      return { value: [box(10, { type: 'Integer', singleton: true })], context };
+    } else if (dateTime.day !== undefined) {
+      return { value: [box(8, { type: 'Integer', singleton: true })], context };
+    } else if (dateTime.month !== undefined) {
+      return { value: [box(6, { type: 'Integer', singleton: true })], context };
+    } else {
+      return { value: [box(4, { type: 'Integer', singleton: true })], context };
+    }
+  }
+  
+  if (isFHIRTime(inputValue)) {
+    const time = inputValue as any;
+    // Time precision: hour=2, minute=4, second=6, millisecond=9
+    // But spec shows hour=4, minute=4, second=6, millisecond=9
+    // Looking at examples: @T10:30 has "10:30" which is 4 characters for HH:mm
+    // @T10:30:00.000 has milliseconds which would be 9 for HH:mm:ss.fff
+    if (time.millisecond !== undefined) {
+      return { value: [box(9, { type: 'Integer', singleton: true })], context };
+    } else if (time.second !== undefined) {
+      return { value: [box(6, { type: 'Integer', singleton: true })], context };
+    } else if (time.minute !== undefined) {
+      return { value: [box(4, { type: 'Integer', singleton: true })], context };
+    } else {
+      // Hour only would be 2 (HH)
+      return { value: [box(2, { type: 'Integer', singleton: true })], context };
+    }
+  }
+  
+  // Handle decimal/numeric types
+  if (typeof inputValue === 'number') {
+    // For integers, precision is always 0
+    if (Number.isInteger(inputValue)) {
+      return { value: [box(0, { type: 'Integer', singleton: true })], context };
+    }
+    
+    // For decimals, count significant digits after the decimal point
+    const decimalPlaces = getDecimalPlaces(inputValue);
+    return { value: [box(decimalPlaces, { type: 'Integer', singleton: true })], context };
+  }
+  
+  // For any other type, return empty
+  return { value: [], context };
+};
+
+export const precisionFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'precision',
+  category: ['utility'],
+  description: 'Returns the number of digits of precision for decimal values, or the precision indicator for temporal values (year=4, month=6, day=8, etc.). Returns empty for other types.',
+  examples: [
+    "1.58700.precision()",
+    "@2014.precision()",
+    "@2014-01-05T10:30:00.000.precision()",
+    "@T10:30.precision()",
+    "{}.precision()"
+  ],
+  signatures: [
+    {
+      name: 'precision',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'precision',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'precision',
+      input: { type: 'Date', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'precision',
+      input: { type: 'DateTime', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'precision',
+      input: { type: 'Time', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'precision',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: false }
+    }
+  ],
+  evaluate
+};