fhirpath-ts 0.0.0-bootstrap.0

package/src/functions/tree.ts

@@ -0,0 +1,112 @@
+import { pairEquals } from '../engine/operators/equality.ts'
+import { readModelProperty } from '../fhir/model-navigation.ts'
+import type { ModelProvider } from '../model/provider.ts'
+import { SYSTEM_BOOLEAN, SYSTEM_STRING, systemTypeOf, toTypedValue, type TypedValue } from '../values/typed-value.ts'
+import { registerFunction } from './registry.ts'
+
+/**
+ * All immediate child nodes of an item. `resourceType` is a JSON discriminator, not
+ * an element, and `_field` keys are primitive-extension metadata handled elsewhere.
+ */
+export function childrenOf(item: TypedValue, model?: ModelProvider): TypedValue[] {
+  const value = item.value
+  if (typeof value !== 'object' || value === null) {
+    // A primitive's children are its element id and extensions (FHIR spec).
+    return primitiveMetadataChildren(item)
+  }
+  // With a model, children keep their element types (so `code as Coding` works
+  // downstream) and elements present only through a _field sibling still appear.
+  if (model && item.type.startsWith(`${model.namespace}.`)) {
+    const elements = model.listElements?.(item.type)
+    if (elements !== undefined) {
+      const typed: TypedValue[] = []
+      for (const element of elements) {
+        typed.push(...(readModelProperty(model, item, element) ?? []))
+      }
+      return typed
+    }
+  }
+  const result: TypedValue[] = []
+  for (const [key, child] of Object.entries(value)) {
+    if (key === 'resourceType' || key.startsWith('_') || child === null || child === undefined) {
+      continue
+    }
+    if (Array.isArray(child)) {
+      for (const element of child) {
+        if (element !== null && element !== undefined) {
+          result.push(toTypedValue(element))
+        }
+      }
+    } else {
+      result.push(toTypedValue(child))
+    }
+  }
+  return result
+}
+
+function primitiveMetadataChildren(item: TypedValue): TypedValue[] {
+  const metadata = item.primitiveElement as { id?: unknown; extension?: unknown } | undefined
+  if (metadata === undefined || metadata === null) {
+    return []
+  }
+  const result: TypedValue[] = []
+  if (metadata.id !== undefined && metadata.id !== null) {
+    result.push({ type: 'System.String', value: metadata.id })
+  }
+  if (Array.isArray(metadata.extension)) {
+    result.push(...metadata.extension.map(extension => ({ type: 'FHIR.Extension', value: extension })))
+  }
+  return result
+}
+
+registerFunction('children', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (context, input) => input.flatMap(item => childrenOf(item, context.model)),
+})
+
+registerFunction('descendants', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (context, input) => {
+    // repeat(children()): collect transitively, excluding the input itself. The
+    // dedup granularity differs from repeat() on purpose and is pinned by the
+    // official suites: descendants() keeps `=`-equal siblings produced in the same
+    // round (a batch filter against prior rounds only), where repeat() collapses
+    // them (incremental within-round dedup). They cannot share one closure.
+    //
+    // Dedup is `existing.value === item.value || pairEquals(existing, item)` against
+    // prior rounds, indexed for O(1) on the common case: `seenValues` (a Set of raw
+    // values) resolves the `===` branch, and it also covers `pairEquals` for
+    // String/Boolean, whose equality *is* `===`. The remaining classes (numeric,
+    // temporal, quantity, complex) can be pairEquals-equal without being `===`-equal,
+    // so those fall back to a scan of same-class prior items. The index updates only
+    // between rounds, preserving the batch semantics.
+    const collected: TypedValue[] = []
+    const seenValues = new Set<unknown>()
+    const fallback: TypedValue[] = []
+    const needsFallback = (item: TypedValue): boolean => {
+      const type = systemTypeOf(item)
+      return type !== SYSTEM_STRING && type !== SYSTEM_BOOLEAN
+    }
+    const isDuplicate = (item: TypedValue): boolean => {
+      if (seenValues.has(item.value)) {
+        return true
+      }
+      return needsFallback(item) && fallback.some(existing => pairEquals(existing, item) === true)
+    }
+    let current = input.flatMap(item => childrenOf(item, context.model))
+    while (current.length > 0) {
+      const fresh = current.filter(item => !isDuplicate(item))
+      for (const item of fresh) {
+        seenValues.add(item.value)
+        if (needsFallback(item)) {
+          fallback.push(item)
+        }
+      }
+      collected.push(...fresh)
+      current = fresh.flatMap(item => childrenOf(item, context.model))
+    }
+    return collected
+  },
+})

