@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/contains-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';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // If right is empty, result is empty
@@ -40,6 +40,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
 export const containsOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
   symbol: 'contains',
   name: 'contains',
+  doesNotPropagateEmpty: true,  // Empty left operand returns false
   category: ['membership'],
   precedence: PRECEDENCE.IN_CONTAINS,
   associativity: 'left',

package/src/operations/convertsToBoolean-function.ts

@@ -0,0 +1,78 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToBoolean() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToBoolean', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToBoolean', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // Check if the value can be converted to Boolean
+  
+  // Boolean - always convertible
+  if (typeof inputValue === 'boolean') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Integer - 1 and 0 are convertible
+  if (typeof inputValue === 'number' && Number.isInteger(inputValue)) {
+    const canConvert = inputValue === 1 || inputValue === 0;
+    return { value: [box(canConvert, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Decimal - 1.0 and 0.0 are convertible
+  if (typeof inputValue === 'number' && !Number.isInteger(inputValue)) {
+    const canConvert = inputValue === 1.0 || inputValue === 0.0;
+    return { value: [box(canConvert, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // String - check if it's a valid boolean representation (case insensitive)
+  if (typeof inputValue === 'string') {
+    const lowerValue = inputValue.toLowerCase();
+    const validRepresentations = ['true', 't', 'yes', 'y', '1', '1.0', 'false', 'f', 'no', 'n', '0', '0.0'];
+    const canConvert = validRepresentations.includes(lowerValue);
+    return { value: [box(canConvert, { type: 'Boolean', singleton: true })], context };
+  }
+
+  // For all other types, return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToBooleanFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToBoolean',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to a Boolean. Returns true for: Boolean (any), Integer (1 or 0), Decimal (1.0 or 0.0), String (\'true\'/\'t\'/\'yes\'/\'y\'/\'1\'/\'1.0\'/\'false\'/\'f\'/\'no\'/\'n\'/\'0\'/\'0.0\', case insensitive). Returns false for all other values.',
+  examples: [
+    "'true'.convertsToBoolean()",
+    "'invalid'.convertsToBoolean()",
+    "1.convertsToBoolean()",
+    "2.convertsToBoolean()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToBoolean',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/convertsToDecimal-function.ts

@@ -0,0 +1,82 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToDecimal() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToDecimal', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToDecimal', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // Check if the value can be converted to Decimal
+  
+  // Integer or Decimal - always convertible
+  if (typeof inputValue === 'number') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Boolean - always convertible (true -> 1.0, false -> 0.0)
+  if (typeof inputValue === 'boolean') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // String - check if valid decimal format
+  if (typeof inputValue === 'string') {
+    // Use the regex from the spec: (\+|-)?\d+(\.\d+)?
+    const decimalRegex = /^(\+|-)?\d+(\.\d+)?$/;
+    
+    if (!decimalRegex.test(inputValue)) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    const parsedValue = parseFloat(inputValue);
+    
+    // Check for valid number
+    if (isNaN(parsedValue)) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+
+  // For all other types, return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToDecimalFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToDecimal',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to a Decimal. Returns true for: Integer (any), Decimal (any), Boolean (any), String matching regex (\\+|-)?\\d+(\\.\\d+)?. Returns false for all other types.',
+  examples: [
+    "'42'.convertsToDecimal()",
+    "'3.14'.convertsToDecimal()",
+    "true.convertsToDecimal()",
+    "'invalid'.convertsToDecimal()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToDecimal',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/convertsToInteger-function.ts

@@ -0,0 +1,71 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToInteger() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToInteger', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToInteger', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // Check if the value can be converted to Integer
+  
+  // Integer - always convertible
+  if (typeof inputValue === 'number' && Number.isInteger(inputValue)) {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // String - check if valid integer format
+  if (typeof inputValue === 'string') {
+    // Regex from spec: (\+|-)?\d+
+    const integerRegex = /^(\+|-)?\d+$/;
+    const canConvert = integerRegex.test(inputValue);
+    return { value: [box(canConvert, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Boolean - always convertible (true -> 1, false -> 0)
+  if (typeof inputValue === 'boolean') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+
+  // For all other types (including decimals), return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToIntegerFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToInteger',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to an Integer. Returns true for: Integer (any), String matching regex (\\+|-)?\\d+, Boolean (any). Returns false for all other types including decimals.',
+  examples: [
+    "'42'.convertsToInteger()",
+    "'3.14'.convertsToInteger()",
+    "true.convertsToInteger()",
+    "3.14.convertsToInteger()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToInteger',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/convertsToLong-function.ts

@@ -0,0 +1,89 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToLong() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToLong', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToLong', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // Check if the value can be converted to Long
+  // Note: In JavaScript, we don't have a separate Long type, but we can check
+  // if the value would be a valid long (integer within safe bounds)
+  
+  // Integer - always convertible to Long
+  if (typeof inputValue === 'number' && Number.isInteger(inputValue)) {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // String - check if valid integer format (same as convertsToInteger)
+  if (typeof inputValue === 'string') {
+    // Regex from spec: (\+|-)?\d+
+    const integerRegex = /^(\+|-)?\d+$/;
+    if (!integerRegex.test(inputValue)) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    // For Long, we should check if the value is within valid bounds
+    // In JavaScript, we can safely represent integers up to Number.MAX_SAFE_INTEGER
+    try {
+      const longValue = BigInt(inputValue);
+      // Check if it can be safely represented
+      // For FHIRPath, Long is typically 64-bit integer
+      const MAX_LONG = BigInt('9223372036854775807');
+      const MIN_LONG = BigInt('-9223372036854775808');
+      
+      const canConvert = longValue >= MIN_LONG && longValue <= MAX_LONG;
+      return { value: [box(canConvert, { type: 'Boolean', singleton: true })], context };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  // Boolean - always convertible (true -> 1, false -> 0)
+  if (typeof inputValue === 'boolean') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+
+  // For all other types (including decimals), return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToLongFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToLong',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to a Long (64-bit integer). Returns true for: Integer (any), String matching regex (\\+|-)?\\d+ within 64-bit bounds, Boolean (any). Returns false for all other types including decimals.',
+  examples: [
+    "'42'.convertsToLong()",
+    "'9223372036854775807'.convertsToLong()",
+    "'9223372036854775808'.convertsToLong()",
+    "true.convertsToLong()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToLong',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/convertsToQuantity-function.ts

@@ -0,0 +1,116 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+import { createQuantity, isValidQuantity } from '../complex-types/quantity-value';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToQuantity() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToQuantity', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToQuantity', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  const typeInfo = boxedInputValue.typeInfo;
+
+  // Check if the value can be converted to Quantity
+  
+  // Already a Quantity
+  if (typeInfo?.type === 'Quantity') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Check for Quantity object structure
+  if (inputValue && typeof inputValue === 'object') {
+    const obj = inputValue as any;
+    // Check if it looks like a Quantity (has value and unit properties)
+    if (typeof obj.value === 'number' && typeof obj.unit === 'string') {
+      // Validate that the unit is valid (either UCUM or calendar duration)
+      try {
+        const quantity = createQuantity(obj.value, obj.unit);
+        const isValid = isValidQuantity(quantity);
+        return { value: [box(isValid, { type: 'Boolean', singleton: true })], context };
+      } catch {
+        return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+      }
+    }
+  }
+  
+  // String - check if it can be parsed as a quantity (e.g., "10 mg", "5.5 km")
+  if (typeof inputValue === 'string') {
+    // Try to parse as quantity: number followed by space(s) and unit
+    // This matches the pattern: <number> <unit>
+    const quantityRegex = /^(\+|-)?\d+(\.\d+)?\s+.+$/;
+    
+    if (!quantityRegex.test(inputValue.trim())) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    // Split into value and unit parts
+    const parts = inputValue.trim().split(/\s+/);
+    if (parts.length < 2) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    const valueStr = parts[0];
+    const unit = parts.slice(1).join(' ');
+    
+    const value = parseFloat(valueStr!);
+    if (isNaN(value)) {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    // Check if the unit is valid
+    try {
+      const quantity = createQuantity(value, unit);
+      const isValid = isValidQuantity(quantity);
+      return { value: [box(isValid, { type: 'Boolean', singleton: true })], context };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  // Integer or Decimal with no unit - not a valid quantity
+  // (quantities must have units)
+  if (typeof inputValue === 'number') {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+
+  // For all other types, return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToQuantityFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToQuantity',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to a Quantity. Returns true for: Quantity (any), String in format "number unit" with valid UCUM or calendar duration unit. Returns false for numbers without units and all other types.',
+  examples: [
+    "'10 mg'.convertsToQuantity()",
+    "'5.5 km'.convertsToQuantity()",
+    "10.convertsToQuantity()",
+    "'invalid'.convertsToQuantity()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToQuantity',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/convertsToString-function.ts

@@ -0,0 +1,88 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // convertsToString() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('convertsToString', 0, args.length);
+  }
+
+  // If input collection is empty, result is empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input collection contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('convertsToString', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+
+  // Check if the value can be converted to String
+  
+  // String - always convertible
+  if (typeof inputValue === 'string') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Integer or Decimal - always convertible
+  if (typeof inputValue === 'number') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Boolean - always convertible
+  if (typeof inputValue === 'boolean') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Check for temporal types (Date, Time, DateTime) - these are convertible
+  if (inputValue && typeof inputValue === 'object') {
+    // Check if it has type property indicating temporal type
+    const objWithType = inputValue as any;
+    if (objWithType.type === 'Date' || objWithType.type === 'DateTime' || objWithType.type === 'Time') {
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    // Check boxed type info
+    const typeInfo = boxedInputValue.typeInfo;
+    if (typeInfo?.type === 'Date' || typeInfo?.type === 'DateTime' || typeInfo?.type === 'Time') {
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+    }
+    
+    // Check for Quantity type
+    if (objWithType.type === 'Quantity' || typeInfo?.type === 'Quantity') {
+      return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+
+  // For complex objects and other types, return false
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToStringFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'convertsToString',
+  category: ['type-conversion'],
+  description: 'Returns true if the input can be converted to a String. Returns true for: String (any), Integer (any), Decimal (any), Boolean (any), Date, DateTime, Time, Quantity. Returns false for complex objects and resources.',
+  examples: [
+    "'test'.convertsToString()",
+    "42.convertsToString()",
+    "true.convertsToString()",
+    "Patient.convertsToString()"
+  ],
+  signatures: [
+    {
+      name: 'convertsToString',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/count-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) => {
   return { 
@@ -11,6 +11,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const countFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'count',
+  doesNotPropagateEmpty: true,
   category: ['collection'],
   description: 'Returns the number of items in the collection',
   examples: ['Patient.name.count()'],

package/src/operations/dateOf-function.ts

@@ -0,0 +1,69 @@
+// dateOf() function - Extracts date component from Date or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { createDate, isFHIRDate, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const dateOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // dateOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('dateOf', 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('dateOf', 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)) {
+    // Already a Date, return as-is
+    return {
+      value: [box(value, { type: 'Date', singleton: true })],
+      context
+    };
+  }
+  
+  if (isFHIRDateTime(value)) {
+    // Extract date component (preserve precision)
+    const date = createDate(value.year, value.month, value.day);
+    return {
+      value: [box(date, { type: 'Date', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Date or DateTime, return empty
+  return { value: [], context };
+};
+
+export const dateOfFunction: FunctionDefinition & { evaluate: typeof dateOfEvaluator } = {
+  name: 'dateOf',
+  category: ['temporal'],
+  description: 'Returns the date component of a Date or DateTime value',
+  examples: [
+    '@2012-01-01T12:30:00.dateOf()',
+    'Patient.birthDate.dateOf()'
+  ],
+  signatures: [
+    {
+      name: 'dateOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Date', singleton: true }
+    }
+  ],
+  evaluate: dateOfEvaluator
+};