@openhi/constructs 0.0.0 → 0.0.1

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

@@ -0,0 +1,646 @@
+import {
+  __require
+} from "./chunk-LZOMFHX3.mjs";
+
+// src/data/lambda/rest-api-lambda.handler.ts
+import serverlessExpress from "@codegenie/serverless-express";
+
+// src/data/rest-api/rest-api.ts
+import path from "path";
+import cors from "cors";
+import express2 from "express";
+
+// src/data/middleware/open-hi-context.ts
+var STATIC_TENANT_ID = "tenant-1";
+var STATIC_WORKSPACE_ID = "ws-1";
+var STATIC_USER_ID = "rest-api";
+var STATIC_USER_NAME = "REST API";
+function openHiContextMiddleware(req, _res, next) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  req.openhiContext = {
+    tenantId: STATIC_TENANT_ID,
+    workspaceId: STATIC_WORKSPACE_ID,
+    date: now,
+    userId: STATIC_USER_ID,
+    username: STATIC_USER_NAME
+  };
+  next();
+}
+
+// src/data/rest-api/ehr/r4/Patient.ts
+import express from "express";
+
+// src/lib/compression.ts
+import { gzipSync, gunzipSync } from "zlib";
+var ENVELOPE_VERSION = 1;
+var COMPRESSION_ALGOS = {
+  NONE: "none",
+  GZIP: "gzip",
+  BROTLI: "brotli",
+  DEFLATE: "deflate"
+};
+function isEnvelope(obj) {
+  return typeof obj === "object" && obj !== null && "v" in obj && "algo" in obj && "payload" in obj && typeof obj.payload === "string";
+}
+function compressResource(jsonString, options) {
+  const algo = options?.algo ?? COMPRESSION_ALGOS.GZIP;
+  if (algo === COMPRESSION_ALGOS.NONE) {
+    const envelope2 = {
+      v: ENVELOPE_VERSION,
+      algo: COMPRESSION_ALGOS.NONE,
+      payload: jsonString
+    };
+    return JSON.stringify(envelope2);
+  }
+  const buf = Buffer.from(jsonString, "utf-8");
+  const payload = gzipSync(buf).toString("base64");
+  const envelope = {
+    v: ENVELOPE_VERSION,
+    algo: COMPRESSION_ALGOS.GZIP,
+    payload
+  };
+  return JSON.stringify(envelope);
+}
+function decompressResource(compressedOrRaw) {
+  try {
+    const parsed = JSON.parse(compressedOrRaw);
+    if (isEnvelope(parsed)) {
+      if (parsed.algo === COMPRESSION_ALGOS.GZIP) {
+        const buf = Buffer.from(parsed.payload, "base64");
+        return gunzipSync(buf).toString("utf-8");
+      }
+      if (parsed.algo === COMPRESSION_ALGOS.NONE) {
+        return parsed.payload;
+      }
+      return parsed.payload;
+    }
+  } catch {
+  }
+  try {
+    const buf = Buffer.from(compressedOrRaw, "base64");
+    if (buf.length >= 2 && buf[0] === 31 && buf[1] === 139) {
+      return gunzipSync(buf).toString("utf-8");
+    }
+  } catch {
+  }
+  return compressedOrRaw;
+}
+
+// src/data/dynamo/ehr/r4/ehr-r4-data-service.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { Service } from "electrodb";
+
+// src/data/dynamo/ehr/r4/Patient.ts
+import { Entity } from "electrodb";
+var Patient = new Entity({
+  model: {
+    entity: "patient",
+    service: "fhir",
+    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/ehr/r4/ehr-r4-data-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"
+  }
+});
+var entities = { patient: Patient };
+var EhrR4DataService = new Service(entities, { table, client });
+function getEhrR4DataService(tableName) {
+  return new Service(entities, { table: tableName, client });
+}
+
+// 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;
+    if (root.resourceType === "Patient" && root.id) {
+      return root;
+    }
+    if (root.resourceType === "Bundle" && "entry" in parsed) {
+      const entries = parsed.entry;
+      if (Array.isArray(entries)) {
+        const patientEntry = entries.find(
+          (e) => e?.resource?.resourceType === "Patient" && e.resource.id
+        );
+        if (patientEntry?.resource) {
+          return patientEntry.resource;
+        }
+      }
+    }
+  }
+  throw new Error(
+    "File must be a FHIR Patient resource or a Bundle containing at least one Patient entry"
+  );
+}
+var SK = "CURRENT";
+var defaultAudit = {
+  createdDate: (/* @__PURE__ */ new Date()).toISOString(),
+  createdById: "import",
+  createdByName: "Bulk import",
+  modifiedDate: (/* @__PURE__ */ new Date()).toISOString(),
+  modifiedById: "import",
+  modifiedByName: "Bulk import"
+};
+function patientToPutAttrs(patient, options) {
+  const {
+    tenantId,
+    workspaceId,
+    createdDate,
+    createdById,
+    createdByName,
+    modifiedDate,
+    modifiedById,
+    modifiedByName
+  } = options;
+  const lastUpdated = patient.meta?.lastUpdated ?? modifiedDate ?? defaultAudit.modifiedDate ?? (/* @__PURE__ */ new Date()).toISOString();
+  const auditMerged = {
+    ...defaultAudit,
+    ...createdDate != null && { createdDate },
+    ...createdById != null && { createdById },
+    ...createdByName != null && { createdByName },
+    ...modifiedDate != null && { modifiedDate },
+    ...modifiedById != null && { modifiedById },
+    ...modifiedByName != null && { modifiedByName }
+  };
+  const patientWithMeta = {
+    ...patient,
+    meta: mergeAuditIntoMeta(patient.meta, auditMerged)
+  };
+  if (lastUpdated && !patientWithMeta.meta.lastUpdated) {
+    patientWithMeta.meta.lastUpdated = lastUpdated;
+  }
+  return {
+    sk: SK,
+    tenantId,
+    workspaceId,
+    id: patient.id,
+    resource: compressResource(JSON.stringify(patientWithMeta)),
+    vid: lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36),
+    lastUpdated,
+    identifierSystem: "",
+    identifierValue: "",
+    facilityId: "",
+    normalizedName: ""
+  };
+}
+async function importPatientFromFile(filePath, options) {
+  const resolved = resolve(filePath);
+  const raw = readFileSync(resolved, "utf-8");
+  const parsed = JSON.parse(raw);
+  const patient = extractPatient(parsed);
+  const tableName = options.tableName ?? process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+  const service = getEhrR4DataService(tableName);
+  const attrs = patientToPutAttrs(patient, options);
+  const result = await service.entities.patient.put(attrs).go();
+  const data = result.data;
+  if (!data) {
+    throw new Error(`Put failed for Patient ${patient.id}`);
+  }
+  return {
+    id: data.id,
+    tenantId: data.tenantId,
+    workspaceId: data.workspaceId
+  };
+}
+async function main() {
+  const [, , fileArg, tenantId = "tenant-1", workspaceId = "ws-1"] = process.argv;
+  if (!fileArg) {
+    console.error(
+      "Usage: import-patient.ts <path-to-patient.json> [tenantId] [workspaceId]"
+    );
+    process.exit(1);
+  }
+  try {
+    const result = await importPatientFromFile(fileArg, {
+      tenantId,
+      workspaceId
+    });
+    console.log(
+      `Imported Patient ${result.id} (tenant=${result.tenantId}, workspace=${result.workspaceId})`
+    );
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+}
+if (__require.main === module) {
+  void main();
+}
+
+// src/data/rest-api/ehr/r4/Patient.ts
+var BASE_PATH = "/ehr/r4/Patient";
+var router = express.Router();
+var SK2 = "CURRENT";
+var TABLE_NAME = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+async function listPatients(req, res) {
+  const { tenantId, workspaceId } = req.openhiContext;
+  const service = getEhrR4DataService(TABLE_NAME);
+  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_PATH}/${item.id}`,
+        resource: { ...resource, id: item.id }
+      };
+    });
+    const bundle = {
+      resourceType: "Bundle",
+      type: "searchset",
+      total: entries.length,
+      link: [{ relation: "self", url: BASE_PATH }],
+      entry: entries
+    };
+    return res.json(bundle);
+  } catch (err) {
+    console.error("GET /Patient list error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "exception",
+          diagnostics: String(err)
+        }
+      ]
+    });
+  }
+}
+router.get("/", listPatients);
+async function getPatientById(req, res) {
+  const id = String(req.params.id);
+  const { tenantId, workspaceId } = req.openhiContext;
+  const service = getEhrR4DataService(TABLE_NAME);
+  try {
+    const result = await service.entities.patient.get({ tenantId, workspaceId, id, sk: "CURRENT" }).go();
+    if (!result.data) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "not-found",
+            diagnostics: `Patient ${id} not found`
+          }
+        ]
+      });
+    }
+    const resource = JSON.parse(
+      decompressResource(result.data.resource)
+    );
+    return res.json({ ...resource, id: result.data.id });
+  } catch (err) {
+    console.error("GET Patient error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "exception",
+          diagnostics: String(err)
+        }
+      ]
+    });
+  }
+}
+router.get("/:id", getPatientById);
+async function createPatient(req, res) {
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId, date, userId, username } = ctx;
+  const body = req.body;
+  const id = body?.id ?? `patient-${Date.now()}`;
+  const patient = {
+    ...body,
+    resourceType: "Patient",
+    id,
+    meta: {
+      ...body?.meta ?? {},
+      lastUpdated: date,
+      versionId: "1"
+    }
+  };
+  const options = {
+    tenantId,
+    workspaceId,
+    createdDate: date,
+    createdById: userId,
+    createdByName: username,
+    modifiedDate: date,
+    modifiedById: userId,
+    modifiedByName: username
+  };
+  const service = getEhrR4DataService(TABLE_NAME);
+  try {
+    const attrs = patientToPutAttrs(patient, options);
+    await service.entities.patient.put(
+      attrs
+    ).go();
+    return res.status(201).location(`${BASE_PATH}/${id}`).json(patient);
+  } catch (err) {
+    console.error("POST Patient error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        { severity: "error", code: "exception", diagnostics: String(err) }
+      ]
+    });
+  }
+}
+router.post("/", createPatient);
+async function updatePatient(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId, date, userId, username } = ctx;
+  const body = req.body;
+  const patient = {
+    ...body,
+    resourceType: "Patient",
+    id,
+    meta: {
+      ...body?.meta ?? {},
+      lastUpdated: date,
+      versionId: "2"
+    }
+  };
+  const service = getEhrR4DataService(TABLE_NAME);
+  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: userId,
+          modifiedByName: username
+        }
+      )
+    };
+    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) }
+      ]
+    });
+  }
+}
+router.put("/:id", updatePatient);
+async function deletePatient(req, res) {
+  const id = String(req.params.id);
+  const { tenantId, workspaceId } = req.openhiContext;
+  const service = getEhrR4DataService(TABLE_NAME);
+  try {
+    await service.entities.patient.delete({ tenantId, workspaceId, id, sk: SK2 }).go();
+    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) }
+      ]
+    });
+  }
+}
+router.delete("/:id", deletePatient);
+
+// src/data/rest-api/rest-api.ts
+var app = express2();
+app.set("view engine", "ejs");
+app.set("views", path.join(__dirname, "views"));
+app.use(cors());
+app.use(express2.json());
+app.use(express2.urlencoded({ extended: true }));
+app.get("/", (_req, res) => {
+  return res.status(200).json({ message: "POC App is running" });
+});
+app.use("/ehr", openHiContextMiddleware);
+app.use("/ehr/r4/Patient", router);
+
+// src/data/lambda/rest-api-lambda.handler.ts
+var handler = serverlessExpress({ app });
+export {
+  handler
+};
+//# sourceMappingURL=rest-api-lambda.handler.mjs.map