Introduce answer expression support

Author: olimsaidov

demo/samples/answer-expression.json

@@ -0,0 +1,74 @@
+{
+  "resourceType": "Questionnaire",
+  "id": "answer-expression",
+  "status": "active",
+  "title": "Answer Expression Showcase",
+  "description": "Demonstrates runtime answer lists populated by sdc-questionnaire-answerExpression for multiple data types.",
+  "item": [
+    {
+      "linkId": "dynamic-colors",
+      "text": "Collect and reuse color choices",
+      "type": "group",
+      "extension": [
+        {
+          "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-variable",
+          "valueExpression": {
+            "name": "collectedColors",
+            "language": "text/fhirpath",
+            "expression": "%context.item.where(linkId='color-source').answer.valueString"
+          }
+        }
+      ],
+      "item": [
+        {
+          "linkId": "color-source",
+          "type": "string",
+          "repeats": true,
+          "text": "Add every color that should be available"
+        },
+        {
+          "linkId": "color-select",
+          "type": "string",
+          "text": "Pick a favorite color",
+          "extension": [
+            {
+              "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-answerExpression",
+              "valueExpression": {
+                "language": "text/fhirpath",
+                "expression": "%collectedColors"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "linkId": "sleep-patterns",
+      "text": "Choose typical sleep duration",
+      "type": "decimal",
+      "extension": [
+        {
+          "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-answerExpression",
+          "valueExpression": {
+            "language": "text/fhirpath",
+            "expression": "(6.0 | 7.0 | 7.5 | 8.0)"
+          }
+        }
+      ]
+    },
+    {
+      "linkId": "dose-options",
+      "text": "Suggested dosage",
+      "type": "quantity",
+      "extension": [
+        {
+          "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-answerExpression",
+          "valueExpression": {
+            "language": "text/fhirpath",
+            "expression": "(%factory.Quantity('http://unitsofmeasure.org', 'mg', 50, 'mg') | %factory.Quantity('http://unitsofmeasure.org', 'mg', 100, 'mg') | %factory.Quantity('http://unitsofmeasure.org', 'mg', 150, 'mg'))"
+          }
+        }
+      ]
+    }
+  ]
+}

demo/samples/index.ts

@@ -15,6 +15,7 @@ import expressionCalculated from "./expression-calculated.json" assert { type: "
 import expressionEnableWhen from "./expression-enable-when.json" assert { type: "json" };
 import expressionDynamicBounds from "./expression-dynamic-bounds.json" assert { type: "json" };
 import answerOptions from "./answer-options.json" assert { type: "json" };
+import answerExpression from "./answer-expression.json" assert { type: "json" };
 import validation from "./validation.json" assert { type: "json" };
 import targetConstraint from "./target-constraint.json" assert { type: "json" };
 
@@ -100,6 +101,11 @@ export const demoSamples: readonly DemoSample[] = [
     label: "Answer options",
     questionnaire: answerOptions as Questionnaire,
   },
+  {
+    id: "answer-expression",
+    label: "Answer expressions",
+    questionnaire: answerExpression as Questionnaire,
+  },
   {
     id: "validation",
     label: "Validation",

lib/__tests__/utils.test.ts

@@ -1,7 +1,15 @@
 import { describe, expect, it } from "vitest";
-import type { Attachment, Coding, Element, Quantity, Reference } from "fhir/r5";
+import type {
+  Attachment,
+  Coding,
+  Element,
+  Quantity,
+  QuestionnaireItemAnswerOption,
+  Reference,
+} from "fhir/r5";
 
 import {
+  answerify,
   areValuesEqual,
   cloneValue,
   countDecimalPlaces,
@@ -252,6 +260,143 @@ describe("stringifyValue", () => {
   });
 });
 
+describe("answerify", () => {
+  it("flattens nested collections", () => {
+    const result = answerify("string", ["Alpha", ["Beta", ["Gamma"]]]);
+    expect(result).toEqual([
+      { valueString: "Alpha" },
+      { valueString: "Beta" },
+      { valueString: "Gamma" },
+    ]);
+  });
+
+  it("coerces boolean strings", () => {
+    const result = answerify("boolean", ["true", "FALSE", "maybe"]);
+    expect(result).toEqual([{ valueBoolean: true }, { valueBoolean: false }]);
+  });
+
+  it("parses numerics for integer questions", () => {
+    const result = answerify("integer", ["5", 7, "oops"]);
+    expect(result).toEqual([{ valueInteger: 5 }, { valueInteger: 7 }]);
+  });
+
+  it("parses numerics for decimal questions", () => {
+    const result = answerify("decimal", ["1.5", 2, "oops"]);
+    expect(result).toEqual([{ valueDecimal: 1.5 }, { valueDecimal: 2 }]);
+  });
+
+  it("wraps bare coding objects", () => {
+    const coding: Coding = { system: "http://loinc.org", code: "718-7" };
+    const [option] = answerify("coding", coding);
+    expect(option).toEqual({ valueCoding: coding });
+    expect(option.valueCoding).toBe(coding);
+  });
+
+  it("returns structured codings unchanged when provided as answerOption", () => {
+    const option: QuestionnaireItemAnswerOption = {
+      valueCoding: { system: "http://loinc.org", code: "890-5" },
+      extension: [{ url: "test", valueString: "meta" }],
+    };
+    const [result] = answerify("coding", [option]);
+    expect(result).not.toBe(option);
+    expect(result.valueCoding).toEqual(option.valueCoding);
+    expect(result.extension).toBe(option.extension);
+  });
+
+  it("clones provided answerOption wrappers", () => {
+    const original = {
+      valueCoding: { code: "opt", display: "Option" },
+      extension: [{ url: "x", valueString: "meta" }],
+    } satisfies QuestionnaireItemAnswerOption;
+
+    const [option] = answerify("coding", [original]);
+
+    expect(option.valueCoding).toEqual(original.valueCoding);
+    expect(option.valueCoding).toBe(original.valueCoding);
+    expect(option.extension).toEqual(original.extension);
+    expect(option.extension).toBe(original.extension);
+  });
+
+  it("filters unsupported values", () => {
+    const result = answerify("boolean", [null, undefined, 1, "maybe"]);
+    expect(result).toEqual([]);
+  });
+
+  it("clones structured quantity answers", () => {
+    const quantity = { value: 42, unit: "kg" } satisfies Quantity;
+    const result = answerify("quantity", quantity);
+    expect(result).toHaveLength(1);
+    expect((result[0] as { valueQuantity?: Quantity }).valueQuantity).toBe(
+      quantity,
+    );
+  });
+
+  it("passes through references", () => {
+    const reference = {
+      reference: "Patient/1",
+      display: "Alice",
+    } satisfies Reference;
+    const result = answerify("reference", reference);
+    expect(result).toHaveLength(1);
+    expect((result[0] as { valueReference?: Reference }).valueReference).toBe(
+      reference,
+    );
+  });
+
+  it("passes through attachments", () => {
+    const attachment = {
+      url: "https://example.org",
+      title: "Scan",
+    } satisfies Attachment;
+    const result = answerify("attachment", attachment);
+    expect(result).toHaveLength(1);
+    expect(
+      (result[0] as { valueAttachment?: Attachment }).valueAttachment,
+    ).toBe(attachment);
+  });
+
+  it("accepts string-like types", () => {
+    const result = answerify("string", "alpha");
+    expect(result).toEqual([{ valueString: "alpha" }]);
+  });
+
+  it("accepts text type", () => {
+    const result = answerify("text", "long form");
+    expect(result).toEqual([{ valueString: "long form" }]);
+  });
+
+  it("accepts date values", () => {
+    const result = answerify("date", ["2025-01-01", "invalid"]);
+    expect(result.map((option) => getValue(option, "date"))).toEqual([
+      "2025-01-01",
+      "invalid",
+    ]);
+  });
+
+  it("accepts dateTime values", () => {
+    const result = answerify("dateTime", ["2025-01-01T09:30:00Z", 42]);
+    expect(result).toEqual([{ valueDateTime: "2025-01-01T09:30:00Z" }]);
+  });
+
+  it("accepts time values", () => {
+    const result = answerify("time", ["08:15:00", null]);
+    expect(result).toEqual([{ valueTime: "08:15:00" }]);
+  });
+
+  it("rejects unsupported types", () => {
+    const result = answerify("reference", ["string", 42, null]);
+    expect(result).toEqual([]);
+  });
+
+  it("handles empty source arrays", () => {
+    expect(answerify("string", [])).toEqual([]);
+  });
+
+  it("ignores undefined root value", () => {
+    expect(answerify("string", undefined)).toEqual([]);
+  });
+});
+
 describe("areValuesEqual", () => {
   describe("string", () => {
     it("returns true for equal strings", () => {

lib/components/nodes/question-node.tsx

@@ -22,7 +22,7 @@ export const QuestionNode = observer(function QuestionNode({
 }: {
   item: IQuestionNode;
 }) {
-  if ((item.template.answerOption?.length ?? 0) > 0) {
+  if (item.answerOptions.length > 0) {
     return <AnswerOptionNode item={item} />;
   }
 

lib/components/questions/__tests__/answer-option-node.test.tsx

@@ -1,11 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { render, screen } from "@testing-library/react";
+import { act, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import type { Questionnaire, QuestionnaireResponse } from "fhir/r5";
 
 import { FormStore } from "../../../stores/form-store.ts";
 import { isQuestionNode } from "../../../stores/question-store.ts";
 import { QuestionNode } from "../../nodes/question-node.tsx";
+import {
+  makeAnswerExpression,
+  makeVariable,
+} from "../../../stores/__tests__/expression-fixtures.ts";
 
 function getQuestionNode(form: FormStore, linkId: string) {
   const node = form.scope.lookupNode(linkId);
@@ -45,7 +49,9 @@ describe("AnswerOptionNode", () => {
     expect(combobox).toHaveValue("");
 
     const user = userEvent.setup();
-    const greenOption = screen.getByRole("option", { name: "Green" }) as HTMLOptionElement;
+    const greenOption = screen.getByRole("option", {
+      name: "Green",
+    }) as HTMLOptionElement;
     await user.selectOptions(combobox, greenOption.value);
 
     expect(greenOption.selected).toBe(true);
@@ -88,7 +94,9 @@ describe("AnswerOptionNode", () => {
     render(<QuestionNode item={question} />);
 
     const combobox = screen.getByRole("combobox", { name: /severity/i });
-    const selectedOption = screen.getByRole("option", { name: "Moderate" }) as HTMLOptionElement;
+    const selectedOption = screen.getByRole("option", {
+      name: "Moderate",
+    }) as HTMLOptionElement;
     expect(combobox).toBeInTheDocument();
     expect(selectedOption.selected).toBe(true);
     expect(question.answers.at(0)?.value).toMatchObject({
@@ -149,4 +157,61 @@ describe("AnswerOptionNode", () => {
     ).toBeNull();
     expect(question.answers.at(0)?.value).toBe("Vanilla");
   });
+
+  it("upgrades a question to a select when answerExpression yields options", async () => {
+    const questionnaire: Questionnaire = {
+      resourceType: "Questionnaire",
+      status: "active",
+      item: [
+        {
+          linkId: "panel",
+          type: "group",
+          extension: [
+            makeVariable(
+              "sourceValues",
+              "%context.item.where(linkId='source').answer.valueString",
+            ),
+          ],
+          item: [
+            {
+              linkId: "source",
+              text: "Source",
+              type: "string",
+            },
+            {
+              linkId: "mirror",
+              text: "Mirror",
+              type: "string",
+              extension: [makeAnswerExpression("%sourceValues")],
+            },
+          ],
+        },
+      ],
+    };
+
+    const form = new FormStore(questionnaire);
+    const source = getQuestionNode(form, "source");
+    const mirror = getQuestionNode(form, "mirror");
+
+    render(<QuestionNode item={mirror} />);
+
+    expect(
+      screen.getByRole("textbox", { name: /mirror/i }),
+    ).toBeInTheDocument();
+
+    await act(async () => {
+      source.setAnswer(0, "Alpha");
+    });
+
+    const combobox = await screen.findByRole("combobox", { name: /mirror/i });
+    expect(combobox).toBeInTheDocument();
+    expect(screen.getByRole("option", { name: "Alpha" })).toBeInTheDocument();
+
+    await act(async () => {
+      source.setAnswer(0, "Beta");
+    });
+
+    expect(screen.getByRole("option", { name: "Beta" })).toBeInTheDocument();
+    expect(screen.queryByRole("option", { name: "Alpha" })).toBeNull();
+  });
 });