package/src/functions/type-specifier.ts

@@ -0,0 +1,29 @@
+import { FhirPathTypeError } from '../errors.ts'
+import type { AstNode } from '../parser/ast.ts'
+
+/**
+ * `ofType(Quantity)`, `is(System.Boolean)`, and `as(FHIR.Patient)` receive their type
+ * as an expression that parsed as an identifier or dotted identifier chain; read it
+ * back as a qualified type name.
+ */
+export function typePartsFromArgument(functionName: string, node: AstNode): string[] {
+  const parts = collect(node)
+  if (!parts) {
+    throw new FhirPathTypeError(`Function '${functionName}' expects a type name argument`)
+  }
+  return parts
+}
+
+function collect(node: AstNode): string[] | undefined {
+  if (node.kind === 'identifier') {
+    return [node.name]
+  }
+  if (node.kind === 'dot') {
+    const left = collect(node.left)
+    const right = node.right.kind === 'identifier' ? node.right.name : undefined
+    if (left && right !== undefined) {
+      return [...left, right]
+    }
+  }
+  return undefined
+}

package/src/functions/utility.ts

@@ -0,0 +1,82 @@
+import { withFrame } from '../engine/context.ts'
+import { booleanSingleton, wrapBoolean } from '../values/collection.ts'
+import { Temporal } from '../values/datetime.ts'
+import { SYSTEM_DATE, SYSTEM_DATETIME, SYSTEM_TIME, type TypedValue } from '../values/typed-value.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+registerFunction('not', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const value = booleanSingleton(input)
+    return wrapBoolean(value === undefined ? undefined : !value)
+  },
+})
+
+registerFunction('trace', {
+  minArity: 1,
+  maxArity: 2,
+  evaluate: (context, input, args, evaluateNode) => {
+    const name = evaluateNode(argAt(args, 0), context, input)
+    const label = typeof name[0]?.value === 'string' ? (name[0].value as string) : ''
+    const traced =
+      args.length === 2
+        ? withFrame(context, { thisValue: input }, frameContext => evaluateNode(argAt(args, 1), frameContext, input))
+        : input
+    context.trace(label, traced)
+    return input
+  },
+})
+
+/** The evaluation clock is fixed per evaluation, so these are deterministic within one run. */
+function clockParts(now: Date): { date: string; time: string; offset: number } {
+  const pad = (value: number): string => String(value).padStart(2, '0')
+  const date = `${String(now.getFullYear()).padStart(4, '0')}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`
+  const millis = String(now.getMilliseconds()).padStart(3, '0')
+  const time = `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${millis}`
+  return { date, time, offset: -now.getTimezoneOffset() }
+}
+
+registerFunction('now', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: context => {
+    const { date, time, offset } = clockParts(context.now)
+    const value = Temporal.parseDateTime(`${date}T${time}`)
+    /* v8 ignore next 3 -- the clock always renders a valid dateTime */
+    if (!value) {
+      return []
+    }
+    const withOffset = Temporal.fromFields('dateTime', {
+      year: value.year,
+      month: value.month,
+      day: value.day,
+      hour: value.hour,
+      minute: value.minute,
+      second: value.second,
+      fraction: value.fraction,
+      timezoneOffsetMinutes: offset,
+    }) as Temporal
+    return [{ type: SYSTEM_DATETIME, value: withOffset }] as TypedValue[]
+  },
+})
+
+registerFunction('today', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: context => {
+    const { date } = clockParts(context.now)
+    const value = Temporal.parseDate(date) as Temporal
+    return [{ type: SYSTEM_DATE, value }] as TypedValue[]
+  },
+})
+
+registerFunction('timeOfDay', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: context => {
+    const { time } = clockParts(context.now)
+    const value = Temporal.parseTime(time) as Temporal
+    return [{ type: SYSTEM_TIME, value }] as TypedValue[]
+  },
+})

