@openmrs/esm-patient-common-lib 13.0.2-pre.12803 → 13.0.2-pre.12809

package/package.json

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

package/src/visit/index.ts

@@ -1,2 +1 @@
 export * from './revalidation-utils';
-export * from './visit-mutations';

package/src/visit/revalidation-utils.test.ts

@@ -1,41 +1,46 @@
-import { vi, describe, it, expect, test } from 'vitest';
+import { vi, describe, it, expect } from 'vitest';
 import {
-  invalidateVisitHistory,
+  invalidateVisits,
   invalidatePatientEncounters,
   invalidateVisitAndEncounterData,
-  invalidateCurrentVisit,
   invalidateVisitByUuid,
 } from './revalidation-utils';
 
 const mockMutate = vi.fn();
 
 describe('revalidation-utils', () => {
-  describe('invalidateVisitHistory', () => {
-    it('should invalidate visit history keys but not current visit keys', () => {
+  describe('invalidateVisits', () => {
+    it('should invalidate active visit, visit history and visit-by-uuid keys', () => {
       const patientUuid = 'test-patient-123';
 
-      invalidateVisitHistory(mockMutate, patientUuid);
+      invalidateVisits(mockMutate, patientUuid);
 
       expect(mockMutate).toHaveBeenCalledTimes(1);
       expect(mockMutate).toHaveBeenCalledWith(expect.any(Function));
 
-      // Test the cache key matcher function
       const matcherFn = mockMutate.mock.calls[0][0];
 
-      // Should invalidate visit history keys (with pagination params)
+      // Active visit keys
+      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=false')).toBe(true);
+
+      // Visit history keys (with pagination params)
       expect(
         matcherFn(
           '/ws/rest/v1/visit?patient=test-patient-123&v=custom:(uuid,location)&limit=10&startIndex=0&totalCount=true',
         ),
       ).toBe(true);
 
-      // Should invalidate visit history keys (without includeInactive)
+      // Visit history keys (without includeInactive)
       expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom:(uuid,location)')).toBe(true);
 
-      // Should NOT invalidate current visit keys (with includeInactive=false)
-      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=false')).toBe(false);
+      // Visits fetched by UUID (e.g. the visit context)
+      expect(matcherFn('/ws/rest/v1/visit/test-visit-123?v=custom:(uuid,display)')).toBe(true);
+      expect(matcherFn('/ws/rest/v1/visit/test-visit-123/attribute')).toBe(true);
+
+      // Past visit keys (includeInactive=true)
+      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=true')).toBe(true);
 
-      // Should not match other patient's keys
+      // Should not match other patient's visit lists
       expect(matcherFn('/ws/rest/v1/visit?patient=other-patient&v=custom')).toBe(false);
 
       // Should not match non-visit endpoints
@@ -77,7 +82,7 @@ describe('revalidation-utils', () => {
   });
 
   describe('invalidateVisitAndEncounterData', () => {
-    it('should call both visit history and encounter invalidation functions', () => {
+    it('should call both visit and encounter invalidation functions', () => {
       const patientUuid = 'test-patient-123';
 
       invalidateVisitAndEncounterData(mockMutate, patientUuid);
@@ -93,38 +98,13 @@ describe('revalidation-utils', () => {
 
       // Visit matcher should work
       expect(visitMatcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&limit=10')).toBe(true);
+      expect(visitMatcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=false')).toBe(true);
 
       // Encounter matcher should work
       expect(encounterMatcherFn('/ws/rest/v1/encounter?patient=test-patient-123&v=custom')).toBe(true);
     });
   });
 
-  describe('invalidateCurrentVisit', () => {
-    it('should invalidate only current visit keys', () => {
-      const patientUuid = 'test-patient-123';
-
-      invalidateCurrentVisit(mockMutate, patientUuid);
-
-      expect(mockMutate).toHaveBeenCalledTimes(1);
-      expect(mockMutate).toHaveBeenCalledWith(expect.any(Function));
-
-      const matcherFn = mockMutate.mock.calls[0][0];
-
-      // Should match current visit key (includeInactive=false)
-      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=false')).toBe(true);
-
-      // Should not match other visit keys
-      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=true')).toBe(false);
-      expect(
-        matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&limit=10&startIndex=0&totalCount=true'),
-      ).toBe(false);
-      expect(matcherFn('/ws/rest/v1/visit/test-patient-123')).toBe(false);
-
-      // Should not match encounter keys
-      expect(matcherFn('/ws/rest/v1/encounter?patient=test-patient-123&v=custom')).toBe(false);
-    });
-  });
-
   describe('invalidateVisitByUuid', () => {
     it('should invalidate only keys for the specified visit', () => {
       const visitUuid = 'test-visit-123';

package/src/visit/revalidation-utils.ts

@@ -2,59 +2,25 @@ import type { KeyedMutator } from 'swr';
 import { restBaseUrl } from '@openmrs/esm-framework';
 
 /**
- * Invalidates visit history table data without triggering global visit revalidation cascade.
- *
- * This function provides surgical SWR cache invalidation for visit operations. It targets only
- * the paginated visit data used by the visit history table, avoiding unnecessary revalidation
- * of the 28+ components that use current visit data via the useVisit hook.
- *
- * The implementation uses URL pattern matching to discriminate between:
- * - Current visit keys (includeInactive=false) - these are NOT invalidated
- * - Visit history keys (no includeInactive param, or pagination params) - these ARE invalidated
+ * Invalidates all visit data for a patient: active and past visit lists (e.g. `useVisit`, the visit
+ * history table) as well as individual visits fetched by UUID (e.g. the visit context).
  *
  * Cache key patterns:
- * - Current visit: /visit?patient=123&v=custom&includeInactive=false
+ * - Active visit: /visit?patient=123&v=custom&includeInactive=false
  * - Visit history: /visit?patient=123&v=custom:(uuid,location...)&limit=10&startIndex=0&totalCount=true
+ * - Visit by UUID: /visit/<visit-uuid>?v=custom:(uuid,...)
  *
- * This approach eliminates the 13+ cascade revalidation requests that were previously triggered
- * by global mutateVisit() calls, reducing network traffic and improving performance.
+ * Visit-by-UUID keys do not carry the patient UUID, so all of them are invalidated.
  *
  * @param mutate - SWR mutate function from useSWRConfig()
  * @param patientUuid - Patient UUID to target visit data for
- *
- * @example
- * ```typescript
- * import { useSWRConfig } from 'swr';
- * import { invalidateVisitHistory } from '@openmrs/esm-patient-common-lib';
- *
- * function MyComponent({ patientUuid }) {
- *   const { mutate } = useSWRConfig();
- *
- *   const handleVisitUpdate = async () => {
- *     // Perform visit operation...
- *     await updateVisit(visitData);
- *
- *     // Invalidate only visit history table, not current visit components
- *     invalidateVisitHistory(mutate, patientUuid);
- *   };
- * }
- * ```
  */
-export function invalidateVisitHistory(mutate: KeyedMutator<unknown>, patientUuid: string): void {
+export function invalidateVisits(mutate: KeyedMutator<unknown>, patientUuid: string): void {
   mutate((key) => {
-    if (typeof key === 'string' && key.includes(`${restBaseUrl}/visit?patient=${patientUuid}`)) {
-      // Current visit keys have includeInactive=false
-      const isCurrentVisitKey = key.includes('includeInactive=false');
-
-      // Visit history keys typically have pagination parameters or no includeInactive parameter
-      const hasHistoryParams = key.includes('limit=') || key.includes('startIndex=') || key.includes('totalCount=');
-      const hasNoIncludeInactive = !key.includes('includeInactive');
-
-      // Invalidate if it's clearly a history key OR if it doesn't have includeInactive=false
-      // This ensures we target visit history while preserving current visit cache
-      return !isCurrentVisitKey && (hasHistoryParams || hasNoIncludeInactive);
-    }
-    return false;
+    return (
+      typeof key === 'string' &&
+      (key.includes(`${restBaseUrl}/visit?patient=${patientUuid}`) || key.includes(`${restBaseUrl}/visit/`))
+    );
   });
 }
 
@@ -82,25 +48,7 @@ export function invalidatePatientEncounters(mutate: KeyedMutator<unknown>, patie
 }
 
 /**
- * Invalidates only the current (active) visit cache for a specific patient.
- *
- * This refreshes components using useVisit without triggering the visit revalidation cascade.
- *
- * @param mutate - SWR mutate function from useSWRConfig()
- * @param patientUuid - Patient UUID to target current visit data for
- */
-export function invalidateCurrentVisit(mutate: KeyedMutator<unknown>, patientUuid: string): void {
-  mutate((key) => {
-    return (
-      typeof key === 'string' &&
-      key.includes(`${restBaseUrl}/visit?patient=${patientUuid}`) &&
-      key.includes('includeInactive=false')
-    );
-  });
-}
-
-/**
- * Combination utility that invalidates both visit history and encounter data.
+ * Combination utility that invalidates both visit (active and past) and encounter data.
  *
  * This is commonly needed when operations affect both visit structure and encounter content,
  * such as form submissions, visit note creation, or encounter deletion.
@@ -115,7 +63,7 @@ export function invalidateCurrentVisit(mutate: KeyedMutator<unknown>, patientUui
  * ```
  */
 export function invalidateVisitAndEncounterData(mutate: KeyedMutator<unknown>, patientUuid: string): void {
-  invalidateVisitHistory(mutate, patientUuid);
+  invalidateVisits(mutate, patientUuid);
   invalidatePatientEncounters(mutate, patientUuid);
 }
 

package/src/visit/visit-mutations.ts

@@ -1,193 +0,0 @@
-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;
-  notes?: boolean;
-  orders?: boolean;
-  observations?: boolean;
-}
-
-/**
- * Hook providing optimistic update utilities for visit-related data.
- * This hook helps reduce the number of network requests by updating SWR caches directly
- * instead of triggering full revalidations across all visit-related hooks.
- *
- * @param patientUuid The UUID of the patient
- * @returns Object containing optimistic update functions
- */
-export function useOptimisticVisitMutations(patientUuid: string) {
-  const { mutate } = useSWRConfig();
-  const { visitContext, mutateVisitContext } = usePatientChartStore(patientUuid);
-
-  /**
-   * Optimistically updates visit data in SWR caches without triggering network requests.
-   * Updates both the current visit cache and visit list caches.
-   */
-  const updateVisitOptimistically = useCallback(
-    (visitUuid: string, updates: Partial<Visit>) => {
-      // Update current visit SWR cache if it matches
-      if (visitContext?.uuid === visitUuid) {
-        mutateVisitContext?.();
-      }
-
-      // Update visit lists across all hooks using regex pattern matching
-      const visitListPattern = new RegExp(`${restBaseUrl}/visit\\?patient=${patientUuid}`);
-
-      mutate(
-        visitListPattern,
-        (current: any) => {
-          if (!current?.data?.results) return current;
-          return {
-            ...current,
-            data: {
-              ...current.data,
-              results: current.data.results.map((visit: Visit) =>
-                visit.uuid === visitUuid ? { ...visit, ...updates } : visit,
-              ),
-            },
-          };
-        },
-        false, // Don't revalidate
-      );
-    },
-    [visitContext, mutateVisitContext, mutate, patientUuid],
-  );
-
-  /**
-   * Optimistically removes a visit from SWR caches without triggering network requests.
-   * Removes from visit lists and revalidates current visit if the deleted visit was current.
-   */
-  const removeVisitOptimistically = useCallback(
-    (visitUuid: string) => {
-      // Remove from all visit list caches
-      const visitListPattern = new RegExp(`${restBaseUrl}/visit\\?patient=${patientUuid}`);
-
-      mutate(
-        visitListPattern,
-        (current: any) => {
-          if (!current?.data?.results) return current;
-          return {
-            ...current,
-            data: {
-              ...current.data,
-              results: current.data.results.filter((visit: Visit) => visit.uuid !== visitUuid),
-            },
-          };
-        },
-        false, // Don't revalidate
-      );
-
-      // If deleted visit was current, revalidate current visit to get new state
-      if (visitContext?.uuid === visitUuid) {
-        mutateVisitContext?.();
-      }
-    },
-    [visitContext, mutateVisitContext, mutate, patientUuid],
-  );
-
-  /**
-   * Optimistically adds a new visit to SWR caches without triggering network requests.
-   * Adds to visit lists and updates current visit cache if appropriate.
-   */
-  const addVisitOptimistically = useCallback(
-    (newVisit: Visit) => {
-      // Add to visit list caches
-      const visitListPattern = new RegExp(`${restBaseUrl}/visit\\?patient=${patientUuid}`);
-
-      mutate(
-        visitListPattern,
-        (current: any) => {
-          if (!current?.data?.results) return current;
-          return {
-            ...current,
-            data: {
-              ...current.data,
-              results: [newVisit, ...current.data.results],
-            },
-          };
-        },
-        false, // Don't revalidate
-      );
-
-      // If this is an active visit (no stopDatetime), update current visit cache
-      if (!newVisit.stopDatetime) {
-        mutate(
-          `${restBaseUrl}/visit?patient=${patientUuid}&v=custom`,
-          (current: any) => ({
-            ...current,
-            data: newVisit,
-          }),
-          false, // Don't revalidate
-        );
-      }
-    },
-    [mutate, patientUuid],
-  );
-
-  /**
-   * Selectively invalidates only specific visit-related data that cannot be optimistically updated.
-   * This replaces the global mutateVisit() pattern with targeted revalidation.
-   */
-  const invalidateVisitRelatedData = useCallback(
-    (options: VisitMutationOptions = {}) => {
-      const promises = [];
-
-      if (options.encounters) {
-        promises.push(mutate(new RegExp(`${restBaseUrl}/encounter\\?patient=${patientUuid}`)));
-      }
-      if (options.notes) {
-        promises.push(mutate(new RegExp(`${restBaseUrl}/encounter\\?patient=${patientUuid}.*obs=`)));
-      }
-      if (options.orders) {
-        promises.push(mutate(new RegExp(`${restBaseUrl}/order\\?patient=${patientUuid}`)));
-      }
-      if (options.observations) {
-        promises.push(mutate(new RegExp(`${restBaseUrl}/obs\\?patient=${patientUuid}`)));
-      }
-
-      return Promise.all(promises);
-    },
-    [mutate, patientUuid],
-  );
-
-  /**
-   * Revalidates only the current visit data with a single targeted request.
-   * This confirms the optimistic update with fresh server data.
-   */
-  const revalidateCurrentVisit = useCallback(() => {
-    // Single revalidation request for current visit only
-    return mutate(`${restBaseUrl}/visit?patient=${patientUuid}&v=custom`);
-  }, [mutate, patientUuid]);
-
-  /**
-   * Fallback function that triggers full revalidation when optimistic updates fail.
-   * This ensures data consistency when errors occur.
-   */
-  const revalidateAllVisitData = useCallback(() => {
-    // Revalidate current visit
-    mutate(`${restBaseUrl}/visit?patient=${patientUuid}&v=custom`);
-
-    // Revalidate visit lists
-    mutate(new RegExp(`${restBaseUrl}/visit\\?patient=${patientUuid}`));
-
-    // Revalidate related data
-    return invalidateVisitRelatedData({
-      encounters: true,
-      notes: true,
-      orders: true,
-      observations: true,
-    });
-  }, [mutate, patientUuid, invalidateVisitRelatedData]);
-
-  return {
-    addVisitOptimistically,
-    invalidateVisitRelatedData,
-    removeVisitOptimistically,
-    revalidateAllVisitData,
-    revalidateCurrentVisit,
-    updateVisitOptimistically,
-  };
-}