@openhi/constructs 0.0.0

package/lib/data/rest-api/ehr/r4/Patient.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patientRouter = void 0;
+exports.listPatients = listPatients;
+exports.getPatientById = getPatientById;
+exports.createPatient = createPatient;
+exports.updatePatient = updatePatient;
+exports.deletePatient = deletePatient;
+const express_1 = __importDefault(require("express"));
+const compression_1 = require("../../../../lib/compression");
+const ehr_r4_data_service_1 = require("../../../dynamo/ehr/r4/ehr-r4-data-service");
+const import_patient_1 = require("../../../import-patient");
+const BASE_PATH = "/ehr/r4/Patient";
+const router = express_1.default.Router();
+exports.patientRouter = router;
+const SK = "CURRENT";
+const TABLE_NAME = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+/**
+ * GET /ehr/r4/Patient — search/list: returns a FHIR Bundle (searchset) from the data store.
+ * Uses GSI4 (Resource Type Index) to list all Patients in the workspace without a table scan.
+ * @see {@link https://github.com/codedrifters/openhi/blob/main/sites/www-docs/content/architecture/dynamodb-single-table-design.md | DynamoDB Single-Table Design} — GSI4, Query and Access Rules (no scans).
+ */
+async function listPatients(req, res) {
+    const { tenantId, workspaceId } = req.openhiContext;
+    const service = (0, ehr_r4_data_service_1.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((0, compression_1.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 = (0, ehr_r4_data_service_1.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((0, compression_1.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),
+                },
+            ],
+        });
+    }
+}
+/** GET /ehr/r4/Patient/:id — read: returns a single Patient resource from the data store or 404. */
+router.get("/:id", getPatientById);
+/** POST /ehr/r4/Patient — create: accepts Patient in body, persists via data store, returns 201. */
+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 = (0, ehr_r4_data_service_1.getEhrR4DataService)(TABLE_NAME);
+    try {
+        const attrs = (0, import_patient_1.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);
+/** PUT /ehr/r4/Patient/:id — update: accepts Patient in body, persists via data store, returns 200. */
+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 = (0, ehr_r4_data_service_1.getEhrR4DataService)(TABLE_NAME);
+    try {
+        const existing = await service.entities.patient
+            .get({ tenantId, workspaceId, id, sk: SK })
+            .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((0, compression_1.decompressResource)(existing.data.resource)).meta
+            : undefined;
+        const patientWithMeta = {
+            ...patient,
+            meta: (0, import_patient_1.mergeAuditIntoMeta)(patient.meta ?? existingMeta, {
+                modifiedDate: date,
+                modifiedById: userId,
+                modifiedByName: username,
+            }),
+        };
+        await service.entities.patient
+            .patch({ tenantId, workspaceId, id, sk: SK })
+            .set({
+            resource: (0, compression_1.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);
+/** DELETE /ehr/r4/Patient/:id — delete: removes from data store, returns 204. */
+async function deletePatient(req, res) {
+    const id = String(req.params.id);
+    const { tenantId, workspaceId } = req.openhiContext;
+    const service = (0, ehr_r4_data_service_1.getEhrR4DataService)(TABLE_NAME);
+    try {
+        await service.entities.patient
+            .delete({ tenantId, workspaceId, id, sk: SK })
+            .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);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Patient.js","sourceRoot":"","sources":["../../../../../src/data/rest-api/ehr/r4/Patient.ts"],"names":[],"mappings":"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","sourcesContent":["import express, { Request, Response } from \"express\";\nimport {\n  compressResource,\n  decompressResource,\n} from \"../../../../lib/compression\";\nimport { getEhrR4DataService } from \"../../../dynamo/ehr/r4/ehr-r4-data-service\";\nimport {\n  mergeAuditIntoMeta,\n  patientToPutAttrs,\n  type ImportPatientOptions,\n} from \"../../../import-patient\";\n\nconst BASE_PATH = \"/ehr/r4/Patient\";\nconst router: express.Router = express.Router();\nconst SK = \"CURRENT\";\n\nconst TABLE_NAME = process.env.DYNAMO_TABLE_NAME ?? \"jesttesttable\";\n\n/**\n * GET /ehr/r4/Patient — search/list: returns a FHIR Bundle (searchset) from the data store.\n * Uses GSI4 (Resource Type Index) to list all Patients in the workspace without a table scan.\n * @see {@link https://github.com/codedrifters/openhi/blob/main/sites/www-docs/content/architecture/dynamodb-single-table-design.md | DynamoDB Single-Table Design} — GSI4, Query and Access Rules (no scans).\n */\nexport async function listPatients(\n  req: Request,\n  res: Response,\n): Promise<Response> {\n  const { tenantId, workspaceId } = req.openhiContext!;\n  const service = getEhrR4DataService(TABLE_NAME);\n\n  try {\n    const result = await service.entities.patient.query\n      .gsi4({ tenantId, workspaceId })\n      .go();\n\n    const entries = (result.data ?? []).map((item) => {\n      const resource = JSON.parse(decompressResource(item.resource)) as Record<\n        string,\n        unknown\n      >;\n      return {\n        fullUrl: `${BASE_PATH}/${item.id}`,\n        resource: { ...resource, id: item.id },\n      };\n    });\n    const bundle = {\n      resourceType: \"Bundle\",\n      type: \"searchset\",\n      total: entries.length,\n      link: [{ relation: \"self\", url: BASE_PATH }],\n      entry: entries,\n    };\n    return res.json(bundle);\n  } catch (err: unknown) {\n    console.error(\"GET /Patient list error:\", err);\n    return res.status(500).json({\n      resourceType: \"OperationOutcome\",\n      issue: [\n        {\n          severity: \"error\",\n          code: \"exception\",\n          diagnostics: String(err),\n        },\n      ],\n    });\n  }\n}\n\nrouter.get(\"/\", listPatients);\n\nexport async function getPatientById(\n  req: Request,\n  res: Response,\n): Promise<Response> {\n  const id = String(req.params.id);\n  const { tenantId, workspaceId } = req.openhiContext!;\n  const service = getEhrR4DataService(TABLE_NAME);\n\n  try {\n    const result = await service.entities.patient\n      .get({ tenantId, workspaceId, id, sk: \"CURRENT\" })\n      .go();\n\n    if (!result.data) {\n      return res.status(404).json({\n        resourceType: \"OperationOutcome\",\n        issue: [\n          {\n            severity: \"error\",\n            code: \"not-found\",\n            diagnostics: `Patient ${id} not found`,\n          },\n        ],\n      });\n    }\n\n    const resource = JSON.parse(\n      decompressResource(result.data.resource),\n    ) as Record<string, unknown>;\n    return res.json({ ...resource, id: result.data.id });\n  } catch (err: unknown) {\n    console.error(\"GET Patient error:\", err);\n    return res.status(500).json({\n      resourceType: \"OperationOutcome\",\n      issue: [\n        {\n          severity: \"error\",\n          code: \"exception\",\n          diagnostics: String(err),\n        },\n      ],\n    });\n  }\n}\n\n/** GET /ehr/r4/Patient/:id — read: returns a single Patient resource from the data store or 404. */\nrouter.get(\"/:id\", getPatientById);\n\n/** POST /ehr/r4/Patient — create: accepts Patient in body, persists via data store, returns 201. */\nexport async function createPatient(\n  req: Request,\n  res: Response,\n): Promise<Response> {\n  const ctx = req.openhiContext!;\n  const { tenantId, workspaceId, date, userId, username } = ctx;\n  const body = req.body as Record<string, unknown>;\n  const id = (body?.id as string) ?? `patient-${Date.now()}`;\n  const patient = {\n    ...body,\n    resourceType: \"Patient\",\n    id,\n    meta: {\n      ...((body?.meta as object) ?? {}),\n      lastUpdated: date,\n      versionId: \"1\",\n    },\n  } as { resourceType: string; id: string; meta?: { lastUpdated?: string } };\n  const options: ImportPatientOptions = {\n    tenantId,\n    workspaceId,\n    createdDate: date,\n    createdById: userId,\n    createdByName: username,\n    modifiedDate: date,\n    modifiedById: userId,\n    modifiedByName: username,\n  };\n  const service = getEhrR4DataService(TABLE_NAME);\n\n  try {\n    const attrs = patientToPutAttrs(patient, options);\n    await service.entities.patient\n      .put(\n        attrs as unknown as Parameters<typeof service.entities.patient.put>[0],\n      )\n      .go();\n    return res.status(201).location(`${BASE_PATH}/${id}`).json(patient);\n  } catch (err: unknown) {\n    console.error(\"POST Patient error:\", err);\n    return res.status(500).json({\n      resourceType: \"OperationOutcome\",\n      issue: [\n        { severity: \"error\", code: \"exception\", diagnostics: String(err) },\n      ],\n    });\n  }\n}\n\nrouter.post(\"/\", createPatient);\n\n/** PUT /ehr/r4/Patient/:id — update: accepts Patient in body, persists via data store, returns 200. */\nexport async function updatePatient(\n  req: Request,\n  res: Response,\n): Promise<Response> {\n  const id = String(req.params.id);\n  const ctx = req.openhiContext!;\n  const { tenantId, workspaceId, date, userId, username } = ctx;\n  const body = req.body as Record<string, unknown>;\n  const patient = {\n    ...body,\n    resourceType: \"Patient\",\n    id,\n    meta: {\n      ...((body?.meta as object) ?? {}),\n      lastUpdated: date,\n      versionId: \"2\",\n    },\n  };\n  const service = getEhrR4DataService(TABLE_NAME);\n\n  try {\n    const existing = await service.entities.patient\n      .get({ tenantId, workspaceId, id, sk: SK })\n      .go();\n    if (!existing.data) {\n      return res.status(404).json({\n        resourceType: \"OperationOutcome\",\n        issue: [\n          {\n            severity: \"error\",\n            code: \"not-found\",\n            diagnostics: `Patient ${id} not found`,\n          },\n        ],\n      });\n    }\n    const existingMeta =\n      existing.data.resource != null\n        ? (\n            JSON.parse(decompressResource(existing.data.resource)) as {\n              meta?: Record<string, unknown>;\n            }\n          ).meta\n        : undefined;\n    const patientWithMeta = {\n      ...patient,\n      meta: mergeAuditIntoMeta(\n        (patient.meta as Record<string, unknown> | undefined) ?? existingMeta,\n        {\n          modifiedDate: date,\n          modifiedById: userId,\n          modifiedByName: username,\n        },\n      ),\n    };\n    await service.entities.patient\n      .patch({ tenantId, workspaceId, id, sk: SK })\n      .set({\n        resource: compressResource(JSON.stringify(patientWithMeta)),\n        lastUpdated: date,\n      })\n      .go();\n    return res.json(patientWithMeta);\n  } catch (err: unknown) {\n    console.error(\"PUT Patient error:\", err);\n    return res.status(500).json({\n      resourceType: \"OperationOutcome\",\n      issue: [\n        { severity: \"error\", code: \"exception\", diagnostics: String(err) },\n      ],\n    });\n  }\n}\n\nrouter.put(\"/:id\", updatePatient);\n\n/** DELETE /ehr/r4/Patient/:id — delete: removes from data store, returns 204. */\nexport async function deletePatient(\n  req: Request,\n  res: Response,\n): Promise<Response> {\n  const id = String(req.params.id);\n  const { tenantId, workspaceId } = req.openhiContext!;\n  const service = getEhrR4DataService(TABLE_NAME);\n\n  try {\n    await service.entities.patient\n      .delete({ tenantId, workspaceId, id, sk: SK })\n      .go();\n    return res.status(204).send();\n  } catch (err: unknown) {\n    console.error(\"DELETE Patient error:\", err);\n    return res.status(500).json({\n      resourceType: \"OperationOutcome\",\n      issue: [\n        { severity: \"error\", code: \"exception\", diagnostics: String(err) },\n      ],\n    });\n  }\n}\n\nrouter.delete(\"/:id\", deletePatient);\n\nexport { router as patientRouter };\n"]}

package/lib/data/rest-api/rest-api-local.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/data/rest-api/rest-api-local.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rest_api_1 = require("./rest-api");
+const port = 3000;
+rest_api_1.app.listen(port, () => {
+    console.log(`POC app listening at http://localhost:${port}`);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdC1hcGktbG9jYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGF0YS9yZXN0LWFwaS9yZXN0LWFwaS1sb2NhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHlDQUFpQztBQUVqQyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUM7QUFFbEIsY0FBRyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFO0lBQ3BCLE9BQU8sQ0FBQyxHQUFHLENBQUMseUNBQXlDLElBQUksRUFBRSxDQUFDLENBQUM7QUFDL0QsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhcHAgfSBmcm9tIFwiLi9yZXN0LWFwaVwiO1xuXG5jb25zdCBwb3J0ID0gMzAwMDtcblxuYXBwLmxpc3Rlbihwb3J0LCAoKSA9PiB7XG4gIGNvbnNvbGUubG9nKGBQT0MgYXBwIGxpc3RlbmluZyBhdCBodHRwOi8vbG9jYWxob3N0OiR7cG9ydH1gKTtcbn0pO1xuIl19

package/lib/data/rest-api/rest-api-mockdata.d.ts

@@ -0,0 +1,7 @@
+interface Dictionary {
+    [key: string]: object;
+}
+declare const patientsMock: Dictionary;
+declare const careTeamParticipantsMock: Dictionary;
+declare const organizationsMock: Dictionary;
+export { patientsMock, careTeamParticipantsMock, organizationsMock };