package/src/functions/variables.ts

@@ -0,0 +1,36 @@
+import { withFrame } from '../engine/context.ts'
+import { FhirPathTypeError } from '../errors.ts'
+import { singleton } from '../values/collection.ts'
+import { SYSTEM_STRING, systemTypeOf, type TypedValue } from '../values/typed-value.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+/**
+ * defineVariable(name [, value]) — ballot STU. The variable joins the current
+ * expression chain's scope (see EvaluationContext.variables): later links of the
+ * same dot chain see it, sibling operator operands and arguments do not.
+ */
+registerFunction('defineVariable', {
+  minArity: 1,
+  maxArity: 2,
+  evaluate: (context, input, args, evaluateNode) => {
+    const nameValue = singleton(evaluateNode(argAt(args, 0), context, input))
+    if (nameValue === undefined || systemTypeOf(nameValue) !== SYSTEM_STRING) {
+      throw new FhirPathTypeError('defineVariable() expects a String name')
+    }
+    const name = nameValue.value as string
+    if (context.env.has(name)) {
+      throw new FhirPathTypeError(`Cannot override the environment variable %${name}`)
+    }
+    if (context.variables.has(name)) {
+      throw new FhirPathTypeError(`Variable %${name} is already defined in this scope`)
+    }
+    // The value expression evaluates against the function input, e.g.
+    // Patient.name.defineVariable('n2', skip(1).first()).
+    const value: TypedValue[] =
+      args.length === 2
+        ? withFrame(context, { thisValue: input }, frameContext => evaluateNode(argAt(args, 1), frameContext, input))
+        : input
+    context.variables.set(name, value)
+    return input
+  },
+})

package/src/index.ts

@@ -0,0 +1,30 @@
+export type { CustomFunctionSignature, ValueArgSpec } from './analyzer/signatures.ts'
+export type { BundleLike } from './api/bundle.ts'
+export type {
+  AnyExpression,
+  CustomFunction,
+  EvaluateOptions,
+  OverloadedCustomFunction,
+  SingleCustomFunction,
+} from './api/compile.ts'
+export { compile, CompiledExpression, DEFAULT_PARSE_CACHE_SIZE } from './api/compile.ts'
+export type { ConstraintCheckResult, ConstraintIssue, FhirConstraint, OperationOutcome } from './api/constraints.ts'
+export type { ColumnTypeMismatch, DtoBase, DtoClass, DtoEnv, DtoInstance, DtoOptions, DtoRow } from './api/dto.ts'
+export { column, criteria, defineDto } from './api/dto.ts'
+export type { EngineInput, EngineOptions, TypedEvaluateOptions } from './api/engine.ts'
+export { BoundExpression, FhirPathEngine, recordEngines } from './api/engine.ts'
+export { evaluate } from './api/evaluate.ts'
+export type { ColumnOptions, ColumnResult, Projection, ProjectionColumn, ProjectionColumns } from './api/project.ts'
+export { fhirpath } from './api/tagged.ts'
+export type { HostNativeFunction, RegexEngine } from './engine/context.ts'
+export type { SourceSpan } from './errors.ts'
+export { FhirPathError, FhirPathRuntimeError, FhirPathSyntaxError, FhirPathTypeError } from './errors.ts'
+export type { ElementInfo, ModelProvider } from './model/provider.ts'
+export type { AstNode } from './parser/ast.ts'
+export { parse } from './parser/parser.ts'
+export { printExpression } from './parser/printer.ts'
+export type { FhirpathInput, FhirpathResult, FhirpathResultIn, FhirTypeName } from './typed/infer.ts'
+export { Temporal } from './values/datetime.ts'
+export { Decimal } from './values/decimal.ts'
+export type { ValueKind } from './values/type-compat.ts'
+export type { QuantityValue, TypedValue } from './values/typed-value.ts'

