@openmrs/esm-emr-api 6.3.1-pre.2986

package/mock.ts

@@ -0,0 +1,12 @@
+import { vi } from 'vitest';
+
+export const setCurrentVisit = vi.fn();
+export const attachmentUrl = '/ws/rest/v1/attachment';
+export const getAttachmentByUuid = vi.fn();
+export const getAttachments = vi.fn();
+export const createAttachment = vi.fn();
+export const deleteAttachmentPermanently = vi.fn();
+export const updateVisit = vi.fn();
+export const saveVisit = vi.fn();
+export const getVisitsForPatient = vi.fn();
+export const getStartedVisit = vi.fn();

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@openmrs/esm-emr-api",
+  "version": "6.3.1-pre.2986",
+  "license": "MPL-2.0",
+  "description": "The javascript module for interacting with the OpenMRS API",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./src/public": {
+      "types": "./src/public.ts",
+      "default": "./dist/public.js"
+    },
+    "./mock": {
+      "import": "./mock.ts",
+      "require": "./mock-jest.ts"
+    }
+  },
+  "source": true,
+  "scripts": {
+    "test": "cross-env TZ=UTC vitest run --passWithNoTests",
+    "test:watch": "cross-env TZ=UTC vitest watch --passWithNoTests",
+    "build": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
+    "build:development": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
+    "typescript": "tsc --project tsconfig.build.json",
+    "lint": "eslint src --ext ts,tsx"
+  },
+  "keywords": [
+    "openmrs",
+    "microfrontends"
+  ],
+  "directories": {
+    "lib": "dist",
+    "src": "src"
+  },
+  "browserslist": [
+    "extends browserslist-config-openmrs"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openmrs/openmrs-esm-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/openmrs/openmrs-esm-core/issues"
+  },
+  "homepage": "https://github.com/openmrs/openmrs-esm-core#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/fhir": "0.0.31",
+    "lodash-es": "^4.17.21"
+  },
+  "peerDependencies": {
+    "@openmrs/esm-api": "6.x",
+    "@openmrs/esm-offline": "6.x",
+    "@openmrs/esm-state": "6.x"
+  },
+  "devDependencies": {
+    "@openmrs/esm-api": "6.3.1-pre.2986",
+    "@openmrs/esm-offline": "6.3.1-pre.2986",
+    "@openmrs/esm-state": "6.3.1-pre.2986",
+    "@swc/cli": "^0.7.7",
+    "@swc/core": "^1.11.29",
+    "concurrently": "^9.1.2",
+    "cross-env": "^7.0.3",
+    "happy-dom": "^17.4.7",
+    "rimraf": "^6.0.1",
+    "rxjs": "^6.5.3",
+    "vitest": "^3.1.4"
+  },
+  "stableVersion": "6.2.0"
+}

package/src/attachments.ts

@@ -0,0 +1,43 @@
+/** @module @category API */
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-api';
+import type { UploadedFile } from './types';
+
+export const attachmentUrl = `${restBaseUrl}/attachment`;
+
+export function getAttachmentByUuid(attachmentUuid: string, abortController: AbortController) {
+  return openmrsFetch(`${attachmentUrl}/${attachmentUuid}`, {
+    signal: abortController.signal,
+  });
+}
+
+export function getAttachments(patientUuid: string, includeEncounterless: boolean, abortController: AbortController) {
+  return openmrsFetch(`${attachmentUrl}?patient=${patientUuid}&includeEncounterless=${includeEncounterless}`, {
+    signal: abortController.signal,
+  });
+}
+
+export async function createAttachment(patientUuid: string, fileToUpload: UploadedFile) {
+  const formData = new FormData();
+
+  formData.append('fileCaption', fileToUpload.fileDescription);
+  formData.append('patient', patientUuid);
+
+  if (fileToUpload.file) {
+    formData.append('file', fileToUpload.file, fileToUpload.fileName);
+  } else {
+    formData.append('file', new File([''], fileToUpload.fileName), fileToUpload.fileName);
+    formData.append('base64Content', fileToUpload.base64Content);
+  }
+
+  return openmrsFetch(`${attachmentUrl}`, {
+    method: 'POST',
+    body: formData,
+  });
+}
+
+export function deleteAttachmentPermanently(attachmentUuid: string, abortController: AbortController) {
+  return openmrsFetch(`${attachmentUrl}/${attachmentUuid}`, {
+    method: 'DELETE',
+    signal: abortController.signal,
+  });
+}

