@olaboot/esm-form-engine-lib 4.1.0

package/src/adapters/encounter-role-adapter.ts

@@ -0,0 +1,54 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import {
+  type ValueAndDisplay,
+  type FormField,
+  type FormFieldValueAdapter,
+  type FormProcessorContextProps,
+} from '../types';
+import { gracefullySetSubmission } from '../utils/common-utils';
+
+export const EncounterRoleAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    gracefullySetSubmission(field, value, null);
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    const encounter = sourceObject ?? context.domainObjectValue;
+    if (encounter) {
+      return getLatestEncounterRole(encounter)?.uuid;
+    }
+    return context.customDependencies.defaultEncounterRole.uuid;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): ValueAndDisplay {
+    const encounter = sourceObject ?? context.previousDomainObjectValue;
+    if (encounter) {
+      const role = getLatestEncounterRole(encounter);
+      return {
+        value: role?.uuid,
+        display: role?.name,
+      };
+    }
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: any) {
+    if (value?.display) {
+      return value.display;
+    }
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};
+
+function getLatestEncounterRole(encounter: OpenmrsResource) {
+  if (encounter && encounter['encounterProviders']?.length) {
+    const lastProviderIndex = encounter['encounterProviders'].length - 1;
+    return encounter['encounterProviders'][lastProviderIndex].encounterRole;
+  }
+  return null;
+}

package/src/adapters/inline-date-adapter.ts

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

package/src/adapters/obs-adapter.ts

