@openmrs/esm-form-engine-lib 2.1.0-pre.1362

package/src/adapters/obs-adapter.ts

@@ -0,0 +1,280 @@
+import dayjs from 'dayjs';
+import { ConceptTrue, codedTypes } from '../constants';
+import {
+  type OpenmrsObs,
+  type FormField,
+  type OpenmrsEncounter,
+  type AttachmentResponse,
+  type Attachment,
+  type ValueAndDisplay,
+} from '../types';
+import { hasRendering, gracefullySetSubmission, clearSubmission, flattenObsList } from '../utils/common-utils';
+import { parseToLocalDateTime } from '../utils/form-helper';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormFieldValueAdapter } from '../types';
+import { isEmpty } from '../validators/form-validator';
+import { getAttachmentByUuid } from '../api';
+import { formatDate, restBaseUrl } from '@openmrs/esm-framework';
+
+// Temporarily holds observations that have already been bound with matching fields
+export let assignedObsIds: string[] = [];
+
+export const ObsAdapter: FormFieldValueAdapter = {
+  async getInitialValue(field: FormField, sourceObject: any, context: FormContextProps) {
+    const encounter = sourceObject ?? (context.domainObjectValue as OpenmrsEncounter);
+    if (hasRendering(field, 'file')) {
+      const ac = new AbortController();
+      const attachmentsResponse = await getAttachmentByUuid(context.patient.id, encounter.uuid, ac);
+      // TODO: This seems like a violation of the data model.
+      // I think we should instead use something like `formFieldPath` to do the mapping.
+      const rawAttachment = attachmentsResponse.results?.find((attachment) => attachment.comment === field.id);
+      return rawAttachment ? generateAttachment(rawAttachment) : null;
+    }
+    return extractFieldValue(field, findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field), true);
+  },
+  async getPreviousValue(field: FormField, sourceObject: any, context: FormContextProps): Promise<ValueAndDisplay> {
+    const encounter = sourceObject ?? (context.previousDomainObjectValue as OpenmrsEncounter);
+    if (encounter) {
+      const value = extractFieldValue(
+        field,
+        findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field),
+        true,
+      );
+      if (!isEmpty(value)) {
+        return {
+          value,
+          display: this.getDisplayValue(field, value),
+        };
+      }
+    }
+    return null;
+  },
+  getDisplayValue: (field: FormField, value: any) => {
+    const rendering = field.questionOptions.rendering;
+    if (isEmpty(value)) {
+      return value;
+    }
+    if (rendering == 'checkbox') {
+      return value.map(
+        (selected) => field.questionOptions.answers?.find((option) => option.concept == selected)?.label,
+      );
+    }
+    if (rendering === 'toggle') {
+      return value ? field.questionOptions.toggleOptions.labelTrue : field.questionOptions.toggleOptions.labelFalse;
+    }
+    if (codedTypes.includes(rendering)) {
+      return field.questionOptions.answers?.find((option) => option.concept == value)?.label;
+    }
+    return value;
+  },
+  transformFieldValue: (field: FormField, value: any, context: FormContextProps) => {
+    // clear previous submission
+    clearSubmission(field);
+    if (!field.meta.previousValue && isEmpty(value)) {
+      return null;
+    }
+    if (hasRendering(field, 'checkbox')) {
+      return handleMultiSelect(field, value);
+    }
+    if (!isEmpty(value) && hasPreviousObsValueChanged(field, value)) {
+      return gracefullySetSubmission(field, editObs(field, value), undefined);
+    }
+    if (field.meta.previousValue && isEmpty(value)) {
+      return gracefullySetSubmission(field, undefined, voidObs(field.meta.previousValue));
+    }
+    if (!isEmpty(value)) {
+      return gracefullySetSubmission(field, constructObs(field, value), undefined);
+    }
+    return null;
+  },
+  tearDown: function (): void {
+    assignedObsIds = [];
+  },
+};
+
+// Helpers
+
+/**
+ * Extracts field's primitive value from obs
+ */
+function extractFieldValue(field: FormField, obsList: OpenmrsObs[] = [], makeFieldDirty = false) {
+  const rendering = field.questionOptions.rendering;
+  if (!field.meta) {
+    field.meta = {
+      previousValue: null,
+    };
+  }
+  if (obsList.length) {
+    if (rendering == 'checkbox') {
+      assignedObsIds.push(...obsList.map((obs) => obs.uuid));
+      field.meta.previousValue = makeFieldDirty ? obsList : null;
+      return obsList.map((o) => o.value.uuid);
+    }
+    const obs = obsList[0];
+    if (makeFieldDirty) {
+      field.meta.previousValue = { ...obs };
+    }
+    assignedObsIds.push(obs.uuid);
+    if (typeof obs.value === 'string' || typeof obs.value === 'number') {
+      if (rendering.startsWith('date')) {
+        const dateObject = parseToLocalDateTime(obs.value as string);
+        if (makeFieldDirty) {
+          field.meta.previousValue.value = dayjs(dateObject).format('YYYY-MM-DD HH:mm');
+        }
+        return dateObject;
+      }
+      return obs.value;
+    }
+    if (rendering == 'toggle') {
+      return obs.value.uuid === ConceptTrue;
+    }
+    if (rendering == 'fixed-value') {
+      return field['fixedValue'];
+    }
+    return obs.value?.uuid;
+  }
+  return '';
+}
+
+export function constructObs(field: FormField, value: any): Partial<OpenmrsObs> {
+  if (isEmpty(value) && field.type !== 'obsGroup') {
+    return null;
+  }
+  const draftObs =
+    field.type === 'obsGroup'
+      ? { groupMembers: [] }
+      : {
+          value: field.questionOptions.rendering.startsWith('date') ? formatDateByPickerType(field, value) : value,
+        };
+  return {
+    ...draftObs,
+    concept: field.questionOptions.concept,
+    formFieldNamespace: 'rfe-forms',
+    formFieldPath: `rfe-forms-${field.id}`,
+  };
+}
+
+export function voidObs(obs: OpenmrsObs) {
+  return { uuid: obs.uuid, voided: true };
+}
+
+export function editObs(field: FormField, newValue: any) {
+  const oldObs = field.meta.previousValue;
+  const formattedValue = field.questionOptions.rendering.startsWith('date')
+    ? formatDateByPickerType(field, newValue)
+    : newValue;
+  return {
+    uuid: oldObs.uuid,
+    value: formattedValue,
+    formFieldNamespace: 'rfe-forms',
+    formFieldPath: `rfe-forms-${field.id}`,
+  };
+}
+
+function formatDateByPickerType(field: FormField, value: Date) {
+  if (field.datePickerFormat) {
+    switch (field.datePickerFormat) {
+      case 'calendar':
+        return dayjs(value).format('YYYY-MM-DD');
+      case 'timer':
+        return dayjs(value).format('HH:mm');
+      case 'both':
+        return dayjs(value).format('YYYY-MM-DD HH:mm');
+      default:
+        return dayjs(value).format('YYYY-MM-DD');
+    }
+  }
+  return value;
+}
+
+export function hasPreviousObsValueChanged(field: FormField, newValue: any) {
+  const previousObs = field.meta.previousValue;
+  if (isEmpty(previousObs)) {
+    return false;
+  }
+  if (codedTypes.includes(field.questionOptions.rendering)) {
+    return previousObs.value.uuid !== newValue;
+  }
+  if (hasRendering(field, 'date')) {
+    return dayjs(newValue).diff(dayjs(previousObs.value), 'D') !== 0;
+  }
+  if (hasRendering(field, 'datetime') || field.datePickerFormat === 'both') {
+    return dayjs(newValue).diff(dayjs(previousObs.value), 'minute') !== 0;
+  }
+  if (hasRendering(field, 'toggle')) {
+    return (previousObs.value.uuid === ConceptTrue) !== newValue;
+  }
+  return previousObs.value !== newValue;
+}
+
+function handleMultiSelect(field: FormField, values: Array<string> = []) {
+  // three possible scenarios
+  // 1. we have a previous value and an empty current value
+  // 2. a mix of both (previous and current)
+  // 3. we only have a current value
+
+  if (field.meta.previousValue && isEmpty(values)) {
+    // we assume the user cleared the existing value(s)
+    // so we void all previous values
+    return gracefullySetSubmission(
+      field,
+      null,
+      field.meta.previousValue.map((previousValue) => voidObs(previousValue)),
+    );
+  }
+  if (field.meta.previousValue && !isEmpty(values)) {
+    const toBeVoided = field.meta.previousValue.filter((obs) => !values.includes(obs.value.uuid));
+    const toBeCreated = values.filter((v) => !field.meta.previousValue.some((obs) => obs.value.uuid === v));
+    return gracefullySetSubmission(
+      field,
+      toBeCreated.map((value) => constructObs(field, value)),
+      toBeVoided.map((obs) => voidObs(obs)),
+    );
+  }
+  return gracefullySetSubmission(
+    field,
+    values.map((value) => constructObs(field, value)),
+    undefined,
+  );
+}
+
+/**
+ * Retrieves a list of observations from a given `obsList` that correspond to the specified field.
+ *
+ * Notes:
+ * If the query by field-path returns an empty list, the function falls back to querying
+ * by concept and uses `claimedObsIds` to exclude already assigned observations.
+ */
+export function findObsByFormField(
+  obsList: Array<OpenmrsObs>,
+  claimedObsIds: string[],
+  field: FormField,
+): OpenmrsObs[] {
+  const obs = obsList.filter(
+    (o) => o.formFieldPath == `rfe-forms-${field.id}` && o.concept.uuid == field.questionOptions.concept,
+  );
+
+  // We shall fall back to mapping by the associated concept
+  // That being said, we shall find all matching obs and pick the one that wasn't previously claimed.
+  if (!obs?.length) {
+    const obsByConcept = obsList.filter((obs) => obs.concept.uuid == field.questionOptions.concept);
+    return claimedObsIds?.length ? obsByConcept.filter((obs) => !claimedObsIds.includes(obs.uuid)) : obsByConcept;
+  }
+
+  return obs;
+}
+
+function generateAttachment(rawAttachment: AttachmentResponse): Attachment {
+  const attachmentUrl = `${restBaseUrl}/attachment`;
+  return {
+    id: rawAttachment.uuid,
+    src: `${window.openmrsBase}${attachmentUrl}/${rawAttachment.uuid}/bytes`,
+    title: rawAttachment.comment,
+    description: '',
+    dateTime: formatDate(new Date(rawAttachment.dateTime), {
+      mode: 'wide',
+    }),
+    bytesMimeType: rawAttachment.bytesMimeType,
+    bytesContentFamily: rawAttachment.bytesContentFamily,
+  };
+}

