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

package/src/operations/temporal-functions.ts

@@ -0,0 +1,555 @@
+// Built-in temporal functions for FHIRPath
+import type { FunctionDefinition } from '../types';
+import type { FunctionEvaluator } from '../types';
+import { box } from '../interpreter/boxing';
+import { createDate, createDateTime, createTime, isFHIRDate, isFHIRDateTime, isFHIRTime } from '../complex-types/temporal';
+
+// ============================================================================
+// now() function - Returns current DateTime
+// ============================================================================
+
+export const nowEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_now_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const now = new Date();
+  const dateTime = createDateTime(
+    now.getFullYear(),
+    now.getMonth() + 1,
+    now.getDate(),
+    now.getHours(),
+    now.getMinutes(),
+    now.getSeconds(),
+    now.getMilliseconds(),
+    -now.getTimezoneOffset() // Convert to minutes from UTC (JS gives minutes to subtract from UTC)
+  );
+  
+  return {
+    value: [box(dateTime, { type: 'DateTime', singleton: true })],
+    context
+  };
+};
+
+export const nowFunction: FunctionDefinition & { evaluate: typeof nowEvaluator } = {
+  name: 'now',
+  category: ['temporal'],
+  description: 'Returns the current date and time as a DateTime value',
+  examples: ['now()', 'Patient.birthDate < now()'],
+  signatures: [
+    {
+      name: 'now',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'DateTime', singleton: true }
+    }
+  ],
+  evaluate: nowEvaluator
+};
+
+// ============================================================================
+// today() function - Returns current Date
+// ============================================================================
+
+export const todayEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_today_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const today = new Date();
+  const date = createDate(
+    today.getFullYear(),
+    today.getMonth() + 1,
+    today.getDate()
+  );
+  
+  return {
+    value: [box(date, { type: 'Date', singleton: true })],
+    context
+  };
+};
+
+export const todayFunction: FunctionDefinition & { evaluate: typeof todayEvaluator } = {
+  name: 'today',
+  category: ['temporal'],
+  description: 'Returns the current date (no time component)',
+  examples: ['today()', 'Patient.birthDate < today()'],
+  signatures: [
+    {
+      name: 'today',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'Date', singleton: true }
+    }
+  ],
+  evaluate: todayEvaluator
+};
+
+// ============================================================================
+// timeOfDay() function - Returns current Time
+// ============================================================================
+
+export const timeOfDayEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_timeOfDay_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const now = new Date();
+  const time = createTime(
+    now.getHours(),
+    now.getMinutes(),
+    now.getSeconds(),
+    now.getMilliseconds()
+  );
+  
+  return {
+    value: [box(time, { type: 'Time', singleton: true })],
+    context
+  };
+};
+
+export const timeOfDayFunction: FunctionDefinition & { evaluate: typeof timeOfDayEvaluator } = {
+  name: 'timeOfDay',
+  category: ['temporal'],
+  description: 'Returns the current time of day',
+  examples: ['timeOfDay()', '@T09:00 < timeOfDay()'],
+  signatures: [
+    {
+      name: 'timeOfDay',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: timeOfDayEvaluator
+};
+
+// ============================================================================
+// toDate() function - Convert to Date
+// ============================================================================
+
+export const toDateEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a Date, return as is
+  if (typeInfo?.type === 'Date') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a DateTime, extract the date portion
+  if (typeInfo?.type === 'DateTime' && item && typeof item === 'object') {
+    const dateTime = item as any;
+    const date = createDate(dateTime.year, dateTime.month, dateTime.day);
+    return {
+      value: [box(date, { type: 'Date', singleton: true })],
+      context
+    };
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      if (isFHIRDate(temporal)) {
+        return {
+          value: [box(temporal, { type: 'Date', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toDate() to return []
+  return { value: [], context };
+};
+
+export const toDateFunction: FunctionDefinition & { evaluate: typeof toDateEvaluator } = {
+  name: 'toDate',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a Date value',
+  examples: ["'2020-01-15'.toDate()", '@2020-01-15T10:30:00.toDate()'],
+  signatures: [
+    {
+      name: 'any-toDate',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Date', singleton: true }
+    }
+  ],
+  evaluate: toDateEvaluator
+};
+
+// ============================================================================
+// toDateTime() function - Convert to DateTime
+// ============================================================================
+
+export const toDateTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a DateTime, return as is
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a Date, convert to DateTime with time as 00:00:00
+  if (typeInfo?.type === 'Date' && item && typeof item === 'object') {
+    const date = item as any;
+    const dateTime = createDateTime(
+      date.year,
+      date.month,
+      date.day,
+      0, 0, 0, 0
+    );
+    return {
+      value: [box(dateTime, { type: 'DateTime', singleton: true })],
+      context
+    };
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate, isFHIRDateTime } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      if (isFHIRDateTime(temporal)) {
+        return {
+          value: [box(temporal, { type: 'DateTime', singleton: true })],
+          context
+        };
+      } else if (isFHIRDate(temporal)) {
+        // Convert Date to DateTime (with time as 00:00:00)
+        const dateTime = createDateTime(
+          temporal.year,
+          temporal.month,
+          temporal.day,
+          0, 0, 0, 0
+        );
+        return {
+          value: [box(dateTime, { type: 'DateTime', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toDateTime() to return []
+  return { value: [], context };
+};
+
+export const toDateTimeFunction: FunctionDefinition & { evaluate: typeof toDateTimeEvaluator } = {
+  name: 'toDateTime',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a DateTime value',
+  examples: ["'2020-01-15T10:30:00Z'.toDateTime()", '@2020-01-15.toDateTime()'],
+  signatures: [
+    {
+      name: 'any-toDateTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'DateTime', singleton: true }
+    }
+  ],
+  evaluate: toDateTimeEvaluator
+};
+
+// ============================================================================
+// toTime() function - Convert to Time
+// ============================================================================
+
+export const toTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a Time, return as is
+  if (typeInfo?.type === 'Time') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a DateTime, extract the time portion
+  if (typeInfo?.type === 'DateTime' && item && typeof item === 'object') {
+    const dateTime = item as any;
+    if (dateTime.hour !== undefined) {
+      const time = createTime(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+      return {
+        value: [box(time, { type: 'Time', singleton: true })],
+        context
+      };
+    }
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRTime } = await import('../complex-types/temporal');
+      // For time strings, prepend T if not present
+      const timeString = item.startsWith('T') ? '@' + item : '@T' + item;
+      const temporal = parseTemporalLiteral(timeString);
+      if (isFHIRTime(temporal)) {
+        return {
+          value: [box(temporal, { type: 'Time', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toTime() to return []
+  return { value: [], context };
+};
+
+export const toTimeFunction: FunctionDefinition & { evaluate: typeof toTimeEvaluator } = {
+  name: 'toTime',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a Time value',
+  examples: ["'14:30:00'.toTime()", '@2020-01-15T10:30:00.toTime()'],
+  signatures: [
+    {
+      name: 'any-toTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: toTimeEvaluator
+};
+
+// ============================================================================
+// convertsToDate() function - Check if convertible to Date
+// ============================================================================
+
+export const convertsToDateEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a Date
+  if (typeInfo?.type === 'Date') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // DateTime can be converted
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      return {
+        value: [box(isFHIRDate(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToDateFunction: FunctionDefinition & { evaluate: typeof convertsToDateEvaluator } = {
+  name: 'convertsToDate',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a Date',
+  examples: ["'2020-01-15'.convertsToDate()", "'invalid'.convertsToDate()"],
+  signatures: [
+    {
+      name: 'convertsToDate',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToDateEvaluator
+};
+
+// ============================================================================
+// convertsToDateTime() function - Check if convertible to DateTime
+// ============================================================================
+
+export const convertsToDateTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a DateTime
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Date can be converted
+  if (typeInfo?.type === 'Date') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate, isFHIRDateTime } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      return {
+        value: [box(isFHIRDateTime(temporal) || isFHIRDate(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToDateTimeFunction: FunctionDefinition & { evaluate: typeof convertsToDateTimeEvaluator } = {
+  name: 'convertsToDateTime',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a DateTime',
+  examples: ["'2020-01-15T10:30:00'.convertsToDateTime()", "'invalid'.convertsToDateTime()"],
+  signatures: [
+    {
+      name: 'convertsToDateTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToDateTimeEvaluator
+};
+
+// ============================================================================
+// convertsToTime() function - Check if convertible to Time
+// ============================================================================
+
+export const convertsToTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a Time
+  if (typeInfo?.type === 'Time') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // DateTime can be converted if it has time components
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRTime } = await import('../complex-types/temporal');
+      const timeString = item.startsWith('T') ? '@' + item : '@T' + item;
+      const temporal = parseTemporalLiteral(timeString);
+      return {
+        value: [box(isFHIRTime(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToTimeFunction: FunctionDefinition & { evaluate: typeof convertsToTimeEvaluator } = {
+  name: 'convertsToTime',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a Time',
+  examples: ["'14:30:00'.convertsToTime()", "'invalid'.convertsToTime()"],
+  signatures: [
+    {
+      name: 'convertsToTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToTimeEvaluator
+};

package/src/operations/timeOf-function.ts

@@ -0,0 +1,67 @@
+// timeOf() function - Extracts time component from DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { createTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const timeOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // timeOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('timeOf', 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('timeOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a DateTime
+  if (isFHIRDateTime(value)) {
+    // Check if time component is present
+    if (value.hour === undefined) {
+      // No time component present
+      return { value: [], context };
+    }
+    
+    // Extract time component (preserve precision)
+    const time = createTime(value.hour, value.minute, value.second, value.millisecond);
+    return {
+      value: [box(time, { type: 'Time', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a DateTime, return empty
+  return { value: [], context };
+};
+
+export const timeOfFunction: FunctionDefinition & { evaluate: typeof timeOfEvaluator } = {
+  name: 'timeOf',
+  category: ['temporal'],
+  description: 'Returns the time component of a DateTime value',
+  examples: [
+    '@2012-01-01T12:30:00.timeOf()',
+    'Observation.effectiveDateTime.timeOf()'
+  ],
+  signatures: [
+    {
+      name: 'timeOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: timeOfEvaluator
+};

package/src/operations/timezoneOffsetOf-function.ts

@@ -0,0 +1,69 @@
+// timezoneOffsetOf() function - Extracts timezone offset component from DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const timezoneOffsetOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // timezoneOffsetOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('timezoneOffsetOf', 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('timezoneOffsetOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a DateTime with timezone
+  if (isFHIRDateTime(value)) {
+    // Check if timezone offset is present
+    if (value.timezoneOffset === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the timezone offset as a Decimal (hours)
+    // The timezoneOffset is stored in minutes, convert to decimal hours
+    const offsetInHours = value.timezoneOffset / 60;
+    
+    return {
+      value: [box(offsetInHours, { type: 'Decimal', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a DateTime, return empty
+  return { value: [], context };
+};
+
+export const timezoneOffsetOfFunction: FunctionDefinition & { evaluate: typeof timezoneOffsetOfEvaluator } = {
+  name: 'timezoneOffsetOf',
+  category: ['temporal'],
+  description: 'Returns the timezone offset component of a DateTime value as decimal hours',
+  examples: [
+    '@2012-01-01T12:30:00.000-07:00.timezoneOffsetOf()',
+    '@2012-01-01T12:30:00.000+05:30.timezoneOffsetOf()',
+    'Patient.lastUpdated.timezoneOffsetOf()'
+  ],
+  signatures: [
+    {
+      name: 'timezoneOffsetOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
+  evaluate: timezoneOffsetOfEvaluator
+};