@openmrs/esm-offline 3.2.1-pre.986 → 3.3.1-pre.1173

package/jest.config.js

@@ -1,5 +1,8 @@
 module.exports = {
   transform: {
-    "^.+\\.tsx?$": "babel-jest",
+    "^.+\\.tsx?$": ["@swc/jest"],
+  },
+  moduleNameMapper: {
+    "lodash-es": "lodash",
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-offline",
-  "version": "3.2.1-pre.986",
+  "version": "3.3.1-pre.1173",
   "license": "MPL-2.0",
   "description": "Helper utilities for OpenMRS",
   "browser": "dist/openmrs-esm-offline.js",
@@ -36,10 +36,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "^3.2.1-pre.986",
-    "@openmrs/esm-globals": "^3.2.1-pre.986",
-    "@openmrs/esm-state": "^3.2.1-pre.986",
-    "@openmrs/esm-styleguide": "^3.2.1-pre.986",
+    "@openmrs/esm-api": "^3.3.1-pre.1173",
+    "@openmrs/esm-globals": "^3.3.1-pre.1173",
+    "@openmrs/esm-state": "^3.3.1-pre.1173",
+    "@openmrs/esm-styleguide": "^3.3.1-pre.1173",
     "@types/uuid": "^8.3.0",
     "rxjs": "^6.5.3"
   },
@@ -56,5 +56,5 @@
     "uuid": "^8.3.2",
     "workbox-window": "^6.1.5"
   },
-  "gitHead": "970eb8ac9493a64af6d84c3f8a9620f96f01a1a3"
+  "gitHead": "957c0c36b8f754808127269f6e50b90992a60559"
 }

package/src/index.ts

@@ -1,10 +1,7 @@
 export * from "./service-worker";
 export * from "./service-worker-http-headers";
 export * from "./service-worker-messaging";
-export * from "./service-worker-events";
-export * from "./events";
 export * from "./mode";
-export * from "./patches";
 export * from "./sync";
 export * from "./uuid";
 export * from "./offline-patient-data";

package/src/mode.ts

