@openmrs/esm-patient-registration-app 3.0.2-pre.310 → 3.0.2-pre.316

package/src/offline.resources.ts

@@ -1,7 +1,8 @@
 import React from 'react';
 import find from 'lodash-es/find';
 import camelCase from 'lodash-es/camelCase';
-import { FetchResponse, openmrsFetch, SessionUser } from '@openmrs/esm-framework';
+import escapeRegExp from 'lodash-es/escapeRegExp';
+import { FetchResponse, messageOmrsServiceWorker, openmrsFetch, SessionUser } from '@openmrs/esm-framework';
 import { PatientIdentifierType, FetchedPatientIdentifierType } from './patient-registration/patient-registration-types';
 import { mockAutoGenerationOptionsResult } from '../__mocks__/autogenerationoptions.mock';
 import { cacheForOfflineHeaders } from './constants';
@@ -16,26 +17,20 @@ export interface Resources {
 export const ResourcesContext = React.createContext<Resources>(null);
 
 export async function fetchCurrentSession(abortController?: AbortController): Promise<FetchResponse<SessionUser>> {
-  const { data } = await openmrsFetch('/ws/rest/v1/session', {
-    signal: abortController?.signal,
-    headers: cacheForOfflineHeaders,
-  });
+  const { data } = await cacheAndFetch('/ws/rest/v1/session', abortController);
   return data;
 }
 
 export async function fetchAddressTemplate(abortController?: AbortController) {
-  const { data } = await openmrsFetch('/ws/rest/v1/systemsetting?q=layout.address.format&v=custom:(value)', {
-    signal: abortController?.signal,
-    headers: cacheForOfflineHeaders,
-  });
+  const { data } = await cacheAndFetch(
+    '/ws/rest/v1/systemsetting?q=layout.address.format&v=custom:(value)',
+    abortController,
+  );
   return data;
 }
 
 export async function fetchAllRelationshipTypes(abortController?: AbortController) {
-  const { data } = await openmrsFetch('/ws/rest/v1/relationshiptype?v=default', {
-    signal: abortController?.signal,
-    headers: cacheForOfflineHeaders,
-  });
+  const { data } = await cacheAndFetch('/ws/rest/v1/relationshiptype?v=default', abortController);
   return data;
 }
 
@@ -69,14 +64,14 @@ export async function fetchPatientIdentifierTypesWithSources(
 }
 
 async function fetchPrimaryIdentifierType(abortController: AbortController): Promise<FetchedPatientIdentifierType> {
-  const primaryIdentifierTypeResponse = await openmrsFetch(
+  const primaryIdentifierTypeResponse = await cacheAndFetch(
     '/ws/rest/v1/metadatamapping/termmapping?v=full&code=emr.primaryIdentifierType',
-    { signal: abortController?.signal, headers: cacheForOfflineHeaders },
+    abortController,
   );
 
-  const { data: metadata } = await openmrsFetch(
+  const { data: metadata } = await cacheAndFetch(
     `/ws/rest/v1/patientidentifiertype/${primaryIdentifierTypeResponse.data.results[0].metadataUuid}`,
-    { signal: abortController?.signal, headers: cacheForOfflineHeaders },
+    abortController,
   );
 
   return {
@@ -92,25 +87,25 @@ async function fetchPrimaryIdentifierType(abortController: AbortController): Pro
 async function fetchSecondaryIdentifierTypes(
   abortController?: AbortController,
 ): Promise<Array<FetchedPatientIdentifierType>> {
-  const secondaryIdentifierTypeResponse = await openmrsFetch(
+  const secondaryIdentifierTypeResponse = await cacheAndFetch(
     '/ws/rest/v1/metadatamapping/termmapping?v=full&code=emr.extraPatientIdentifierTypes',
-    { signal: abortController?.signal, headers: cacheForOfflineHeaders },
+    abortController,
   );
 
   if (secondaryIdentifierTypeResponse.data.results) {
     const extraIdentifierTypesSetUuid = secondaryIdentifierTypeResponse.data.results[0].metadataUuid;
-    const metadataResponse = await openmrsFetch(
+    const metadataResponse = await cacheAndFetch(
       `/ws/rest/v1/metadatamapping/metadataset/${extraIdentifierTypesSetUuid}/members`,
-      { signal: abortController?.signal, headers: cacheForOfflineHeaders },
+      abortController,
     );
 
     if (metadataResponse.data.results) {
       return await Promise.all(
         metadataResponse.data.results.map(async (setMember) => {
-          const type = await openmrsFetch(`/ws/rest/v1/patientidentifiertype/${setMember.metadataUuid}`, {
-            signal: abortController?.signal,
-            headers: cacheForOfflineHeaders,
-          });
+          const type = await cacheAndFetch(
+            `/ws/rest/v1/patientidentifiertype/${setMember.metadataUuid}`,
+            abortController,
+          );
 
           return {
             name: type.data.name,
@@ -129,10 +124,10 @@ async function fetchSecondaryIdentifierTypes(
 }
 
 async function fetchIdentifierSources(identifierType: string, abortController?: AbortController) {
-  return await openmrsFetch(`/ws/rest/v1/idgen/identifiersource?v=full&identifierType=${identifierType}`, {
-    signal: abortController?.signal,
-    headers: cacheForOfflineHeaders,
-  });
+  return await cacheAndFetch(
+    `/ws/rest/v1/idgen/identifiersource?v=full&identifierType=${identifierType}`,
+    abortController,
+  );
 }
 
 function fetchAutoGenerationOptions(identifierType: string, abortController?: AbortController) {
@@ -142,3 +137,12 @@ function fetchAutoGenerationOptions(identifierType: string, abortController?: Ab
   // });‚
   return Promise.resolve(mockAutoGenerationOptionsResult);
 }
+
+async function cacheAndFetch(url: string, abortController?: AbortController) {
+  await messageOmrsServiceWorker({
+    type: 'registerDynamicRoute',
+    pattern: escapeRegExp(url),
+  });
+
+  return await openmrsFetch(url, { headers: cacheForOfflineHeaders, signal: abortController?.signal });
+}

package/src/offline.ts

@@ -41,15 +41,15 @@ export async function syncPatientRegistration(
   options: SyncProcessOptions<PatientRegistration>,
 ) {
   await FormManager.savePatientFormOnline(
-    undefined,
-    queuedPatient.formValues,
-    queuedPatient.patientUuidMap,
-    queuedPatient.initialAddressFieldValues,
-    queuedPatient.identifierTypes,
-    queuedPatient.capturePhotoProps,
-    queuedPatient.patientPhotoConceptUuid,
-    queuedPatient.currentLocation,
-    queuedPatient.personAttributeSections,
+    queuedPatient._patientRegistrationData.isNewPatient,
+    queuedPatient._patientRegistrationData.formValues,
+    queuedPatient._patientRegistrationData.patientUuidMap,
+    queuedPatient._patientRegistrationData.initialAddressFieldValues,
+    queuedPatient._patientRegistrationData.identifierTypes,
+    queuedPatient._patientRegistrationData.capturePhotoProps,
+    queuedPatient._patientRegistrationData.patientPhotoConceptUuid,
+    queuedPatient._patientRegistrationData.currentLocation,
+    queuedPatient._patientRegistrationData.personAttributeSections,
     options.abort,
   );
 }

package/src/patient-registration/form-manager.ts

@@ -10,6 +10,7 @@ import {
   CapturePhotoProps,
   PatientIdentifier,
   PatientIdentifierValue,
+  PatientRegistration,
 } from './patient-registration-types';
 import {
   addPatientIdentifier,
@@ -24,7 +25,7 @@ import {
 import isEqual from 'lodash-es/isEqual';
 
 export type SavePatientForm = (
-  patientUuid: string | undefined,
+  isNewPatient: boolean,
   values: FormValues,
   patientUuidMap: PatientUuidMapType,
   initialAddressFieldValues: Record<string, any>,
@@ -38,7 +39,7 @@ export type SavePatientForm = (
 
 export default class FormManager {
   static async savePatientFormOffline(
-    patientUuid = v4(),
+    isNewPatient: boolean,
     values: FormValues,
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
@@ -48,10 +49,12 @@ export default class FormManager {
     currentLocation: string,
     personAttributeSections: any,
   ): Promise<null> {
-    await queueSynchronizationItem(
-      patientRegistration,
-      {
-        patientUuid,
+    const syncItem: PatientRegistration = {
+      fhirPatient: FormManager.mapPatientToFhirPatient(
+        FormManager.getPatientToCreate(values, personAttributeSections, patientUuidMap, initialAddressFieldValues, []),
+      ),
+      _patientRegistrationData: {
+        isNewPatient,
         formValues: values,
         patientUuidMap,
         initialAddressFieldValues,
@@ -61,18 +64,19 @@ export default class FormManager {
         currentLocation,
         personAttributeSections,
       },
-      {
-        id: patientUuid,
-        displayName: 'Patient registration',
-        dependencies: [],
-      },
-    );
+    };
+
+    await queueSynchronizationItem(patientRegistration, syncItem, {
+      id: values.patientUuid,
+      displayName: 'Patient registration',
+      dependencies: [],
+    });
 
     return null;
   }
 
   static async savePatientFormOnline(
-    patientUuid: string | undefined,
+    isNewPatient: boolean,
     values: FormValues,
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
@@ -90,9 +94,9 @@ export default class FormManager {
       abortController,
     );
 
-    if (patientUuid) {
+    if (!isNewPatient) {
       await Promise.all(
-        FormManager.savePatientIdentifiers(patientUuid, patientIdentifiers, values.identifiers, abortController),
+        FormManager.savePatientIdentifiers(values.patientUuid, patientIdentifiers, values.identifiers, abortController),
       );
     }
 
@@ -104,11 +108,15 @@ export default class FormManager {
       patientIdentifiers,
     );
 
-    FormManager.getDeletedNames(patientUuidMap).forEach(async (name) => {
+    FormManager.getDeletedNames(values.patientUuid, patientUuidMap).forEach(async (name) => {
       await deletePersonName(name.nameUuid, name.personUuid, abortController);
     });
 
-    const savePatientResponse = await savePatient(abortController, createdPatient, patientUuidMap.patientUuid);
+    const savePatientResponse = await savePatient(
+      abortController,
+      createdPatient,
+      isNewPatient ? undefined : values.patientUuid,
+    );
 
     if (savePatientResponse.ok) {
       await Promise.all(
@@ -145,7 +153,7 @@ export default class FormManager {
   }
 
   static getPatientIdentifiersToCreate(
-    patientIdentifiers: PatientIdentifierValue[], // values.identifiers
+    patientIdentifiers: PatientIdentifierValue[],
     identifierTypes: Array<PatientIdentifierType>,
     location: string,
     abortController: AbortController,
@@ -192,12 +200,12 @@ export default class FormManager {
     return Promise.all(identifierTypeRequests);
   }
 
-  static getDeletedNames(patientUuidMap: PatientUuidMapType) {
+  static getDeletedNames(patientUuid: string, patientUuidMap: PatientUuidMapType) {
     if (patientUuidMap?.additionalNameUuid) {
       return [
         {
           nameUuid: patientUuidMap.additionalNameUuid,
-          personUuid: patientUuidMap.patientUuid,
+          personUuid: patientUuid,
         },
       ];
     }
@@ -218,9 +226,9 @@ export default class FormManager {
     }
 
     return {
-      uuid: patientUuidMap['patientUuid'],
+      uuid: values.patientUuid,
       person: {
-        uuid: patientUuidMap['patientUuid'],
+        uuid: values.patientUuid,
         names: FormManager.getNames(values, patientUuidMap),
         gender: values.gender.charAt(0),
         birthdate: values.birthdate,
@@ -309,4 +317,45 @@ export default class FormManager {
       }
     });
   }
+
+  static mapPatientToFhirPatient(patient: Partial<Patient>): fhir.Patient {
+    // Important:
+    // When changing this code, ideally assume that `patient` can be missing any attribute.
+    // The `fhir.Patient` provides us with the benefit that all properties are nullable and thus
+    // not required (technically, at least). -> Even if we cannot map some props here, we still
+    // provide a valid fhir.Patient object. The various patient chart modules should be able to handle
+    // such missing props correctly (and should be updated if they don't).
+
+    // Gender in the original object only uses a single letter. fhir.Patient expects a full string.
+    const genderMap = {
+      M: 'male',
+      F: 'female',
+      O: 'other',
+      U: 'unknown',
+    };
+
+    // Mapping inspired by:
+    // https://github.com/openmrs/openmrs-module-fhir/blob/669b3c52220bb9abc622f815f4dc0d8523687a57/api/src/main/java/org/openmrs/module/fhir/api/util/FHIRPatientUtil.java#L36
+    // https://github.com/openmrs/openmrs-esm-patient-management/blob/94e6f637fb37cf4984163c355c5981ea6b8ca38c/packages/esm-patient-search-app/src/patient-search-result/patient-search-result.component.tsx#L21
+    // Update as required.
+    return {
+      id: patient.uuid,
+      gender: genderMap[patient.person?.gender],
+      birthDate: patient.person?.birthdate,
+      deceasedBoolean: patient.person.dead,
+      deceasedDateTime: patient.person.deathDate,
+      name: patient.person?.names?.map((name) => ({
+        given: [name.givenName, name.middleName].filter(Boolean),
+        family: name.familyName,
+      })),
+      address: patient.person?.addresses.map((address) => ({
+        city: address.cityVillage,
+        country: address.country,
+        postalCode: address.postalCode,
+        state: address.stateProvince,
+        use: 'home',
+      })),
+      telecom: patient.person.attributes?.filter((attribute) => attribute.attributeType === 'Telephone Number'),
+    };
+  }
 }

package/src/patient-registration/input/dummy-data/dummy-data-input.component.tsx

@@ -1,4 +1,5 @@
 import React from 'react';
+import { v4 } from 'uuid';
 import { FormValues } from '../../patient-registration-types';
 import styles from './../input.scss';
 
@@ -7,6 +8,7 @@ interface DummyDataInputProps {
 }
 
 export const dummyFormValues: FormValues = {
+  patientUuid: v4(),
   givenName: 'John',
   middleName: '',
   familyName: 'Smith',

package/src/patient-registration/patient-registration-hooks.ts

@@ -1,12 +1,8 @@
 import { getSynchronizationItems, usePatient } from '@openmrs/esm-framework';
 import { Dispatch, useEffect, useState } from 'react';
+import { v4 } from 'uuid';
 import { patientRegistration } from '../constants';
-import {
-  FormValues,
-  PatientIdentifierValue,
-  PatientRegistration,
-  PatientUuidMapType,
-} from './patient-registration-types';
+import { FormValues, PatientRegistration, PatientUuidMapType } from './patient-registration-types';
 import {
   getAddressFieldValuesFromFhirPatient,
   getFormValuesFromFhirPatient,
@@ -15,57 +11,61 @@ import {
   getPhonePersonAttributeValueFromFhirPatient,
 } from './patient-registration-utils';
 
-const blankFormValues: FormValues = {
-  givenName: '',
-  middleName: '',
-  familyName: '',
-  unidentifiedPatient: false,
-  additionalGivenName: '',
-  additionalMiddleName: '',
-  additionalFamilyName: '',
-  addNameInLocalLanguage: false,
-  gender: '',
-  birthdate: null,
-  yearsEstimated: 0,
-  monthsEstimated: 0,
-  birthdateEstimated: false,
-  telephoneNumber: '',
-  address1: '',
-  address2: '',
-  cityVillage: '',
-  stateProvince: '',
-  country: '',
-  postalCode: '',
-  isDead: false,
-  deathDate: '',
-  deathCause: '',
-  relationships: [{ relatedPerson: '', relationship: '' }],
-  identifiers: [],
-};
-
-export function useInitialFormValues(
-  patientUuid: string,
-  fallback = blankFormValues,
-): [FormValues, Dispatch<FormValues>] {
-  const { isLoading, patient } = usePatient(patientUuid);
-  const [initialFormValues, setInitialFormValues] = useState<FormValues>(fallback);
+export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch<FormValues>] {
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
+  const [initialFormValues, setInitialFormValues] = useState<FormValues>({
+    patientUuid: v4(),
+    givenName: '',
+    middleName: '',
+    familyName: '',
+    unidentifiedPatient: false,
+    additionalGivenName: '',
+    additionalMiddleName: '',
+    additionalFamilyName: '',
+    addNameInLocalLanguage: false,
+    gender: '',
+    birthdate: null,
+    yearsEstimated: 0,
+    monthsEstimated: 0,
+    birthdateEstimated: false,
+    telephoneNumber: '',
+    address1: '',
+    address2: '',
+    cityVillage: '',
+    stateProvince: '',
+    country: '',
+    postalCode: '',
+    isDead: false,
+    deathDate: '',
+    deathCause: '',
+    relationships: [{ relatedPerson: '', relationship: '' }],
+    identifiers: [],
+  });
 
   useEffect(() => {
     (async () => {
-      if (patient) {
+      if (patientToEdit) {
         setInitialFormValues({
           ...initialFormValues,
-          ...getFormValuesFromFhirPatient(patient),
-          ...getAddressFieldValuesFromFhirPatient(patient),
-          ...getPhonePersonAttributeValueFromFhirPatient(patient),
+          ...getFormValuesFromFhirPatient(patientToEdit),
+          ...getAddressFieldValuesFromFhirPatient(patientToEdit),
+          ...getPhonePersonAttributeValueFromFhirPatient(patientToEdit),
           identifiers: await getPatientIdentifiers(patientUuid),
         });
-      } else if (!isLoading && patientUuid) {
+      } else if (!isLoadingPatientToEdit && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
-        setInitialFormValues(registration?.formValues ?? fallback);
+
+        if (!registration._patientRegistrationData.formValues) {
+          console.error(
+            `Found a queued offline patient registration for patient ${patientUuid}, but without form values. Not using these values.`,
+          );
+          return;
+        }
+
+        setInitialFormValues(registration._patientRegistrationData.formValues);
       }
     })();
-  }, [isLoading, patient, patientUuid]);
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
   return [initialFormValues, setInitialFormValues];
 }
@@ -83,7 +83,7 @@ export function useInitialAddressFieldValues(patientUuid: string, fallback = {})
         });
       } else if (!isLoading && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
-        setInitialAddressFieldValues(registration?.initialAddressFieldValues ?? fallback);
+        setInitialAddressFieldValues(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback);
       }
     })();
   }, [isLoading, patient, patientUuid]);
@@ -93,26 +93,25 @@ export function useInitialAddressFieldValues(patientUuid: string, fallback = {})
 
 export function usePatientUuidMap(
   patientUuid: string,
-  fallback = {},
+  fallback: PatientUuidMapType = {},
 ): [PatientUuidMapType, Dispatch<PatientUuidMapType>] {
-  const { isLoading, patient } = usePatient(patientUuid);
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
   const [patientUuidMap, setPatientUuidMap] = useState(fallback);
 
   useEffect(() => {
-    (async () => {
-      if (patient) {
-        setPatientUuidMap({ ...patientUuidMap, ...getPatientUuidMapFromFhirPatient(patient) });
-      } else if (!isLoading && patientUuid) {
-        const registration = await getPatientRegistration(patientUuid);
-        setPatientUuidMap(registration?.initialAddressFieldValues ?? fallback);
-      }
-    })();
-  }, [isLoading, patient, patientUuid]);
+    if (patientToEdit) {
+      setPatientUuidMap({ ...patientUuidMap, ...getPatientUuidMapFromFhirPatient(patientToEdit) });
+    } else if (!isLoadingPatientToEdit && patientUuid) {
+      getPatientRegistration(patientUuid).then((registration) =>
+        setPatientUuidMap(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback),
+      );
+    }
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
   return [patientUuidMap, setPatientUuidMap];
 }
 
 async function getPatientRegistration(patientUuid: string) {
   const items = await getSynchronizationItems<PatientRegistration>(patientRegistration);
-  return items.find((item) => item.patientUuid === patientUuid);
+  return items.find((item) => item._patientRegistrationData.formValues.patientUuid === patientUuid);
 }

package/src/patient-registration/patient-registration-types.tsx

@@ -38,15 +38,25 @@ export interface PatientIdentifierValue {
 
 export interface PatientRegistration {
   id?: number;
-  patientUuid: string;
-  formValues: FormValues;
-  patientUuidMap: PatientUuidMapType;
-  initialAddressFieldValues: Record<string, any>;
-  identifierTypes: Array<PatientIdentifierType>;
-  capturePhotoProps: CapturePhotoProps;
-  patientPhotoConceptUuid: string;
-  currentLocation: string;
-  personAttributeSections: any;
+  /**
+   * The preliminary patient in the FHIR format.
+   */
+  fhirPatient: fhir.Patient;
+  /**
+   * Internal data collected by patient-registration. Required for later syncing and editing.
+   * Not supposed to be used outside of this module.
+   */
+  _patientRegistrationData: {
+    isNewPatient: boolean;
+    formValues: FormValues;
+    patientUuidMap: PatientUuidMapType;
+    initialAddressFieldValues: Record<string, any>;
+    identifierTypes: Array<PatientIdentifierType>;
+    capturePhotoProps: CapturePhotoProps;
+    patientPhotoConceptUuid: string;
+    currentLocation: string;
+    personAttributeSections: any;
+  };
 }
 
 /**
@@ -100,6 +110,7 @@ export interface IdentifierSource {
 }
 
 export interface FormValues {
+  patientUuid: string;
   givenName: string;
   middleName: string;
   familyName: string;
@@ -129,7 +140,6 @@ export interface FormValues {
 
 export interface PatientUuidMapType {
   additionalNameUuid?: string;
-  patientUuid?: string;
   preferredNameUuid?: string;
   preferredAddressUuid?: string;
 }

package/src/patient-registration/patient-registration-utils.ts

@@ -73,6 +73,7 @@ export function getFormValuesFromFhirPatient(patient: fhir.Patient) {
   const patientName = patient.name[0];
   const additionalPatientName = patient.name[1];
 
+  result.patientUuid = patient.id;
   result.givenName = patientName?.given[0];
   result.middleName = patientName?.given[1];
   result.familyName = patientName?.family;
@@ -142,7 +143,6 @@ export function getPatientUuidMapFromFhirPatient(patient: fhir.Patient): Patient
   const address = patient.address?.[0];
 
   return {
-    patientUuid: patient.id,
     preferredNameUuid: patientName?.id,
     additionalNameUuid: additionalPatientName?.id,
     preferredAddressUuid: address?.id,

package/src/patient-registration/patient-registration.component.tsx

@@ -36,21 +36,21 @@ export const PatientRegistration: React.FC<PatientRegistrationProps> = ({ savePa
   const { currentSession, addressTemplate, patientIdentifiers } = useContext(ResourcesContext);
   const { search } = useLocation();
   const config = useConfig();
-  const { patientUuid } = match.params;
   const [sections, setSections] = useState([]);
   const [target, setTarget] = useState<undefined | string>();
   const [validationSchema, setValidationSchema] = useState(initialSchema);
-  const { isLoading, patient } = usePatient(patientUuid);
+  const { patientUuid: uuidOfPatientToEdit } = match.params;
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(uuidOfPatientToEdit);
   const { t } = useTranslation();
   const [capturePhotoProps, setCapturePhotoProps] = useState<CapturePhotoProps | null>(null);
   const [fieldConfigs, setFieldConfigs] = useState({});
-  const [initialFormValues, setInitialFormValues] = useInitialFormValues(patientUuid);
-  const [initialAddressFieldValues] = useInitialAddressFieldValues(patientUuid);
-  const [patientUuidMap] = usePatientUuidMap(patientUuid);
+  const [initialFormValues, setInitialFormValues] = useInitialFormValues(uuidOfPatientToEdit);
+  const [initialAddressFieldValues] = useInitialAddressFieldValues(uuidOfPatientToEdit);
+  const [patientUuidMap] = usePatientUuidMap(uuidOfPatientToEdit);
   const location = currentSession.sessionLocation?.uuid;
-  const inEditMode = isLoading ? undefined : !!(patientUuid && patient);
+  const inEditMode = isLoadingPatientToEdit ? undefined : !!(uuidOfPatientToEdit && patientToEdit);
   const showDummyData = useMemo(() => localStorage.getItem('openmrs:devtools') === 'true' && !inEditMode, [inEditMode]);
-  const { data: photo } = usePatientPhoto(patient?.id);
+  const { data: photo } = usePatientPhoto(patientToEdit?.id);
 
   useEffect(() => {
     exportedInitialFormValuesForTesting = initialFormValues;
@@ -98,8 +98,8 @@ export const PatientRegistration: React.FC<PatientRegistrationProps> = ({ savePa
     helpers.setSubmitting(true);
 
     try {
-      const createdPatientUuid = await savePatientForm(
-        patientUuid,
+      await savePatientForm(
+        !inEditMode,
         values,
         patientUuidMap,
         initialAddressFieldValues,
@@ -124,14 +124,12 @@ export const PatientRegistration: React.FC<PatientRegistrationProps> = ({ savePa
         kind: 'success',
       });
 
-      if (createdPatientUuid) {
-        const redirectUrl = interpolateUrl(
-          new URLSearchParams(search).get('afterUrl') ||
-            interpolateString(config.links.submitButton, { patientUuid: createdPatientUuid }),
-        );
+      const redirectUrl = interpolateUrl(
+        new URLSearchParams(search).get('afterUrl') ||
+          interpolateString(config.links.submitButton, { patientUuid: values.patientUuid }),
+      );
 
-        setTarget(redirectUrl);
-      }
+      setTarget(redirectUrl);
     } catch (error) {
       if (error.responseBody?.error?.globalErrors) {
         error.responseBody.error.globalErrors.forEach((error) => {

package/src/patient-registration/patient-registration.resource.tsx

@@ -19,8 +19,8 @@ function dataURItoFile(dataURI: string) {
   return new File([blob], 'patient-photo.png');
 }
 
-export function savePatient(abortController: AbortController, patient: Patient, patientUuid: string) {
-  return openmrsFetch(`/ws/rest/v1/patient/${patientUuid || ''}`, {
+export function savePatient(abortController: AbortController, patient: Patient, updatePatientUuid?: string) {
+  return openmrsFetch(`/ws/rest/v1/patient/${updatePatientUuid || ''}`, {
     headers: {
       'Content-Type': 'application/json',
     },