@kenyaemr/esm-express-workflow-app 5.4.4-pre.43 → 5.4.4-pre.430

package/src/shared/utils/index.ts

@@ -100,8 +100,6 @@ export function buildGeneralOrder(order: Order, action?: OrderAction): OrderBask
     action: action,
     display: order.display,
     previousOrder: action !== 'NEW' ? order.uuid : null,
-    orderer: order.orderer.uuid,
-    careSetting: order.careSetting.uuid,
     instructions: order.instructions,
     urgency: order.urgency,
     accessionNumber: order.accessionNumber,
@@ -109,6 +107,7 @@ export function buildGeneralOrder(order: Order, action?: OrderAction): OrderBask
     orderNumber: order.orderNumber,
     orderType: order.orderType.uuid,
     scheduledDate: order.scheduledDate ? new Date(order.scheduledDate) : null,
+    visit: order.encounter.visit,
   };
 }
 
@@ -151,15 +150,151 @@ export function sanitizePhoneNumber(phoneNumber: string): string {
  * @returns The masked phone number
  */
 export const maskPhoneNumber = (phoneNumber: string): string => {
+  if (!phoneNumber) {
+    return '';
+  }
   const digits = phoneNumber.replace(/\D/g, '');
-
   if (digits.length < 8) {
     return phoneNumber;
   }
-
   const firstPart = digits.slice(0, -6);
   const maskedPart = '*'.repeat(4);
   const lastPart = digits.slice(-2);
-
   return `${firstPart}${maskedPart}${lastPart}`;
 };
+
+/**
+ * Extracts the most meaningful error message from a Savannah IL / SHA upstream error response.
+ *
+ * Savannah errors come in several shapes:
+ *   { success: false, error: "...", upstream_error: { error: "Bad Request", message: "specific reason" } }
+ *   { success: false, error: "..." }
+ *   { error: "...", message: "..." }
+ *   "plain string"
+ */
+
+export interface UpstreamErrorBody {
+  error?: string;
+  message?: string;
+}
+
+export interface SavannahErrorResponse {
+  success?: boolean;
+  error?: string;
+  upstream_error?: UpstreamErrorBody;
+  message?: string;
+}
+
+/**
+ * Returns the most specific human-readable error message available.
+ * Priority: upstream_error.message > upstream_error.error > message > error > fallback
+ */
+export function extractUpstreamError(
+  response: SavannahErrorResponse | string | unknown,
+  fallback = 'An unexpected error occurred. Please try again.',
+): string {
+  if (!response) {
+    return fallback;
+  }
+
+  if (typeof response === 'string') {
+    return response || fallback;
+  }
+
+  const res = response as SavannahErrorResponse;
+
+  const upstreamMsg = res.upstream_error?.message?.trim();
+  if (upstreamMsg) {
+    return upstreamMsg;
+  }
+
+  const upstreamErr = res.upstream_error?.error?.trim();
+  if (upstreamErr && upstreamErr.toLowerCase() !== 'bad request') {
+    return upstreamErr;
+  }
+
+  const topMsg = res.message?.trim();
+  if (topMsg) {
+    return topMsg;
+  }
+
+  const topError = res.error?.trim();
+  if (topError && !res.upstream_error) {
+    return topError;
+  }
+
+  if (topError) {
+    return topError;
+  }
+
+  return fallback;
+}
+
+/**
+ * Extracts error from a caught Error/unknown in catch blocks.
+ * Handles: openmrsFetch errors (with .responseBody), Error objects, raw response objects.
+ *
+ * IMPORTANT: openmrsFetch errors are Error instances AND carry a .responseBody field.
+ * We must check responseBody FIRST, otherwise we'd fall into the Error branch and surface
+ * the raw "Server responded with 400..." technical message instead of the upstream message.
+ */
+export function extractFetchError(err: unknown, fallback = 'An unexpected error occurred. Please try again.'): string {
+  if (!err) {
+    return fallback;
+  }
+
+  if (typeof err === 'object' && err !== null) {
+    const e = err as Record<string, unknown>;
+
+    if (e.responseBody) {
+      return extractUpstreamError(e.responseBody as SavannahErrorResponse, fallback);
+    }
+
+    if (e.data) {
+      return extractUpstreamError(e.data as SavannahErrorResponse, fallback);
+    }
+  }
+
+  if (err instanceof Error) {
+    const msg = err.message;
+    if (msg) {
+      try {
+        const parsed = JSON.parse(msg);
+        return extractUpstreamError(parsed, msg);
+      } catch {
+        return msg;
+      }
+    }
+    return fallback;
+  }
+
+  if (typeof err === 'object' && err !== null) {
+    const e = err as Record<string, unknown>;
+    if ('upstream_error' in e || 'error' in e || 'message' in e) {
+      return extractUpstreamError(e as SavannahErrorResponse, fallback);
+    }
+  }
+
+  return fallback;
+}
+
+export function getPatientPrintFields(patient?: fhir.Patient) {
+  const name =
+    patient?.name?.[0]?.text ??
+    [patient?.name?.[0]?.given?.join(' '), patient?.name?.[0]?.family].filter(Boolean).join(' ');
+  const id = patient?.identifier?.[0]?.value;
+  const age = patient?.birthDate
+    ? Math.floor((Date.now() - new Date(patient.birthDate).getTime()) / 3.15576e10)
+    : undefined;
+  return {
+    patientName: name || undefined,
+    patientId: id,
+    patientAge: age,
+  };
+}
+
+export const documentId = () => {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substr(2, 9);
+  return `PM-${timestamp}-${random}`.toUpperCase();
+};

package/src/types/index.ts

@@ -110,3 +110,15 @@ export type QueueEntriesPagination = {
   goToPrevious: () => void;
   defaultPageSize: number;
 };
+
+export interface QueueEntryPayload {
+  visit: { uuid: string };
+  queueEntry: {
+    status: { uuid: string };
+    priority: { uuid: string };
+    queue: { uuid: string };
+    patient: { uuid: string };
+    startedAt: Date;
+    sortWeight: number;
+  };
+}