@kenyaemr/esm-pcs-app 5.4.5-pre.1092

package/src/resources/link-dependant.resource.ts

@@ -0,0 +1,268 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { getLocalIdentifierValue } from './identifiers';
+import { createDependantPatient, createPatientFromDemographics } from './patient-create.resource';
+import { findExistingLocalPatient } from './patient-search.resource';
+import useSWR from 'swr';
+import { getPrimaryContact } from './pcs.resource';
+import { launchCheckInWorkspace, readLocalPatient, stampAndCheckIn } from './link-participant.resource';
+import {
+  type IdentifierTypeUuids,
+  type PcsDependantDemographics,
+  type PcsHieDependant,
+  type PcsParticipant,
+} from '../types';
+
+interface LinkDependantOptions {
+  /** A row from `getDependentsFromContacts` — an HIE contact, not necessarily a patient here yet. */
+  dependant: any;
+  parentPhoneNumber?: string;
+  participant: PcsParticipant;
+  studyParticipantIdentifierType: string;
+  pbidsEnrollmentAttributeType: string;
+  cardseEnrollmentAttributeType: string;
+  /** The identifier types a created patient's HIE identifiers are written against. */
+  uuids: IdentifierTypeUuids;
+}
+
+/**
+ * Resolves a dependant to a local record, creating them when they are not registered here.
+ *
+ * `isDependent: true` matters — it makes `extractPatientIdentifiers` skip `household-number`,
+ * which belongs to the parent, so a miss here doesn't silently match the parent's own record.
+ *
+ * Deliberately calls `createPatient` rather than `createDependentPatient`: the latter launches
+ * the visit workspace inside itself, which would fire before the study data is written.
+ */
+async function resolveLocalDependant(
+  dependant: PcsHieDependant,
+  parentPhoneNumber: string | undefined,
+  uuids: IdentifierTypeUuids,
+) {
+  const existing = await findExistingLocalPatient(dependant.contactData, true);
+  if (existing) {
+    return existing;
+  }
+
+  return createDependantPatient(dependant, parentPhoneNumber ? { ...uuids } : uuids, parentPhoneNumber);
+}
+
+/**
+ * Links a dependant in the HIE dependants table to a participant from their mother's PCS
+ * record: create if needed, stamp the study identifier and both enrolment attributes, check in.
+ */
+export async function linkDependantToParticipant({
+  dependant,
+  parentPhoneNumber,
+  participant,
+  studyParticipantIdentifierType,
+  pbidsEnrollmentAttributeType,
+  cardseEnrollmentAttributeType,
+  uuids,
+}: LinkDependantOptions) {
+  const localPatient = await resolveLocalDependant(dependant, parentPhoneNumber, uuids);
+
+  return stampAndCheckIn({
+    localPatient,
+    participant,
+    studyParticipantIdentifierType,
+    pbidsEnrollmentAttributeType,
+    cardseEnrollmentAttributeType,
+  });
+}
+
+/**
+ * Which of the mother's HIE dependants are already linked to a PCS participant, keyed by
+ * candidate id, with the study ID each one holds.
+ *
+ * One SWR key over all candidates rather than a hook per row: Carbon's `RadioButtonGroup`
+ * clones its children expecting `RadioButton` elements, so a per-row wrapper component would
+ * break its `valueSelected` / `onChange` wiring.
+ */
+export function useHieDependantLinkState(candidates: Array<any>, identifierTypes: Array<string>) {
+  const key = candidates.length
+    ? `pcs-hie-dependant-link-state/${candidates.map((candidate) => candidate.id).join(',')}`
+    : null;
+
+  const { data, isLoading } = useSWR(key, async () => {
+    const resolved = await Promise.all(
+      candidates.map(async (candidate) => {
+        const localPatient = await findExistingLocalPatient(candidate.contactData, true).catch(() => null);
+        const studyId = identifierTypes
+          .filter(Boolean)
+          .map((identifierType) => getLocalIdentifierValue(localPatient, identifierType))
+          .find(Boolean);
+
+        return [candidate.id, studyId] as const;
+      }),
+    );
+
+    return Object.fromEntries(resolved) as Record<string, string | undefined>;
+  });
+
+  return { linkedById: data ?? {}, isChecking: isLoading };
+}
+
+interface CreateAndLinkOptions {
+  participant: PcsParticipant;
+  nationalIdUUID: string;
+  phoneAttributeTypeUUID: string;
+  studyParticipantIdentifierType: string;
+  pbidsEnrollmentAttributeType: string;
+  cardseEnrollmentAttributeType: string;
+}
+
+/** A PCS participant mapped onto the same create. */
+function createPatientFromParticipant(
+  participant: PcsParticipant,
+  nationalIdUUID: string,
+  phoneAttributeTypeUUID: string,
+) {
+  const contact = getPrimaryContact(participant);
+
+  return createPatientFromDemographics(
+    {
+      firstName: participant.firstName,
+      middleName: participant.middleName,
+      lastName: participant.lastName,
+      sex: participant.sex,
+      dateOfBirth: participant.dateOfBirth,
+      nationalId: contact?.nationalId,
+      phone: contact?.phone,
+    },
+    nationalIdUUID,
+    phoneAttributeTypeUUID,
+  );
+}
+
+/**
+ * For a PCS dependant the HIE has no record of: build the patient from PCS's own demographics,
+ * then stamp **this participant's** identifier — they already hold a permanent one, so nothing
+ * temporary is minted and PCS keeps a single record for the child.
+ */
+export async function createAndLinkFromParticipant({
+  participant,
+  nationalIdUUID,
+  phoneAttributeTypeUUID,
+  studyParticipantIdentifierType,
+  pbidsEnrollmentAttributeType,
+  cardseEnrollmentAttributeType,
+}: CreateAndLinkOptions) {
+  const localPatient = await createPatientFromParticipant(participant, nationalIdUUID, phoneAttributeTypeUUID);
+
+  return stampAndCheckIn({
+    localPatient,
+    participant,
+    studyParticipantIdentifierType,
+    pbidsEnrollmentAttributeType,
+    cardseEnrollmentAttributeType,
+  });
+}
+
+interface CreatePcsParticipantOptions {
+  patientUuid: string;
+  motherId: string;
+}
+
+/**
+ * The request as the module documents it. Kept real and separately testable so the path and
+ * both field names are pinned rather than discovered at integration time — the same split the
+ * search side uses with `buildParticipantSearchUrl`.
+ */
+export function buildCreateParticipantRequest({ patientUuid, motherId }: CreatePcsParticipantOptions) {
+  return {
+    url: `${restBaseUrl}/pbids-participants`,
+    options: {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: { patientUuid, motherId },
+    },
+  };
+}
+
+/**
+ * Documented failures, all of which surface through the form's notification rather than
+ * indicating a bug here: `409` when the patient already holds a study or temporary identifier,
+ * `400` for a missing field or an unknown patient or mother, and `503` when the PCS database is
+ * unreachable.
+ */
+async function createPcsParticipant({ patientUuid, motherId }: CreatePcsParticipantOptions): Promise<PcsParticipant> {
+  const request = buildCreateParticipantRequest({ patientUuid, motherId });
+  const { data } = await openmrsFetch<PcsParticipant>(request.url, request.options);
+  return data;
+}
+
+interface CreateDependantWithTemporaryIdOptions {
+  demographics: PcsDependantDemographics;
+  motherIndividualId: string;
+  nationalIdUUID: string;
+  phoneAttributeTypeUUID: string;
+}
+
+/**
+ * The tail both temporary-ID flows share: have the module create a participant against the
+ * mother's and mint the study id, then start the visit.
+ *
+ * Nothing is written client-side. The module owns both sides — it assigns the identifier and
+ * sets the `PBIDS Enrolled` / `CARDSE Enrolled` attributes to match the PCS row, which the docs
+ * are explicit must stay in step. The re-read is how we see what it wrote; the record we hold
+ * could not carry it.
+ */
+async function mintTemporaryIdAndCheckIn(localPatient: any, motherIndividualId: string) {
+  if (!localPatient?.uuid) {
+    throw new Error('The patient record could not be created');
+  }
+
+  const participant = await createPcsParticipant({ patientUuid: localPatient.uuid, motherId: motherIndividualId });
+
+  const updated = (await readLocalPatient(localPatient.uuid).catch(() => null)) ?? localPatient;
+
+  await launchCheckInWorkspace(updated, updated.uuid);
+
+  return { localPatient: updated, participant };
+}
+
+/**
+ * For an infant in neither PCS nor the HIE: register them here from typed demographics, then
+ * mint a temporary study id against their mother's participant.
+ */
+export async function createDependantWithTemporaryId({
+  demographics,
+  motherIndividualId,
+  nationalIdUUID,
+  phoneAttributeTypeUUID,
+}: CreateDependantWithTemporaryIdOptions) {
+  const localPatient = await createPatientFromDemographics(demographics, nationalIdUUID, phoneAttributeTypeUUID);
+
+  return mintTemporaryIdAndCheckIn(localPatient, motherIndividualId);
+}
+
+interface LinkHieDependantOptions {
+  /** A row from `getDependentsFromContacts` — an HIE contact, not necessarily a patient here yet. */
+  dependant: any;
+  parentPhoneNumber?: string;
+  motherIndividualId: string;
+  /** The identifier types a created patient's HIE identifiers are written against. */
+  uuids: IdentifierTypeUuids;
+}
+
+/**
+ * For a child the HIE lists under her mother but PCS has no row for: reuse her local record when
+ * she is already registered here, create it from the HIE contact when she isn't, then mint a
+ * temporary study id.
+ *
+ * Differs from `createDependantWithTemporaryId` only at the head — resolve-or-create from an HIE
+ * contact, rather than create from typed demographics.
+ *
+ * A child linked elsewhere between the list rendering and this call comes back as the documented
+ * `409`; that race belongs to the server, not to a second client-side check.
+ */
+export async function linkHieDependantWithTemporaryId({
+  dependant,
+  parentPhoneNumber,
+  motherIndividualId,
+  uuids,
+}: LinkHieDependantOptions) {
+  const localPatient = await resolveLocalDependant(dependant, parentPhoneNumber, uuids);
+
+  return mintTemporaryIdAndCheckIn(localPatient, motherIndividualId);
+}