package/src/adapters/obs-comment-adapter.ts

@@ -0,0 +1,60 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField, type FormFieldValueAdapter, type FormProcessorContextProps } from '../types';
+import { hasSubmission } from '../utils/common-utils';
+import { isEmpty } from '../validators/form-validator';
+import { editObs, hasPreviousObsValueChanged } from './obs-adapter';
+
+export const ObsCommentAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    const targetField = context.getFormField(field.meta.targetField);
+    const targetFieldCurrentValue = context.methods.getValues(targetField.id);
+
+    if (targetField.meta.submission?.newValue) {
+      if (isEmpty(value) && !isNewSubmissionEffective(targetField, targetFieldCurrentValue)) {
+        // clear submission
+        targetField.meta.submission.newValue = null;
+      } else {
+        targetField.meta.submission.newValue.comment = value;
+      }
+    } else if (!hasSubmission(targetField) && targetField.meta.previousValue) {
+      if (isEmpty(value) && isEmpty(targetField.meta.previousValue.comment)) {
+        return null;
+      }
+      // generate submission
+      const newSubmission = editObs(targetField, targetFieldCurrentValue);
+      targetField.meta.submission = {
+        newValue: {
+          ...newSubmission,
+          comment: value,
+        },
+      };
+    }
+    return null;
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    const encounter = sourceObject ?? context.domainObjectValue;
+    if (encounter) {
+      const targetFieldId = field.id.split('_obs_comment')[0];
+      const targetField = context.formFields.find((field) => field.id === targetFieldId);
+      return targetField?.meta.previousValue?.comment;
+    }
+    return null;
+  },
+  getPreviousValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: string) {
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};
+
+export function isNewSubmissionEffective(targetField: FormField, targetFieldCurrentValue: any) {
+  return (
+    hasPreviousObsValueChanged(targetField, targetFieldCurrentValue) ||
+    !isEmpty(targetField.meta.submission.newValue.obsDatetime)
+  );
+}

