@openhi/constructs 0.0.32 → 0.0.34

package/lib/rest-api-lambda.handler.mjs

@@ -7,7 +7,7 @@ import serverlessExpress from "@codegenie/serverless-express";
 
 // src/data/rest-api/rest-api.ts
 import path from "path";
-import express3 from "express";
+import express5 from "express";
 
 // src/data/middleware/normalize-json-body.ts
 function normalizeJsonBodyMiddleware(req, _res, next) {
@@ -72,13 +72,9 @@ function openHiContextMiddleware(req, res, next) {
   next();
 }
 
-// src/data/rest-api/routes/configuration/configuration.ts
+// src/data/rest-api/routes/control/configuration/configuration.ts
 import express from "express";
 
-// src/data/rest-api/routes/configuration/configuration-common.ts
-var BASE_PATH = "/Configuration";
-var SK = "CURRENT";
-
 // src/lib/compression.ts
 import { gzipSync, gunzipSync } from "zlib";
 var ENVELOPE_VERSION = 1;
@@ -135,16 +131,26 @@ function decompressResource(compressedOrRaw) {
   return compressedOrRaw;
 }
 
-// src/data/dynamo/dynamo-service.ts
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+// src/data/dynamo/dynamo-control-service.ts
 import { Service } from "electrodb";
 
-// src/data/dynamo/entities/configuration.ts
+// src/data/dynamo/dynamo-client.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+var defaultTableName = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+var dynamoClient = new DynamoDBClient({
+  ...process.env.MOCK_DYNAMODB_ENDPOINT && {
+    endpoint: process.env.MOCK_DYNAMODB_ENDPOINT,
+    sslEnabled: false,
+    region: "local"
+  }
+});
+
+// src/data/dynamo/entities/control/configuration-entity.ts
 import { Entity } from "electrodb";
-var Configuration = new Entity({
+var ConfigurationEntity = new Entity({
   model: {
     entity: "configuration",
-    service: "openhi",
+    service: "control",
     version: "01"
   },
   attributes: {
@@ -221,7 +227,7 @@ var Configuration = new Entity({
       pk: {
         field: "PK",
         composite: ["tenantId", "workspaceId", "userId", "roleId"],
-        template: "OHI#CONFIG#TID#${tenantId}#WID#${workspaceId}#UID#${userId}#RID#${roleId}"
+        template: "CONFIG#TID#${tenantId}#WID#${workspaceId}#UID#${userId}#RID#${roleId}"
       },
       sk: {
         field: "SK",
@@ -247,213 +253,134 @@ var Configuration = new Entity({
   }
 });
 
-// src/data/dynamo/entities/patient.ts
-import { Entity as Entity2 } from "electrodb";
-var Patient = new Entity2({
-  model: {
-    entity: "patient",
-    service: "openhi",
-    version: "01"
-  },
-  attributes: {
-    /** Sort key. "CURRENT" for current version; version history in S3. */
-    sk: {
-      type: "string",
-      required: true,
-      default: "CURRENT"
-    },
-    tenantId: {
-      type: "string",
-      required: true
-    },
-    workspaceId: {
-      type: "string",
-      required: true
-    },
-    /** FHIR Resource.id; logical id in URL and PK. */
-    id: {
-      type: "string",
-      required: true
-    },
-    /** FHIR resource as JSON string. JSON.stringify(resource) on write; JSON.parse(item.resource) on read. */
-    resource: {
-      type: "string",
-      required: true
-    },
-    /** Version id (e.g. ULID). Tracks current version; S3 history key. */
-    vid: {
-      type: "string",
-      required: true
-    },
-    lastUpdated: {
-      type: "string",
-      required: true
-    },
-    deleted: {
-      type: "boolean",
-      required: false
-    },
-    bundleId: {
-      type: "string",
-      required: false
-    },
-    msgId: {
-      type: "string",
-      required: false
-    },
-    // Audit is in FHIR resource meta (meta.extension), not item attributes. See data-store-entities.md.
-    // --- GSI2 (Identifier Lookup): optional; set when indexing this patient by identifier (e.g. MRN)
-    /** Identifier system (e.g. MRN system URI). When set with identifierValue, item is written to GSI2. */
-    identifierSystem: {
-      type: "string",
-      required: false
-    },
-    /** Identifier value (e.g. MRN). When set with identifierSystem, item is written to GSI2. */
-    identifierValue: {
-      type: "string",
-      required: false
-    },
-    /** For GSI2/GSI3 projection: base table PK/SK so GetItem can be used after query. */
-    resourcePk: {
-      type: "string",
-      required: false
-    },
-    resourceSk: {
-      type: "string",
-      required: false
-    },
-    /** For GSI2 projection: display name for roster/lookup. */
-    display: {
-      type: "string",
-      required: false
-    },
-    /** For GSI2 projection: resource status if applicable. */
-    status: {
-      type: "string",
-      required: false
-    },
-    // --- GSI3 (Facility Ops): optional; set when indexing this patient on a facility roster
-    /** Facility id. When set with normalizedName, item is written to GSI3. */
-    facilityId: {
-      type: "string",
-      required: false
-    },
-    /** Normalized display name for roster sort. When set with facilityId, item is written to GSI3. */
-    normalizedName: {
-      type: "string",
-      required: false
-    }
-  },
-  indexes: {
-    /** Base table: PK, SK (data store key names). PK is built from tenantId, workspaceId, id; do not supply PK from outside. */
-    record: {
-      pk: {
-        field: "PK",
-        composite: ["tenantId", "workspaceId", "id"],
-        template: "TID#${tenantId}#WID#${workspaceId}#RT#Patient#ID#${id}"
-      },
-      sk: {
-        field: "SK",
-        composite: ["sk"]
-      }
-    },
-    /**
-     * GSI1 — Reverse Reference: query "what references this patient?".
-     * Patient items are never written to GSI1 (condition: false); reference index items
-     * are written by other resources. This index enables querying GSI1 by REFTO#RT#Patient#ID#<id>.
-     */
-    gsi1: {
-      index: "GSI1",
-      condition: () => false,
-      pk: {
-        field: "GSI1PK",
-        composite: ["tenantId", "workspaceId", "id"],
-        template: "TID#${tenantId}#WID#${workspaceId}#REFTO#RT#Patient#ID#${id}"
-      },
-      sk: {
-        field: "GSI1SK",
-        composite: []
-      }
-    },
-    /** GSI2 — Identifier Lookup: MRN, NPI, member ID, etc. Keys built from identifier components. */
-    gsi2: {
-      index: "GSI2",
-      condition: (attr) => attr.identifierSystem != null && attr.identifierValue != null,
-      pk: {
-        field: "GSI2PK",
-        composite: [
-          "tenantId",
-          "workspaceId",
-          "identifierSystem",
-          "identifierValue"
-        ],
-        template: "TID#${tenantId}#WID#${workspaceId}#IDENT#${identifierSystem}#${identifierValue}"
-      },
-      sk: {
-        field: "GSI2SK",
-        composite: ["id"],
-        template: "RT#Patient#ID#${id}"
-      }
-    },
-    /** GSI3 — Facility Ops: facility roster, worklists. Keys built from facility + name. */
-    gsi3: {
-      index: "GSI3",
-      condition: (attr) => attr.facilityId != null && attr.normalizedName != null,
-      pk: {
-        field: "GSI3PK",
-        composite: ["tenantId", "workspaceId", "facilityId"],
-        template: "TID#${tenantId}#WID#${workspaceId}#FAC#${facilityId}"
-      },
-      sk: {
-        field: "GSI3SK",
-        composite: ["id", "normalizedName"],
-        template: "TYPE#PATIENT#PAT#${id}#NAME#${normalizedName}"
-      }
-    },
-    /** GSI4 — Resource Type Index: list all Patients in workspace (no scan). */
-    gsi4: {
-      index: "GSI4",
-      condition: () => true,
-      pk: {
-        field: "GSI4PK",
-        composite: ["tenantId", "workspaceId"],
-        template: "TID#${tenantId}#WID#${workspaceId}#RT#Patient"
-      },
-      sk: {
-        field: "GSI4SK",
-        composite: ["id"],
-        template: "ID#${id}"
-      }
-    }
-  }
-});
-
-// src/data/dynamo/dynamo-service.ts
-var table = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
-var client = new DynamoDBClient({
-  ...process.env.MOCK_DYNAMODB_ENDPOINT && {
-    endpoint: process.env.MOCK_DYNAMODB_ENDPOINT,
-    sslEnabled: false,
-    region: "local"
-  }
+// src/data/dynamo/dynamo-control-service.ts
+var controlPlaneEntities = {
+  configuration: ConfigurationEntity
+};
+var controlPlaneService = new Service(controlPlaneEntities, {
+  table: defaultTableName,
+  client: dynamoClient
 });
-var entities = { patient: Patient, configuration: Configuration };
-var DynamoDataService = new Service(entities, { table, client });
-function getDynamoDataService(tableName) {
-  const resolved = tableName ?? table;
-  return new Service(entities, { table: resolved, client });
+var DynamoControlService = {
+  entities: controlPlaneService.entities
+};
+function getDynamoControlService(tableName) {
+  const resolved = tableName ?? defaultTableName;
+  const service = new Service(controlPlaneEntities, {
+    table: resolved,
+    client: dynamoClient
+  });
+  return {
+    entities: service.entities
+  };
 }
 
-// src/data/rest-api/routes/configuration/configuration-create.ts
-async function createConfiguration(req, res) {
-  const ctx = req.openhiContext;
+// src/data/operations/control/configuration/configuration-create-operation.ts
+var SK = "CURRENT";
+async function createConfigurationOperation(params) {
+  const { context, body, tableName } = params;
   const {
     tenantId: ctxTenantId,
     workspaceId: ctxWorkspaceId,
     actorId: ctxActorId,
     date
-  } = ctx;
-  const body = req.body;
+  } = context;
+  const key = body.key;
+  const id = body.id ?? `config-${key}-${Date.now()}`;
+  const resourcePayload = body.resource;
+  const resourceStr = typeof resourcePayload === "string" ? resourcePayload : JSON.stringify(resourcePayload ?? {});
+  const tenantId = body.tenantId ?? ctxTenantId;
+  const workspaceId = body.workspaceId ?? ctxWorkspaceId;
+  const userId = body.userId ?? ctxActorId ?? "-";
+  const roleId = body.roleId ?? context.roleId ?? "-";
+  const lastUpdated = body.lastUpdated ?? date;
+  const vid = body.vid ?? (date.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36));
+  const service = getDynamoControlService(tableName);
+  await service.entities.configuration.put({
+    tenantId,
+    workspaceId,
+    userId,
+    roleId,
+    key,
+    id,
+    resource: compressResource(resourceStr),
+    vid,
+    lastUpdated,
+    sk: SK
+  }).go();
+  const resource = typeof resourcePayload === "object" ? resourcePayload : JSON.parse(resourceStr);
+  return {
+    id,
+    key,
+    resource: {
+      resourceType: "Configuration",
+      id,
+      key,
+      resource
+    },
+    meta: { lastUpdated, versionId: vid }
+  };
+}
+
+// src/data/rest-api/routes/common.ts
+var BASE_PATH = {
+  CONFIGURATION: "/Configuration",
+  ENCOUNTER: "/Encounter",
+  PATIENT: "/Patient",
+  PRACTITIONER: "/Practitioner"
+};
+function requireJsonBody(req, res) {
+  const raw = req.body;
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
+    return {
+      errorResponse: res.status(400).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "invalid",
+            diagnostics: "Request body must be a JSON object."
+          }
+        ]
+      })
+    };
+  }
+  return { body: raw };
+}
+function buildSearchsetBundle(basePath, entries) {
+  return {
+    resourceType: "Bundle",
+    type: "searchset",
+    total: entries.length,
+    link: [{ relation: "self", url: basePath }],
+    entry: entries.map((item) => ({
+      fullUrl: `${basePath}/${item.id}`,
+      resource: item.resource
+    }))
+  };
+}
+function sendOperationOutcome404(res, diagnostics) {
+  return res.status(404).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "not-found", diagnostics }]
+  });
+}
+function sendOperationOutcome500(res, err, logContext) {
+  if (logContext) {
+    console.error(logContext, err);
+  }
+  return res.status(500).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "exception", diagnostics: String(err) }]
+  });
+}
+
+// src/data/rest-api/routes/control/configuration/configuration-create-route.ts
+async function createConfigurationRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
   const key = body?.key;
   if (!key || typeof key !== "string") {
     return res.status(400).json({
@@ -467,37 +394,26 @@ async function createConfiguration(req, res) {
       ]
     });
   }