package/src/resources/link-participant.resource.test.ts

@@ -0,0 +1,336 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getSessionLocation, launchWorkspace2, launchWorkspaceGroup2, openmrsFetch } from '@openmrs/esm-framework';
+import { createDependantPatient, createPatientFromHiePatient } from './patient-create.resource';
+import { findExistingLocalPatient } from './patient-search.resource';
+import { delinkParticipant, linkParticipantToPatient, syncStudyAttributes } from './link-participant.resource';
+import { type PcsParticipant, type PcsSearchSubject } from '../types';
+
+vi.mock('@openmrs/esm-framework', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@openmrs/esm-framework')>()),
+  openmrsFetch: vi.fn(),
+  getSessionLocation: vi.fn(),
+  launchWorkspace2: vi.fn(),
+  launchWorkspaceGroup2: vi.fn(),
+}));
+
+vi.mock('./patient-create.resource', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('./patient-create.resource')>()),
+  createDependantPatient: vi.fn(),
+  createPatientFromHiePatient: vi.fn(),
+}));
+vi.mock('./patient-search.resource', () => ({ findExistingLocalPatient: vi.fn() }));
+
+const mockOpenmrsFetch = vi.mocked(openmrsFetch);
+const mockGetSessionLocation = vi.mocked(getSessionLocation);
+const mockCreateDependantPatient = vi.mocked(createDependantPatient);
+const mockCreatePatientFromHie = vi.mocked(createPatientFromHiePatient);
+const mockFindExistingLocalPatient = vi.mocked(findExistingLocalPatient);
+
+const uuids = {
+  nationalIdUUID: 'national-id-type',
+  shaNumberUUID: 'sha-number-type',
+  passportUUID: 'passport-type',
+  birthCertificateUUID: 'birth-certificate-type',
+  crIdentificationNumberUUID: 'cr-number-type',
+  phoneAttributeTypeUUID: 'phone-attr-type',
+};
+
+const STUDY_ID_TYPE = 'study-id-type-uuid';
+const PBIDS_ENROLLMENT_TYPE = 'pbids-enrollment-type-uuid';
+const CARDSE_ENROLLMENT_TYPE = 'cardse-enrollment-type-uuid';
+
+const participant = {
+  individualId: '901-1-1-3',
+  firstName: 'DENNIS',
+  lastName: 'ODONGO',
+  sex: 'M',
+  pbidsEnrolled: true,
+  cardse: false,
+  mother: null,
+  compound: { compoundId: '901-1', headIndividualId: '901-1-1-1', headFirstName: 'JOHN', headLastName: 'ODONGO' },
+  village: { code: '901', name: 'TEST ABUYA' },
+  contacts: [],
+  matchedOn: 'name',
+  matchType: 'EXACT',
+} as PcsParticipant;
+
+const localSubject: PcsSearchSubject = {
+  id: 'local-uuid',
+  source: 'local',
+  patient: { resourceType: 'Patient', id: 'local-uuid' },
+  name: 'Dennis Odongo',
+};
+
+const hieSubject: PcsSearchSubject = {
+  id: 'cr-number',
+  source: 'hie',
+  patient: { resourceType: 'Patient', id: 'cr-number' },
+  name: 'Dennis Odongo',
+};
+
+const link = (subject: PcsSearchSubject) =>
+  linkParticipantToPatient({
+    subject,
+    participant,
+    studyParticipantIdentifierType: STUDY_ID_TYPE,
+    pbidsEnrollmentAttributeType: PBIDS_ENROLLMENT_TYPE,
+    cardseEnrollmentAttributeType: CARDSE_ENROLLMENT_TYPE,
+    uuids,
+  });
+
+/** Routes the mocked fetch by URL so each test only states what it cares about. */
+const respondWith = ({ localPatient, attributes = [] }: { localPatient?: any; attributes?: Array<any> }) => {
+  let customReads = 0;
+
+  mockOpenmrsFetch.mockImplementation((url: string) => {
+    if (url.includes('/attribute?v=default')) {
+      return Promise.resolve({ data: { results: attributes } } as any);
+    }
+    if (url.includes('?v=custom')) {
+      // A local subject is read twice: once to resolve it, once again after the writes. Only
+      // the second is tagged, so a test asserting `reread` genuinely proves the caller got the
+      // refreshed record — returning the first one is what left the row showing "PCS Link".
+      customReads += 1;
+      return Promise.resolve({ data: { ...localPatient, reread: customReads > 1 } } as any);
+    }
+    return Promise.resolve({ data: {} } as any);
+  });
+};
+
+const writes = () =>
+  mockOpenmrsFetch.mock.calls.filter(([, options]) => (options as any)?.method === 'POST').map(([url]) => url);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockGetSessionLocation.mockResolvedValue({ uuid: 'location-uuid' } as any);
+});
+
+describe('linkParticipantToPatient', () => {
+  it('uses the existing record for a local patient and never creates one', async () => {
+    respondWith({ localPatient: { uuid: 'local-uuid', identifiers: [] } });
+
+    const result = await link(localSubject);
+
+    expect(mockCreatePatientFromHie).not.toHaveBeenCalled();
+    expect(writes()).toContain('/ws/rest/v1/patient/local-uuid/identifier');
+    // Returning the pre-write object is what made the dependants row keep offering to link.
+    expect(result.reread).toBe(true);
+  });
+
+  it('creates the patient for an HIE match, then writes the study data, then checks in once', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue(null);
+    mockCreatePatientFromHie.mockResolvedValue({ uuid: 'new-uuid', identifiers: [] } as any);
+    respondWith({});
+
+    await link(hieSubject);
+
+    expect(mockCreatePatientFromHie).toHaveBeenCalledOnce();
+    expect(writes()).toEqual([
+      '/ws/rest/v1/patient/new-uuid/identifier',
+      '/ws/rest/v1/person/new-uuid/attribute',
+      '/ws/rest/v1/person/new-uuid/attribute',
+    ]);
+    // The workspace must open last, and exactly once — the Check In path double-launches
+    // because createHIEPatient launches internally; this must not reproduce that.
+    expect(mockLaunchedAfterWrites()).toBe(true);
+    expect(launchWorkspaceGroup2).toHaveBeenCalledOnce();
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+
+  it('refuses to re-point a patient already linked to another participant', async () => {
+    respondWith({
+      localPatient: {
+        uuid: 'local-uuid',
+        identifiers: [{ uuid: 'identifier-uuid', identifier: '901-9-9-9', identifierType: { uuid: STUDY_ID_TYPE } }],
+      },
+    });
+
+    // This used to overwrite the identifier in place, silently moving the child from one
+    // participant to another and destroying the previous link.
+    await expect(link(localSubject)).rejects.toThrow('already linked to PCS participant 901-9-9-9');
+    expect(writes()).toEqual([]);
+    expect(launchWorkspace2).not.toHaveBeenCalled();
+  });
+
+  it('is a no-op when the patient already holds this same participant', async () => {
+    respondWith({
+      localPatient: {
+        uuid: 'local-uuid',
+        identifiers: [{ uuid: 'identifier-uuid', identifier: '901-1-1-3', identifierType: { uuid: STUDY_ID_TYPE } }],
+      },
+    });
+
+    await link(localSubject);
+
+    // Re-linking to the same participant stays idempotent — no identifier write at all.
+    expect(writes().filter((url) => url.includes('/identifier'))).toEqual([]);
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+
+  it('leaves an attribute alone when it already holds the right value', async () => {
+    respondWith({
+      localPatient: { uuid: 'local-uuid', identifiers: [] },
+      attributes: [{ uuid: 'attribute-uuid', value: 'true', attributeType: { uuid: PBIDS_ENROLLMENT_TYPE } }],
+    });
+
+    await link(localSubject);
+
+    // PBIDS enrollment already reads 'true'; only the CARDSE attribute is written.
+    expect(writes().filter((url) => url.includes('/attribute'))).toEqual(['/ws/rest/v1/person/local-uuid/attribute']);
+  });
+
+  it('writes both enrolment flags as boolean strings', async () => {
+    respondWith({ localPatient: { uuid: 'local-uuid', identifiers: [] } });
+
+    await link(localSubject);
+
+    const attributePosts = mockOpenmrsFetch.mock.calls
+      .filter(([url, options]) => url.includes('/attribute') && (options as any)?.method === 'POST')
+      .map(([, options]) => (options as any).body);
+
+    // The fixture is pbidsEnrolled: true, cardse: false — `false` is written, not skipped.
+    expect(attributePosts).toEqual([
+      { attributeType: PBIDS_ENROLLMENT_TYPE, value: 'true' },
+      { attributeType: CARDSE_ENROLLMENT_TYPE, value: 'false' },
+    ]);
+  });
+
+  it('throws without checking in when a write fails', async () => {
+    respondWith({ localPatient: { uuid: 'local-uuid', identifiers: [] } });
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+      if (options?.method === 'POST') {
+        return Promise.reject(new Error('Identifier already in use'));
+      }
+      return Promise.resolve({ data: { uuid: 'local-uuid', identifiers: [] } } as any);
+    });
+
+    await expect(link(localSubject)).rejects.toThrow('Identifier already in use');
+    expect(launchWorkspace2).not.toHaveBeenCalled();
+  });
+});
+
+/** True when every POST was issued before the workspace was launched. */
+function mockLaunchedAfterWrites() {
+  return (
+    vi.mocked(launchWorkspaceGroup2).mock.invocationCallOrder[0] >
+    Math.max(...mockOpenmrsFetch.mock.invocationCallOrder)
+  );
+}
+
+describe('delinkParticipant', () => {
+  const delink = (localPatient: any) =>
+    delinkParticipant({
+      localPatient,
+      studyParticipantIdentifierType: STUDY_ID_TYPE,
+      pbidsEnrollmentAttributeType: PBIDS_ENROLLMENT_TYPE,
+      cardseEnrollmentAttributeType: CARDSE_ENROLLMENT_TYPE,
+    });
+
+  const deletes = () =>
+    mockOpenmrsFetch.mock.calls.filter(([, options]) => (options as any)?.method === 'DELETE').map(([url]) => url);
+
+  it('voids the identifier and both attributes', async () => {
+    mockOpenmrsFetch.mockResolvedValue({
+      data: {
+        results: [
+          { uuid: 'status-attr', attributeType: { uuid: PBIDS_ENROLLMENT_TYPE } },
+          { uuid: 'category-attr', attributeType: { uuid: CARDSE_ENROLLMENT_TYPE } },
+        ],
+      },
+    } as any);
+
+    await delink({
+      uuid: 'local-uuid',
+      identifiers: [{ uuid: 'identifier-uuid', identifierType: { uuid: STUDY_ID_TYPE } }],
+    });
+
+    expect(deletes()).toEqual([
+      '/ws/rest/v1/patient/local-uuid/identifier/identifier-uuid',
+      '/ws/rest/v1/person/local-uuid/attribute/status-attr',
+      '/ws/rest/v1/person/local-uuid/attribute/category-attr',
+    ]);
+  });
+
+  it('still succeeds when the study data was only partly written', async () => {
+    mockOpenmrsFetch.mockResolvedValue({ data: { results: [] } } as any);
+
+    await expect(delink({ uuid: 'local-uuid', identifiers: [] })).resolves.toBeUndefined();
+    expect(deletes()).toEqual([]);
+  });
+
+  it('leaves an already-voided attribute alone', async () => {
+    mockOpenmrsFetch.mockResolvedValue({
+      data: {
+        results: [{ uuid: 'status-attr', voided: true, attributeType: { uuid: PBIDS_ENROLLMENT_TYPE } }],
+      },
+    } as any);
+
+    await delink({ uuid: 'local-uuid', identifiers: [] });
+
+    expect(deletes()).toEqual([]);
+  });
+});
+
+describe('syncStudyAttributes', () => {
+  const sync = () =>
+    syncStudyAttributes({
+      personUuid: 'local-uuid',
+      participant,
+      pbidsEnrollmentAttributeType: PBIDS_ENROLLMENT_TYPE,
+      cardseEnrollmentAttributeType: CARDSE_ENROLLMENT_TYPE,
+    });
+
+  const posts = () =>
+    mockOpenmrsFetch.mock.calls
+      .filter(([, options]) => (options as any)?.method === 'POST')
+      .map(([url, options]) => [url, (options as any).body]);
+
+  /** The fixture is pbidsEnrolled: true, cardse: false. */
+  const withAttributes = (attributes: Array<any>) =>
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+      if (options?.method === 'POST') {
+        return Promise.resolve({ data: {} } as any);
+      }
+      return Promise.resolve({ data: { results: attributes } } as any);
+    });
+
+  it('writes only the flag that drifted and reports just that one', async () => {
+    withAttributes([
+      { uuid: 'pbids-attr', value: 'true', attributeType: { uuid: PBIDS_ENROLLMENT_TYPE } },
+      { uuid: 'cardse-attr', value: 'true', attributeType: { uuid: CARDSE_ENROLLMENT_TYPE } },
+    ]);
+
+    await expect(sync()).resolves.toEqual(['cardse']);
+    expect(posts()).toEqual([['/ws/rest/v1/person/local-uuid/attribute/cardse-attr', { value: 'false' }]]);
+  });
+
+  it('writes nothing when the patient already matches PCS', async () => {
+    withAttributes([
+      { uuid: 'pbids-attr', value: 'true', attributeType: { uuid: PBIDS_ENROLLMENT_TYPE } },
+      { uuid: 'cardse-attr', value: 'false', attributeType: { uuid: CARDSE_ENROLLMENT_TYPE } },
+    ]);
+
+    await expect(sync()).resolves.toEqual([]);
+    expect(posts()).toEqual([]);
+  });
+
+  it('creates both attributes when the patient has none', async () => {
+    withAttributes([]);
+
+    await expect(sync()).resolves.toEqual(['pbids', 'cardse']);
+    expect(posts()).toEqual([
+      ['/ws/rest/v1/person/local-uuid/attribute', { attributeType: PBIDS_ENROLLMENT_TYPE, value: 'true' }],
+      ['/ws/rest/v1/person/local-uuid/attribute', { attributeType: CARDSE_ENROLLMENT_TYPE, value: 'false' }],
+    ]);
+  });
+
+  it('propagates a write failure so the caller can report it', async () => {
+    mockOpenmrsFetch.mockImplementation((_url: string, options?: any) =>
+      options?.method === 'POST'
+        ? Promise.reject(new Error('Attribute type not found'))
+        : Promise.resolve({ data: { results: [] } } as any),
+    );
+
+    await expect(sync()).rejects.toThrow('Attribute type not found');
+  });
+});