@openmrs/esm-patient-common-lib 11.3.1-pre.9294 → 11.3.1-pre.9296

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-patient-common-lib",
-  "version": "11.3.1-pre.9294",
+  "version": "11.3.1-pre.9296",
   "license": "MPL-2.0",
   "description": "Library for common patient chart components",
   "browser": "dist/openmrs-esm-patient-common-lib.js",

package/src/offline/visit.ts

@@ -5,7 +5,7 @@ import {
   queueSynchronizationItem,
   useConnectivity,
   useSession,
-  useVisit,
+  type useVisit,
   type Visit,
 } from '@openmrs/esm-framework';
 import { useEffect, useState } from 'react';
@@ -23,20 +23,6 @@ export interface OfflineVisit extends NewVisitPayload {
   uuid: string;
 }
 
-/**
- * Similar to {@link useVisit}, returns the given patient's active visit, but also considers
- * offline visits created by the patient chart while offline.
- * @param patientUuid The UUID of the patient.
- */
-export function useVisitOrOfflineVisit(patientUuid: string) {
-  const isOnline = useConnectivity();
-
-  const onlineVisit = useVisit(patientUuid);
-  const offlineVisit = useOfflineVisit(patientUuid);
-
-  return isOnline ? onlineVisit : offlineVisit;
-}
-
 /**
  * Returns the patient's current offline visit.
  * @param patientUuid The UUID of the patient.
@@ -132,7 +118,7 @@ export async function createOfflineVisitForPatient(
   };
 
   await queueSynchronizationItem(visitSyncType, offlineVisit, descriptor);
-  return offlineVisit;
+  return offlineVisitToVisit(offlineVisit);
 }
 
 function offlineVisitToVisit(offlineVisit: OfflineVisit): Visit {

package/src/orders/useOrderBasket.test.tsx

@@ -2,6 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { useOrderBasket } from './useOrderBasket';
 import { type OrderBasketItem, type PostDataPrepFunction } from './types';
 import { _resetOrderBasketStore } from './store';
+import { mockFhirPatient } from '__mocks__';
 
 const mockDrugOrderBasketItem = {
   action: 'NEW',
@@ -19,7 +20,9 @@ describe('useOrderBasket', () => {
   });
 
   it('returns the correct list of orders given a grouping', () => {
-    const { result } = renderHook(() => useOrderBasket('medications', ((x) => x) as unknown as PostDataPrepFunction));
+    const { result } = renderHook(() =>
+      useOrderBasket(mockFhirPatient, 'medications', ((x) => x) as unknown as PostDataPrepFunction),
+    );
     expect(result.current.orders).toEqual([]);
     act(() => {
       result.current.setOrders([mockDrugOrderBasketItem]);
@@ -29,10 +32,10 @@ describe('useOrderBasket', () => {
 
   it('can modify items in one grouping without affecting the other', () => {
     const { result: drugResult } = renderHook(() =>
-      useOrderBasket('medications', ((x) => x) as unknown as PostDataPrepFunction),
+      useOrderBasket(mockFhirPatient, 'medications', ((x) => x) as unknown as PostDataPrepFunction),
     );
     const { result: labResult } = renderHook(() =>
-      useOrderBasket('labs', ((x) => x) as unknown as PostDataPrepFunction),
+      useOrderBasket(mockFhirPatient, 'labs', ((x) => x) as unknown as PostDataPrepFunction),
     );
     expect(drugResult.current.orders).toEqual([]);
     expect(labResult.current.orders).toEqual([]);

package/src/orders/useOrderBasket.ts

@@ -1,16 +1,15 @@
 import { type Actions, useStoreWithActions } from '@openmrs/esm-framework';
 import type { OrderBasketItem, PostDataPrepFunction } from './types';
-import { getPatientUuidFromStore } from '../store/patient-chart-store';
 import { useEffect } from 'react';
 import { type OrderBasketStore, orderBasketStore } from './store';
 
 const orderBasketStoreActions = {
   setOrderBasketItems(
     state: OrderBasketStore,
+    patientUuid: string,
     grouping: string,
     value: Array<OrderBasketItem> | (() => Array<OrderBasketItem>),
   ) {
-    const patientUuid = getPatientUuidFromStore();
     if (!Object.keys(state.postDataPrepFunctions).includes(grouping)) {
       console.warn(`Programming error: You must register a postDataPrepFunction for grouping ${grouping} `);
     }
@@ -34,8 +33,11 @@ const orderBasketStoreActions = {
   },
 } satisfies Actions<OrderBasketStore>;
 
-function getOrderItems(items: OrderBasketStore['items'], grouping?: string | null): Array<OrderBasketItem> {
-  const patientUuid = getPatientUuidFromStore();
+function getOrderItems(
+  patientUuid: string,
+  items: OrderBasketStore['items'],
+  grouping?: string | null,
+): Array<OrderBasketItem> {
   const patientItems = items?.[patientUuid] ?? {};
   return grouping ? patientItems[grouping] ?? [] : Object.values(patientItems).flat();
 }
@@ -44,9 +46,8 @@ export interface ClearOrdersOptions {
   exceptThoseMatching: (order: OrderBasketItem) => boolean;
 }
 
-function clearOrders(options?: ClearOrdersOptions) {
+function clearOrders(patientUuid: string, options?: ClearOrdersOptions) {
   const exceptThoseMatchingFcn = options?.exceptThoseMatching ?? (() => false);
-  const patientUuid = getPatientUuidFromStore();
   const items = orderBasketStore.getState().items;
   const patientItems = items[patientUuid] ?? {};
   const newPatientItems = Object.fromEntries(
@@ -77,13 +78,18 @@ type UseOrderBasketReturn<T, U> = {
  *  A PostDataPrepFunction must be provided for each grouping, but does not necessarily have to be provided
  *  in every usage of useOrderBasket with a grouping key.
  */