-  const id = body?.id ?? `config-${key}-${Date.now()}`;
-  const resourcePayload = body?.resource;
-  const resourceStr = typeof resourcePayload === "string" ? resourcePayload : JSON.stringify(resourcePayload ?? {});
-  const tenantId = body?.tenantId ?? ctxTenantId;
-  const workspaceId = body?.workspaceId ?? ctxWorkspaceId;
-  const userId = body?.userId ?? ctxActorId ?? "-";
-  const roleId = body?.roleId ?? "-";
-  const vid = body?.vid ?? (date.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36));
-  const lastUpdated = body?.lastUpdated ?? date;
-  const service = getDynamoDataService();
   try {
-    await service.entities.configuration.put({
-      tenantId,
-      workspaceId,
-      userId,
-      roleId,
-      key,
-      id,
-      resource: compressResource(resourceStr),
-      vid,
-      lastUpdated,
-      sk: SK
-    }).go();
+    const result = await createConfigurationOperation({
+      context: ctx,
+      body: {
+        key,
+        id: body?.id,
+        resource: body?.resource,
+        tenantId: body?.tenantId,
+        workspaceId: body?.workspaceId,
+        userId: body?.userId,
+        roleId: body?.roleId,
+        vid: body?.vid,
+        lastUpdated: body?.lastUpdated
+      }
+    });
     const config = {
-      resourceType: "Configuration",
-      id,
-      key,
-      resource: typeof resourcePayload === "object" ? resourcePayload : JSON.parse(resourceStr),
-      meta: { lastUpdated, versionId: vid }
+      ...result.resource,
+      meta: result.meta
     };
-    return res.status(201).location(`${BASE_PATH}/${key}`).json(config);
+    return res.status(201).location(`${BASE_PATH.CONFIGURATION}/${result.key}`).json(config);
   } catch (err) {
     console.error("POST Configuration error:", err);
     return res.status(500).json({
@@ -509,15 +425,29 @@ async function createConfiguration(req, res) {
   }
 }
 
-// src/data/rest-api/routes/configuration/configuration-delete.ts
-async function deleteConfiguration(req, res) {
-  const key = String(req.params.key);
-  const ctx = req.openhiContext;
-  const { tenantId, workspaceId, actorId, roleId: ctxRoleId } = ctx;
+// src/data/operations/control/configuration/configuration-delete-operation.ts
+var SK2 = "CURRENT";
+async function deleteConfigurationOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId, actorId, roleId: ctxRoleId } = context;
   const roleId = ctxRoleId ?? "-";
-  const service = getDynamoDataService();
+  const service = getDynamoControlService(tableName);
+  await service.entities.configuration.delete({
+    tenantId,
+    workspaceId,
+    userId: actorId,
+    roleId,
+    key: id,
+    sk: SK2
+  }).go();
+}
+
+// src/data/rest-api/routes/control/configuration/configuration-delete-route.ts
+async function deleteConfigurationRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
   try {
-    await service.entities.configuration.delete({ tenantId, workspaceId, userId: actorId, roleId, key, sk: SK }).go();
+    await deleteConfigurationOperation({ context: ctx, id });
     return res.status(204).send();
   } catch (err) {
     console.error("DELETE Configuration error:", err);
@@ -530,37 +460,87 @@ async function deleteConfiguration(req, res) {
   }
 }
 
-// src/data/rest-api/routes/configuration/configuration-get-by-key.ts
-async function getConfigurationByKey(req, res) {
-  const key = String(req.params.key);
-  const ctx = req.openhiContext;
-  const { tenantId, workspaceId, actorId, roleId: ctxRoleId } = ctx;
+// src/data/errors/domain-errors.ts
+var DomainError = class extends Error {
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = options?.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotFoundError = class extends DomainError {
+  constructor(message, options) {
+    super(message, "NOT_FOUND", options);
+  }
+};
+var ValidationError = class extends DomainError {
+  constructor(message, options) {
+    super(message, "VALIDATION", options);
+  }
+};
+var ConflictError = class extends DomainError {
+  constructor(message, options) {
+    super(message, "CONFLICT", options);
+  }
+};
+function domainErrorToHttpStatus(err) {
+  if (err instanceof NotFoundError) return 404;
+  if (err instanceof ValidationError) return 400;
+  if (err instanceof ConflictError) return 409;
+  return null;
+}
+
+// src/data/operations/control/configuration/configuration-get-by-id-operation.ts
+var SK3 = "CURRENT";
+async function getConfigurationByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId, actorId, roleId: ctxRoleId } = context;
   const roleId = ctxRoleId ?? "-";
-  const service = getDynamoDataService();
+  const service = getDynamoControlService(tableName);
+  const result = await service.entities.configuration.get({ tenantId, workspaceId, userId: actorId, roleId, key: id, sk: SK3 }).go();
+  if (!result.data) {
+    throw new NotFoundError(`Configuration ${id} not found`, {
+      details: { id }
+    });
+  }
+  const resource = JSON.parse(
+    decompressResource(result.data.resource)
+  );
+  return {
+    id: result.data.id,
+    key: result.data.key,
+    resource: {
+      ...resource,
+      resourceType: "Configuration",
+      id: result.data.id,
+      key: result.data.key
+    }
+  };
+}
+
+// src/data/rest-api/routes/control/configuration/configuration-get-by-id-route.ts
+async function getConfigurationByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
   try {
-    const result = await service.entities.configuration.get({ tenantId, workspaceId, userId: actorId, roleId, key, sk: SK }).go();
-    if (!result.data) {
+    const result = await getConfigurationByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
       return res.status(404).json({
         resourceType: "OperationOutcome",
         issue: [
           {
             severity: "error",
             code: "not-found",
-            diagnostics: `Configuration ${key} not found`
+            diagnostics: err instanceof NotFoundError ? err.message : `Configuration ${id} not found`
           }
         ]
       });
     }
-    const resource = JSON.parse(
-      decompressResource(result.data.resource)
-    );
-    return res.json({
-      ...resource,
-      resourceType: "Configuration",
-      id: result.data.id,
-      key: result.data.key
-    });
-  } catch (err) {
     console.error("GET Configuration error:", err);
     return res.status(500).json({
       resourceType: "OperationOutcome",
@@ -575,6 +555,30 @@ async function getConfigurationByKey(req, res) {
   }
 }
 
+// src/data/operations/control/configuration/configuration-list-operation.ts
+async function listConfigurationsOperation(params) {
+  const { context, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoControlService(tableName);
+  const result = await service.entities.configuration.query.gsi4({ tenantId, workspaceId }).go();
+  const entries = (result.data ?? []).map(
+    (item) => {
+      const resource = JSON.parse(decompressResource(item.resource));
+      return {
+        id: item.id,
+        key: item.key,
+        resource: {
+          resourceType: "Configuration",
+          id: item.id,
+          key: item.key,
+          resource
+        }
+      };
+    }
+  );
+  return { entries };
+}
+
 // src/data/rest-api/dynamic-configuration.ts
 import {
   DescribeParametersCommand,
@@ -598,9 +602,9 @@ async function getDynamicConfigurationEntries(context) {
     return getStaticDummyEntry(context);
   }
   const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
-  const client2 = new SSMClient({ region });
+  const client = new SSMClient({ region });
   try {
-    const describeResult = await client2.send(
+    const describeResult = await client.send(
       new DescribeParametersCommand({
         ParameterFilters: [
           {
@@ -624,7 +628,7 @@ async function getDynamicConfigurationEntries(context) {
     const parameters = [];
     for (let i = 0; i < names.length; i += 10) {
       const batch = names.slice(i, i + 10);
-      const getResult = await client2.send(
+      const getResult = await client.send(
         new GetParametersCommand({
           Names: batch,
           WithDecryption: true
@@ -688,29 +692,28 @@ function getStaticDummyEntry(_context) {
   return [dummy];
 }
 
-// src/data/rest-api/routes/configuration/configuration-list.ts
-async function listConfigurations(req, res) {
-  const { tenantId, workspaceId } = req.openhiContext;
-  const service = getDynamoDataService();
+// src/data/rest-api/routes/control/configuration/configuration-list-route.ts
+async function listConfigurationsRoute(req, res) {
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId } = ctx;
   try {
-    const result = await service.entities.configuration.query.gsi4({ tenantId, workspaceId }).go();
-    const dynamoEntries = (result.data ?? []).map((item) => {
-      const resource = JSON.parse(decompressResource(item.resource));
-      return {
-        fullUrl: `${BASE_PATH}/${item.key}`,
-        resource: { ...resource, id: item.id, key: item.key }
-      };
+    const { entries: dynamoEntries } = await listConfigurationsOperation({
+      context: ctx
     });
+    const dynamoBundleEntries = dynamoEntries.map((e) => ({
+      fullUrl: `${BASE_PATH.CONFIGURATION}/${e.key}`,
+      resource: e.resource
+    }));
     const dynamicEntries = await getDynamicConfigurationEntries({
       tenantId,
       workspaceId
     });
-    const entries = [...dynamoEntries, ...dynamicEntries];
+    const entries = [...dynamoBundleEntries, ...dynamicEntries];
     const bundle = {
       resourceType: "Bundle",
       type: "searchset",
       total: entries.length,
-      link: [{ relation: "self", url: BASE_PATH }],
+      link: [{ relation: "self", url: BASE_PATH.CONFIGURATION }],
       entry: entries
     };
     return res.json(bundle);
@@ -729,114 +732,1180 @@ async function listConfigurations(req, res) {
   }
 }
 
-// src/data/rest-api/routes/configuration/configuration-update.ts
-async function updateConfiguration(req, res) {
-  const key = String(req.params.key);
-  const ctx = req.openhiContext;
-  const { tenantId, workspaceId, actorId, date, roleId: ctxRoleId } = ctx;
+// src/data/operations/control/configuration/configuration-update-operation.ts
+var SK4 = "CURRENT";
+async function updateConfigurationOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, actorId, date, roleId: ctxRoleId } = context;
   const roleId = ctxRoleId ?? "-";
-  const body = req.body;
-  const resourcePayload = body?.resource;
+  const service = getDynamoControlService(tableName);
+  const existing = await service.entities.configuration.get({ tenantId, workspaceId, userId: actorId, roleId, key: id, sk: SK4 }).go();
+  if (!existing.data) {
+    throw new NotFoundError(`Configuration ${id} not found`, {
+      details: { id }
+    });
+  }
+  const resourcePayload = body.resource;
   const resourceStr = typeof resourcePayload === "string" ? resourcePayload : JSON.stringify(resourcePayload ?? {});
-  const lastUpdated = body?.lastUpdated ?? date;
-  const service = getDynamoDataService();
-  try {
-    const existing = await service.entities.configuration.get({ tenantId, workspaceId, userId: actorId, roleId, key, sk: SK }).go();
-    if (!existing.data) {
-      return res.status(404).json({
-        resourceType: "OperationOutcome",
-        issue: [
-          {
-            severity: "error",
+  const lastUpdated = body.lastUpdated ?? date;
+  const nextVid = existing.data.vid != null ? String(Number(existing.data.vid) + 1) : date.replace(/[-:T.Z]/g, "").slice(0, 12) || "2";
+  await service.entities.configuration.patch({ tenantId, workspaceId, userId: actorId, roleId, key: id, sk: SK4 }).set({
+    resource: compressResource(resourceStr),
+    lastUpdated,
+    vid: nextVid
+  }).go();
+  const parsedResource = typeof resourcePayload === "object" ? resourcePayload : JSON.parse(resourceStr);
+  return {
+    id: existing.data.id,
+    key: existing.data.key,
+    resource: {
+      resourceType: "Configuration",
+      id: existing.data.id,
+      key: existing.data.key,
+      resource: parsedResource
+    },
+    meta: { lastUpdated, versionId: nextVid }
+  };
+}
+
+// src/data/rest-api/routes/control/configuration/configuration-update-route.ts
+async function updateConfigurationRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  try {
+    const result = await updateConfigurationOperation({
+      context: ctx,
+      id,
+      body: {
+        resource: body?.resource,
+        lastUpdated: body?.lastUpdated
+      }
+    });
+    return res.json({
+      ...result.resource,
+      meta: result.meta
+    });
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
             code: "not-found",
-            diagnostics: `Configuration ${key} not found`
+            diagnostics: err instanceof NotFoundError ? err.message : `Configuration ${id} not found`
           }
         ]
       });
     }
-    const nextVid = existing.data.vid != null ? String(Number(existing.data.vid) + 1) : date.replace(/[-:T.Z]/g, "").slice(0, 12) || "2";
-    await service.entities.configuration.patch({ tenantId, workspaceId, userId: actorId, roleId, key, sk: SK }).set({
-      resource: compressResource(resourceStr),
-      lastUpdated,
-      vid: nextVid
-    }).go();
-    const config = {
-      resourceType: "Configuration",
-      id: existing.data.id,
-      key: existing.data.key,
-      resource: typeof resourcePayload === "object" ? resourcePayload : JSON.parse(resourceStr),
-      meta: { lastUpdated, versionId: nextVid }
-    };
-    return res.json(config);
-  } catch (err) {
     console.error("PUT Configuration error:", err);
     return res.status(500).json({
       resourceType: "OperationOutcome",
       issue: [
-        { severity: "error", code: "exception", diagnostics: String(err) }
+        {
+          severity: "error",
+          code: "exception",
+          diagnostics: String(err)
+        }
       ]
     });
   }
 }
 
-// src/data/rest-api/routes/configuration/configuration.ts
+// src/data/rest-api/routes/control/configuration/configuration.ts
 var router = express.Router();
-router.get("/", listConfigurations);
-router.get("/:key", getConfigurationByKey);
-router.post("/", createConfiguration);
-router.put("/:key", updateConfiguration);
-router.delete("/:key", deleteConfiguration);
+router.get("/", listConfigurationsRoute);
+router.get("/:id", getConfigurationByIdRoute);
+router.post("/", createConfigurationRoute);
+router.put("/:id", updateConfigurationRoute);
+router.delete("/:id", deleteConfigurationRoute);
 
-// src/data/rest-api/routes/patient/patient.ts
+// src/data/rest-api/routes/data/encounter/encounter.ts
 import express2 from "express";
 
-// src/data/rest-api/routes/patient/patient-common.ts
-var BASE_PATH3 = "/Patient";
-var SK2 = "CURRENT";
-function requireJsonBody(req, res) {
-  const raw = req.body;
-  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
+// src/data/operations/data/encounter/encounter-create-operation.ts
+import { ulid } from "ulid";
+
+// src/data/audit-meta.ts
+var OPENHI_EXT = "http://openhi.org/fhir/StructureDefinition";
+function mergeAuditIntoMeta(meta, audit) {
+  const existing = meta ?? {};
+  const ext = [
+    ...Array.isArray(existing.extension) ? existing.extension : []
+  ];
+  const byUrl = new Map(ext.map((e) => [e.url, e]));
+  function set(url, value, type) {
+    if (value == null) return;
+    byUrl.set(url, { url, [type]: value });
+  }
+  set(`${OPENHI_EXT}/created-date`, audit.createdDate, "valueDateTime");
+  set(`${OPENHI_EXT}/created-by-id`, audit.createdById, "valueString");
+  set(`${OPENHI_EXT}/created-by-name`, audit.createdByName, "valueString");
+  set(`${OPENHI_EXT}/modified-date`, audit.modifiedDate, "valueDateTime");
+  set(`${OPENHI_EXT}/modified-by-id`, audit.modifiedById, "valueString");
+  set(`${OPENHI_EXT}/modified-by-name`, audit.modifiedByName, "valueString");
+  set(`${OPENHI_EXT}/deleted-date`, audit.deletedDate, "valueDateTime");
+  set(`${OPENHI_EXT}/deleted-by-id`, audit.deletedById, "valueString");
+  set(`${OPENHI_EXT}/deleted-by-name`, audit.deletedByName, "valueString");
+  return { ...existing, extension: Array.from(byUrl.values()) };
+}
+
+// src/data/dynamo/dynamo-data-service.ts
+import { Service as Service2 } from "electrodb";
+
+// src/data/dynamo/entities/data-entity-common.ts
+import { Entity as Entity2 } from "electrodb";
+var dataEntityAttributes = {
+  /** Sort key. "CURRENT" for current version; version history in S3. */
+  sk: {
+    type: "string",
+    required: true,
+    default: "CURRENT"
+  },
+  tenantId: {
+    type: "string",
+    required: true
+  },
+  workspaceId: {
+    type: "string",
+    required: true
+  },
+  /** FHIR Resource.id; logical id in URL and PK. */
+  id: {
+    type: "string",
+    required: true
+  },
+  /** FHIR resource as JSON string. JSON.stringify(resource) on write; JSON.parse(item.resource) on read. */
+  resource: {
+    type: "string",
+    required: true
+  },
+  /** Version id (e.g. ULID). Tracks current version; S3 history key. */
+  vid: {
+    type: "string",
+    required: true
+  },
+  lastUpdated: {
+    type: "string",
+    required: true
+  },
+  deleted: {
+    type: "boolean",
+    required: false
+  },
+  bundleId: {
+    type: "string",
+    required: false
+  },
+  msgId: {
+    type: "string",
+    required: false
+  }
+};
+function createDataEntity(entity, resourceTypeLabel) {
+  return new Entity2({
+    model: {
+      entity,
+      service: "data",
+      version: "01"
+    },
+    attributes: dataEntityAttributes,
+    indexes: {
+      /** Base table: PK, SK (data store key names). PK is built from tenantId, workspaceId, id. */
+      record: {
+        pk: {
+          field: "PK",
+          composite: ["tenantId", "workspaceId", "id"],
+          template: `TID#\${tenantId}#WID#\${workspaceId}#RT#${resourceTypeLabel}#ID#\${id}`
+        },
+        sk: {
+          field: "SK",
+          composite: ["sk"]
+        }
+      },
+      /** GSI4 — Resource Type Index: list all resources of this type in a workspace (no scan). Used by list operations (e.g. GET /Patient). */
+      gsi4: {
+        index: "GSI4",
+        pk: {
+          field: "GSI4PK",
+          composite: ["tenantId", "workspaceId"],
+          template: `TID#\${tenantId}#WID#\${workspaceId}#RT#${resourceTypeLabel}`
+        },
+        sk: {
+          field: "GSI4SK",
+          composite: ["id"],
+          template: `ID#\${id}`
+        }
+      }
+    }
+  });
+}
+
+// src/data/dynamo/entities/data/account-entity.ts
+var AccountEntity = createDataEntity("account", "Account");
+
+// src/data/dynamo/entities/data/activity-definition-entity.ts
+var ActivityDefinitionEntity = createDataEntity(
+  "activitydefinition",
+  "ActivityDefinition"
+);
+
+// src/data/dynamo/entities/data/adverse-event-entity.ts
+var AdverseEventEntity = createDataEntity(
+  "adverseevent",
+  "AdverseEvent"
+);
+
+// src/data/dynamo/entities/data/allergy-intolerance-entity.ts
+var AllergyIntoleranceEntity = createDataEntity(
+  "allergyintolerance",
+  "AllergyIntolerance"
+);
+
+// src/data/dynamo/entities/data/appointment-entity.ts
+var AppointmentEntity = createDataEntity("appointment", "Appointment");
+
+// src/data/dynamo/entities/data/appointment-response-entity.ts
+var AppointmentResponseEntity = createDataEntity(
+  "appointmentresponse",
+  "AppointmentResponse"
+);
+
+// src/data/dynamo/entities/data/audit-event-entity.ts
+var AuditEventEntity = createDataEntity("auditevent", "AuditEvent");
+
+// src/data/dynamo/entities/data/basic-entity.ts
+var BasicEntity = createDataEntity("basic", "Basic");
+
+// src/data/dynamo/entities/data/biologically-derived-product-entity.ts
+var BiologicallyDerivedProductEntity = createDataEntity(
+  "biologicallyderivedproduct",
+  "BiologicallyDerivedProduct"
+);
+
+// src/data/dynamo/entities/data/body-structure-entity.ts
+var BodyStructureEntity = createDataEntity(
+  "bodystructure",
+  "BodyStructure"
+);
+
+// src/data/dynamo/entities/data/care-plan-entity.ts
+var CarePlanEntity = createDataEntity("careplan", "CarePlan");
+
+// src/data/dynamo/entities/data/care-team-entity.ts
+var CareTeamEntity = createDataEntity("careteam", "CareTeam");
+
+// src/data/dynamo/entities/data/catalog-entry-entity.ts
+var CatalogEntryEntity = createDataEntity(
+  "catalogentry",
+  "CatalogEntry"
+);
+
+// src/data/dynamo/entities/data/charge-item-definition-entity.ts
+var ChargeItemDefinitionEntity = createDataEntity(
+  "chargeitemdefinition",
+  "ChargeItemDefinition"
+);
+
+// src/data/dynamo/entities/data/charge-item-entity.ts
+var ChargeItemEntity = createDataEntity("chargeitem", "ChargeItem");
+
+// src/data/dynamo/entities/data/claim-entity.ts
+var ClaimEntity = createDataEntity("claim", "Claim");
+
+// src/data/dynamo/entities/data/claim-response-entity.ts
+var ClaimResponseEntity = createDataEntity(
+  "claimresponse",
+  "ClaimResponse"
+);
+
+// src/data/dynamo/entities/data/clinical-impression-entity.ts
+var ClinicalImpressionEntity = createDataEntity(
+  "clinicalimpression",
+  "ClinicalImpression"
+);
+
+// src/data/dynamo/entities/data/communication-entity.ts
+var CommunicationEntity = createDataEntity(
+  "communication",
+  "Communication"
+);
+
+// src/data/dynamo/entities/data/communication-request-entity.ts
+var CommunicationRequestEntity = createDataEntity(
+  "communicationrequest",
+  "CommunicationRequest"
+);
+
+// src/data/dynamo/entities/data/composition-entity.ts
+var CompositionEntity = createDataEntity("composition", "Composition");
+
+// src/data/dynamo/entities/data/condition-entity.ts
+var ConditionEntity = createDataEntity("condition", "Condition");
+
+// src/data/dynamo/entities/data/consent-entity.ts
+var ConsentEntity = createDataEntity("consent", "Consent");
+
+// src/data/dynamo/entities/data/contract-entity.ts
+var ContractEntity = createDataEntity("contract", "Contract");
+
+// src/data/dynamo/entities/data/coverage-eligibility-request-entity.ts
+var CoverageEligibilityRequestEntity = createDataEntity(
+  "coverageeligibilityrequest",
+  "CoverageEligibilityRequest"
+);
+
+// src/data/dynamo/entities/data/coverage-eligibility-response-entity.ts
+var CoverageEligibilityResponseEntity = createDataEntity(
+  "coverageeligibilityresponse",
+  "CoverageEligibilityResponse"
+);
+
+// src/data/dynamo/entities/data/coverage-entity.ts
+var CoverageEntity = createDataEntity("coverage", "Coverage");
+
+// src/data/dynamo/entities/data/detected-issue-entity.ts
+var DetectedIssueEntity = createDataEntity(
+  "detectedissue",
+  "DetectedIssue"
+);
+
+// src/data/dynamo/entities/data/device-definition-entity.ts
+var DeviceDefinitionEntity = createDataEntity(
+  "devicedefinition",
+  "DeviceDefinition"
+);
+
+// src/data/dynamo/entities/data/device-entity.ts
+var DeviceEntity = createDataEntity("device", "Device");
+
+// src/data/dynamo/entities/data/device-metric-entity.ts
+var DeviceMetricEntity = createDataEntity(
+  "devicemetric",
+  "DeviceMetric"
+);
+
+// src/data/dynamo/entities/data/device-request-entity.ts
+var DeviceRequestEntity = createDataEntity(
+  "devicerequest",
+  "DeviceRequest"
+);
+
+// src/data/dynamo/entities/data/device-use-statement-entity.ts
+var DeviceUseStatementEntity = createDataEntity(
+  "deviceusestatement",
+  "DeviceUseStatement"
+);
+
+// src/data/dynamo/entities/data/diagnostic-report-entity.ts
+var DiagnosticReportEntity = createDataEntity(
+  "diagnosticreport",
+  "DiagnosticReport"
+);
+
+// src/data/dynamo/entities/data/document-manifest-entity.ts
+var DocumentManifestEntity = createDataEntity(
+  "documentmanifest",
+  "DocumentManifest"
+);
+
+// src/data/dynamo/entities/data/document-reference-entity.ts
+var DocumentReferenceEntity = createDataEntity(
+  "documentreference",
+  "DocumentReference"
+);
+
+// src/data/dynamo/entities/data/effect-evidence-synthesis-entity.ts
+var EffectEvidenceSynthesisEntity = createDataEntity(
+  "effectevidencesynthesis",
+  "EffectEvidenceSynthesis"
+);
+
+// src/data/dynamo/entities/data/encounter-entity.ts
+var EncounterEntity = createDataEntity("encounter", "Encounter");
+
+// src/data/dynamo/entities/data/endpoint-entity.ts
+var EndpointEntity = createDataEntity("endpoint", "Endpoint");
+
+// src/data/dynamo/entities/data/enrollment-request-entity.ts
+var EnrollmentRequestEntity = createDataEntity(
+  "enrollmentrequest",
+  "EnrollmentRequest"
+);
+
+// src/data/dynamo/entities/data/enrollment-response-entity.ts
+var EnrollmentResponseEntity = createDataEntity(
+  "enrollmentresponse",
+  "EnrollmentResponse"
+);
+
+// src/data/dynamo/entities/data/episode-of-care-entity.ts
+var EpisodeOfCareEntity = createDataEntity(
+  "episodeofcare",
+  "EpisodeOfCare"
+);
+
+// src/data/dynamo/entities/data/event-definition-entity.ts
+var EventDefinitionEntity = createDataEntity(
+  "eventdefinition",
+  "EventDefinition"
+);
+
+// src/data/dynamo/entities/data/evidence-entity.ts
+var EvidenceEntity = createDataEntity("evidence", "Evidence");
+
+// src/data/dynamo/entities/data/evidence-variable-entity.ts
+var EvidenceVariableEntity = createDataEntity(
+  "evidencevariable",
+  "EvidenceVariable"
+);
+
+// src/data/dynamo/entities/data/explanation-of-benefit-entity.ts
+var ExplanationOfBenefitEntity = createDataEntity(
+  "explanationofbenefit",
+  "ExplanationOfBenefit"
+);
+
+// src/data/dynamo/entities/data/family-member-history-entity.ts
+var FamilyMemberHistoryEntity = createDataEntity(
+  "familymemberhistory",
+  "FamilyMemberHistory"
+);
+
+// src/data/dynamo/entities/data/flag-entity.ts
+var FlagEntity = createDataEntity("flag", "Flag");
+
+// src/data/dynamo/entities/data/goal-entity.ts
+var GoalEntity = createDataEntity("goal", "Goal");
+
+// src/data/dynamo/entities/data/group-entity.ts
+var GroupEntity = createDataEntity("group", "Group");
+
+// src/data/dynamo/entities/data/guidance-response-entity.ts
+var GuidanceResponseEntity = createDataEntity(
+  "guidanceresponse",
+  "GuidanceResponse"
+);
+
+// src/data/dynamo/entities/data/healthcare-service-entity.ts
+var HealthcareServiceEntity = createDataEntity(
+  "healthcareservice",
+  "HealthcareService"
+);
+
+// src/data/dynamo/entities/data/imaging-study-entity.ts
+var ImagingStudyEntity = createDataEntity(
+  "imagingstudy",
+  "ImagingStudy"
+);
+
+// src/data/dynamo/entities/data/immunization-entity.ts
+var ImmunizationEntity = createDataEntity(
+  "immunization",
+  "Immunization"
+);
+
+// src/data/dynamo/entities/data/immunization-evaluation-entity.ts
+var ImmunizationEvaluationEntity = createDataEntity(
+  "immunizationevaluation",
+  "ImmunizationEvaluation"
+);
+
+// src/data/dynamo/entities/data/immunization-recommendation-entity.ts
+var ImmunizationRecommendationEntity = createDataEntity(
+  "immunizationrecommendation",
+  "ImmunizationRecommendation"
+);
+
+// src/data/dynamo/entities/data/insurance-plan-entity.ts
+var InsurancePlanEntity = createDataEntity(
+  "insuranceplan",
+  "InsurancePlan"
+);
+
+// src/data/dynamo/entities/data/invoice-entity.ts
+var InvoiceEntity = createDataEntity("invoice", "Invoice");
+
+// src/data/dynamo/entities/data/library-entity.ts
+var LibraryEntity = createDataEntity("library", "Library");
+
+// src/data/dynamo/entities/data/linkage-entity.ts
+var LinkageEntity = createDataEntity("linkage", "Linkage");
+
+// src/data/dynamo/entities/data/list-entity.ts
+var ListEntity = createDataEntity("list", "List");
+
+// src/data/dynamo/entities/data/location-entity.ts
+var LocationEntity = createDataEntity("location", "Location");
+
+// src/data/dynamo/entities/data/measure-entity.ts
+var MeasureEntity = createDataEntity("measure", "Measure");
+
+// src/data/dynamo/entities/data/measure-report-entity.ts
+var MeasureReportEntity = createDataEntity(
+  "measurereport",
+  "MeasureReport"
+);
+
+// src/data/dynamo/entities/data/media-entity.ts
+var MediaEntity = createDataEntity("media", "Media");
+
+// src/data/dynamo/entities/data/medication-administration-entity.ts
+var MedicationAdministrationEntity = createDataEntity(
+  "medicationadministration",
+  "MedicationAdministration"
+);
+
+// src/data/dynamo/entities/data/medication-dispense-entity.ts
+var MedicationDispenseEntity = createDataEntity(
+  "medicationdispense",
+  "MedicationDispense"
+);
+
+// src/data/dynamo/entities/data/medication-entity.ts
+var MedicationEntity = createDataEntity("medication", "Medication");
+
+// src/data/dynamo/entities/data/medication-knowledge-entity.ts
+var MedicationKnowledgeEntity = createDataEntity(
+  "medicationknowledge",
+  "MedicationKnowledge"
+);
+
+// src/data/dynamo/entities/data/medication-request-entity.ts
+var MedicationRequestEntity = createDataEntity(
+  "medicationrequest",
+  "MedicationRequest"
+);
+
+// src/data/dynamo/entities/data/medication-statement-entity.ts
+var MedicationStatementEntity = createDataEntity(
+  "medicationstatement",
+  "MedicationStatement"
+);
+
+// src/data/dynamo/entities/data/message-header-entity.ts
+var MessageHeaderEntity = createDataEntity(
+  "messageheader",
+  "MessageHeader"
+);
+
+// src/data/dynamo/entities/data/molecular-sequence-entity.ts
+var MolecularSequenceEntity = createDataEntity(
+  "molecularsequence",
+  "MolecularSequence"
+);
+
+// src/data/dynamo/entities/data/nutrition-order-entity.ts
+var NutritionOrderEntity = createDataEntity(
+  "nutritionorder",
+  "NutritionOrder"
+);
+
+// src/data/dynamo/entities/data/observation-entity.ts
+var ObservationEntity = createDataEntity("observation", "Observation");
+
+// src/data/dynamo/entities/data/organization-affiliation-entity.ts
+var OrganizationAffiliationEntity = createDataEntity(
+  "organizationaffiliation",
+  "OrganizationAffiliation"
+);
+
+// src/data/dynamo/entities/data/organization-entity.ts
+var OrganizationEntity = createDataEntity(
+  "organization",
+  "Organization"
+);
+
+// src/data/dynamo/entities/data/patient-entity.ts
+var PatientEntity = createDataEntity("patient", "Patient");
+
+// src/data/dynamo/entities/data/payment-notice-entity.ts
+var PaymentNoticeEntity = createDataEntity(
+  "paymentnotice",
+  "PaymentNotice"
+);
+
+// src/data/dynamo/entities/data/payment-reconciliation-entity.ts
+var PaymentReconciliationEntity = createDataEntity(
+  "paymentreconciliation",
+  "PaymentReconciliation"
+);
+
+// src/data/dynamo/entities/data/person-entity.ts
+var PersonEntity = createDataEntity("person", "Person");
+
+// src/data/dynamo/entities/data/plan-definition-entity.ts
+var PlanDefinitionEntity = createDataEntity(
+  "plandefinition",
+  "PlanDefinition"
+);
+
+// src/data/dynamo/entities/data/practitioner-entity.ts
+var PractitionerEntity = createDataEntity(
+  "practitioner",
+  "Practitioner"
+);
+
+// src/data/dynamo/entities/data/practitioner-role-entity.ts
+var PractitionerRoleEntity = createDataEntity(
+  "practitionerrole",
+  "PractitionerRole"
+);
+
+// src/data/dynamo/entities/data/procedure-entity.ts
+var ProcedureEntity = createDataEntity("procedure", "Procedure");
+
+// src/data/dynamo/entities/data/provenance-entity.ts
+var ProvenanceEntity = createDataEntity("provenance", "Provenance");
+
+// src/data/dynamo/entities/data/questionnaire-entity.ts
+var QuestionnaireEntity = createDataEntity(
+  "questionnaire",
+  "Questionnaire"
+);
+
+// src/data/dynamo/entities/data/questionnaire-response-entity.ts
+var QuestionnaireResponseEntity = createDataEntity(
+  "questionnaireresponse",
+  "QuestionnaireResponse"
+);
+
+// src/data/dynamo/entities/data/related-person-entity.ts
+var RelatedPersonEntity = createDataEntity(
+  "relatedperson",
+  "RelatedPerson"
+);
+
+// src/data/dynamo/entities/data/request-group-entity.ts
+var RequestGroupEntity = createDataEntity(
+  "requestgroup",
+  "RequestGroup"
+);
+
+// src/data/dynamo/entities/data/research-study-entity.ts
+var ResearchStudyEntity = createDataEntity(
+  "researchstudy",
+  "ResearchStudy"
+);
+
+// src/data/dynamo/entities/data/research-subject-entity.ts
+var ResearchSubjectEntity = createDataEntity(
+  "researchsubject",
+  "ResearchSubject"
+);
+
+// src/data/dynamo/entities/data/risk-assessment-entity.ts
+var RiskAssessmentEntity = createDataEntity(
+  "riskassessment",
+  "RiskAssessment"
+);
+
+// src/data/dynamo/entities/data/risk-evidence-synthesis-entity.ts
+var RiskEvidenceSynthesisEntity = createDataEntity(
+  "riskevidencesynthesis",
+  "RiskEvidenceSynthesis"
+);
+
+// src/data/dynamo/entities/data/schedule-entity.ts
+var ScheduleEntity = createDataEntity("schedule", "Schedule");
+
+// src/data/dynamo/entities/data/service-request-entity.ts
+var ServiceRequestEntity = createDataEntity(
+  "servicerequest",
+  "ServiceRequest"
+);
+
+// src/data/dynamo/entities/data/slot-entity.ts
+var SlotEntity = createDataEntity("slot", "Slot");
+
+// src/data/dynamo/entities/data/specimen-entity.ts
+var SpecimenEntity = createDataEntity("specimen", "Specimen");
+
+// src/data/dynamo/entities/data/subscription-entity.ts
+var SubscriptionEntity = createDataEntity(
+  "subscription",
+  "Subscription"
+);
+
+// src/data/dynamo/entities/data/substance-entity.ts
+var SubstanceEntity = createDataEntity("substance", "Substance");
+
+// src/data/dynamo/entities/data/supply-delivery-entity.ts
+var SupplyDeliveryEntity = createDataEntity(
+  "supplydelivery",
+  "SupplyDelivery"
+);
+
+// src/data/dynamo/entities/data/supply-request-entity.ts
+var SupplyRequestEntity = createDataEntity(
+  "supplyrequest",
+  "SupplyRequest"
+);
+
+// src/data/dynamo/entities/data/task-entity.ts
+var TaskEntity = createDataEntity("task", "Task");
+
+// src/data/dynamo/entities/data/verification-result-entity.ts
+var VerificationResultEntity = createDataEntity(
+  "verificationresult",
+  "VerificationResult"
+);
+
+// src/data/dynamo/entities/data/vision-prescription-entity.ts
+var VisionPrescriptionEntity = createDataEntity(
+  "visionprescription",
+  "VisionPrescription"
+);
+
+// src/data/dynamo/dynamo-data-service.ts
+var dataPlaneEntities = {
+  account: AccountEntity,
+  activitydefinition: ActivityDefinitionEntity,
+  adverseevent: AdverseEventEntity,
+  allergyintolerance: AllergyIntoleranceEntity,
+  auditevent: AuditEventEntity,
+  basic: BasicEntity,
+  biologicallyderivedproduct: BiologicallyDerivedProductEntity,
+  bodystructure: BodyStructureEntity,
+  appointment: AppointmentEntity,
+  appointmentresponse: AppointmentResponseEntity,
+  careplan: CarePlanEntity,
+  careteam: CareTeamEntity,
+  catalogentry: CatalogEntryEntity,
+  chargeitem: ChargeItemEntity,
+  chargeitemdefinition: ChargeItemDefinitionEntity,
+  claim: ClaimEntity,
+  claimresponse: ClaimResponseEntity,
+  clinicalimpression: ClinicalImpressionEntity,
+  communication: CommunicationEntity,
+  communicationrequest: CommunicationRequestEntity,
+  composition: CompositionEntity,
+  condition: ConditionEntity,
+  consent: ConsentEntity,
+  contract: ContractEntity,
+  coverage: CoverageEntity,
+  coverageeligibilityrequest: CoverageEligibilityRequestEntity,
+  coverageeligibilityresponse: CoverageEligibilityResponseEntity,
+  detectedissue: DetectedIssueEntity,
+  device: DeviceEntity,
+  devicedefinition: DeviceDefinitionEntity,
+  devicemetric: DeviceMetricEntity,
+  devicerequest: DeviceRequestEntity,
+  deviceusestatement: DeviceUseStatementEntity,
+  diagnosticreport: DiagnosticReportEntity,
+  documentmanifest: DocumentManifestEntity,
+  documentreference: DocumentReferenceEntity,
+  effectevidencesynthesis: EffectEvidenceSynthesisEntity,
+  encounter: EncounterEntity,
+  endpoint: EndpointEntity,
+  enrollmentrequest: EnrollmentRequestEntity,
+  enrollmentresponse: EnrollmentResponseEntity,
+  episodeofcare: EpisodeOfCareEntity,
+  eventdefinition: EventDefinitionEntity,
+  evidence: EvidenceEntity,
+  evidencevariable: EvidenceVariableEntity,
+  explanationofbenefit: ExplanationOfBenefitEntity,
+  familymemberhistory: FamilyMemberHistoryEntity,
+  flag: FlagEntity,
+  goal: GoalEntity,
+  group: GroupEntity,
+  guidanceresponse: GuidanceResponseEntity,
+  healthcareservice: HealthcareServiceEntity,
+  immunization: ImmunizationEntity,
+  immunizationevaluation: ImmunizationEvaluationEntity,
+  immunizationrecommendation: ImmunizationRecommendationEntity,
+  imagingstudy: ImagingStudyEntity,
+  insuranceplan: InsurancePlanEntity,
+  invoice: InvoiceEntity,
+  library: LibraryEntity,
+  linkage: LinkageEntity,
+  list: ListEntity,
+  location: LocationEntity,
+  medication: MedicationEntity,
+  medicationadministration: MedicationAdministrationEntity,
+  medicationdispense: MedicationDispenseEntity,
+  medicationknowledge: MedicationKnowledgeEntity,
+  medicationrequest: MedicationRequestEntity,
+  medicationstatement: MedicationStatementEntity,
+  media: MediaEntity,
+  measure: MeasureEntity,
+  measurereport: MeasureReportEntity,
+  messageheader: MessageHeaderEntity,
+  molecularsequence: MolecularSequenceEntity,
+  nutritionorder: NutritionOrderEntity,
+  observation: ObservationEntity,
+  organization: OrganizationEntity,
+  organizationaffiliation: OrganizationAffiliationEntity,
+  patient: PatientEntity,
+  paymentnotice: PaymentNoticeEntity,
+  paymentreconciliation: PaymentReconciliationEntity,
+  person: PersonEntity,
+  plandefinition: PlanDefinitionEntity,
+  practitioner: PractitionerEntity,
+  practitionerrole: PractitionerRoleEntity,
+  procedure: ProcedureEntity,
+  provenance: ProvenanceEntity,
+  questionnaire: QuestionnaireEntity,
+  questionnaireresponse: QuestionnaireResponseEntity,
+  requestgroup: RequestGroupEntity,
+  relatedperson: RelatedPersonEntity,
+  researchstudy: ResearchStudyEntity,
+  researchsubject: ResearchSubjectEntity,
+  riskassessment: RiskAssessmentEntity,
+  riskevidencesynthesis: RiskEvidenceSynthesisEntity,
+  schedule: ScheduleEntity,
+  servicerequest: ServiceRequestEntity,
+  specimen: SpecimenEntity,
+  substance: SubstanceEntity,
+  subscription: SubscriptionEntity,
+  supplydelivery: SupplyDeliveryEntity,
+  supplyrequest: SupplyRequestEntity,
+  slot: SlotEntity,
+  task: TaskEntity,
+  visionprescription: VisionPrescriptionEntity,
+  verificationresult: VerificationResultEntity
+};
+var dataPlaneService = new Service2(dataPlaneEntities, {
+  table: defaultTableName,
+  client: dynamoClient
+});
+var DynamoDataService = {
+  entities: dataPlaneService.entities
+};
+function getDynamoDataService(tableName) {
+  const resolved = tableName ?? defaultTableName;
+  const service = new Service2(dataPlaneEntities, {
+    table: resolved,
+    client: dynamoClient
+  });
+  return {
+    entities: service.entities
+  };
+}
+
+// src/data/operations/data-operations-common.ts
+var DATA_ENTITY_SK = "CURRENT";
+async function getDataEntityById(entity, tenantId, workspaceId, id, resourceLabel) {
+  const result = await entity.get({
+    tenantId,
+    workspaceId,
+    id,
+    sk: DATA_ENTITY_SK
+  }).go();
+  if (!result.data) {
+    throw new NotFoundError(`${resourceLabel} ${id} not found`, {
+      details: { id }
+    });
+  }
+  const parsed = JSON.parse(decompressResource(result.data.resource));
+  return {
+    id: result.data.id,
+    resource: { ...parsed, id: result.data.id }
+  };
+}
+async function deleteDataEntityById(entity, tenantId, workspaceId, id) {
+  await entity.delete({
+    tenantId,
+    workspaceId,
+    id,
+    sk: DATA_ENTITY_SK
+  }).go();
+}
+async function listDataEntitiesByWorkspace(entity, tenantId, workspaceId) {
+  const result = await entity.query.gsi4({ tenantId, workspaceId }).go();
+  const items = result.data ?? [];
+  const entries = items.map((item) => {
+    const parsed = JSON.parse(decompressResource(item.resource));
     return {
-      errorResponse: res.status(400).json({
-        resourceType: "OperationOutcome",
-        issue: [
-          {
-            severity: "error",
-            code: "invalid",
-            diagnostics: "Request body must be a JSON object."
-          }
-        ]
-      })
+      id: item.id,
+      resource: { ...parsed, id: item.id }
     };
+  });
+  return { entries };
+}
+async function createDataEntityRecord(entity, tenantId, workspaceId, id, resourceWithAudit, fallbackDate) {
+  const lastUpdated = resourceWithAudit.meta?.lastUpdated ?? fallbackDate ?? (/* @__PURE__ */ new Date()).toISOString();
+  const vid = lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36);
+  await entity.put({
+    sk: DATA_ENTITY_SK,
+    tenantId,
+    workspaceId,
+    id,
+    resource: compressResource(JSON.stringify(resourceWithAudit)),
+    vid,
+    lastUpdated
+  }).go();
+  return {
+    id,
+    resource: resourceWithAudit
+  };
+}
+async function updateDataEntityById(entity, tenantId, workspaceId, id, resourceLabel, context, buildPatched) {
+  const existing = await entity.get({
+    tenantId,
+    workspaceId,
+    id,
+    sk: DATA_ENTITY_SK
+  }).go();
+  if (!existing.data) {
+    throw new NotFoundError(`${resourceLabel} ${id} not found`, {
+      details: { id }
+    });
+  }
+  const existingStr = decompressResource(existing.data.resource);
+  const { resource, lastUpdated } = buildPatched(existingStr);
+  await entity.patch({
+    tenantId,
+    workspaceId,
+    id,
+    sk: DATA_ENTITY_SK
+  }).set({
+    resource: compressResource(JSON.stringify(resource)),
+    lastUpdated
+  }).go();
+  return {
+    id,
+    resource
+  };
+}
+
+// src/data/operations/data/encounter/encounter-create-operation.ts
+async function createEncounterOperation(params) {
+  const { context, body, id: optionalId, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const id = body.id ?? optionalId ?? ulid();
+  const meta = {
+    ...body.meta ?? {},
+    lastUpdated: date,
+    versionId: "1"
+  };
+  const encounterWithAudit = {
+    ...body,
+    resourceType: "Encounter",
+    id,
+    meta: mergeAuditIntoMeta(meta, {
+      createdDate: date,
+      createdById: actorId,
+      createdByName: actorName,
+      modifiedDate: date,
+      modifiedById: actorId,
+      modifiedByName: actorName
+    })
+  };
+  const service = getDynamoDataService(tableName);
+  return createDataEntityRecord(
+    service.entities.encounter,
+    tenantId,
+    workspaceId,
+    id,
+    encounterWithAudit,
+    date
+  );
+}
+
+// src/data/rest-api/routes/data/encounter/encounter-create-route.ts
+async function createEncounterRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const encounter = {
+    ...body,
+    resourceType: "Encounter"
+  };
+  try {
+    const result = await createEncounterOperation({
+      context: ctx,
+      body: encounter
+    });
+    return res.status(201).location(`${BASE_PATH.ENCOUNTER}/${result.id}`).json(result.resource);
+  } catch (err) {
+    console.error("POST Encounter error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        { severity: "error", code: "exception", diagnostics: String(err) }
+      ]
+    });
+  }
+}
+
+// src/data/operations/data/encounter/encounter-delete-operation.ts
+async function deleteEncounterOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.encounter,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/encounter/encounter-delete-route.ts
+async function deleteEncounterRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    await deleteEncounterOperation({ context: ctx, id });
+    return res.status(204).send();
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "DELETE Encounter error:");
+  }
+}
+
+// src/data/operations/data/encounter/encounter-get-by-id-operation.ts
+async function getEncounterByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.encounter,
+    tenantId,
+    workspaceId,
+    id,
+    "Encounter"
+  );
+}
+
+// src/data/rest-api/routes/data/encounter/encounter-get-by-id-route.ts
+async function getEncounterByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    const result = await getEncounterByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Encounter ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Encounter error:");
+  }
+}
+
+// src/data/operations/data/encounter/encounter-list-operation.ts
+async function listEncountersOperation(params) {
+  const { context, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.encounter,
+    tenantId,
+    workspaceId
+  );
+}
+
+// src/data/rest-api/routes/data/encounter/encounter-list-route.ts
+async function listEncountersRoute(req, res) {
+  const ctx = req.openhiContext;
+  try {
+    const result = await listEncountersOperation({ context: ctx });
+    const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Encounter list error:");
+  }
+}
+
+// src/data/operations/data/encounter/encounter-update-operation.ts
+async function updateEncounterOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.encounter,
+    tenantId,
+    workspaceId,
+    id,
+    "Encounter",
+    context,
+    (existingResourceStr) => {
+      const bodyWithResource = body;
+      const existingMeta = JSON.parse(existingResourceStr).meta;
+      const encounter = {
+        ...body,
+        resourceType: "Encounter",
+        id,
+        meta: {
+          ...bodyWithResource.meta ?? {},
+          lastUpdated: date,
+          versionId: "2"
+        }
+      };
+      const encounterWithMeta = {
+        ...encounter,
+        meta: mergeAuditIntoMeta(encounter.meta ?? existingMeta, {
+          modifiedDate: date,
+          modifiedById: actorId,
+          modifiedByName: actorName
+        })
+      };
+      return {
+        resource: encounterWithMeta,
+        lastUpdated: date
+      };
+    }
+  );
+}
+
+// src/data/rest-api/routes/data/encounter/encounter-update-route.ts
+async function updateEncounterRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const encounter = {
+    ...body,
+    resourceType: "Encounter",
+    id,
+    meta: {
+      ...body?.meta ?? {},
+      lastUpdated: ctx.date,
+      versionId: "2"
+    }
+  };
+  try {
+    const result = await updateEncounterOperation({
+      context: ctx,
+      id,
+      body: encounter
+    });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Encounter ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "PUT Encounter error:");
   }
-  return { body: raw };
 }
 
+// src/data/rest-api/routes/data/encounter/encounter.ts
+var router2 = express2.Router();
+router2.get("/", listEncountersRoute);
+router2.get("/:id", getEncounterByIdRoute);
+router2.post("/", createEncounterRoute);
+router2.put("/:id", updateEncounterRoute);
+router2.delete("/:id", deleteEncounterRoute);
+
+// src/data/rest-api/routes/data/patient/patient.ts
+import express3 from "express";
+
+// src/data/operations/data/patient/patient-create-operation.ts
+import { ulid as ulid2 } from "ulid";
+
 // src/data/import-patient.ts
 import { readFileSync } from "fs";
 import { resolve } from "path";
-var OPENHI_EXT = "http://openhi.org/fhir/StructureDefinition";
-function mergeAuditIntoMeta(meta, audit) {
-  const existing = meta ?? {};
-  const ext = [
-    ...Array.isArray(existing.extension) ? existing.extension : []
-  ];
-  const byUrl = new Map(ext.map((e) => [e.url, e]));
-  function set(url, value, type) {
-    if (value == null) return;
-    byUrl.set(url, { url, [type]: value });
-  }
-  set(`${OPENHI_EXT}/created-date`, audit.createdDate, "valueDateTime");
-  set(`${OPENHI_EXT}/created-by-id`, audit.createdById, "valueString");
-  set(`${OPENHI_EXT}/created-by-name`, audit.createdByName, "valueString");
-  set(`${OPENHI_EXT}/modified-date`, audit.modifiedDate, "valueDateTime");
-  set(`${OPENHI_EXT}/modified-by-id`, audit.modifiedById, "valueString");
-  set(`${OPENHI_EXT}/modified-by-name`, audit.modifiedByName, "valueString");
-  set(`${OPENHI_EXT}/deleted-date`, audit.deletedDate, "valueDateTime");
-  set(`${OPENHI_EXT}/deleted-by-id`, audit.deletedById, "valueString");
-  set(`${OPENHI_EXT}/deleted-by-name`, audit.deletedByName, "valueString");
-  return { ...existing, extension: Array.from(byUrl.values()) };
-}
 function extractPatient(parsed) {
   if (parsed && typeof parsed === "object" && "resourceType" in parsed) {
     const root = parsed;
@@ -859,7 +1928,7 @@ function extractPatient(parsed) {
     "File must be a FHIR Patient resource or a Bundle containing at least one Patient entry"
   );
 }
-var SK3 = "CURRENT";
+var SK5 = "CURRENT";
 var defaultAudit = {
   createdDate: (/* @__PURE__ */ new Date()).toISOString(),
   createdById: "import",
@@ -897,7 +1966,7 @@ function patientToPutAttrs(patient, options) {
     patientWithMeta.meta.lastUpdated = lastUpdated;
   }
   return {
-    sk: SK3,
+    sk: SK5,
     tenantId,
     workspaceId,
     id: patient.id,
@@ -953,23 +2022,21 @@ if (__require.main === module) {
   void main();
 }
 
-// src/data/rest-api/routes/patient/patient-create.ts
-async function createPatient(req, res) {
-  const bodyResult = requireJsonBody(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
-  const ctx = req.openhiContext;
-  const { tenantId, workspaceId, date, actorId, actorName } = ctx;
-  const body = bodyResult.body;
-  const id = body?.id ?? `patient-${Date.now()}`;
+// src/data/operations/data/patient/patient-create-operation.ts
+async function createPatientOperation(params) {
+  const { context, body, id: optionalId } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const id = body.id ?? optionalId ?? ulid2();
+  const meta = {
+    ...body.meta ?? {},
+    lastUpdated: date,
+    versionId: "1"
+  };
   const patient = {
     ...body,
     resourceType: "Patient",
     id,
-    meta: {
-      ...body?.meta ?? {},
-      lastUpdated: date,
-      versionId: "1"
-    }
+    meta
   };
   const options = {
     tenantId,
@@ -981,13 +2048,31 @@ async function createPatient(req, res) {
     modifiedById: actorId,
     modifiedByName: actorName
   };
-  const service = getDynamoDataService();
+  const service = getDynamoDataService(params.tableName);
+  const attrs = patientToPutAttrs(patient, options);
+  await service.entities.patient.put(attrs).go();
+  return {
+    id,
+    resource: patient
+  };
+}
+
+// src/data/rest-api/routes/data/patient/patient-create-route.ts
+async function createPatientRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const patient = {
+    ...body,
+    resourceType: "Patient"
+  };
   try {
-    const attrs = patientToPutAttrs(patient, options);
-    await service.entities.patient.put(
-      attrs
-    ).go();
-    return res.status(201).location(`${BASE_PATH3}/${id}`).json(patient);
+    const result = await createPatientOperation({
+      context: ctx,
+      body: patient
+    });
+    return res.status(201).location(`${BASE_PATH.PATIENT}/${result.id}`).json(result.resource);
   } catch (err) {
     console.error("POST Patient error:", err);
     return res.status(500).json({
@@ -999,180 +2084,409 @@ async function createPatient(req, res) {
   }
 }
 
-// src/data/rest-api/routes/patient/patient-delete.ts
-async function deletePatient(req, res) {
+// src/data/operations/data/patient/patient-delete-operation.ts
+async function deletePatientOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-delete-route.ts
+async function deletePatientRoute(req, res) {
   const id = String(req.params.id);
-  const { tenantId, workspaceId } = req.openhiContext;
-  const service = getDynamoDataService();
+  const ctx = req.openhiContext;
   try {
-    await service.entities.patient.delete({ tenantId, workspaceId, id, sk: SK2 }).go();
+    await deletePatientOperation({ context: ctx, id });
     return res.status(204).send();
   } catch (err) {
-    console.error("DELETE Patient error:", err);
-    return res.status(500).json({
-      resourceType: "OperationOutcome",
-      issue: [
-        { severity: "error", code: "exception", diagnostics: String(err) }
-      ]
-    });
+    return sendOperationOutcome500(res, err, "DELETE Patient error:");
   }
 }
 
-// src/data/rest-api/routes/patient/patient-get-by-id.ts
-async function getPatientById(req, res) {
+// src/data/operations/data/patient/patient-get-by-id-operation.ts
+async function getPatientByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id,
+    "Patient"
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-get-by-id-route.ts
+async function getPatientByIdRoute(req, res) {
   const id = String(req.params.id);
-  const { tenantId, workspaceId } = req.openhiContext;
-  const service = getDynamoDataService();
+  const ctx = req.openhiContext;
   try {
-    const result = await service.entities.patient.get({ tenantId, workspaceId, id, sk: SK2 }).go();
-    if (!result.data) {
-      return res.status(404).json({
-        resourceType: "OperationOutcome",
-        issue: [
-          {
-            severity: "error",
-            code: "not-found",
-            diagnostics: `Patient ${id} not found`
-          }
-        ]
-      });
+    const result = await getPatientByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
     }
-    const resource = JSON.parse(
-      decompressResource(result.data.resource)
-    );
-    return res.json({ ...resource, id: result.data.id });
+    return sendOperationOutcome500(res, err, "GET Patient error:");
+  }
+}
+
+// src/data/operations/data/patient/patient-list-operation.ts
+async function listPatientsOperation(params) {
+  const { context, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.patient,
+    tenantId,
+    workspaceId
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-list-route.ts
+async function listPatientsRoute(req, res) {
+  const ctx = req.openhiContext;
+  try {
+    const result = await listPatientsOperation({ context: ctx });
+    const bundle = buildSearchsetBundle(BASE_PATH.PATIENT, result.entries);
+    return res.json(bundle);
   } catch (err) {
-    console.error("GET Patient error:", err);
-    return res.status(500).json({
-      resourceType: "OperationOutcome",
-      issue: [
-        {
-          severity: "error",
-          code: "exception",
-          diagnostics: String(err)
+    return sendOperationOutcome500(res, err, "GET /Patient list error:");
+  }
+}
+
+// src/data/operations/data/patient/patient-update-operation.ts
+async function updatePatientOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id,
+    "Patient",
+    context,
+    (existingResourceStr) => {
+      const bodyWithResource = body;
+      const existingMeta = JSON.parse(existingResourceStr).meta;
+      const patient = {
+        ...body,
+        resourceType: "Patient",
+        id,
+        meta: {
+          ...bodyWithResource.meta ?? {},
+          lastUpdated: date,
+          versionId: "2"
         }
-      ]
+      };
+      const patientWithMeta = {
+        ...patient,
+        meta: mergeAuditIntoMeta(patient.meta ?? existingMeta, {
+          modifiedDate: date,
+          modifiedById: actorId,
+          modifiedByName: actorName
+        })
+      };
+      return {
+        resource: patientWithMeta,
+        lastUpdated: date
+      };
+    }
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-update-route.ts
+async function updatePatientRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const patient = {
+    ...body,
+    resourceType: "Patient",
+    id
+  };
+  try {
+    const result = await updatePatientOperation({
+      context: ctx,
+      id,
+      body: patient
     });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "PUT Patient error:");
   }
 }
 
-// src/data/rest-api/routes/patient/patient-list.ts
-async function listPatients(req, res) {
-  const { tenantId, workspaceId } = req.openhiContext;
-  const service = getDynamoDataService();
+// src/data/rest-api/routes/data/patient/patient.ts
+var router3 = express3.Router();
+router3.get("/", listPatientsRoute);
+router3.get("/:id", getPatientByIdRoute);
+router3.post("/", createPatientRoute);
+router3.put("/:id", updatePatientRoute);
+router3.delete("/:id", deletePatientRoute);
+
+// src/data/rest-api/routes/data/practitioner/practitioner.ts
+import express4 from "express";
+
+// src/data/operations/data/practitioner/practitioner-create-operation.ts
+import { ulid as ulid3 } from "ulid";
+async function createPractitionerOperation(params) {
+  const { context, body, id: optionalId, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const id = body.id ?? optionalId ?? ulid3();
+  const meta = {
+    ...body.meta ?? {},
+    lastUpdated: date,
+    versionId: "1"
+  };
+  const practitionerWithAudit = {
+    ...body,
+    resourceType: "Practitioner",
+    id,
+    meta: mergeAuditIntoMeta(meta, {
+      createdDate: date,
+      createdById: actorId,
+      createdByName: actorName,
+      modifiedDate: date,
+      modifiedById: actorId,
+      modifiedByName: actorName
+    })
+  };
+  const service = getDynamoDataService(tableName);
+  return createDataEntityRecord(
+    service.entities.practitioner,
+    tenantId,
+    workspaceId,
+    id,
+    practitionerWithAudit,
+    date
+  );
+}
+
+// src/data/rest-api/routes/data/practitioner/practitioner-create-route.ts
+async function createPractitionerRoute(req, res) {
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const practitioner = {
+    ...body,
+    resourceType: "Practitioner"
+  };
   try {
-    const result = await service.entities.patient.query.gsi4({ tenantId, workspaceId }).go();
-    const entries = (result.data ?? []).map((item) => {
-      const resource = JSON.parse(decompressResource(item.resource));
-      return {
-        fullUrl: `${BASE_PATH3}/${item.id}`,
-        resource: { ...resource, id: item.id }
-      };
+    const result = await createPractitionerOperation({
+      context: ctx,
+      body: practitioner
     });
-    const bundle = {
-      resourceType: "Bundle",
-      type: "searchset",
-      total: entries.length,
-      link: [{ relation: "self", url: BASE_PATH3 }],
-      entry: entries
-    };
-    return res.json(bundle);
+    return res.status(201).location(`${BASE_PATH.PRACTITIONER}/${result.id}`).json(result.resource);
   } catch (err) {
-    console.error("GET /Patient list error:", err);
+    console.error("POST Practitioner error:", err);
     return res.status(500).json({
       resourceType: "OperationOutcome",
       issue: [
-        {
-          severity: "error",
-          code: "exception",
-          diagnostics: String(err)
-        }
+        { severity: "error", code: "exception", diagnostics: String(err) }
       ]
     });
   }
 }
 
-// src/data/rest-api/routes/patient/patient-update.ts
-async function updatePatient(req, res) {
+// src/data/operations/data/practitioner/practitioner-delete-operation.ts
+async function deletePractitionerOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.practitioner,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/practitioner/practitioner-delete-route.ts
+async function deletePractitionerRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    await deletePractitionerOperation({ context: ctx, id });
+    return res.status(204).send();
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "DELETE Practitioner error:");
+  }
+}
+
+// src/data/operations/data/practitioner/practitioner-get-by-id-operation.ts
+async function getPractitionerByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.practitioner,
+    tenantId,
+    workspaceId,
+    id,
+    "Practitioner"
+  );
+}
+
+// src/data/rest-api/routes/data/practitioner/practitioner-get-by-id-route.ts
+async function getPractitionerByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    const result = await getPractitionerByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Practitioner ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Practitioner error:");
+  }
+}
+
+// src/data/operations/data/practitioner/practitioner-list-operation.ts
+async function listPractitionersOperation(params) {
+  const { context, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.practitioner,
+    tenantId,
+    workspaceId
+  );
+}
+
+// src/data/rest-api/routes/data/practitioner/practitioner-list-route.ts
+async function listPractitionersRoute(req, res) {
+  const ctx = req.openhiContext;
+  try {
+    const result = await listPractitionersOperation({ context: ctx });
+    const bundle = buildSearchsetBundle(BASE_PATH.PRACTITIONER, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Practitioner list error:");
+  }
+}
+
+// src/data/operations/data/practitioner/practitioner-update-operation.ts
+async function updatePractitionerOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.practitioner,
+    tenantId,
+    workspaceId,
+    id,
+    "Practitioner",
+    context,
+    (existingResourceStr) => {
+      const bodyWithResource = body;
+      const existingMeta = JSON.parse(existingResourceStr).meta;
+      const practitioner = {
+        ...body,
+        resourceType: "Practitioner",
+        id,
+        meta: {
+          ...bodyWithResource.meta ?? {},
+          lastUpdated: date,
+          versionId: "2"
+        }
+      };
+      const practitionerWithMeta = {
+        ...practitioner,
+        meta: mergeAuditIntoMeta(practitioner.meta ?? existingMeta, {
+          modifiedDate: date,
+          modifiedById: actorId,
+          modifiedByName: actorName
+        })
+      };
+      return {
+        resource: practitionerWithMeta,
+        lastUpdated: date
+      };
+    }
+  );
+}
+
+// src/data/rest-api/routes/data/practitioner/practitioner-update-route.ts
+async function updatePractitionerRoute(req, res) {
   const bodyResult = requireJsonBody(req, res);
   if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
   const id = String(req.params.id);
   const ctx = req.openhiContext;
-  const { tenantId, workspaceId, date, actorId, actorName } = ctx;
   const body = bodyResult.body;
-  const patient = {
+  const practitioner = {
     ...body,
-    resourceType: "Patient",
+    resourceType: "Practitioner",
     id,
     meta: {
       ...body?.meta ?? {},
-      lastUpdated: date,
+      lastUpdated: ctx.date,
       versionId: "2"
     }
   };
-  const service = getDynamoDataService();
   try {
-    const existing = await service.entities.patient.get({ tenantId, workspaceId, id, sk: SK2 }).go();
-    if (!existing.data) {
-      return res.status(404).json({
-        resourceType: "OperationOutcome",
-        issue: [
-          {
-            severity: "error",
-            code: "not-found",
-            diagnostics: `Patient ${id} not found`
-          }
-        ]
-      });
-    }
-    const existingMeta = existing.data.resource != null ? JSON.parse(decompressResource(existing.data.resource)).meta : void 0;
-    const patientWithMeta = {
-      ...patient,
-      meta: mergeAuditIntoMeta(
-        patient.meta ?? existingMeta,
-        {
-          modifiedDate: date,
-          modifiedById: actorId,
-          modifiedByName: actorName
-        }
-      )
-    };
-    await service.entities.patient.patch({ tenantId, workspaceId, id, sk: SK2 }).set({
-      resource: compressResource(JSON.stringify(patientWithMeta)),
-      lastUpdated: date
-    }).go();
-    return res.json(patientWithMeta);
-  } catch (err) {
-    console.error("PUT Patient error:", err);
-    return res.status(500).json({
-      resourceType: "OperationOutcome",
-      issue: [
-        { severity: "error", code: "exception", diagnostics: String(err) }
-      ]
+    const result = await updatePractitionerOperation({
+      context: ctx,
+      id,
+      body: practitioner
     });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Practitioner ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "PUT Practitioner error:");
   }
 }
 
-// src/data/rest-api/routes/patient/patient.ts
-var router2 = express2.Router();
-router2.get("/", listPatients);
-router2.get("/:id", getPatientById);
-router2.post("/", createPatient);
-router2.put("/:id", updatePatient);
-router2.delete("/:id", deletePatient);
+// src/data/rest-api/routes/data/practitioner/practitioner.ts
+var router4 = express4.Router();
+router4.get("/", listPractitionersRoute);
+router4.get("/:id", getPractitionerByIdRoute);
+router4.post("/", createPractitionerRoute);
+router4.put("/:id", updatePractitionerRoute);
+router4.delete("/:id", deletePractitionerRoute);
 
 // src/data/rest-api/rest-api.ts
-var app = express3();
+var app = express5();
 app.set("view engine", "ejs");
 app.set("views", path.join(__dirname, "views"));
-app.use(express3.json());
-app.use(express3.urlencoded({ extended: true }));
+app.use(express5.json());
+app.use(express5.urlencoded({ extended: true }));
 app.use(normalizeJsonBodyMiddleware);
 app.get("/", (_req, res) => {
   return res.status(200).json({ message: "POC App is running" });
 });
-app.use(["/Patient", "/Configuration"], openHiContextMiddleware);
-app.use("/Patient", router2);
+app.use(
+  ["/Patient", "/Encounter", "/Practitioner", "/Configuration"],
+  openHiContextMiddleware
+);
+app.use("/Patient", router3);
+app.use("/Encounter", router2);
+app.use("/Practitioner", router4);
 app.use("/Configuration", router);
 
 // src/data/lambda/rest-api-lambda.handler.ts