@openhi/constructs 0.0.5 → 0.0.6

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

@@ -8,7 +8,7 @@ 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";
+import express3 from "express";
 
 // src/data/middleware/open-hi-context.ts
 var STATIC_TENANT_ID = "tenant-1";
@@ -625,18 +625,486 @@ async function deletePatient(req, res) {
 }
 router.delete("/:id", deletePatient);
 
+// src/data/rest-api/ohi/Configuration.ts
+import express2 from "express";
+
+// src/data/rest-api/ohi/dynamic-configuration.ts
+import {
+  DescribeParametersCommand,
+  GetParametersCommand,
+  SSMClient
+} from "@aws-sdk/client-ssm";
+var BASE_PATH2 = "/ohi/Configuration";
+var TAG_KEY_BRANCH = "openhi:branch-name";
+var TAG_KEY_HTTP_API_PARAM = "openhi:param-name";
+function getSsmDynamicConfigEnvFilter() {
+  const branchTagValue = process.env.BRANCH_TAG_VALUE;
+  const httpApiTagValue = process.env.HTTP_API_TAG_VALUE;
+  if (branchTagValue == null || branchTagValue === "" || httpApiTagValue == null || httpApiTagValue === "") {
+    return null;
+  }
+  return { branchTagValue, httpApiTagValue };
+}
+async function getDynamicConfigurationEntries(context) {
+  const envFilter = getSsmDynamicConfigEnvFilter();
+  if (envFilter == null) {
+    return getStaticDummyEntry(context);
+  }
+  const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
+  const client3 = new SSMClient({ region });
+  try {
+    const describeResult = await client3.send(
+      new DescribeParametersCommand({
+        ParameterFilters: [
+          {
+            Key: `tag:${TAG_KEY_BRANCH}`,
+            Option: "Equals",
+            Values: [envFilter.branchTagValue]
+          },
+          {
+            Key: `tag:${TAG_KEY_HTTP_API_PARAM}`,
+            Option: "Equals",
+            Values: [envFilter.httpApiTagValue]
+          }
+        ],
+        MaxResults: 50
+      })
+    );
+    const names = (describeResult.Parameters ?? []).map((p) => p.Name).filter((n) => n != null);
+    if (names.length === 0) {
+      return getStaticDummyEntry(context);
+    }
+    const parameters = [];
+    for (let i = 0; i < names.length; i += 10) {
+      const batch = names.slice(i, i + 10);
+      const getResult = await client3.send(
+        new GetParametersCommand({
+          Names: batch,
+          WithDecryption: true
+        })
+      );
+      for (const p of getResult.Parameters ?? []) {
+        const name = p.Name;
+        const value = p.Value;
+        if (name != null && value != null) {
+          parameters.push({ name, value });
+        }
+      }
+    }
+    const parameterList = parameters.map((p) => {
+      const shortName = p.name.includes("/") ? p.name.split("/").slice(-1)[0] : p.name;
+      return { name: shortName, valueString: p.value };
+    });
+    const entry = {
+      fullUrl: `${BASE_PATH2}/ssm-dynamic`,
+      resource: {
+        resourceType: "Configuration",
+        id: "ssm-dynamic",
+        key: "ssm-dynamic",
+        resource: {
+          parameter: parameterList
+        },
+        meta: {
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          versionId: "1"
+        }
+      }
+    };
+    return [entry];
+  } catch (err) {
+    console.error("getDynamicConfigurationEntries SSM error:", err);
+    return getStaticDummyEntry(context);
+  }
+}
+function getStaticDummyEntry(_context) {
+  const dummy = {
+    fullUrl: `${BASE_PATH2}/dynamic-dummy`,
+    resource: {
+      resourceType: "Configuration",
+      id: "dynamic-dummy",
+      key: "dynamic-dummy",
+      resource: {
+        parameter: [
+          {
+            name: "description",
+            valueString: "Statically generated dummy configuration (not from DynamoDB)."
+          },
+          { name: "source", valueString: "dynamic-configuration" }
+        ]
+      },
+      meta: {
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        versionId: "1"
+      }
+    }
+  };
+  return [dummy];
+}
+
+// src/data/dynamo/ohi/ohi-data-service.ts
+import { DynamoDBClient as DynamoDBClient2 } from "@aws-sdk/client-dynamodb";
+import { Service as Service2 } from "electrodb";
+
+// src/data/dynamo/ohi/Configuration.ts
+import { Entity as Entity2 } from "electrodb";
+var Configuration = new Entity2({
+  model: {
+    entity: "configuration",
+    service: "ohi",
+    version: "01"
+  },
+  attributes: {
+    /** Sort key. "CURRENT" for current version; version history in S3. */
+    sk: {
+      type: "string",
+      required: true,
+      default: "CURRENT"
+    },
+    /** Tenant scope. Use "BASELINE" when the config is baseline default (no tenant). */
+    tenantId: {
+      type: "string",
+      required: true,
+      default: "BASELINE"
+    },
+    /** Workspace scope. Use "-" when absent. */
+    workspaceId: {
+      type: "string",
+      required: true,
+      default: "-"
+    },
+    /** User scope. Use "-" when absent. */
+    userId: {
+      type: "string",
+      required: true,
+      default: "-"
+    },
+    /** Role scope. Use "-" when absent. */
+    roleId: {
+      type: "string",
+      required: true,
+      default: "-"
+    },
+    /** Config type (category), e.g. endpoints, branding, display. */
+    key: {
+      type: "string",
+      required: true
+    },
+    /** FHIR Resource.id; logical id in URL and for the Configuration resource. */
+    id: {
+      type: "string",
+      required: true
+    },
+    /** Payload 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
+    }
+  },
+  indexes: {
+    /** Base table: PK, SK (data store key names). PK is built from tenantId, workspaceId, userId, roleId; SK is built from key and sk. Do not supply PK or SK from outside. */
+    record: {
+      pk: {
+        field: "PK",
+        composite: ["tenantId", "workspaceId", "userId", "roleId"],
+        template: "OHI#CONFIG#TID#${tenantId}#WID#${workspaceId}#UID#${userId}#RID#${roleId}"
+      },
+      sk: {
+        field: "SK",
+        composite: ["key", "sk"],
+        template: "KEY#${key}#SK#${sk}"
+      }
+    },
+    /** GSI4 — Resource Type Index: list all Configuration in a tenant or workspace (no scan). Use for "list configs scoped to this tenant" (workspaceId = "-") or "list configs scoped to this workspace". Does not support hierarchical resolution in one query; use base table GetItem in fallback order (user → workspace → tenant → baseline) for that. */
+    gsi4: {
+      index: "GSI4",
+      condition: () => true,
+      pk: {
+        field: "GSI4PK",
+        composite: ["tenantId", "workspaceId"],
+        template: "TID#${tenantId}#WID#${workspaceId}#RT#Configuration"
+      },
+      sk: {
+        field: "GSI4SK",
+        composite: ["key", "sk"],
+        template: "KEY#${key}#SK#${sk}"
+      }
+    }
+  }
+});
+
+// src/data/dynamo/ohi/ohi-data-service.ts
+var table2 = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+var client2 = new DynamoDBClient2({
+  ...process.env.MOCK_DYNAMODB_ENDPOINT && {
+    endpoint: process.env.MOCK_DYNAMODB_ENDPOINT,
+    sslEnabled: false,
+    region: "local"
+  }
+});
+var entities2 = { configuration: Configuration };
+var OhiDataService = new Service2(entities2, { table: table2, client: client2 });
+function getOhiDataService(tableName) {
+  return new Service2(entities2, { table: tableName, client: client2 });
+}
+
+// src/data/rest-api/ohi/Configuration.ts
+var BASE_PATH3 = "/ohi/Configuration";
+var router2 = express2.Router();
+var SK3 = "CURRENT";
+var TABLE_NAME2 = process.env.DYNAMO_TABLE_NAME ?? "jesttesttable";
+async function listConfigurations(req, res) {
+  const { tenantId, workspaceId } = req.openhiContext;
+  const service = getOhiDataService(TABLE_NAME2);
+  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_PATH3}/${item.key}`,
+        resource: { ...resource, id: item.id, key: item.key }
+      };
+    });
+    const dynamicEntries = await getDynamicConfigurationEntries({
+      tenantId,
+      workspaceId
+    });
+    const entries = [...dynamoEntries, ...dynamicEntries];
+    const bundle = {
+      resourceType: "Bundle",
+      type: "searchset",
+      total: entries.length,
+      link: [{ relation: "self", url: BASE_PATH3 }],
+      entry: entries
+    };
+    return res.json(bundle);
+  } catch (err) {
+    console.error("GET /Configuration list error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "exception",
+          diagnostics: String(err)
+        }
+      ]
+    });
+  }
+}
+router2.get("/", listConfigurations);
+async function getConfigurationByKey(req, res) {
+  const key = String(req.params.key);
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId, userId } = ctx;
+  const roleId = "roleId" in ctx && typeof ctx.roleId === "string" ? ctx.roleId : "-";
+  const service = getOhiDataService(TABLE_NAME2);
+  try {
+    const result = await service.entities.configuration.get({ tenantId, workspaceId, userId, roleId, key, sk: SK3 }).go();
+    if (!result.data) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "not-found",
+            diagnostics: `Configuration ${key} 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",
+      issue: [
+        {
+          severity: "error",
+          code: "exception",
+          diagnostics: String(err)
+        }
+      ]
+    });
+  }
+}
+router2.get("/:key", getConfigurationByKey);
+async function createConfiguration(req, res) {
+  const ctx = req.openhiContext;
+  const {
+    tenantId: ctxTenantId,
+    workspaceId: ctxWorkspaceId,
+    userId: ctxUserId,
+    date
+  } = ctx;
+  const body = req.body;
+  const key = body?.key;
+  if (!key || typeof key !== "string") {
+    return res.status(400).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "required",
+          diagnostics: "Configuration key is required"
+        }
+      ]
+    });
+  }
+  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 ?? ctxUserId ?? "-";
+  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 = getOhiDataService(TABLE_NAME2);
+  try {
+    await service.entities.configuration.put({
+      tenantId,
+      workspaceId,
+      userId,
+      roleId,
+      key,
+      id,
+      resource: compressResource(resourceStr),
+      vid,
+      lastUpdated,
+      sk: SK3
+    }).go();
+    const config = {
+      resourceType: "Configuration",
+      id,
+      key,
+      resource: typeof resourcePayload === "object" ? resourcePayload : JSON.parse(resourceStr),
+      meta: { lastUpdated, versionId: vid }
+    };
+    return res.status(201).location(`${BASE_PATH3}/${key}`).json(config);
+  } catch (err) {
+    console.error("POST Configuration error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        { severity: "error", code: "exception", diagnostics: String(err) }
+      ]
+    });
+  }
+}
+router2.post("/", createConfiguration);
+async function updateConfiguration(req, res) {
+  const key = String(req.params.key);
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId, userId, date } = ctx;
+  const roleId = "roleId" in ctx && typeof ctx.roleId === "string" ? ctx.roleId : "-";
+  const body = req.body;
+  const resourcePayload = body?.resource;
+  const resourceStr = typeof resourcePayload === "string" ? resourcePayload : JSON.stringify(resourcePayload ?? {});
+  const lastUpdated = body?.lastUpdated ?? date;
+  const service = getOhiDataService(TABLE_NAME2);
+  try {
+    const existing = await service.entities.configuration.get({ tenantId, workspaceId, userId, roleId, key, sk: SK3 }).go();
+    if (!existing.data) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "not-found",
+            diagnostics: `Configuration ${key} 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, roleId, key, sk: SK3 }).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) }
+      ]
+    });
+  }
+}
+router2.put("/:key", updateConfiguration);
+async function deleteConfiguration(req, res) {
+  const key = String(req.params.key);
+  const ctx = req.openhiContext;
+  const { tenantId, workspaceId, userId } = ctx;
+  const roleId = "roleId" in ctx && typeof ctx.roleId === "string" ? ctx.roleId : "-";
+  const service = getOhiDataService(TABLE_NAME2);
+  try {
+    await service.entities.configuration.delete({ tenantId, workspaceId, userId, roleId, key, sk: SK3 }).go();
+    return res.status(204).send();
+  } catch (err) {
+    console.error("DELETE Configuration error:", err);
+    return res.status(500).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        { severity: "error", code: "exception", diagnostics: String(err) }
+      ]
+    });
+  }
+}
+router2.delete("/:key", deleteConfiguration);
+
 // src/data/rest-api/rest-api.ts
-var app = express2();
+var app = express3();
 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.use(express3.json());
+app.use(express3.urlencoded({ extended: true }));
 app.get("/", (_req, res) => {
   return res.status(200).json({ message: "POC App is running" });
 });
 app.use("/ehr", openHiContextMiddleware);
+app.use("/ohi", openHiContextMiddleware);
 app.use("/ehr/r4/Patient", router);
+app.use("/ohi/Configuration", router2);
 
 // src/data/lambda/rest-api-lambda.handler.ts
 var handler = serverlessExpress({ app });