codex ui part 2

Author: dehall

test-server/README.md

@@ -33,19 +33,42 @@ A barebones implementation of the FHIR [$cql](https://build.fhir.org/ig/HL7/cql-
 ## CQL Execution Workbench
 
 When the server is running, open `http://localhost:8000` in a browser. The workbench
-accepts a **System-only CQL expression** (for example, `1 + 2`), translates it to ELM,
-and executes it against the current checkout of `cql-execution`. It displays both the
-native execution result and the translated ELM.
+supports two local testing modes:
+
+- **Expression** mode accepts a System-only CQL expression (for example, `1 + 2`),
+  wraps it in a temporary `Unfiltered` library, translates it to ELM, and executes it
+  against the current checkout of `cql-execution`.
+- **FHIR Bundle** mode accepts a full CQL library plus a FHIR Bundle JSON payload,
+  translates the library to ELM, and executes it in `Patient` context so CQL
+  **Retrieves** such as `[Condition]` run against the supplied Bundle.
 
 The page calls `POST /api/execute` with a JSON body such as:
 
 ```json
 { "cql": "1 + 2" }
 ```
 
-It returns a JSON object containing `result` and `elm`. Invalid or non-executable CQL
-returns HTTP 422 with an error message. This endpoint is intended for local testing and
-demos; `/fhir/$cql` remains the FHIR-operation endpoint.
+FHIR mode includes a `bundle` field:
+
+```json
+{
+  "cql": "library BundleDemo version '1.0.0' ...",
+  "bundle": {
+    "resourceType": "Bundle",
+    "type": "collection",
+    "entry": []
+  }
+}
+```
+
+The response always includes `elm` and `result`. In FHIR mode, `result` contains
+`patientResults` and `unfilteredResults`. Invalid or non-executable CQL returns HTTP 422
+with an error message. Invalid Bundle payloads return HTTP 400. This endpoint is intended
+for local testing and demos; `/fhir/$cql` remains the FHIR-operation endpoint.
+
+FHIR Bundle execution depends on the optional `cql-exec-fhir` package. If it is not
+available in the local environment yet, the workbench returns a clear error explaining
+that the dependency must be installed before FHIR mode can run.
 
 ## Prerequisites
 

test-server/package.json

@@ -21,6 +21,7 @@
   "description": "",
   "dependencies": {
     "@cqframework/cql": "^4.0.0-beta.1",
+    "cql-exec-fhir": "^2.1.6",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "tslog": "^4.11.0"

test-server/src/app.ts

@@ -2,7 +2,7 @@ import 'dotenv/config';
 import express, { type Request, type Response } from 'express';
 import path from 'node:path';
 import logger from './logger';
-import { $cql, executeExpression } from './operation';
+import { $cql, executeExpression, executeFhirLibrary } from './operation';
 
 const app = express();
 app.use(express.json({ type: ['application/json', 'application/fhir+json'] }));
@@ -22,18 +22,51 @@ function getCql(body: unknown): string | undefined {
   return undefined;
 }
 
+function hasBundle(body: unknown): body is { bundle: unknown } {
+  return typeof body === 'object' && body !== null && 'bundle' in body;
+}
+
+function getBundle(body: unknown): Record<string, unknown> | undefined {
+  if (!hasBundle(body)) {
+    return undefined;
+  }
+
+  const { bundle } = body;
+  if (
+    typeof bundle === 'object' &&
+    bundle !== null &&
+    'resourceType' in bundle &&
+    bundle.resourceType === 'Bundle'
+  ) {
+    return bundle as Record<string, unknown>;
+  }
+
+  return undefined;
+}
+
 app.post('/api/execute', async (req: Request, res: Response) => {
   const cql = getCql(req.body);
   if (!cql) {
     return res.status(400).json({ error: "Missing non-empty 'cql' string in request body" });
   }
 
   try {
+    const bundle = getBundle(req.body);
+    if (hasBundle(req.body) && !bundle) {
+      return res.status(400).json({
+        error: "If provided, 'bundle' must be a FHIR Bundle object with resourceType 'Bundle'"
+      });
+    }
+
+    if (bundle) {
+      return res.json(await executeFhirLibrary(cql, bundle));
+    }
+
     return res.json(await executeExpression(cql));
   } catch (err) {
-    logger.error('Error executing CQL expression:', err);
+    logger.error('Error executing CQL request:', err);
     return res.status(422).json({
-      error: err instanceof Error ? err.message : 'Unable to translate or execute the CQL expression'
+      error: err instanceof Error ? err.message : 'Unable to translate or execute the supplied CQL'
     });
   }
 });

test-server/src/operation.ts

@@ -1,6 +1,6 @@
 import { Parameters } from 'fhir/r4';
 import logger from './logger';
-import { translate } from './translate';
+import { translateExpression, translateLibrary } from './translate';
 import { CodeService, DateTime, Executor, Library, PatientSource } from '../..';
 import { toParameters } from './convert';
 
@@ -13,12 +13,44 @@ export interface ExpressionExecution {
   result: unknown;
 }
 
+export interface FhirLibraryExecution {
+  elm: unknown;
+  result: {
+    patientResults: unknown;
+    unfilteredResults: unknown;
+  };
+}
+
+interface FhirPatientSourceModule {
+  PatientSource?: {
+    FHIRv401: (options?: { requireProfileTagging?: boolean }) => {
+      loadBundles: (bundles: unknown[]) => void;
+    };
+  };
+}
+
+function getFhirPatientSource() {
+  try {
+    const module = require('cql-exec-fhir') as FhirPatientSourceModule;
+    const factory = module.PatientSource?.FHIRv401;
+    if (typeof factory !== 'function') {
+      throw new Error("Module does not expose PatientSource.FHIRv401()");
+    }
+    return factory();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `FHIR execution requires the optional 'cql-exec-fhir' dependency. Install test-server dependencies when your environment allows it. Details: ${message}`
+    );
+  }
+}
+
 export async function executeExpression(expression: string): Promise<ExpressionExecution> {
   const id = counter++;
   logger.debug(`[${id}] Expression:   ${expression}`);
 
   // 1: Translate CQL to ELM
-  const elm = await translate(expression, USE_TRANSLATION_SERVICE);
+  const elm = await translateExpression(expression, USE_TRANSLATION_SERVICE);
 
   // 2: Execute ELM
   const library = new Library(elm);
@@ -32,6 +64,31 @@ export async function executeExpression(expression: string): Promise<ExpressionE
   return { elm, result: result.unfilteredResults.expression };
 }
 
+export async function executeFhirLibrary(cql: string, bundle: unknown): Promise<FhirLibraryExecution> {
+  const id = counter++;
+  logger.debug(`[${id}] FHIR CQL library received`);
+
+  const elm = await translateLibrary(cql, USE_TRANSLATION_SERVICE);
+  const library = new Library(elm);
+  const codeService = new CodeService();
+  const patientSource = getFhirPatientSource();
+  patientSource.loadBundles([bundle]);
+
+  const executionDateTime = DateTime.fromJSDate(new Date(), 0);
+  const executor = new Executor(library, codeService);
+  const result = await executor.exec(patientSource as never, executionDateTime);
+  logger.debug(`[${id}] Patient Results: `, result.patientResults);
+  logger.debug(`[${id}] Unfiltered Results: `, result.unfilteredResults);
+
+  return {
+    elm,
+    result: {
+      patientResults: result.patientResults,
+      unfilteredResults: result.unfilteredResults
+    }
+  };
+}
+
 export async function $cql(expression: string): Promise<Parameters> {
   const execution = await executeExpression(expression);