-export function useOrderBasket<T extends OrderBasketItem>(): UseOrderBasketReturn<T, void>;
-export function useOrderBasket<T extends OrderBasketItem>(grouping: string): UseOrderBasketReturn<T, string>;
+export function useOrderBasket<T extends OrderBasketItem>(patient: fhir.Patient): UseOrderBasketReturn<T, void>;
 export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
+  grouping: string,
+): UseOrderBasketReturn<T, string>;
+export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
   grouping: string,
   postDataPrepFunction: PostDataPrepFunction,
 ): UseOrderBasketReturn<T, string>;
 export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
   grouping?: string | null,
   postDataPrepFunction?: PostDataPrepFunction,
 ): UseOrderBasketReturn<T, string | void> {
@@ -91,7 +97,7 @@ export function useOrderBasket<T extends OrderBasketItem>(
     orderBasketStore,
     orderBasketStoreActions,
   );
-  const orders = getOrderItems(items, grouping);
+  const orders = getOrderItems(patient.id, items, grouping);
 
   useEffect(() => {
     if (postDataPrepFunction && !postDataPrepFunctions[grouping]) {
@@ -99,15 +105,19 @@ export function useOrderBasket<T extends OrderBasketItem>(
     }
   }, [postDataPrepFunction, grouping, postDataPrepFunctions, setPostDataPrepFunctionForGrouping]);
 
+  const clearOrdersForPatient = (options?: ClearOrdersOptions) => {
+    clearOrders(patient.id, options);
+  };
+
   if (typeof grouping === 'string') {
     const setOrders = (value: Array<T> | (() => Array<T>)) => {
-      return setOrderBasketItems(grouping, value);
+      return setOrderBasketItems(patient.id, grouping, value);
     };
-    return { orders, clearOrders, setOrders } as UseOrderBasketReturn<T, string>;
+    return { orders, clearOrders: clearOrdersForPatient, setOrders } as UseOrderBasketReturn<T, string>;
   } else {
     const setOrders = (groupingKey: string, value: Array<T> | (() => Array<T>)) => {
-      setOrderBasketItems(groupingKey, value);
+      setOrderBasketItems(patient.id, groupingKey, value);
     };
-    return { orders, clearOrders, setOrders } as UseOrderBasketReturn<T, void>;
+    return { orders, clearOrders: clearOrdersForPatient, setOrders } as UseOrderBasketReturn<T, void>;
   }
 }

package/src/store/patient-chart-store.ts

@@ -1,40 +1,54 @@
-import { createGlobalStore, useStore } from '@openmrs/esm-framework';
+import { type Actions, createGlobalStore, useStoreWithActions, type Visit } from '@openmrs/esm-framework';
 
 export interface PatientChartStore {
-  patientUuid?: string;
-  patient?: fhir.Patient;
+  patientUuid: string;
+  patient: fhir.Patient;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
 }
 
 const patientChartStoreName = 'patient-chart-global-store';
 
-const patientChartStore = createGlobalStore<PatientChartStore>(patientChartStoreName, {});
+const patientChartStore = createGlobalStore<PatientChartStore>(patientChartStoreName, {
+  patientUuid: null,
+  patient: null,
+  visitContext: null,
+  mutateVisitContext: null,
+});
 
-/**
- * This function returns the patient chart store.
- *
- * The patient chart store is used to store all global variables used in the patient chart.
- * In the recent requirements, patient chart is now not only bound with `/patient/{patientUuid}/` path.
- */
-export function getPatientChartStore() {
-  return patientChartStore;
-}
-
-export function usePatientChartStore() {
-  return useStore(patientChartStore);
-}
+const patientChartStoreActions = {
+  setPatient(_, patient: fhir.Patient) {
+    return { patient, patientUuid: patient?.id ?? null };
+  },
+  setVisitContext(_, visitContext: Visit, mutateVisitContext: () => void) {
+    return { visitContext, mutateVisitContext };
+  },
+} satisfies Actions<PatientChartStore>;
 
 /**
- * This function will get the patient UUID from either URL, or will look into the patient chart store.
- * @returns {string} patientUuid
- */
-export function getPatientUuidFromStore(): string | undefined {
-  return patientChartStore.getState().patientUuid;
-}
-
-/**
- * This function will get the current patient from the store
- * @returns {string} patientUuid
+ * Hook to access the values and sets of the patient chart store.
+ * Note: This hooks SHOULD only be used by components inside the patient chart app.
+ *
+ * Workspaces / extensions that can be mounted by other apps (ex: the start visit form in the queue's app,
+ * the clinical forms workspace in the ward app)
+ * should have the patient / visitContext explicitly passed in as props.
+ *
+ * As a safety feature, this hook requires the patientUuid as the input, and only
+ * returns the actual store values if input patientUuid matches that in the store.
  */
-export function getPatientFromStore(): fhir.Patient | undefined {
-  return patientChartStore.getState().patient;
+export function usePatientChartStore(patientUuid: string) {
+  const store = useStoreWithActions(patientChartStore, patientChartStoreActions);
+  if (store.patientUuid === patientUuid) {
+    return store;
+  } else {
+    const fakeStore: typeof store = {
+      ...store,
+      mutateVisitContext: null,
+      setVisitContext: () => {},
+      patient: null,
+      patientUuid: null,
+      visitContext: null,
+    };
+    return fakeStore;
+  }
 }

package/src/visit/revalidation-utils.ts

@@ -100,3 +100,12 @@ export function invalidateVisitAndEncounterData(mutate: KeyedMutator<unknown>, p
   invalidateVisitHistory(mutate, patientUuid);
   invalidatePatientEncounters(mutate, patientUuid);
 }
+
+/**
+ * Invalidates a visit fetched by URL /visit/<uuid>
+ * @param mutate - SWR mutate function from useSWRConfig()
+ * @param visitUuid
+ */
+export function invalidateVisitByUuid(mutate: KeyedMutator<unknown>, visitUuid: string) {
+  mutate(new RegExp(`${restBaseUrl}/visit/${visitUuid}`));
+}

package/src/visit/visit-mutations.ts

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { useSWRConfig } from 'swr';
 import { useVisit, type Visit, restBaseUrl } from '@openmrs/esm-framework';
+import { usePatientChartStore } from '../store/patient-chart-store';
 
 export interface VisitMutationOptions {
   encounters?: boolean;
@@ -19,7 +20,7 @@ export interface VisitMutationOptions {
  */
 export function useOptimisticVisitMutations(patientUuid: string) {
   const { mutate } = useSWRConfig();
-  const { currentVisit } = useVisit(patientUuid);
+  const { visitContext, mutateVisitContext } = usePatientChartStore(patientUuid);
 
   /**
    * Optimistically updates visit data in SWR caches without triggering network requests.
@@ -28,15 +29,8 @@ export function useOptimisticVisitMutations(patientUuid: string) {
   const updateVisitOptimistically = useCallback(
     (visitUuid: string, updates: Partial<Visit>) => {
       // Update current visit SWR cache if it matches
-      if (currentVisit?.uuid === visitUuid) {
-        mutate(
-          `${restBaseUrl}/visit?patient=${patientUuid}&v=custom`,
-          (current: any) => ({
-            ...current,
-            data: { ...current?.data, ...updates },
-          }),
-          false, // Don't revalidate
-        );
+      if (visitContext?.uuid === visitUuid) {
+        mutateVisitContext();
       }
 
       // Update visit lists across all hooks using regex pattern matching
@@ -59,7 +53,7 @@ export function useOptimisticVisitMutations(patientUuid: string) {
         false, // Don't revalidate
       );
     },
-    [currentVisit, mutate, patientUuid],
+    [visitContext, mutateVisitContext, mutate, patientUuid],
   );
 
   /**
@@ -87,11 +81,11 @@ export function useOptimisticVisitMutations(patientUuid: string) {
       );
 
       // If deleted visit was current, revalidate current visit to get new state
-      if (currentVisit?.uuid === visitUuid) {
-        mutate(`${restBaseUrl}/visit?patient=${patientUuid}&v=custom`);
+      if (visitContext?.uuid === visitUuid) {
+        mutateVisitContext();
       }
     },
-    [currentVisit, mutate, patientUuid],
+    [visitContext, mutateVisitContext, mutate, patientUuid],
   );
 
   /**

package/src/workspaces.ts

@@ -5,15 +5,17 @@ import {
   navigateAndLaunchWorkspace,
   showModal,
   useFeatureFlag,
+  type Visit,
 } from '@openmrs/esm-framework';
 import { launchStartVisitPrompt } from './launchStartVisitPrompt';
 import { usePatientChartStore } from './store/patient-chart-store';
 import { useSystemVisitSetting } from './useSystemVisitSetting';
-import { useVisitOrOfflineVisit } from './offline/visit';
 
 export interface DefaultPatientWorkspaceProps extends DefaultWorkspaceProps {
   patient: fhir.Patient;
   patientUuid: string;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
 }
 
 export function launchPatientChartWithWorkspaceOpen({
@@ -35,15 +37,14 @@ export function launchPatientChartWithWorkspaceOpen({
   });
 }
 
-export function useLaunchWorkspaceRequiringVisit<T extends object>(workspaceName: string) {
-  const { patientUuid } = usePatientChartStore();
+export function useLaunchWorkspaceRequiringVisit<T extends object>(patientUuid: string, workspaceName: string) {
+  const { visitContext } = usePatientChartStore(patientUuid);
   const { systemVisitEnabled } = useSystemVisitSetting();
-  const { currentVisit } = useVisitOrOfflineVisit(patientUuid);
   const isRdeEnabled = useFeatureFlag('rde');
 
   const launchPatientWorkspaceCb = useCallback(
     (additionalProps?: T) => {
-      if (!systemVisitEnabled || currentVisit) {
+      if (!systemVisitEnabled || visitContext) {
         launchWorkspace(workspaceName, additionalProps);
       } else {
         if (isRdeEnabled) {
@@ -58,7 +59,7 @@ export function useLaunchWorkspaceRequiringVisit<T extends object>(workspaceName
         }
       }
     },
-    [currentVisit, systemVisitEnabled, workspaceName, isRdeEnabled, patientUuid],
+    [visitContext, systemVisitEnabled, workspaceName, isRdeEnabled, patientUuid],
   );
   return launchPatientWorkspaceCb;
 }