package/src/adapters/orders-adapter.ts

@@ -0,0 +1,75 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormFieldValueAdapter, type FormProcessorContextProps } from '..';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField } from '../types';
+import { clearSubmission, gracefullySetSubmission } from '../utils/common-utils';
+
+export let assignedOrderIds: string[] = [];
+const defaultOrderType = 'testorder';
+const defaultCareSetting = '6f0c9a92-6f24-11e3-af88-005056821db0';
+
+export const OrdersAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    if (context.sessionMode == 'edit' && field.meta?.previousValue?.uuid) {
+      return editOrder(value, field, context.currentProvider.uuid);
+    }
+    const newValue = constructNewOrder(value, field, context.currentProvider.uuid);
+    gracefullySetSubmission(field, newValue, null);
+    return newValue;
+  },
+  getInitialValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    const availableOrderables = field.questionOptions.answers?.map((answer) => answer.concept) || [];
+    const matchedOrder = sourceObject?.orders
+      .filter((order) => !assignedOrderIds.includes(order.uuid) && !order.voided)
+      .find((order) => availableOrderables.includes(order.concept.uuid));
+    if (matchedOrder) {
+      field.meta = { ...(field.meta || {}), previousValue: matchedOrder };
+      assignedOrderIds.push(matchedOrder.uuid);
+      return matchedOrder.concept.uuid;
+    }
+    return null;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    return null;
+  },
+  getDisplayValue: (field: FormField, value: any) => {
+    return field.questionOptions.answers?.find((option) => option.concept == value)?.label || value;
+  },
+  tearDown: function (): void {
+    assignedOrderIds = [];
+  },
+};
+
+function constructNewOrder(value: any, field: FormField, orderer: string) {
+  if (!value) {
+    return null;
+  }
+  return {
+    action: 'NEW',
+    concept: value,
+    type: field?.questionOptions?.orderType || defaultOrderType,
+    careSetting: field?.questionOptions?.orderSettingUuid || defaultCareSetting,
+    orderer: orderer,
+  };
+}
+
+function editOrder(newOrder: any, field: FormField, orderer: string) {
+  if (newOrder === field.meta.previousValue?.concept?.uuid) {
+    clearSubmission(field);
+    return null;
+  }
+  const voided = {
+    uuid: field.meta.previousValue?.uuid,
+    voided: true,
+  };
+  gracefullySetSubmission(field, constructNewOrder(newOrder, field, orderer), voided);
+  return field.meta.submission.newValue || null;
+}