package/src/current-patient.test.ts

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { openmrsFetch, type FetchResponse } from '@openmrs/esm-api';
+import { getSynchronizationItems } from '@openmrs/esm-offline';
+import { fetchCurrentPatient } from './current-patient';
+
+vi.mock('@openmrs/esm-api');
+
+const mockOpenmrsFetch = vi.mocked(openmrsFetch);
+const mockGetSynchronizationItems = vi.mocked(getSynchronizationItems);
+
+vi.mock('../openmrs-fetch', () => ({
+  openmrsFetch: vi.fn(),
+  fhirBaseUrl: '/ws/fhir2/R4',
+}));
+
+vi.mock('@openmrs/esm-offline', () => ({
+  getSynchronizationItems: vi.fn(),
+}));
+
+describe('fetchPatientData', () => {
+  beforeEach(() => {
+    mockGetSynchronizationItems.mockResolvedValue([]);
+  });
+
+  it('should return null when patientUuid is falsy', async () => {
+    const result = await fetchCurrentPatient('');
+    expect(result).toBeNull();
+  });
+
+  it('should return online patient data when available', async () => {
+    const mockPatient = { id: '123', name: [{ given: ['John'], family: 'Doe' }] };
+    mockOpenmrsFetch.mockResolvedValue({ data: mockPatient, ok: true } as Partial<FetchResponse> as FetchResponse);
+
+    const result = await fetchCurrentPatient('123');
+    expect(result).toEqual(mockPatient);
+  });
+
+  it('should return offline patient data when online fetch fails', async () => {
+    const mockOfflinePatient = { id: '123', name: [{ given: ['Jane'], family: 'Doe' }] };
+    mockOpenmrsFetch.mockRejectedValue(new Error('Network error'));
+    mockGetSynchronizationItems.mockResolvedValue([{ fhirPatient: mockOfflinePatient }]);
+
+    const result = await fetchCurrentPatient('123');
+    expect(result).toEqual(mockOfflinePatient);
+  });
+
+  it('should throw an error when both online and offline fetches fail', async () => {
+    mockOpenmrsFetch.mockRejectedValue(new Error('Network error'));
+    mockGetSynchronizationItems.mockResolvedValue([]);
+
+    await expect(fetchCurrentPatient('123')).rejects.toThrow('Network error');
+  });
+});

package/src/current-patient.ts

