@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/dayOf-function.ts

@@ -0,0 +1,66 @@
+// dayOf() function - Extracts day component from Date or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDate, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const dayOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // dayOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('dayOf', 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('dayOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Date or DateTime
+  if (isFHIRDate(value) || isFHIRDateTime(value)) {
+    // Check if day component is present
+    if (value.day === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the day as an Integer (1-31)
+    return {
+      value: [box(value.day, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Date or DateTime, return empty
+  return { value: [], context };
+};
+
+export const dayOfFunction: FunctionDefinition & { evaluate: typeof dayOfEvaluator } = {
+  name: 'dayOf',
+  category: ['temporal'],
+  description: 'Returns the day component of a Date or DateTime value (1-31)',
+  examples: [
+    '@2014-01-05.dayOf()',
+    '@2014-01-05T10:30:00.dayOf()',
+    'Patient.birthDate.dayOf()'
+  ],
+  signatures: [
+    {
+      name: 'dayOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: dayOfEvaluator
+};

package/src/operations/decimal-boundaries.ts

@@ -0,0 +1,133 @@
+/**
+ * Decimal boundary functions for FHIRPath
+ * 
+ * Implements lowBoundary and highBoundary for decimal values according to the FHIRPath specification.
+ * These functions return the least or greatest possible value at a specified precision.
+ */
+
+/**
+ * Maximum supported precision for decimal values (FHIRPath requires at least 8)
+ */
+const MAX_DECIMAL_PRECISION = 8;
+
+/**
+ * Get the low boundary of a decimal value at the specified precision
+ * 
+ * Returns the least possible value of the input to the specified precision.
+ * For the given precision, returns the truncated value minus half the step size.
+ * 
+ * @param value The decimal value
+ * @param precision The number of decimal places (optional, defaults to input precision + 1)  
+ * @returns The low boundary value, or null if precision is invalid
+ */
+export function getDecimalLowBoundary(value: number, precision?: number): number | null {
+  // Default precision is the input's precision (for decimals) or 1 (for integers)
+  if (precision === undefined) {
+    const str = value.toString();
+    const decimalIndex = str.indexOf('.');
+    const inputPrecision = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+    // For integers, default to precision 1; for decimals, use their precision
+    precision = inputPrecision === 0 ? 1 : Math.min(inputPrecision, MAX_DECIMAL_PRECISION);
+  }
+  
+  // Invalid precision returns null (empty in FHIRPath)
+  if (precision < 0 || precision > MAX_DECIMAL_PRECISION) {
+    return null;
+  }
+  
+  // For precision 0 (integer precision)
+  if (precision === 0) {
+    // For integers at precision 0, return floor - 1 for positive, ceiling + 1 for negative
+    // 1.lowBoundary(0) = 0
+    // -1.lowBoundary(0) = -2
+    const truncated = value >= 0 ? Math.floor(value) : Math.ceil(value);
+    return truncated - 1;
+  }
+  
+  // Calculate the factor for the given precision
+  const factor = Math.pow(10, precision);
+  const stepSize = Math.pow(10, -precision);
+  const halfStep = stepSize / 2;
+  
+  // Check if the original value is an integer
+  const isInteger = Math.floor(value) === value;
+  
+  // For integers with decimal precision, the boundary is 0.5 less than the value
+  if (isInteger && precision > 0) {
+    return value - 0.5;
+  }
+  
+  // Truncate the value to the specified precision using floor (always toward negative infinity)
+  const truncated = Math.floor(value * factor) / factor;
+  
+  // The low boundary is the truncated value minus half a step
+  return truncated - halfStep;
+}
+
+/**
+ * Get the high boundary of a decimal value at the specified precision
+ * 
+ * Returns the greatest possible value of the input to the specified precision.
+ * For the given precision, returns the ceiling value plus half the step size.
+ * 
+ * @param value The decimal value
+ * @param precision The number of decimal places (optional, defaults to input precision + 1)
+ * @returns The high boundary value, or null if precision is invalid
+ */
+export function getDecimalHighBoundary(value: number, precision?: number): number | null {
+  // Default precision is the input's precision (for decimals) or 1 (for integers)
+  if (precision === undefined) {
+    const str = value.toString();
+    const decimalIndex = str.indexOf('.');
+    const inputPrecision = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+    // For integers, default to precision 1; for decimals, use their precision
+    precision = inputPrecision === 0 ? 1 : Math.min(inputPrecision, MAX_DECIMAL_PRECISION);
+  }
+  
+  // Invalid precision returns null (empty in FHIRPath)
+  if (precision < 0 || precision > MAX_DECIMAL_PRECISION) {
+    return null;
+  }
+  
+  // For precision 0 (integer precision)
+  if (precision === 0) {
+    // For integers at precision 0, return ceiling + 1 for positive, floor - 1 for negative
+    // 1.highBoundary(0) = 2
+    // -1.highBoundary(0) = -2
+    const ceiling = value >= 0 ? Math.ceil(value) : Math.floor(value);
+    return ceiling + 1;
+  }
+  
+  // Calculate the factor for the given precision
+  const factor = Math.pow(10, precision);
+  const stepSize = Math.pow(10, -precision);
+  const halfStep = stepSize / 2;
+  
+  // Check if the original value is an integer
+  const isInteger = Math.floor(value) === value;
+  
+  // For integers with decimal precision, the boundary is 0.5 more than the value
+  if (isInteger && precision > 0) {
+    return value + 0.5;
+  }
+  
+  // Ceiling the value to the specified precision (always toward positive infinity)
+  const ceiling = Math.ceil(value * factor) / factor;
+  
+  // The high boundary is the ceiling value plus half a step
+  return ceiling + halfStep;
+}
+
+/**
+ * Format a decimal value to a specific number of decimal places
+ * Ensures trailing zeros are preserved in the output string
+ */
+export function formatDecimalWithPrecision(value: number, precision: number): string {
+  // Handle special case for precision 0
+  if (precision === 0) {
+    return String(Math.round(value));
+  }
+  
+  // Use toFixed to ensure the right number of decimal places
+  return value.toFixed(precision);
+}

package/src/operations/defineVariable-function.ts

@@ -1,20 +1,39 @@
-import type { FunctionDefinition, LiteralNode } from '../types';
+import type { FunctionDefinition, LiteralNode, AnalysisContext, InternalAnalysisResult } 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';
+import { DiagnosticSeverity } from '../types';
+import { toDiagnostic } from '../errors';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length < 1) {
     throw Errors.invalidOperation('defineVariable requires at least 1 argument');
   }
 
-  const nameNode = args[0] as LiteralNode;
-  if (nameNode.valueType !== 'string') {
-    throw Errors.invalidOperation('Variable name must be a string');
+  let varName: string;
+  
+  // Check if first argument is a literal
+  const nameArg = args[0];
+  if (nameArg && nameArg.type === 'Literal' && (nameArg as LiteralNode).valueType === 'string') {
+    // Fast path: literal string
+    varName = (nameArg as LiteralNode).value as string;
+  } else {
+    // Slow path: evaluate expression to get name
+    const nameResult = await evaluator(nameArg!, input, context);
+    if (nameResult.value.length === 0) {
+      throw Errors.invalidOperation('Variable name expression evaluated to empty');
+    }
+    const firstValue = nameResult.value[0];
+    if (!firstValue) {
+      throw Errors.invalidOperation('Variable name expression evaluated to empty');
+    }
+    const nameValue = unbox(firstValue);
+    if (typeof nameValue !== 'string') {
+      throw Errors.invalidOperation('Variable name must evaluate to a string');
+    }
+    varName = nameValue;
   }
-
-  const varName = nameNode.value as string;
   
   let value: any[];
   
@@ -23,29 +42,30 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
     value = input;
   } else {
     // Two arguments: defineVariable(name, value) - evaluate value expression
-    const tempContext = RuntimeContextManager.setVariable(context, '$this', input);
+    // $this should be set to the input collection (unboxed to avoid double-boxing)
+    const unboxedInput = input.map(v => unbox(v));
+    const tempContext = RuntimeContextManager.setVariable(context, '$this', unboxedInput, true);
     const valueExpr = args[1];
     if (!valueExpr) {
       throw Errors.invalidOperation('defineVariable requires a value expression');
     }
+    
     const valueResult = await evaluator(valueExpr, input, tempContext);
     value = valueResult.value;
   }
 
   // Set the variable using RuntimeContextManager (handles prefixes and checks)
+  // This will throw an error if the variable is already defined (per spec)
   const newContext = RuntimeContextManager.setVariable(context, varName, value);
-  
-  // If newContext is same as context, variable already existed - return empty
-  if (newContext === context) {
-    return { value: [], context };
-  }
 
+  
   // Pass through input unchanged
   return { value: input, context: newContext };
 };
 
 export const defineVariableFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'defineVariable',
+  doesNotPropagateEmpty: true,  // defineVariable should always execute to set the variable
   category: ['context'],
   description: 'Defines a variable in the evaluation context',
   examples: [
@@ -58,9 +78,102 @@ export const defineVariableFunction: FunctionDefinition & { evaluate: FunctionEv
     input: { type: 'Any', singleton: false },
     parameters: [
       { name: 'name', type: { type: 'String', singleton: true } },
-      { name: 'value', type: { type: 'Any', singleton: false }, optional: true },
+      { name: 'value', type: { type: 'Any', singleton: false }, optional: true, expression: true },
     ],
     result: { type: 'Any', singleton: false },
   }],
-  evaluate
-};
+  evaluate,
+  async inferResultType(analyzer, node, inputType) {
+    // defineVariable returns its input type unchanged
+    return inputType || { type: 'Any', singleton: false };
+  },
+  /**
+   * Analysis-time behavior for defineVariable.
+   * Adds the variable to the context for downstream expressions.
+   */
+  async analyze(context: AnalysisContext, args): Promise<InternalAnalysisResult> {
+    const diagnostics: any[] = [];
+    
+    // Validate we have at least one argument
+    if (args.length < 1) {
+      return { 
+        type: context.inputType, 
+        diagnostics: [{
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+          message: 'defineVariable requires at least 1 argument',
+          severity: DiagnosticSeverity.Error
+        }]
+      };
+    }
+    
+    // First argument: variable name (can be literal or expression)
+    const nameNode = args[0];
+    let varName: string | undefined;
+    let isDynamic = false;
+    
+    if (nameNode && nameNode.type === 'Literal' && (nameNode as LiteralNode).valueType === 'string') {
+      // Static variable name - full analysis
+      varName = (nameNode as LiteralNode).value as string;
+      
+      // Check if variable already exists
+      if (context.userVariables.has(varName)) {
+        // Flag as warning in analysis; runtime enforces error with proper code (FP6009)
+        diagnostics.push({
+          range: nameNode.range,
+          message: `Variable '${varName}' is already defined`,
+          severity: DiagnosticSeverity.Warning
+        });
+        return { type: context.inputType, diagnostics, context };
+      }
+    } else {
+      // Dynamic variable name - limited analysis
+      isDynamic = true;
+      diagnostics.push({
+        range: nameNode?.range || { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+        message: 'Dynamic variable name: cannot validate variable references at compile time',
+        severity: DiagnosticSeverity.Warning
+      });
+      
+      // Still analyze the expression for other errors
+      if (nameNode) {
+        const nameResult = await context.analyzeNode(nameNode);
+        diagnostics.push(...nameResult.diagnostics);
+        
+        // Check if it evaluates to string type
+        if (nameResult.type.type !== 'String') {
+          diagnostics.push({
+            range: nameNode.range,
+            message: 'Variable name expression must evaluate to String type',
+            severity: DiagnosticSeverity.Error
+          });
+        }
+      }
+    }
+    
+    // Determine the type of the variable
+    let varType = context.inputType;
+    
+    if (args.length >= 2 && args[1]) {
+      // If value expression provided, analyze it to get its type
+      const valueResult = await context.analyzeNode(args[1]);
+      diagnostics.push(...valueResult.diagnostics);
+      varType = valueResult.type;
+    }
+    
+    // Return with modified context
+    // For static names, add the variable to context
+    // For dynamic names, mark that dynamic variables exist
+    let resultContext = context;
+    if (varName) {
+      resultContext = context.withUserVariable(varName, varType);
+    } else if (isDynamic) {
+      resultContext = context.withDynamicVariables();
+    }
+    
+    return {
+      type: context.inputType, // defineVariable returns input unchanged
+      diagnostics,
+      context: resultContext
+    };
+  }
+};

package/src/operations/distinct-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) => {
   // Use Set to track unique values based on unboxed values

package/src/operations/div-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) => {
   if (left.length === 0 || right.length === 0) {

package/src/operations/divide-operator.ts

@@ -1,9 +1,10 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { divideQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { divideQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
+import { Errors } from '../errors';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -20,14 +21,18 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   // Check if both are quantities
   if (l && typeof l === 'object' && 'unit' in l && 
       r && typeof r === 'object' && 'unit' in r) {
-    const result = divideQuantities(l as QuantityValue, r as QuantityValue);
+    const rightQuantity = r as QuantityValue;
+    if (rightQuantity.value === 0) {
+      throw Errors.divisionByZero();
+    }
+    const result = divideQuantities(l as QuantityValue, rightQuantity);
     return { value: result ? [box(result, { type: 'Quantity', singleton: true })] : [], context };
   }
   
   // Handle quantity / number
   if (l && typeof l === 'object' && 'unit' in l && typeof r === 'number') {
     if (r === 0) {
-      return { value: [], context };
+      throw Errors.divisionByZero();
     }
     const q = l as QuantityValue;
     return { value: [box({ value: q.value / r, unit: q.unit }, { type: 'Quantity', singleton: true })], context };
@@ -36,7 +41,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   // Handle numeric division
   if (typeof l === 'number' && typeof r === 'number') {
     if (r === 0) {
-      return { value: [], context };
+      throw Errors.divisionByZero();
     }
     return { value: [box(l / r, { type: 'Any', singleton: true })], context };
   }
@@ -51,7 +56,7 @@ export const divideOperator: OperatorDefinition & { evaluate: OperationEvaluator
   category: ['arithmetic'],
   precedence: PRECEDENCE.MULTIPLICATIVE,
   associativity: 'left',
-  description: 'Divides the left operand by the right operand (supported for Integer, Decimal, and Quantity). The result is always Decimal, even if inputs are both Integer. Division by zero returns empty.',
+  description: 'Divides the left operand by the right operand (supported for Integer, Decimal, and Quantity). The result is always Decimal, even if inputs are both Integer. Division by zero throws an error.',
   examples: ['10 / 2', '7.5 / 1.5', '12 \'cm2\' / 3 \'cm\'', '12 / 0'],
   signatures: [
     {

package/src/operations/dot-operator.ts

@@ -2,7 +2,7 @@ import type { OperatorDefinition } from '../types';
 import { Errors } from '../errors';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 // Note: The dot operator is special and is typically handled directly in the interpreter
 // because it needs to evaluate its operands in sequence, not in parallel

package/src/operations/empty-function.ts

@@ -1,25 +1,34 @@
-import type { FunctionDefinition } from '../types';
-import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import type { FunctionDefinition } from "../types";
+import type { FunctionEvaluator } from "../types";
+import { box, unbox } from "../interpreter/boxing";
 
-export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
-  return { 
-    value: [box(input.length === 0, { type: 'Boolean', singleton: true })], 
-    context 
+export const evaluate: FunctionEvaluator = async (
+  input,
+  context,
+  args,
+  evaluator,
+) => {
+  return {
+    value: [box(input.length === 0, { type: "Boolean", singleton: true })],
+    context,
   };
 };
 
-export const emptyFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
-  name: 'empty',
-  category: ['collection', 'logical'],
-  description: 'Returns true if the collection is empty',
-  examples: ['Patient.name.empty()'],
-  signatures: [{
-
-    name: 'empty',
-    input: { type: 'Any', singleton: false },
-    parameters: [],
-    result: { type: 'Boolean', singleton: true },
-  }],
-  evaluate
-};
+export const emptyFunction: FunctionDefinition & {
+  evaluate: FunctionEvaluator;
+} = {
+  name: "empty",
+  doesNotPropagateEmpty: true,
+  category: ["collection", "logical"],
+  description: "Returns true if the collection is empty",
+  examples: ["Patient.name.empty()"],
+  signatures: [
+    {
+      name: "empty",
+      input: { type: "Any", singleton: false },
+      parameters: [],
+      result: { type: "Boolean", singleton: true },
+    },
+  ],
+  evaluate,
+};

package/src/operations/endsWith-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) => {
   // Validate arguments
@@ -36,6 +36,11 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   }
   const suffixResult = await evaluator(args[0], input, context);
   
+  // If suffix is empty, propagate empty
+  if (suffixResult.value.length === 0) {
+    return { value: [], context };
+  }
+  
   // Validate that suffix is a singleton string
   if (suffixResult.value.length !== 1) {
     throw Errors.invalidOperation('endsWith suffix argument must be a single value');

package/src/operations/equal-operator.ts

@@ -1,36 +1,19 @@
-import type { OperatorDefinition } from '../types';
+import type { OperatorDefinition, OperationEvaluator } from '../types';
 import { PRECEDENCE } from '../types';
-import type { OperationEvaluator } from '../types';
-import { equalQuantities, compareQuantities, type QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { box } from '../interpreter/boxing';
+import { collectionsEqual } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  if (left.length === 0 || right.length === 0) {
-    return { value: [], context };
-  }
+  // Use the unified comparison system
+  const result = collectionsEqual(left, right);
   
-  const boxedL = left[0];
-  const boxedR = right[0];
-  
-  if (!boxedL || !boxedR) {
+  // null means incomparable (returns empty)
+  if (result === null) {
     return { value: [], context };
   }
   
-  const l = unbox(boxedL);
-  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 comparison = compareQuantities(l as QuantityValue, r as QuantityValue);
-    // If quantities are incomparable (different dimensions), return empty
-    if (comparison === null) {
-      return { value: [], context };
-    }
-    return { value: [box(comparison === 0, { type: 'Boolean', singleton: true })], context };
-  }
-  
-  return { value: [box(l === r, { type: 'Boolean', singleton: true })], context };
+  // Return the boolean result
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const equalOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -41,11 +24,19 @@ export const equalOperator: OperatorDefinition & { evaluate: OperationEvaluator
   associativity: 'left',
   description: 'Returns true if the left collection is equal to the right collection. For single items, comparison is type-specific. For collections, comparison is order-dependent.',
   examples: ['name = "John"', 'Patient.name.given = "John"', '5 = 5', '@2018-03-01 = @2018-03-01'],
-  signatures: [{
-    name: 'equal',
-    left: { type: 'Any', singleton: true },
-    right: { type: 'Any', singleton: true },
-    result: { type: 'Boolean', singleton: true },
-  }],
+  signatures: [
+    {
+      name: 'equal',
+      left: { type: 'Any', singleton: true },
+      right: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true },
+    },
+    {
+      name: 'equal',
+      left: { type: 'Any', singleton: false },
+      right: { type: 'Any', singleton: false },
+      result: { type: 'Boolean', singleton: true },
+    }
+  ],
   evaluate
 };