package/src/adapters/patient-identifier-adapter.ts

@@ -0,0 +1,40 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField, type FormFieldValueAdapter, type FormProcessorContextProps } from '../types';
+import { clearSubmission } from '../utils/common-utils';
+import { isEmpty } from '../validators/form-validator';
+
+export const PatientIdentifierAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    clearSubmission(field);
+    if (field.meta?.previousValue?.value === value || isEmpty(value)) {
+      return null;
+    }
+    field.meta.submission.newValue = {
+      identifier: value,
+      identifierType: field.questionOptions.identifierType,
+      uuid: field.meta.previousValue?.id,
+      location: context.location,
+    };
+    return field.meta.submission.newValue;
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    const latestIdentifier = context.patient?.identifier?.find(
+      (identifier) => identifier.type?.coding[0]?.code === field.questionOptions.identifierType,
+    );
+    field.meta = { ...(field.meta || {}), previousValue: latestIdentifier };
+    return latestIdentifier?.value;
+  },
+  getPreviousValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: any) {
+    if (value?.display) {
+      return value.display;
+    }
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

package/src/adapters/program-state-adapter.ts

@@ -0,0 +1,52 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField, type FormProcessorContextProps, type FormFieldValueAdapter } from '../types';
+import dayjs from 'dayjs';
+import { clearSubmission } from '../utils/common-utils';
+import { isEmpty } from '../validators/form-validator';
+
+export const ProgramStateAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    clearSubmission(field);
+    if (field.meta?.previousValue?.uuid === value || isEmpty(value)) {
+      return null;
+    }
+    field.meta.submission.newValue = {
+      state: value,
+      startDate: dayjs().format(),
+    };
+  },
+  getInitialValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    const program = context.customDependencies.patientPrograms?.find(
+      (program) => program.program.uuid === field.questionOptions.programUuid,
+    );
+    if (program?.states?.length > 0) {
+      const currentState = program.states
+        .filter((state) => !state.endDate)
+        .find((state) => state.state.programWorkflow?.uuid === field.questionOptions.workflowUuid)?.state;
+      field.meta = { ...(field.meta || {}), previousValue: currentState };
+      return currentState.uuid;
+    }
+    return null;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: any) {
+    if (value?.display) {
+      return value.display;
+    }
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

package/src/api/index.ts

@@ -0,0 +1,178 @@
+import { fhirBaseUrl, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { encounterRepresentation } from '../constants';
+import { type OpenmrsForm, type PatientIdentifier, type PatientProgramPayload } from '../types';
+import { isUuid } from '../utils/boolean-utils';
+
+export function saveEncounter(abortController: AbortController, payload, encounterUuid?: string) {
+  const url = encounterUuid
+    ? `${restBaseUrl}/encounter/${encounterUuid}?v=${encounterRepresentation}`
+    : `${restBaseUrl}/encounter?v=${encounterRepresentation}`;
+
+  return openmrsFetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: payload,
+    signal: abortController.signal,
+  });
+}
+
+export function saveAttachment(patientUuid, field, conceptUuid, date, encounterUUID, abortController) {
+  const url = `${restBaseUrl}/attachment`;
+
+  const content = field.meta.submission?.newValue?.value;
+  const cameraUploadType = typeof content === 'string' && content?.split(';')[0].split(':')[1].split('/')[1];
+
+  const formData = new FormData();
+  const fileCaption = field.id;
+
+  formData.append('fileCaption', fileCaption);
+  formData.append('patient', patientUuid);
+
+  if (typeof content === 'object') {
+    formData.append('file', content);
+  } else {
+    formData.append('file', new File([''], `camera-upload.${cameraUploadType}`), `camera-upload.${cameraUploadType}`);
+    formData.append('base64Content', content);
+  }
+  formData.append('encounter', encounterUUID);
+  formData.append('obsDatetime', date);
+
+  return openmrsFetch(url, {
+    method: 'POST',
+    signal: abortController.signal,
+    body: formData,
+  });
+}
+
+export function getAttachmentByUuid(patientUuid: string, encounterUuid: string, abortController: AbortController) {
+  const attachmentUrl = `${restBaseUrl}/attachment`;
+  return openmrsFetch(`${attachmentUrl}?patient=${patientUuid}&encounter=${encounterUuid}`, {
+    signal: abortController.signal,
+  }).then((response) => response.data);
+}
+
+export function getConcept(conceptUuid: string, v: string) {
+  return openmrsFetch(`${restBaseUrl}/concept/${conceptUuid}?v=${v}`).then(({ data }) => data.results);
+}
+
+export function getLocationsByTag(tag: string) {
+  return openmrsFetch(`${restBaseUrl}/location?tag=${tag}&v=custom:(uuid,display)`).then(({ data }) => data.results);
+}
+
+export function getAllLocations() {
+  return openmrsFetch<{ results }>(`${restBaseUrl}/location?v=custom:(uuid,display)`).then(({ data }) => data.results);
+}
+
+export async function getPreviousEncounter(patientUuid: string, encounterType: string) {
+  const query = `patient=${patientUuid}&_sort=-date&_count=1&type=${encounterType}`;
+  let response = await openmrsFetch(`${fhirBaseUrl}/Encounter?${query}`);
+  if (response?.data?.entry?.length) {
+    const latestEncounter = response.data.entry[0].resource.id;
+    response = await openmrsFetch(`${restBaseUrl}/encounter/${latestEncounter}?v=${encounterRepresentation}`);
+    return response.data;
+  }
+  return null;
+}
+
+export function getLatestObs(patientUuid: string, conceptUuid: string, encounterTypeUuid?: string) {
+  let params = `patient=${patientUuid}&code=${conceptUuid}${
+    encounterTypeUuid ? `&encounter.type=${encounterTypeUuid}` : ''
+  }`;
+  // the latest obs
+  params += '&_sort=-date&_count=1';
+  return openmrsFetch(`${fhirBaseUrl}/Observation?${params}`).then(({ data }) => {
+    return data.entry?.length ? data.entry[0].resource : null;
+  });
+}
+
+/**
+ * Fetches an OpenMRS form using either its name or UUID.
+ * @param {string} nameOrUUID - The form's name or UUID.
+ * @returns {Promise<OpenmrsForm | null>} - A Promise that resolves to the fetched OpenMRS form or null if not found.
+ */
+export async function fetchOpenMRSForm(nameOrUUID: string): Promise<OpenmrsForm | null> {
+  if (!nameOrUUID) {
+    return null;
+  }
+
+  const { url, isUUID } = isUuid(nameOrUUID)
+    ? { url: `${restBaseUrl}/form/${nameOrUUID}?v=full`, isUUID: true }
+    : { url: `${restBaseUrl}/form?q=${nameOrUUID}&v=full`, isUUID: false };
+
+  const { data: openmrsFormResponse } = await openmrsFetch(url);
+  if (isUUID) {
+    return openmrsFormResponse;
+  }
+
+  return openmrsFormResponse.results?.length
+    ? openmrsFormResponse.results.find((form) => form.retired === false)
+    : new Error(`Form with ${nameOrUUID} was not found`);
+}
+
+/**
+ * Fetches ClobData for a given OpenMRS form.
+ * @param {OpenmrsForm} form - The OpenMRS form object.
+ * @returns {Promise<any | null>} - A Promise that resolves to the fetched ClobData or null if not found.
+ */
+export async function fetchClobData(form: OpenmrsForm): Promise<any | null> {
+  if (!form) {
+    return null;
+  }
+
+  const jsonSchemaResource = form.resources.find(({ name }) => name === 'JSON schema');
+  if (!jsonSchemaResource) {
+    return null;
+  }
+
+  const clobDataUrl = `${restBaseUrl}/clobdata/${jsonSchemaResource.valueReference}`;
+  const { data: clobDataResponse } = await openmrsFetch(clobDataUrl);
+
+  return clobDataResponse;
+}
+
+// Program Enrollment
+export function getPatientEnrolledPrograms(patientUuid: string) {
+  return openmrsFetch(
+    `${restBaseUrl}/programenrollment?patient=${patientUuid}&v=custom:(uuid,display,program:(uuid,name,allWorkflows),dateEnrolled,dateCompleted,location:(uuid,display),states:(state:(uuid,name,concept:(uuid),programWorkflow:(uuid)))`,
+  ).then(({ data }) => {
+    if (data) {
+      return data;
+    }
+    return null;
+  });
+}
+
+export function saveProgramEnrollment(payload: PatientProgramPayload, abortController: AbortController) {
+  if (!payload) {
+    throw new Error('Program enrollment cannot be created because no payload is supplied');
+  }
+  const url = payload.uuid ? `${restBaseUrl}/programenrollment/${payload.uuid}` : `${restBaseUrl}/programenrollment`;
+  return openmrsFetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(payload),
+    signal: abortController.signal,
+  });
+}
+
+export function savePatientIdentifier(patientIdentifier: PatientIdentifier, patientUuid: string) {
+  let url: string;
+
+  if (patientIdentifier.uuid) {
+    url = `${restBaseUrl}/patient/${patientUuid}/identifier/${patientIdentifier.uuid}`;
+  } else {
+    url = `${restBaseUrl}/patient/${patientUuid}/identifier`;
+  }
+
+  return openmrsFetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: JSON.stringify(patientIdentifier),
+  });
+}