@@ -0,0 +1,58 @@
+/** @module @category API */
+import { fhirBaseUrl, openmrsFetch, type FetchConfig, type FetchResponse } from '@openmrs/esm-api';
+import { getSynchronizationItems } from '@openmrs/esm-offline';
+
+export type CurrentPatient = fhir.Patient | FetchResponse<fhir.Patient>;
+
+export interface CurrentPatientOptions {
+  includeConfig?: boolean;
+}
+
+export interface PatientWithFullResponse extends CurrentPatientOptions {
+  includeConfig: true;
+}
+
+export interface OnlyThePatient extends CurrentPatientOptions {
+  includeConfig: false;
+}
+
+export type PatientUuid = string | null;
+
+export async function fetchCurrentPatient(
+  patientUuid: PatientUuid,
+  fetchInit?: FetchConfig,
+  includeOfflinePatients: boolean = true,
+): Promise<fhir.Patient | null> {
+  if (patientUuid) {
+    let err: Error | null = null;
+    const [onlinePatient, offlinePatient] = await Promise.all([
+      openmrsFetch<fhir.Patient>(`${fhirBaseUrl}/Patient/${patientUuid}`, fetchInit).catch<FetchResponse<fhir.Patient>>(
+        (e) => (err = e),
+      ),
+      includeOfflinePatients ? getOfflineRegisteredPatientAsFhirPatient(patientUuid) : Promise.resolve(null),
+    ]);
+
+    if (onlinePatient.ok) {
+      return onlinePatient.data;
+    }
+
+    if (offlinePatient) {
+      return offlinePatient;
+    }
+
+    if (err) {
+      throw err;
+    }
+  }
+
+  return null;
+}
+
+async function getOfflineRegisteredPatientAsFhirPatient(patientUuid: string): Promise<fhir.Patient | null> {
+  const patientRegistrationSyncItems = await getSynchronizationItems<{
+    fhirPatient: fhir.Patient;
+  }>('patient-registration');
+  const patientSyncItem = patientRegistrationSyncItems.find((item) => item.fhirPatient.id === patientUuid);
+
+  return patientSyncItem?.fhirPatient ?? null;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './attachments';
+export * from './current-patient';
+export * from './location';
+export * from './types';
+export * from './visit-type';
+export * from './visit-utils';

package/src/location.ts

@@ -0,0 +1,36 @@
+/** @module @category API */
+import { openmrsObservableFetch, restBaseUrl } from '@openmrs/esm-api';
+import type { Observable } from 'rxjs';
+import { map, take } from 'rxjs/operators/index.js';
+import type { Location } from './types';
+
+export function toLocationObject(openmrsRestForm: any): Location {
+  return {
+    uuid: openmrsRestForm.uuid,
+    display: openmrsRestForm.display,
+  };
+}
+
+export function getLocations(
+  tagUuidOrName: string | null = null,
+  query: string | null = null,
+): Observable<Array<Location>> {
+  const params = new URLSearchParams();
+  if (tagUuidOrName) {
+    params.set('tag', tagUuidOrName);
+  }
+  if (query) {
+    params.set('q', query);
+  }
+  const queryString = params.toString();
+  const url = `${restBaseUrl}/location${queryString ? '?' + queryString : ''}`;
+
+  return openmrsObservableFetch<{ results: Array<Location> }>(url)
+    .pipe(
+      map((results) => {
+        const locations: Array<Location> = results.data.results.map(toLocationObject);
+        return locations;
+      }),
+    )
+    .pipe(take(1));
+}

package/src/public.ts

@@ -0,0 +1,6 @@
+export * from './attachments';
+export * from './current-patient';
+export * from './types';
+export * from './visit-utils';
+export * from './visit-type';
+export * from './location';

package/src/types/attachments-types.ts

@@ -0,0 +1,28 @@
+export interface UploadedFile {
+  file?: File;
+  base64Content: string;
+  fileName: string;
+  fileType: string;
+  fileDescription: string;
+  status?: 'uploading' | 'complete';
+  capturedFromWebcam?: boolean;
+}
+
+export interface Attachment {
+  id: string;
+  src: string;
+  filename: string;
+  dateTime: string;
+  bytesMimeType: string;
+  bytesContentFamily: string;
+  description?: string;
+}
+
+export interface AttachmentResponse {
+  bytesContentFamily: string;
+  bytesMimeType: string;
+  comment: string;
+  dateTime: string;
+  uuid: string;
+  filename?: string;
+}

package/src/types/diagnosis-resource.ts

@@ -0,0 +1,24 @@
+import { type Concept, type ConceptClass, type OpenmrsResource } from '@openmrs/esm-api';
+import { type Encounter } from './encounter-resource';
+import { type Patient } from './patient-resource';
+
+// TODO: make this extends OpenmrsResourceStrict
+export interface Diagnosis extends OpenmrsResource {
+  diagnosis?: {
+    coded?: {
+      uuid: string;
+      display?: string;
+      name?: Concept;
+      datatype?: OpenmrsResource;
+      conceptClass?: ConceptClass;
+    };
+    nonCoded?: string;
+  };
+  patient?: Patient;
+  encounter?: Encounter;
+  certainty?: string;
+  rank?: number;
+  formFieldNamespace?: string;
+  formFieldPath?: string;
+  voided?: boolean;
+}

package/src/types/encounter-resource.ts

@@ -0,0 +1,36 @@
+import { type OpenmrsResource } from '@openmrs/esm-api';
+import { type Diagnosis } from './diagnosis-resource';
+import { type Location } from './location-resource';
+import { type Obs } from './obs-resource';
+import { type Patient } from './patient-resource';
+import { type Visit } from './visit-resource';
+
+// TODO: make this extends OpenmrsResourceStrict
+export interface Encounter extends OpenmrsResource {
+  encounterDatetime?: string;
+  patient?: Patient;
+  location?: Location;
+  encounterType?: EncounterType;
+  obs?: Array<Obs>;
+  visit?: Visit;
+  encounterProviders?: Array<EncounterProvider>;
+  diagnoses?: Array<Diagnosis>;
+  form?: OpenmrsResource;
+}
+
+export interface EncounterType extends OpenmrsResource {
+  name?: string;
+  description?: string;
+  retired?: boolean;
+}
+
+export interface EncounterProvider extends OpenmrsResource {
+  provider?: OpenmrsResource;
+  encounterRole?: EncounterRole;
+}
+
+export interface EncounterRole extends OpenmrsResource {
+  name?: string;
+  description?: string;
+  retired?: boolean;
+}

package/src/types/fhir-resource.ts

@@ -0,0 +1,32 @@
+export interface FHIRResource {
+  resource: {
+    code: { coding: Array<FHIRCode> };
+    effectiveDateTime: Date;
+    encounter: {
+      reference: string;
+      type: string;
+    };
+    id: string;
+    issued: Date;
+    referenceRange: any;
+    resourceType: string;
+    status: string;
+    subject: {
+      display: string;
+      identifier: { id: string; system: string; use: string; value: string };
+      reference: string;
+      type: string;
+    };
+    valueQuantity: {
+      value: number;
+    };
+    valueString: string;
+    valueCodeableConcept: { coding: Array<FHIRCode> };
+  };
+}
+
+export interface FHIRCode {
+  code: string;
+  system: string;
+  display?: string;
+}

package/src/types/fhir.ts

@@ -0,0 +1,102 @@
+/*
+Originally taken from https://github.com/FHIR/fhir.js/blob/ec82ccfc125e05dbb645f47c100fe60f2c34bb73/src/fhir.d.ts
+Has been adapted to be even better - if we can get fhir.js to publish a good version to npm with better typedefs,
+we can remove this file in favor of the one they maintain
+*/
+
+export type ResourceName =
+  | 'DomainResource'
+  | 'Organization'
+  | 'Location'
+  | 'HealthcareService'
+  | 'Practitioner'
+  | 'Patient'
+  | 'RelatedPerson'
+  | 'Device'
+  | 'Account'
+  | 'AllergyIntolerance'
+  | 'Schedule'
+  | 'Slot'
+  | 'Appointment'
+  | 'AppointmentResponse'
+  | 'AuditEvent'
+  | 'Basic'
+  | 'BodySite'
+  | 'Substance'
+  | 'Medication'
+  | 'Group'
+  | 'Specimen'
+  | 'DeviceComponent'
+  | 'DeviceMetric'
+  | 'ValueSet'
+  | 'Questionnaire'
+  | 'QuestionnaireResponse'
+  | 'Observation'
+  | 'FamilyMemberHistory'
+  | 'DocumentReference'
+  | 'DiagnosticOrder'
+  | 'ProcedureRequest'
+  | 'ReferralRequest'
+  | 'Procedure'
+  | 'ImagingStudy'
+  | 'ImagingObjectSelection'
+  | 'Media'
+  | 'DiagnosticReport'
+  | 'CommunicationRequest'
+  | 'DeviceUseRequest'
+  | 'MedicationOrder'
+  | 'NutritionOrder'
+  | 'Order'
+  | 'ProcessRequest'
+  | 'SupplyRequest'
+  | 'VisionPrescription'
+  | 'ClinicalImpression'
+  | 'Condition'
+  | 'EpisodeOfCare'
+  | 'Encounter'
+  | 'MedicationStatement'
+  | 'RiskAssessment'
+  | 'Goal'
+  | 'CarePlan'
+  | 'Composition'
+  | 'Contract'
+  | 'Coverage'
+  | 'ClaimResponse'
+  | 'Claim'
+  | 'Communication'
+  | 'StructureDefinition'
+  | 'ConceptMap'
+  | 'OperationDefinition'
+  | 'Conformance'
+  | 'DataElement'
+  | 'DetectedIssue'
+  | 'DeviceUseStatement'
+  | 'DocumentManifest'
+  | 'EligibilityRequest'
+  | 'EligibilityResponse'
+  | 'EnrollmentRequest'
+  | 'EnrollmentResponse'
+  | 'ExplanationOfBenefit'
+  | 'Flag'
+  | 'Immunization'
+  | 'ImmunizationRecommendation'
+  | 'ImplementationGuide'
+  | 'List'
+  | 'MedicationAdministration'
+  | 'MedicationDispense'
+  | 'OperationOutcome'
+  | 'MessageHeader'
+  | 'NamingSystem'
+  | 'OrderResponse'
+  | 'PaymentNotice'
+  | 'PaymentReconciliation'
+  | 'Person'
+  | 'ProcessResponse'
+  | 'Provenance'
+  | 'SearchParameter'
+  | 'Subscription'
+  | 'SupplyDelivery'
+  | 'TestScript'
+  | 'Binary'
+  | 'Bundle'
+  | 'Parameters';

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from './attachments-types';
+export * from './diagnosis-resource';
+export * from './encounter-resource';
+export * from './fhir';
+export * from './fhir-resource';
+export * from './location-resource';
+export * from './obs-resource';
+export * from './patient-resource';
+export * from './visit-resource';

package/src/types/location-resource.ts

@@ -0,0 +1,49 @@
+import { type OpenmrsResource } from '@openmrs/esm-api';
+
+export interface Location extends OpenmrsResource {
+  name?: string;
+  description?: string;
+  cityVillage?: string;
+  stateProvince?: string;
+  country?: string;
+  postalCode?: string;
+  countyDistrict?: string;
+  latitude?: string;
+  longitude?: string;
+  address1?: string;
+  address2?: string;
+  address3?: string;
+  address4?: string;
+  address5?: string;
+  address6?: string;
+  address7?: string;
+  address8?: string;
+  address9?: string;
+  address10?: string;
+  address11?: string;
+  address12?: string;
+  address13?: string;
+  address14?: string;
+  address15?: string;
+  tags?: Array<OpenmrsResource>;
+  attributes?: Array<OpenmrsResource>;
+  parentLocation?: Location;
+  childLocation?: Location;
+  retired?: boolean;
+}
+
+export interface FHIRLocationResource {
+  resource: {
+    id: string;
+    name: string;
+    resourceType: string;
+    status: 'active' | 'inactive';
+    meta?: {
+      tag?: Array<{
+        code: string;
+        display: string;
+        system: string;
+      }>;
+    };
+  };
+}

package/src/types/obs-resource.ts

@@ -0,0 +1,23 @@
+import { type Concept, type OpenmrsResource, type Person } from '@openmrs/esm-api';
+import { type Encounter } from './encounter-resource';
+import { type Location } from './location-resource';
+
+export interface Obs extends OpenmrsResource {
+  concept?: Concept;
+  person?: Person;
+  obsDatetime?: string;
+  accessionNumber?: string;
+  obsGroup?: Obs;
+  valueCodedName?: OpenmrsResource;
+  groupMembers?: Array<Obs>;
+  comment?: string;
+  location?: Location;
+  order?: OpenmrsResource;
+  encounter?: Encounter;
+  value?: number | string | boolean | OpenmrsResource;
+  valueModifier?: string;
+  formFilePath?: string;
+  formFiledNamespace?: string;
+  status?: 'PRELIMINARY' | 'FINAL' | 'AMENDED';
+  interpretation?: string;
+}

package/src/types/patient-resource.ts

@@ -0,0 +1,27 @@
+import { type OpenmrsResourceStrict, type Person } from '@openmrs/esm-api';
+
+export interface PatientIdentifierType extends OpenmrsResourceStrict {
+  name?: string;
+  description?: string;
+  format?: string;
+  formatDescription?: string;
+  required?: boolean;
+  validator?: string;
+  locationBehavior?: string;
+  uniquenessBehavior?: string;
+  retired?: boolean;
+}
+
+export interface Patient extends OpenmrsResourceStrict {
+  identifiers?: PatientIdentifier[];
+  person?: Person;
+  voided?: boolean;
+}
+
+export interface PatientIdentifier extends OpenmrsResourceStrict {
+  identifier?: string;
+  identifierType?: PatientIdentifierType;
+  location?: Location;
+  preferred?: boolean;
+  voided?: boolean;
+}

package/src/types/visit-resource.ts

@@ -0,0 +1,43 @@
+import { type OpenmrsResource } from '@openmrs/esm-api';
+import { type Encounter } from './encounter-resource';
+import { type Patient } from './patient-resource';
+
+export interface NewVisitPayload {
+  uuid?: string;
+  location: string;
+  patient?: string;
+  startDatetime: Date;
+  visitType: string;
+  stopDatetime?: Date;
+  attributes?: Array<{
+    attributeType: string;
+    value: string;
+  }>;
+}
+
+export type UpdateVisitPayload = Partial<NewVisitPayload> & {};
+
+export interface Visit {
+  uuid: string;
+  display?: string;
+  encounters?: Array<Encounter>;
+  patient?: Patient;
+  visitType: VisitType;
+  location?: Location;
+  startDatetime: string;
+  stopDatetime?: string;
+  attributes?: Array<OpenmrsResource>;
+  [anythingElse: string]: any;
+}
+
+interface Location {
+  uuid: string;
+  display?: string;
+  name?: string;
+}
+
+export interface VisitType {
+  uuid: string;
+  display: string;
+  name?: string;
+}