package/src/lexer/lexer.ts

@@ -0,0 +1,341 @@
+import { FhirPathSyntaxError, type SourceSpan } from '../errors.ts'
+import { KEYWORDS, SPECIAL_VARIABLES, type Token, type TokenKind } from './tokens.ts'
+
+const isDigit = (ch: string): boolean => ch >= '0' && ch <= '9'
+const isIdentifierStart = (ch: string): boolean => (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch === '_'
+const isIdentifierPart = (ch: string): boolean => isIdentifierStart(ch) || isDigit(ch)
+const isWhitespace = (ch: string): boolean => ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n' || ch === '\f'
+const isHexDigit = (ch: string): boolean => isDigit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
+
+const ESCAPES: Readonly<Record<string, string>> = {
+  "'": "'",
+  '"': '"',
+  '`': '`',
+  '/': '/',
+  '\\': '\\',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t',
+}
+
+const TWO_CHAR_OPERATORS: ReadonlySet<string> = new Set(['!=', '!~', '<=', '>='])
+const ONE_CHAR_OPERATORS: ReadonlySet<string> = new Set(['=', '~', '<', '>', '+', '-', '*', '/', '|', '&'])
+const PUNCT: ReadonlySet<string> = new Set(['(', ')', '[', ']', '{', '}', '.', ',', '%'])
+
+class Lexer {
+  private readonly source: string
+  private pos = 0
+
+  constructor(source: string) {
+    this.source = source
+  }
+
+  tokenize(): Token[] {
+    const tokens: Token[] = []
+    for (;;) {
+      const token = this.next()
+      tokens.push(token)
+      if (token.kind === 'end') {
+        return tokens
+      }
+    }
+  }
+
+  private next(): Token {
+    this.skipTrivia()
+    if (this.pos >= this.source.length) {
+      return this.token('end', this.pos, '')
+    }
+    const start = this.pos
+    const ch = this.source[this.pos] as string
+    if (isIdentifierStart(ch)) {
+      return this.readIdentifier(start)
+    }
+    if (isDigit(ch)) {
+      return this.readNumber(start)
+    }
+    switch (ch) {
+      case "'":
+        return this.readString(start)
+      case '`':
+        return this.readDelimitedIdentifier(start)
+      case '@':
+        return this.readDateTimeLiteral(start)
+      case '$':
+        return this.readSpecialVariable(start)
+      default:
+        return this.readOperatorOrPunct(start)
+    }
+  }
+
+  private skipTrivia(): void {
+    while (this.pos < this.source.length) {
+      const ch = this.source[this.pos] as string
+      if (isWhitespace(ch)) {
+        this.advance()
+      } else if (ch === '/' && this.source[this.pos + 1] === '/') {
+        while (this.pos < this.source.length && this.source[this.pos] !== '\n') {
+          this.advance()
+        }
+      } else if (ch === '/' && this.source[this.pos + 1] === '*') {
+        const start = this.spanFrom(this.pos)
+        this.advance()
+        this.advance()
+        while (this.pos < this.source.length && !(this.source[this.pos] === '*' && this.source[this.pos + 1] === '/')) {
+          this.advance()
+        }
+        if (this.pos >= this.source.length) {
+          throw new FhirPathSyntaxError('Unterminated comment', start)
+        }
+        this.advance()
+        this.advance()
+      } else {
+        return
+      }
+    }
+  }
+
+  private readIdentifier(start: number): Token {
+    while (this.pos < this.source.length && isIdentifierPart(this.source[this.pos] as string)) {
+      this.advance()
+    }
+    const text = this.source.slice(start, this.pos)
+    return this.token(KEYWORDS.has(text) ? 'keyword' : 'identifier', start, text)
+  }
+
+  private readNumber(start: number): Token {
+    while (this.pos < this.source.length && isDigit(this.source[this.pos] as string)) {
+      this.advance()
+    }
+    // A '.' continues the number only when a digit follows; `5.single()` is Integer 5 then '.'.
+    if (this.source[this.pos] === '.' && isDigit(this.source[this.pos + 1] ?? '')) {
+      this.advance()
+      while (this.pos < this.source.length && isDigit(this.source[this.pos] as string)) {
+        this.advance()
+      }
+    } else if (this.source[this.pos] === 'L') {
+      // Long literal suffix (ballot STU): 5L is a System.Long.
+      this.advance()
+    }
+    const text = this.source.slice(start, this.pos)
+    return this.token('number', start, text)
+  }
+
+  private readString(start: number): Token {
+    const value = this.readQuoted(start, "'", 'string literal')
+    return this.token('string', start, value)
+  }
+
+  private readDelimitedIdentifier(start: number): Token {
+    const value = this.readQuoted(start, '`', 'delimited identifier')
+    if (value === '') {
+      throw new FhirPathSyntaxError('Empty delimited identifier', this.spanFrom(start))
+    }
+    return this.token('delimitedIdentifier', start, value)
+  }
+
+  private readQuoted(start: number, quote: string, what: string): string {
+    this.advance()
+    let value = ''
+    while (this.pos < this.source.length) {
+      const ch = this.source[this.pos] as string
+      if (ch === quote) {
+        this.advance()
+        return value
+      }
+      if (ch === '\\') {
+        value += this.readEscape()
+      } else {
+        value += ch
+        this.advance()
+      }
+    }
+    throw new FhirPathSyntaxError(`Unterminated ${what}`, this.spanFrom(start))
+  }
+
+  private readEscape(): string {
+    const start = this.pos
+    this.advance()
+    const ch = this.source[this.pos]
+    if (ch === undefined) {
+      throw new FhirPathSyntaxError('Unterminated escape sequence', this.spanFrom(start))
+    }
+    if (ch === 'u') {
+      this.advance()
+      let code = ''
+      for (let i = 0; i < 4; i++) {
+        const hex = this.source[this.pos]
+        if (hex === undefined || !isHexDigit(hex)) {
+          throw new FhirPathSyntaxError('Unicode escape must be \\u followed by 4 hex digits', this.spanFrom(start))
+        }
+        code += hex
+        this.advance()
+      }
+      return String.fromCharCode(Number.parseInt(code, 16))
+    }
+    const resolved = ESCAPES[ch]
+    if (resolved === undefined) {
+      throw new FhirPathSyntaxError(`Invalid escape sequence \\${ch}`, this.spanFrom(start))
+    }
+    this.advance()
+    return resolved
+  }
+
+  private readDateTimeLiteral(start: number): Token {
+    this.advance()
+    if (this.source[this.pos] === 'T') {
+      this.advance()
+      this.readTimeFormat(start, 'time literal')
+      return this.token('time', start, this.source.slice(start + 2, this.pos))
+    }
+    this.readDigits(2, start, 'date literal')
+    this.readDigits(2, start, 'date literal')
+    // Like the reference ANTLR lexer, a component is consumed only when complete:
+    // `@2014-5` is the date @2014 followed by the operator '-' and the number 5.
+    if (this.hasTwoDigitComponent('-')) {
+      this.advance()
+      this.readDigits(2, start, 'date literal')
+      if (this.hasTwoDigitComponent('-')) {
+        this.advance()
+        this.readDigits(2, start, 'date literal')
+      }
+    }
+    if (this.source[this.pos] !== 'T') {
+      return this.token('date', start, this.source.slice(start + 1, this.pos))
+    }
+    this.advance()
+    if (isDigit(this.source[this.pos] ?? '')) {
+      this.readTimeFormat(start, 'dateTime literal')
+      this.readTimezoneOffset()
+    }
+    return this.token('dateTime', start, this.source.slice(start + 1, this.pos))
+  }
+
+  private readTimeFormat(start: number, what: string): void {
+    this.readDigits(2, start, what)
+    if (this.hasTwoDigitComponent(':')) {
+      this.advance()
+      this.readDigits(2, start, what)
+      if (this.hasTwoDigitComponent(':')) {
+        this.advance()
+        this.readDigits(2, start, what)
+        if (this.source[this.pos] === '.' && isDigit(this.source[this.pos + 1] ?? '')) {
+          this.advance()
+          while (isDigit(this.source[this.pos] ?? '')) {
+            this.advance()
+          }
+        }
+      }
+    }
+  }
+
+  private hasTwoDigitComponent(separator: string): boolean {
+    return (
+      this.source[this.pos] === separator &&
+      isDigit(this.source[this.pos + 1] ?? '') &&
+      isDigit(this.source[this.pos + 2] ?? '')
+    )
+  }
+
+  private readTimezoneOffset(): void {
+    const ch = this.source[this.pos]
+    if (ch === 'Z') {
+      this.advance()
+      return
+    }
+    // '+'/'-' is an offset only in the full hh:mm shape; otherwise it is an operator, e.g. `@2014-01-01T10 - 3 days`.
+    if (
+      (ch === '+' || ch === '-') &&
+      isDigit(this.source[this.pos + 1] ?? '') &&
+      isDigit(this.source[this.pos + 2] ?? '') &&
+      this.source[this.pos + 3] === ':' &&
+      isDigit(this.source[this.pos + 4] ?? '') &&
+      isDigit(this.source[this.pos + 5] ?? '')
+    ) {
+      for (let i = 0; i < 6; i++) {
+        this.advance()
+      }
+    }
+  }
+
+  private readDigits(count: number, start: number, what: string): void {
+    for (let i = 0; i < count; i++) {
+      const ch = this.source[this.pos]
+      if (ch === undefined || !isDigit(ch)) {
+        throw new FhirPathSyntaxError(`Invalid ${what}`, this.spanFrom(start))
+      }
+      this.advance()
+    }
+  }
+
+  private readSpecialVariable(start: number): Token {
+    this.advance()
+    while (this.pos < this.source.length && isIdentifierPart(this.source[this.pos] as string)) {
+      this.advance()
+    }
+    const text = this.source.slice(start, this.pos)
+    if (!SPECIAL_VARIABLES.has(text)) {
+      throw new FhirPathSyntaxError(`Unknown special variable ${text}`, this.spanFrom(start))
+    }
+    return this.token('specialVariable', start, text.slice(1))
+  }
+
+  private readOperatorOrPunct(start: number): Token {
+    const two = this.source.slice(this.pos, this.pos + 2)
+    if (TWO_CHAR_OPERATORS.has(two)) {
+      this.advance()
+      this.advance()
+      return this.token('operator', start, two)
+    }
+    const ch = this.source[this.pos] as string
+    if (ONE_CHAR_OPERATORS.has(ch)) {
+      this.advance()
+      return this.token('operator', start, ch)
+    }
+    if (PUNCT.has(ch)) {
+      this.advance()
+      return this.token('punct', start, ch)
+    }
+    throw new FhirPathSyntaxError(`Unexpected character '${ch}'`, this.spanFrom(start))
+  }
+
+  private advance(): void {
+    this.pos += 1
+  }
+
+  private token(kind: TokenKind, start: number, value: string): Token {
+    return {
+      kind,
+      text: this.source.slice(start, this.pos),
+      value,
+      span: this.spanFrom(start),
+    }
+  }
+
+  // Tokens are emitted in source order, so line/column advance incrementally from
+  // the previous span instead of rescanning from offset 0 (which made tokenizing
+  // quadratic in expression length).
+  private lineCursor = 0
+  private cursorLine = 1
+  private cursorColumn = 1
+
+  /** Span from `start` to the current position; line/column point at `start`. */
+  private spanFrom(start: number): SourceSpan {
+    for (let i = this.lineCursor; i < start; i++) {
+      if (this.source[i] === '\n') {
+        this.cursorLine += 1
+        this.cursorColumn = 1
+      } else {
+        this.cursorColumn += 1
+      }
+    }
+    this.lineCursor = Math.max(this.lineCursor, start)
+    return { start, end: this.pos, line: this.cursorLine, column: this.cursorColumn }
+  }
+}
+
+/** Split a FHIRPath expression into tokens. The last token always has kind `end`. */
+export function tokenize(source: string): Token[] {
+  return new Lexer(source).tokenize()
+}