@@ -1,3 +1,5 @@
+/** @module @category Offline */
+
 async function isSafariPrivateBrowsing() {
   const storage = window.sessionStorage;
 

package/src/offline-patient-data.ts

@@ -1,3 +1,4 @@
+/** @module @category Offline */
 import Dexie, { Table } from "dexie";
 import { createGlobalStore } from "@openmrs/esm-state";
 

package/src/public.ts

@@ -0,0 +1,20 @@
+export { OfflineMode, OfflineModeResult, getCurrentOfflineMode } from "./mode";
+export * from "./offline-patient-data";
+export * from "./service-worker-messaging";
+export * from "./service-worker-http-headers";
+export * from "./uuid";
+export {
+  QueueItemDescriptor,
+  SyncItem,
+  SyncProcessOptions,
+  queueSynchronizationItem,
+  getSynchronizationItem,
+  getSynchronizationItems,
+  getFullSynchronizationItems,
+  getFullSynchronizationItemsFor,
+  getOfflineDb,
+  canBeginEditSynchronizationItemsOfType,
+  beginEditSynchronizationItem,
+  deleteSynchronizationItem,
+  setupOfflineSync,
+} from "./sync";

package/src/service-worker-http-headers.ts

@@ -1,3 +1,5 @@
+/** @module @category Offline */
+
 export const omrsOfflineResponseBodyHttpHeaderName =
   "x-omrs-offline-response-body";
 export const omrsOfflineResponseStatusHttpHeaderName =

package/src/service-worker-messaging.ts

@@ -1,3 +1,4 @@
+/** @module @category Offline */
 import type { ImportMap } from "@openmrs/esm-globals";
 import { OmrsOfflineCachingStrategy } from "./service-worker-http-headers";
 import { getOmrsServiceWorker } from "./service-worker";

package/src/sync.test.ts

@@ -0,0 +1,153 @@
+import "fake-indexeddb/auto";
+import { getLoggedInUser, LoggedInUser } from "@openmrs/esm-api";
+import {
+  getFullSynchronizationItems,
+  getFullSynchronizationItemsFor,
+  getOfflineDb,
+  getSynchronizationItems,
+  getSynchronizationItemsFor,
+  QueueItemDescriptor,
+  queueSynchronizationItem,
+  queueSynchronizationItemFor,
+  deleteSynchronizationItem,
+  getSynchronizationItem,
+} from "./sync";
+
+interface MockSyncItem {
+  value: number;
+}
+
+const systemTime = new Date();
+const mockUserId = "00000000-0000-0000-0000-000000000000";
+const mockSyncItemType = "mock-sync-item";
+const defaultMockSyncItem: MockSyncItem = {
+  value: 123,
+};
+const defaultMockSyncItemDescriptor: QueueItemDescriptor = {
+  dependencies: [],
+  id: "123",
+  displayName: "Mock Sync Item",
+  patientUuid: "00000000-0000-0000-0000-000000000001",
+};
+
+jest.mock("@openmrs/esm-api", () => ({
+  getLoggedInUser: jest.fn(async () => ({ uuid: mockUserId })),
+}));
+
+afterEach(async () => {
+  // We want each test case to start fresh with a clean sync queue.
+  await getOfflineDb().syncQueue.clear();
+});
+
+describe("Sync Queue", () => {
+  beforeAll(() => {
+    // We want to control the timers to ensure that we can test the `createdOn` attribute
+    // of the sync item (which is created using `new Date()`).
+    jest.useFakeTimers("modern");
+    jest.setSystemTime(systemTime);
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  it("enqueues sync item with expected attributes", async () => {
+    const id = await queueSynchronizationItemFor(
+      mockUserId,
+      mockSyncItemType,
+      defaultMockSyncItem,
+      defaultMockSyncItemDescriptor
+    );
+    const queuedItems = await getFullSynchronizationItemsFor<MockSyncItem>(
+      mockUserId,
+      mockSyncItemType
+    );
+
+    expect(queuedItems).toHaveLength(1);
+    expect(queuedItems[0].id).toBe(id);
+    expect(queuedItems[0].type).toBe(mockSyncItemType);
+    expect(queuedItems[0].userId).toBe(mockUserId);
+    expect(queuedItems[0].createdOn).toStrictEqual(systemTime);
+    expect(queuedItems[0].content).toStrictEqual(defaultMockSyncItem);
+    expect(queuedItems[0].descriptor).toStrictEqual(
+      defaultMockSyncItemDescriptor
+    );
+  });
+});
+
+describe("Logged-in user specific functions", () => {
+  it("enqueue and return sync items of currently logged-in user", async () => {
+    const loggedInUserId = (await getLoggedInUser()).uuid;
+    await queueSynchronizationItem(mockSyncItemType, defaultMockSyncItem);
+    const queuedItems = await getFullSynchronizationItems(mockSyncItemType);
+
+    expect(queuedItems).toHaveLength(1);
+    expect(queuedItems[0].userId).toBe(loggedInUserId);
+  });
+});
+
+describe("getSynchronizationItems", () => {
+  it("returns `content` of corresponding `getFullSynchronizationItems` call", async () => {
+    await queueSynchronizationItem(mockSyncItemType, defaultMockSyncItem);
+    const items = await getSynchronizationItems(mockSyncItemType);
+    const fullItems = await getFullSynchronizationItems(mockSyncItemType);
+    expect(items).toHaveLength(1);
+    expect(fullItems).toHaveLength(1);
+    expect(items[0]).toStrictEqual(fullItems[0].content);
+  });
+});
+
+describe("getSynchronizationItemsFor", () => {
+  it("returns `content` of corresponding `getFullSynchronizationItemsFor` call", async () => {
+    await queueSynchronizationItemFor(
+      mockUserId,
+      mockSyncItemType,
+      defaultMockSyncItem
+    );
+    const items = await getSynchronizationItemsFor(
+      mockUserId,
+      mockSyncItemType
+    );
+    const fullItems = await getFullSynchronizationItemsFor(
+      mockUserId,
+      mockSyncItemType
+    );
+
+    expect(items).toHaveLength(1);
+    expect(fullItems).toHaveLength(1);
+    expect(items[0]).toStrictEqual(fullItems[0].content);
+  });
+});
+
+describe("getSynchronizationItem", () => {
+  it("returns the specific sync item with given ID", async () => {
+    const id = await queueSynchronizationItem(
+      mockSyncItemType,
+      defaultMockSyncItem
+    );
+    const items = await getFullSynchronizationItems(mockSyncItemType);
+    const item = await getSynchronizationItem(id);
+    expect(item).toStrictEqual(items[0]);
+  });
+
+  it("returns undefined when no item with given ID exists", async () => {
+    const item = await getSynchronizationItem(404);
+    expect(item).toBeUndefined();
+  });
+});
+
+describe("deleteSynchronizationItem", () => {
+  it("deletes sync item with given ID", async () => {
+    const id = await queueSynchronizationItem(
+      mockSyncItemType,
+      defaultMockSyncItem
+    );
+    await deleteSynchronizationItem(id);
+    const items = await getSynchronizationItems(mockSyncItemType);
+    expect(items).toHaveLength(0);
+  });
+
+  it("does not throw when no item with given ID exists", async () => {
+    await deleteSynchronizationItem(404);
+  });
+});

package/src/sync.ts

@@ -1,3 +1,4 @@
+/** @module @category Offline */
 import Dexie, { Table } from "dexie";
 import { getLoggedInUser } from "@openmrs/esm-api";
 import { createGlobalStore } from "@openmrs/esm-state";
@@ -299,26 +300,39 @@ export async function queueSynchronizationItem<T>(
 }
 
 /**
- * Returns all currently queued up sync items of a given user.
+ * Returns the content of all currently queued up sync items of a given user.
  * @param userId The ID of the user whose synchronization items should be returned.
  * @param type The identifying type of the synchronization items to be returned..
  */
 export async function getSynchronizationItemsFor<T>(
   userId: string,
   type: string
+) {
+  const fullItems = await getFullSynchronizationItemsFor<T>(userId, type);
+  return fullItems.map((item) => item.content);
+}
+
+/**
+ * Returns all currently queued up sync items of a given user.
+ * @param userId The ID of the user whose synchronization items should be returned.
+ * @param type The identifying type of the synchronization items to be returned..
+ */
+export async function getFullSynchronizationItemsFor<T>(
+  userId: string,
+  type: string
 ) {
   const table = db.syncQueue;
-  const items: Array<T> = [];
+  const items: Array<SyncItem<T>> = [];
 
   await table.where({ type, userId }).each((item) => {
-    items.push(item.content);
+    items.push(item);
   });
 
   return items;
 }
 
 /**
- * Returns all currently queued up sync items of the currently signed in user.
+ * Returns the content of all currently queued up sync items of the currently signed in user.
  * @param type The identifying type of the synchronization items to be returned.
  */
 export async function getSynchronizationItems<T>(type: string) {
@@ -326,6 +340,15 @@ export async function getSynchronizationItems<T>(type: string) {
   return await getSynchronizationItemsFor<T>(userId, type);
 }
 
+/**
+ * Returns all currently queued up sync items of the currently signed in user.
+ * @param type The identifying type of the synchronization items to be returned.
+ */
+export async function getFullSynchronizationItems<T>(type: string) {
+  const userId = await getUserId();
+  return await getFullSynchronizationItemsFor<T>(userId, type);
+}
+
 /**
  * Returns a queued sync item with the given ID or `undefined` if no such item exists.
  * @param id The ID of the requested sync item.

package/src/uuid.ts

@@ -1,3 +1,4 @@
+/** @module @category Offline */
 import { v4 } from "uuid";
 
 export const offlineUuidPrefix = "OFFLINE+";

package/webpack.config.js

@@ -19,7 +19,7 @@ module.exports = (env) => ({
       {
         test: /\.m?(js|ts|tsx)$/,
         exclude: /(node_modules|bower_components)/,
-        use: "babel-loader",
+        use: "swc-loader",
       },
     ],
   },

package/.babelrc

@@ -1,7 +0,0 @@
-{
-  "presets": [
-    "@babel/preset-env",
-    "@babel/preset-typescript",
-    "@babel/preset-react"
-  ]
-}

package/src/events.ts

@@ -1,18 +0,0 @@
-import { NetworkRequestFailedEvent } from "./service-worker-events";
-
-const networkRequestFailedEventName = "openmrs:network-request-failed";
-
-export function dispatchNetworkRequestFailed(data: NetworkRequestFailedEvent) {
-  window.dispatchEvent(
-    new CustomEvent(networkRequestFailedEventName, { detail: data })
-  );
-}
-
-export function subscribeNetworkRequestFailed(
-  cb: (data: NetworkRequestFailedEvent) => void
-) {
-  const handler = (ev: CustomEvent) => cb(ev.detail);
-  window.addEventListener(networkRequestFailedEventName, handler);
-  return () =>
-    window.removeEventListener(networkRequestFailedEventName, handler);
-}

package/src/patches.ts

@@ -1,7 +0,0 @@
-export function patchXMLHttpRequest() {
-  const send = XMLHttpRequest.prototype.send;
-
-  XMLHttpRequest.prototype.send = function (...args) {
-    return send.apply(this, args);
-  };
-}

package/src/service-worker-events.ts

@@ -1,15 +0,0 @@
-export interface OmrsServiceWorkerEvent<TypeIdentifier extends string> {
-  type: TypeIdentifier;
-}
-
-export interface NetworkRequestFailedEvent
-  extends OmrsServiceWorkerEvent<"networkRequestFailed"> {
-  request: {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    body: string;
-  };
-}
-
-export type KnownOmrsServiceWorkerEvents = NetworkRequestFailedEvent;