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

package/src/operations/is-operator.ts

@@ -1,7 +1,8 @@
 import type { OperatorDefinition, TypeName } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDate, isFHIRDateTime, isFHIRTime } from '../complex-types/temporal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // Right operand should be a type identifier
@@ -13,9 +14,132 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const boxedItem = left[0];
   const item = unbox(boxedItem);
   const typeName = right[0] as string; // Should be a type name like 'String', 'Integer', etc.
-  
-  // If we have a ModelProvider in context, use it for accurate type checking
+  // If we have a ModelProvider and typeInfo, use it for accurate type checking (handles subtypes)
   if (context.modelProvider && boxedItem?.typeInfo) {
+    // Check for namespace-qualified types (e.g., System.Boolean, FHIR.boolean)
+    let checkNamespace: string | undefined;
+    let checkType: string;
+    
+    if (typeName.includes('.')) {
+      const parts = typeName.split('.');
+      checkNamespace = parts[0];
+      checkType = parts.slice(1).join('.');
+    } else {
+      checkType = typeName;
+    }
+    
+    // If checking for System type, ensure it's NOT a FHIR type
+    if (checkNamespace === 'System') {
+      // System types should not match FHIR types
+      if (boxedItem.typeInfo.namespace === 'FHIR') {
+        return { 
+          value: [box(false, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+      // Check if the type matches (without namespace)
+      const normalizedType = checkType;
+      if (boxedItem.typeInfo.type === normalizedType) {
+        return { 
+          value: [box(true, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+    }
+    
+    // If checking for FHIR type
+    if (checkNamespace === 'FHIR') {
+      // Must be a FHIR namespaced type
+      if (boxedItem.typeInfo.namespace === 'FHIR') {
+        // Check the name field for FHIR types (e.g., 'boolean', 'integer')
+        if (boxedItem.typeInfo.name === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+        // Also check if asking for a resource type like FHIR.Patient
+        if (boxedItem.typeInfo.type === checkType || boxedItem.typeInfo.name === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+      }
+      return { 
+        value: [box(false, { type: 'Boolean', singleton: true })], 
+        context 
+      };
+    }
+    
+    // When no namespace is specified (e.g., just "Boolean", "String", "string", "code")
+    if (!checkNamespace) {
+      // Check for System primitive types (capitalized)
+      const systemPrimitiveTypes = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time'];
+      if (systemPrimitiveTypes.includes(checkType)) {
+        // For System primitive types, only match if NOT a FHIR type
+        if (boxedItem.typeInfo.namespace === 'FHIR') {
+          return { 
+            value: [box(false, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+        // Check if the type matches
+        if (boxedItem.typeInfo.type === checkType) {
+          return { 
+            value: [box(true, { type: 'Boolean', singleton: true })], 
+            context 
+          };
+        }
+      }
+      
+      // Check for FHIR primitive types (lowercase) like string, code, id, etc.
+      const fhirPrimitiveTypes = ['string', 'code', 'id', 'uri', 'url', 'canonical', 'uuid', 'oid', 
+                                   'boolean', 'integer', 'decimal', 'base64Binary', 'instant', 
+                                   'date', 'dateTime', 'time', 'unsignedInt', 'positiveInt', 'markdown'];
+      if (fhirPrimitiveTypes.includes(checkType)) {
+        // For FHIR primitive types, check both the name and underlying type
+        if (boxedItem.typeInfo.namespace === 'FHIR') {
+          // Check if the name matches
+          if (boxedItem.typeInfo.name === checkType) {
+            return { 
+              value: [box(true, { type: 'Boolean', singleton: true })], 
+              context 
+            };
+          }
+          // For 'string', also match code, id, etc. (they are all string-based)
+          if (checkType === 'string') {
+            const stringBasedTypes = ['code', 'id', 'uri', 'url', 'canonical', 'uuid', 'oid', 'markdown'];
+            if (boxedItem.typeInfo.name && stringBasedTypes.includes(boxedItem.typeInfo.name)) {
+              return { 
+                value: [box(true, { type: 'Boolean', singleton: true })], 
+                context 
+              };
+            }
+            // Also check if underlying type is String
+            if (boxedItem.typeInfo.type === 'String') {
+              return { 
+                value: [box(true, { type: 'Boolean', singleton: true })], 
+                context 
+              };
+            }
+          }
+        }
+        return { 
+          value: [box(false, { type: 'Boolean', singleton: true })], 
+          context 
+        };
+      }
+      
+      // For non-primitive types (like Patient, Observation), use model provider
+      const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, typeName as TypeName);
+      return { 
+        value: [box(matchingType !== undefined, { type: 'Boolean', singleton: true })], 
+        context 
+      };
+    }
+    
+    // Default case - use model provider's ofType for other checks
     const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, typeName as TypeName);
     return { 
       value: [box(matchingType !== undefined, { type: 'Boolean', singleton: true })], 
@@ -23,11 +147,24 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     };
   }
   
-  // Check if the box has type information
+  // Check if the box has type information (without ModelProvider, check with normalization)
   if (boxedItem?.typeInfo) {
-    // For now, just check exact type match (no subtype support without ModelProvider)
+    // Normalize both types for comparison
+    let boxedType = boxedItem.typeInfo.type;
+    let compareType = typeName;
+    
+    // Normalize System.X to X for primitive types
+    if (compareType.startsWith('System.')) {
+      compareType = compareType.substring(7);
+    }
+    
+    // Also check if boxedType needs normalization (unlikely but consistent)
+    if (boxedType.startsWith('System.')) {
+      boxedType = boxedType.substring(7);
+    }
+    
     return { 
-      value: [box(boxedItem.typeInfo.type === typeName, { type: 'Boolean', singleton: true })], 
+      value: [box(boxedType === compareType, { type: 'Boolean', singleton: true })], 
       context 
     };
   }
@@ -35,9 +172,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   // For FHIR resources without typeInfo, try to get it from modelProvider
   if (context.modelProvider && item && typeof item === 'object' && 'resourceType' in item && typeof item.resourceType === 'string') {
     // Use cached type if available
-    const typeInfo = 'getTypeFromCache' in context.modelProvider 
-      ? (context.modelProvider as any).getTypeFromCache(item.resourceType)
-      : undefined;
+    const typeInfo = await context.modelProvider.getType(item.resourceType);
     if (typeInfo) {
       const matchingType = context.modelProvider.ofType(typeInfo, typeName as TypeName);
       return { 
@@ -52,21 +187,49 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     };
   }
   
-  // Check primitive types
-  switch (typeName) {
+  // Normalize type names - strip namespace for System types
+  // System.Boolean -> Boolean, FHIR.boolean -> boolean, etc.
+  let normalizedTypeName = typeName;
+  if (typeName.startsWith('System.')) {
+    normalizedTypeName = typeName.substring(7); // Remove "System."
+  } else if (typeName.startsWith('FHIR.')) {
+    // For FHIR types, keep the namespace for model provider lookup
+    // but also check without namespace for primitive types
+    normalizedTypeName = typeName;
+  }
+  
+  // Check primitive types (with normalized names)
+  switch (normalizedTypeName) {
     case 'String':
+    case 'System.String':
       return { value: [box(typeof item === 'string', { type: 'Boolean', singleton: true })], context };
     case 'Boolean':
+    case 'System.Boolean':
       return { value: [box(typeof item === 'boolean', { type: 'Boolean', singleton: true })], context };
     case 'Integer':
+    case 'System.Integer':
       return { value: [box(typeof item === 'number' && Number.isInteger(item), { type: 'Boolean', singleton: true })], context };
     case 'Decimal':
+    case 'System.Decimal':
       return { value: [box(typeof item === 'number', { type: 'Boolean', singleton: true })], context };
     case 'Date':
+      // Check if it's a FHIRDate instance or has Date type
+      if (item && typeof item === 'object') {
+        return { value: [box(isFHIRDate(item) || (item as any).kind === 'FHIRDate', { type: 'Boolean', singleton: true })], context };
+      }
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
     case 'DateTime':
+      // Check if it's a FHIRDateTime instance or has DateTime type
+      if (item && typeof item === 'object') {
+        return { value: [box(isFHIRDateTime(item) || (item as any).kind === 'FHIRDateTime', { type: 'Boolean', singleton: true })], context };
+      }
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
     case 'Time':
-      // Simple check for date-like strings
-      return { value: [box(typeof item === 'string' && !isNaN(Date.parse(item)), { type: 'Boolean', singleton: true })], context };
+      // Check if it's a FHIRTime instance or has Time type
+      if (item && typeof item === 'object') {
+        return { value: [box(isFHIRTime(item) || (item as any).kind === 'FHIRTime', { type: 'Boolean', singleton: true })], context };
+      }
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
     default:
       // For complex types, check resourceType
       if (item && typeof item === 'object' && 'resourceType' in item) {

package/src/operations/isDistinct-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) => {
   // isDistinct takes no arguments
@@ -35,6 +35,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const isDistinctFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'isDistinct',
+  doesNotPropagateEmpty: true,  // Returns true for empty collections
   category: ['existence'],
   description: 'Returns true if all the items in the input collection are distinct. To determine whether two items are distinct, the equals (=) operator is used. If the input collection is empty, the result is true.',
   examples: [

package/src/operations/join-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 is empty, return empty

package/src/operations/last-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/lastIndexOf-function.ts

@@ -0,0 +1,85 @@
+import type { FunctionDefinition, FunctionEvaluator, LiteralNode } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+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.stringSingletonRequired('lastIndexOf', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('lastIndexOf');
+  }
+
+  // Check arguments
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('lastIndexOf', 1, args.length);
+  }
+
+  // Evaluate substring argument
+  const substringArg = args[0];
+  if (!substringArg) {
+    throw Errors.argumentRequired('lastIndexOf', 'substring argument');
+  }
+  
+  const substringResult = await evaluator(substringArg, input, context);
+  
+  if (substringResult.value.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (substringResult.value.length > 1) {
+    throw Errors.singletonRequired('lastIndexOf substring', substringResult.value.length);
+  }
+  
+  const boxedSubstring = substringResult.value[0];
+  if (!boxedSubstring) {
+    return { value: [], context };
+  }
+  
+  const substring = unbox(boxedSubstring);
+  if (typeof substring !== 'string') {
+    throw Errors.invalidStringOperation('lastIndexOf', 'substring argument');
+  }
+
+  // Handle empty substring - returns 0 per spec
+  if (substring === '') {
+    return { value: [box(0, { type: 'Integer', singleton: true })], context };
+  }
+
+  // Find the last index
+  const index = inputValue.lastIndexOf(substring);
+  
+  return { value: [box(index, { type: 'Integer', singleton: true })], context };
+};
+
+export const lastIndexOfFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'lastIndexOf',
+  category: ['string'],
+  description: 'Returns the 0-based index of the last position substring is found in the input string, or -1 if it is not found',
+  examples: [
+    "'abcdefg'.lastIndexOf('bc')",
+    "'abcdefg'.lastIndexOf('x')",
+    "'abc abc'.lastIndexOf('a')"
+  ],
+  signatures: [{
+    name: 'lastIndexOf',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'substring', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'Integer', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/length-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) => {
   // Check single item in input

package/src/operations/less-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,14 @@ 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 };
+  // Use the unified compare function which handles all types including FHIR Quantities
+  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 === 'less', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/less-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 === 'less' || comparisonResult.kind === 'equal', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessOrEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/less-than.ts

@@ -1,8 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
-import { compareQuantities, type QuantityValue } from '../quantity-value';
+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) {
@@ -18,19 +18,14 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const leftValue = unbox(boxedLeft);
   const rightValue = unbox(boxedRight);
   
-  // Handle quantity comparison
-  if (leftValue && typeof leftValue === 'object' && 'value' in leftValue && 'unit' in leftValue &&
-      rightValue && typeof rightValue === 'object' && 'value' in rightValue && 'unit' in rightValue) {
-    const comparison = compareQuantities(leftValue as QuantityValue, rightValue as QuantityValue);
-    if (comparison === null) {
-      // Incompatible units - return empty
-      return { value: [], context };
-    }
-    return { value: [box(comparison < 0, { type: 'Boolean', singleton: true })], context };
+  // Use the unified compare function which handles all types including FHIR Quantities
+  const comparisonResult = compare(leftValue, rightValue);
+  
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  // Regular comparison
-  return { value: [box((leftValue as any) < (rightValue as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'less', { type: 'Boolean', singleton: true })], context };
 };
 
 export const lessThanOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/lowBoundary-function.ts

@@ -0,0 +1,120 @@
+// lowBoundary() function - Returns the least possible value to the specified precision
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { 
+  isFHIRDate, isFHIRDateTime, isFHIRTime,
+  getDateLowBoundary, getDateTimeLowBoundary, getTimeLowBoundary 
+} from '../complex-types/temporal';
+import { getDecimalLowBoundary } from './decimal-boundaries';
+import { Errors } from '../errors';
+
+export const lowBoundaryEvaluator: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // lowBoundary() takes optional precision parameter
+  if (args.length > 1) {
+    throw Errors.wrongArgumentCountRange('lowBoundary', 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('lowBoundary', 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('lowBoundary precision', precisionArg.length);
+    }
+    const precisionValue = unbox(precisionArg[0]!);
+    if (typeof precisionValue !== 'number' || !Number.isInteger(precisionValue)) {
+      throw Errors.invalidOperandType('lowBoundary precision', typeof precisionValue);
+    }
+    precision = precisionValue;
+  }
+  
+  // Handle Date
+  if (isFHIRDate(value)) {
+    const result = getDateLowBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'Date', singleton: true })], context };
+  }
+  
+  // Handle DateTime
+  if (isFHIRDateTime(value)) {
+    const result = getDateTimeLowBoundary(value, precision);
+    if (!result) {
+      return { value: [], context };
+    }
+    return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+  }
+  
+  // Handle Time
+  if (isFHIRTime(value)) {
+    const result = getTimeLowBoundary(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 = getDecimalLowBoundary(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 lowBoundaryFunction: FunctionDefinition & { evaluate: typeof lowBoundaryEvaluator } = {
+  name: 'lowBoundary',
+  category: ['utility'],
+  description: 'Returns the least possible value of the input to the specified precision',
+  examples: [
+    '@2014.lowBoundary(6)',
+    '@2014-01-01T08.lowBoundary(17)',
+    '@T10:30.lowBoundary(9)',
+    '1.587.lowBoundary()',
+    '1.587.lowBoundary(2)',
+    '1.lowBoundary(0)'
+  ],
+  signatures: [
+    {
+      name: 'lowBoundary',
+      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: lowBoundaryEvaluator
+};

package/src/operations/lower-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) => {
   // Handle empty input collection