@@ -0,0 +1,349 @@
+import dayjs from 'dayjs';
+import { ConceptTrue, codedTypes } from '../constants';
+import {
+  type Attachment,
+  type OpenmrsObs,
+  type FormField,
+  type OpenmrsEncounter,
+  type ValueAndDisplay,
+  type FormFieldValueAdapter,
+} from '../types';
+import {
+  hasRendering,
+  gracefullySetSubmission,
+  clearSubmission,
+  flattenObsList,
+  parseToLocalDateTime,
+  formatDateAsDisplayString,
+} from '../utils/common-utils';
+import { type FormContextProps } from '../provider/form-provider';
+import { isEmpty } from '../validators/form-validator';
+import { attachmentUrl, getAttachmentByUuid, type OpenmrsResource } 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);
+    const matchingObs = findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field);
+    if (hasRendering(field, 'file') && matchingObs?.length) {
+      return resolveAttachmentsFromObs(field, matchingObs);
+    }
+    return extractFieldValue(field, matchingObs, 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 (value instanceof Date) {
+      return formatDateAsDisplayString(field, 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.initialValue?.omrsObject && isEmpty(value)) {
+      return null;
+    }
+    if (hasRendering(field, 'checkbox')) {
+      return handleMultiSelect(field, Array.isArray(value) ? value : [value]);
+    }
+    if (hasRendering(field, 'file')) {
+      return handleAttachments(field, value);
+    }
+    if (!isEmpty(value) && hasPreviousObsValueChanged(field, value)) {
+      return gracefullySetSubmission(field, editObs(field, value), undefined);
+    }
+    if (field.meta.initialValue?.omrsObject && isEmpty(value)) {
+      return gracefullySetSubmission(field, undefined, voidObs(field.meta.initialValue.omrsObject as OpenmrsObs));
+    }
+    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 = {
+      initialValue: {
+        omrsObject: null,
+        refinedValue: null,
+      },
+    };
+  }
+  if (obsList.length) {
+    if (rendering == 'checkbox') {
+      assignedObsIds.push(...obsList.map((obs) => obs.uuid));
+      field.meta.initialValue.omrsObject = makeFieldDirty ? obsList : null;
+      return obsList.map((o) => o.value.uuid);
+    }
+    const obs = obsList[0];
+    if (makeFieldDirty) {
+      field.meta.initialValue.omrsObject = { ...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) {
+          const obsObject = field.meta.initialValue.omrsObject as OpenmrsObs;
+          obsObject.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.initialValue?.omrsObject as OpenmrsResource;
+  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.initialValue?.omrsObject as OpenmrsResource;
+  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
+  const obsArray = field.meta.initialValue?.omrsObject as Array<OpenmrsResource>;
+  if (obsArray?.length && isEmpty(values)) {
+    // we assume the user cleared the existing value(s)
+    // so we void all previous values
+    return gracefullySetSubmission(
+      field,
+      null,
+      obsArray.map((previousValue) => voidObs(previousValue)),
+    );
+  }
+  if (obsArray?.length && !isEmpty(values)) {
+    const toBeVoided = obsArray.filter((obs) => !values.includes(obs.value.uuid));
+    const toBeCreated = values.filter((v) => !obsArray.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,
+  );
+}
+
+function handleAttachments(field: FormField, attachments: Attachment[] = []) {
+  const voided = attachments
+    .filter((attachment) => attachment.uuid && attachment.voided)
+    .map((voided) => ({ uuid: voided.uuid, voided: true }));
+  const newAttachments = (field.meta.submission.newValue = attachments
+    .filter((attachment) => !attachment.uuid)
+    .map((newAttachment) => ({
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: `rfe-forms-${field.id}`,
+      ...newAttachment,
+    })));
+  return gracefullySetSubmission(field, newAttachments, voided);
+}
+
+/**
+ * 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.
+ *
+ * When the field belongs to an obsGroup (i.e. `field.meta.groupId` is set), the concept
+ * fallback is scoped to observations that are members of the matching parent obsGroup.
+ * This prevents child obs from one obsGroup from being incorrectly assigned to fields
+ * in a different obsGroup that happens to share the same concept.
+ */
+export function findObsByFormField(
+  obsList: Array<OpenmrsObs>,
+  claimedObsIds: string[],
+  field: FormField,
+): OpenmrsObs[] {
+  const obs = obsList.filter((candidate) => {
+    // we ignore the concept for attachments because they're managed from the backend
+    if (hasRendering(field, 'file') && candidate.formFieldPath == `rfe-forms-${field.id}`) {
+      return true;
+    }
+    return (
+      candidate.formFieldPath == `rfe-forms-${field.id}` && candidate.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) {
+    let obsByConcept = obsList.filter((obs) => obs.concept.uuid == field.questionOptions.concept);
+
+    // If this field belongs to an obsGroup, restrict the concept fallback to
+    // respect obsGroup boundaries.  For each candidate obs we check whether it
+    // is a member of any obsGroup in the encounter.  Three cases:
+    //   1. The obs is standalone (not in any group) → allow (normal fallback).
+    //   2. The obs is in a group whose formFieldPath matches the expected
+    //      parent → allow (correct group).
+    //   3. The obs is in a group with a *different* formFieldPath → exclude
+    //      (prevents cross-group concept bleeding, e.g. PrEP → ARV).
+    //   4. The obs is in a group that has no formFieldPath (old encounter) →
+    //      allow (backward compatibility).
+    if (field.meta?.groupId) {
+      const parentPath = `rfe-forms-${field.meta.groupId}`;
+      obsByConcept = obsByConcept.filter((candidate) => {
+        // Find the obsGroup that owns this candidate (if any)
+        const ownerGroup = obsList.find(
+          (o) => o.groupMembers?.some((m) => m.uuid === candidate.uuid),
+        );
+        if (!ownerGroup) return true;                       // case 1: standalone
+        if (!ownerGroup.formFieldPath) return true;         // case 4: old encounter
+        return ownerGroup.formFieldPath == parentPath;      // case 2 or 3
+      });
+    }
+
+    return claimedObsIds?.length ? obsByConcept.filter((obs) => !claimedObsIds.includes(obs.uuid)) : obsByConcept;
+  }
+
+  return obs;
+}
+
+async function resolveAttachmentsFromObs(field: FormField, obs: OpenmrsObs[]) {
+  const abortController = new AbortController();
+  const attachments = await Promise.all(
+    obs.map((obs) =>
+      getAttachmentByUuid(obs.uuid, abortController)
+        .then((response) => response.data)
+        .catch((error) => {
+          console.error(`Failed to fetch attachment ${obs.uuid}:`, error);
+          return null;
+        }),
+    ),
+  );
+
+  field.meta.initialValue = {
+    omrsObject: obs,
+  };
+  return attachments.filter(Boolean).map((attachment) => ({
+    uuid: attachment.uuid,
+    base64Content: `${window.openmrsBase}${attachmentUrl}/${attachment.uuid}/bytes`,
+    fileName: attachment.filename,
+    fileDescription: attachment.comment,
+    fileType: attachment.bytesContentFamily?.toLowerCase(),
+  })) as Attachment[];
+}

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

@@ -0,0 +1,61 @@
+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);
+    const targetFieldInitialObs = targetField.meta.initialValue?.omrsObject as OpenmrsResource;
+
+    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) && targetFieldInitialObs) {
+      if (isEmpty(value) && isEmpty(targetFieldInitialObs.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.initialValue.omrsObject as OpenmrsResource)?.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,82 @@
+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.initialValue?.omrsObject) {
+      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 || {}),
+        initialValue: {
+          omrsObject: matchedOrder,
+          refinedValue: matchedOrder.concept.uuid,
+        },
+      };
+      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) {
+  const previousOrder = field.meta.initialValue?.omrsObject as OpenmrsResource;
+  if (newOrder === previousOrder?.concept?.uuid) {
+    clearSubmission(field);
+    return null;
+  }
+  const voided = {
+    uuid: previousOrder?.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,46 @@
+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.initialValue?.refinedValue === value || isEmpty(value)) {
+      return null;
+    }
+    field.meta.submission.newValue = {
+      identifier: value,
+      identifierType: field.questionOptions.identifierType,
+      uuid: (field.meta.initialValue?.omrsObject as OpenmrsResource)?.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 || {}),
+      initialValue: {
+        omrsObject: latestIdentifier as any,
+        refinedValue: latestIdentifier?.value,
+      },
+    };
+    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;
+  },
+};