@dhis2/app-service-offline 3.1.0 → 3.2.0

package/build/cjs/index.js

@@ -33,6 +33,12 @@ Object.defineProperty(exports, "useOnlineStatus", {
     return _onlineStatus.useOnlineStatus;
   }
 });
+Object.defineProperty(exports, "clearSensitiveCaches", {
+  enumerable: true,
+  get: function () {
+    return _clearSensitiveCaches.clearSensitiveCaches;
+  }
+});
 
 var _offlineProvider = require("./lib/offline-provider");
 
@@ -40,4 +46,6 @@ var _cacheableSection = require("./lib/cacheable-section");
 
 var _cacheableSectionState = require("./lib/cacheable-section-state");
 
-var _onlineStatus = require("./lib/online-status");
+var _onlineStatus = require("./lib/online-status");
+
+var _clearSensitiveCaches = require("./lib/clear-sensitive-caches");

package/build/cjs/lib/__tests__/clear-sensitive-caches.test.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _FDBFactory = _interopRequireDefault(require("fake-indexeddb/lib/FDBFactory"));
+
+var _idb = require("idb");
+
+require("fake-indexeddb/auto");
+
+var _clearSensitiveCaches = require("../clear-sensitive-caches");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Mocks for CacheStorage API
+// Returns true if an existing cache is deleted
+const makeCachesDeleteMock = keys => {
+  return jest.fn().mockImplementation(key => Promise.resolve(keys.includes(key)));
+};
+
+const keysMockDefault = jest.fn().mockImplementation(async () => []);
+const deleteMockDefault = makeCachesDeleteMock([]);
+const cachesDefault = {
+  keys: keysMockDefault,
+  delete: deleteMockDefault
+};
+window.caches = cachesDefault;
+afterEach(() => {
+  window.caches = cachesDefault;
+  jest.clearAllMocks();
+}); // silence debug logs for these tests
+
+const originalDebug = console.debug;
+beforeAll(() => {
+  jest.spyOn(console, 'debug').mockImplementation((...args) => {
+    const pattern = /Clearing sensitive caches/;
+
+    if (typeof args[0] === 'string' && pattern.test(args[0])) {
+      return;
+    }
+
+    return originalDebug.call(console, ...args);
+  });
+});
+afterAll(() => {
+  ;
+  console.debug.mockRestore();
+});
+it('does not fail if there are no caches or no sections-db', () => {
+  return expect((0, _clearSensitiveCaches.clearSensitiveCaches)()).resolves.toBe(false);
+});
+it('clears potentially sensitive caches', async () => {
+  const testKeys = ['cache1', 'cache2', 'app-shell'];
+  const keysMock = jest.fn().mockImplementation(() => Promise.resolve(testKeys));
+  const deleteMock = makeCachesDeleteMock(testKeys);
+  window.caches = {
+    keys: keysMock,
+    delete: deleteMock
+  };
+  const cachesDeleted = await (0, _clearSensitiveCaches.clearSensitiveCaches)();
+  expect(cachesDeleted).toBe(true);
+  expect(deleteMock).toHaveBeenCalledTimes(3);
+  expect(deleteMock.mock.calls[0][0]).toBe('cache1');
+  expect(deleteMock.mock.calls[1][0]).toBe('cache2');
+  expect(deleteMock.mock.calls[2][0]).toBe('app-shell');
+});
+it('preserves keepable caches', async () => {
+  const keysMock = jest.fn().mockImplementation(async () => ['cache1', 'cache2', 'app-shell', 'other-assets', 'workbox-precache-v2-https://hey.howareya.now/']);
+  window.caches = { ...cachesDefault,
+    keys: keysMock
+  };
+  await (0, _clearSensitiveCaches.clearSensitiveCaches)();
+  expect(deleteMockDefault).toHaveBeenCalledTimes(3);
+  expect(deleteMockDefault.mock.calls[0][0]).toBe('cache1');
+  expect(deleteMockDefault.mock.calls[1][0]).toBe('cache2');
+  expect(deleteMockDefault.mock.calls[2][0]).toBe('app-shell');
+  expect(deleteMockDefault).not.toHaveBeenCalledWith('other-assets');
+  expect(deleteMockDefault).not.toHaveBeenCalledWith('workbox-precache-v2-https://hey.howareya.now/');
+});
+describe('clears sections-db', () => {
+  // Test DB
+  function openTestDB(dbName) {
+    // simplified version of app platform openDB logic
+    return (0, _idb.openDB)(dbName, 1, {
+      upgrade(db) {
+        db.createObjectStore(_clearSensitiveCaches.SECTIONS_STORE, {
+          keyPath: 'sectionId'
+        });
+      }
+
+    });
+  }
+
+  afterEach(() => {
+    // reset indexedDB state
+    window.indexedDB = new _FDBFactory.default();
+  });
+  it('clears sections-db if it exists', async () => {
+    // Open and populate test DB
+    const db = await openTestDB(_clearSensitiveCaches.SECTIONS_DB);
+    await db.put(_clearSensitiveCaches.SECTIONS_STORE, {
+      sectionId: 'id-1',
+      lastUpdated: new Date(),
+      requests: 3
+    });
+    await db.put(_clearSensitiveCaches.SECTIONS_STORE, {
+      sectionId: 'id-2',
+      lastUpdated: new Date(),
+      requests: 3
+    });
+    await (0, _clearSensitiveCaches.clearSensitiveCaches)(); // Sections-db should be cleared
+
+    const allSections = await db.getAll(_clearSensitiveCaches.SECTIONS_STORE);
+    expect(allSections).toHaveLength(0);
+  });
+  it("doesn't clear sections-db if it doesn't exist and doesn't open a new one", async () => {
+    const openMock = jest.fn();
+    window.indexedDB.open = openMock;
+    expect(await indexedDB.databases()).not.toContain(_clearSensitiveCaches.SECTIONS_DB);
+    await (0, _clearSensitiveCaches.clearSensitiveCaches)();
+    expect(openMock).not.toHaveBeenCalled();
+    return expect(await indexedDB.databases()).not.toContain(_clearSensitiveCaches.SECTIONS_DB);
+  });
+  it("doesn't handle IDB if 'databases' property is not on window.indexedDB", async () => {
+    // Open DB -- 'indexedDB.open' _would_ get called in this test
+    // if 'databases' property exists
+    await openTestDB(_clearSensitiveCaches.SECTIONS_DB);
+    const openMock = jest.fn();
+    window.indexedDB.open = openMock; // Remove 'databases' from indexedDB prototype for this test
+    // (simulates Firefox environment)
+
+    const idbProto = Object.getPrototypeOf(window.indexedDB);
+    const databases = idbProto.databases;
+    delete idbProto.databases;
+    expect('databases' in window.indexedDB).toBe(false);
+    await expect((0, _clearSensitiveCaches.clearSensitiveCaches)()).resolves.toBeDefined();
+    expect(openMock).not.toHaveBeenCalled(); // Restore indexedDB prototype for later tests
+
+    idbProto.databases = databases;
+    expect('databases' in window.indexedDB).toBe(true);
+  });
+});

package/build/cjs/lib/clear-sensitive-caches.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearSensitiveCaches = clearSensitiveCaches;
+exports.SECTIONS_STORE = exports.SECTIONS_DB = void 0;
+// IndexedDB names; should be the same as in @dhis2/pwa
+const SECTIONS_DB = 'sections-db';
+exports.SECTIONS_DB = SECTIONS_DB;
+const SECTIONS_STORE = 'sections-store'; // Non-sensitive caches that can be kept:
+
+exports.SECTIONS_STORE = SECTIONS_STORE;
+const KEEPABLE_CACHES = [/^workbox-precache/, // precached static assets
+/^other-assets/ // static assets cached at runtime - shouldn't be sensitive
+];
+
+/*
+ * Clears the 'sections-db' IndexedDB if it exists. Designed to avoid opening
+ * a new DB if it doesn't exist yet. Firefox can't check if 'sections-db'
+ * exists, in which circumstance the IndexedDB is unaffected. It's inelegant
+ * but acceptable because the IndexedDB has no sensitive data (only metadata
+ * of recorded sections), and the OfflineInterface handles discrepancies
+ * between CacheStorage and IndexedDB.
+ */
+const clearDB = async dbName => {
+  if (!('databases' in indexedDB)) {
+    // FF does not have indexedDB.databases. For that, just clear caches,
+    // and offline interface will handle discrepancies in PWA apps.
+    return;
+  }
+
+  const dbs = await window.indexedDB.databases();
+
+  if (!dbs.some(({
+    name
+  }) => name === dbName)) {
+    // Sections-db is not created; nothing to do here
+    return;
+  }
+
+  return new Promise((resolve, reject) => {
+    // IndexedDB fun:
+    const openDBRequest = indexedDB.open(dbName);
+
+    openDBRequest.onsuccess = e => {
+      const db = e.target.result;
+      const tx = db.transaction(SECTIONS_STORE, 'readwrite'); // When the transaction completes is when the operation is done:
+
+      tx.oncomplete = () => resolve();
+
+      tx.onerror = e => reject(e.target.error);
+
+      const os = tx.objectStore(SECTIONS_STORE);
+      const clearReq = os.clear();
+
+      clearReq.onerror = e => reject(e.target.error);
+    };
+
+    openDBRequest.onerror = e => {
+      reject(e.target.error);
+    };
+  });
+};
+/**
+ * Used to clear caches and 'sections-db' IndexedDB when a user logs out or a
+ * different user logs in to prevent someone from accessing a different user's
+ * caches. Should be able to be used in a non-PWA app.
+ */
+
+
+async function clearSensitiveCaches(dbName = SECTIONS_DB) {
+  console.debug('Clearing sensitive caches');
+  const cacheKeys = await caches.keys();
+  return Promise.all([// (Resolves to 'false' because this can't detect if anything was deleted):
+  clearDB(dbName).then(() => false), // Remove caches if not in keepable list
+  ...cacheKeys.map(key => {
+    if (!KEEPABLE_CACHES.some(pattern => pattern.test(key))) {
+      return caches.delete(key);
+    }
+
+    return false;
+  })]).then(responses => {
+    // Return true if any caches have been cleared
+    // (caches.delete() returns true if a cache is deleted successfully)
+    // PWA apps can reload to restore their app shell cache
+    return responses.some(response => response);
+  });
+}

package/build/es/index.js

@@ -1,4 +1,5 @@
 export { OfflineProvider } from './lib/offline-provider';
 export { CacheableSection, useCacheableSection } from './lib/cacheable-section';
 export { useCachedSections } from './lib/cacheable-section-state';
-export { useOnlineStatus } from './lib/online-status';
+export { useOnlineStatus } from './lib/online-status';
+export { clearSensitiveCaches } from './lib/clear-sensitive-caches';

package/build/es/lib/__tests__/clear-sensitive-caches.test.js

@@ -0,0 +1,132 @@
+import FDBFactory from 'fake-indexeddb/lib/FDBFactory';
+import { openDB } from 'idb';
+import 'fake-indexeddb/auto';
+import { clearSensitiveCaches, SECTIONS_DB, SECTIONS_STORE } from '../clear-sensitive-caches'; // Mocks for CacheStorage API
+// Returns true if an existing cache is deleted
+
+const makeCachesDeleteMock = keys => {
+  return jest.fn().mockImplementation(key => Promise.resolve(keys.includes(key)));
+};
+
+const keysMockDefault = jest.fn().mockImplementation(async () => []);
+const deleteMockDefault = makeCachesDeleteMock([]);
+const cachesDefault = {
+  keys: keysMockDefault,
+  delete: deleteMockDefault
+};
+window.caches = cachesDefault;
+afterEach(() => {
+  window.caches = cachesDefault;
+  jest.clearAllMocks();
+}); // silence debug logs for these tests
+
+const originalDebug = console.debug;
+beforeAll(() => {
+  jest.spyOn(console, 'debug').mockImplementation((...args) => {
+    const pattern = /Clearing sensitive caches/;
+
+    if (typeof args[0] === 'string' && pattern.test(args[0])) {
+      return;
+    }
+
+    return originalDebug.call(console, ...args);
+  });
+});
+afterAll(() => {
+  ;
+  console.debug.mockRestore();
+});
+it('does not fail if there are no caches or no sections-db', () => {
+  return expect(clearSensitiveCaches()).resolves.toBe(false);
+});
+it('clears potentially sensitive caches', async () => {
+  const testKeys = ['cache1', 'cache2', 'app-shell'];
+  const keysMock = jest.fn().mockImplementation(() => Promise.resolve(testKeys));
+  const deleteMock = makeCachesDeleteMock(testKeys);
+  window.caches = {
+    keys: keysMock,
+    delete: deleteMock
+  };
+  const cachesDeleted = await clearSensitiveCaches();
+  expect(cachesDeleted).toBe(true);
+  expect(deleteMock).toHaveBeenCalledTimes(3);
+  expect(deleteMock.mock.calls[0][0]).toBe('cache1');
+  expect(deleteMock.mock.calls[1][0]).toBe('cache2');
+  expect(deleteMock.mock.calls[2][0]).toBe('app-shell');
+});
+it('preserves keepable caches', async () => {
+  const keysMock = jest.fn().mockImplementation(async () => ['cache1', 'cache2', 'app-shell', 'other-assets', 'workbox-precache-v2-https://hey.howareya.now/']);
+  window.caches = { ...cachesDefault,
+    keys: keysMock
+  };
+  await clearSensitiveCaches();
+  expect(deleteMockDefault).toHaveBeenCalledTimes(3);
+  expect(deleteMockDefault.mock.calls[0][0]).toBe('cache1');
+  expect(deleteMockDefault.mock.calls[1][0]).toBe('cache2');
+  expect(deleteMockDefault.mock.calls[2][0]).toBe('app-shell');
+  expect(deleteMockDefault).not.toHaveBeenCalledWith('other-assets');
+  expect(deleteMockDefault).not.toHaveBeenCalledWith('workbox-precache-v2-https://hey.howareya.now/');
+});
+describe('clears sections-db', () => {
+  // Test DB
+  function openTestDB(dbName) {
+    // simplified version of app platform openDB logic
+    return openDB(dbName, 1, {
+      upgrade(db) {
+        db.createObjectStore(SECTIONS_STORE, {
+          keyPath: 'sectionId'
+        });
+      }
+
+    });
+  }
+
+  afterEach(() => {
+    // reset indexedDB state
+    window.indexedDB = new FDBFactory();
+  });
+  it('clears sections-db if it exists', async () => {
+    // Open and populate test DB
+    const db = await openTestDB(SECTIONS_DB);
+    await db.put(SECTIONS_STORE, {
+      sectionId: 'id-1',
+      lastUpdated: new Date(),
+      requests: 3
+    });
+    await db.put(SECTIONS_STORE, {
+      sectionId: 'id-2',
+      lastUpdated: new Date(),
+      requests: 3
+    });
+    await clearSensitiveCaches(); // Sections-db should be cleared
+
+    const allSections = await db.getAll(SECTIONS_STORE);
+    expect(allSections).toHaveLength(0);
+  });
+  it("doesn't clear sections-db if it doesn't exist and doesn't open a new one", async () => {
+    const openMock = jest.fn();
+    window.indexedDB.open = openMock;
+    expect(await indexedDB.databases()).not.toContain(SECTIONS_DB);
+    await clearSensitiveCaches();
+    expect(openMock).not.toHaveBeenCalled();
+    return expect(await indexedDB.databases()).not.toContain(SECTIONS_DB);
+  });
+  it("doesn't handle IDB if 'databases' property is not on window.indexedDB", async () => {
+    // Open DB -- 'indexedDB.open' _would_ get called in this test
+    // if 'databases' property exists
+    await openTestDB(SECTIONS_DB);
+    const openMock = jest.fn();
+    window.indexedDB.open = openMock; // Remove 'databases' from indexedDB prototype for this test
+    // (simulates Firefox environment)
+
+    const idbProto = Object.getPrototypeOf(window.indexedDB);
+    const databases = idbProto.databases;
+    delete idbProto.databases;
+    expect('databases' in window.indexedDB).toBe(false);
+    await expect(clearSensitiveCaches()).resolves.toBeDefined();
+    expect(openMock).not.toHaveBeenCalled(); // Restore indexedDB prototype for later tests
+
+    idbProto.databases = databases;
+    expect('databases' in window.indexedDB).toBe(true);
+  });
+});

package/build/es/lib/clear-sensitive-caches.js

@@ -0,0 +1,80 @@
+// IndexedDB names; should be the same as in @dhis2/pwa
+export const SECTIONS_DB = 'sections-db';
+export const SECTIONS_STORE = 'sections-store'; // Non-sensitive caches that can be kept:
+
+const KEEPABLE_CACHES = [/^workbox-precache/, // precached static assets
+/^other-assets/ // static assets cached at runtime - shouldn't be sensitive
+];
+
+/*
+ * Clears the 'sections-db' IndexedDB if it exists. Designed to avoid opening
+ * a new DB if it doesn't exist yet. Firefox can't check if 'sections-db'
+ * exists, in which circumstance the IndexedDB is unaffected. It's inelegant
+ * but acceptable because the IndexedDB has no sensitive data (only metadata
+ * of recorded sections), and the OfflineInterface handles discrepancies
+ * between CacheStorage and IndexedDB.
+ */
+const clearDB = async dbName => {
+  if (!('databases' in indexedDB)) {
+    // FF does not have indexedDB.databases. For that, just clear caches,
+    // and offline interface will handle discrepancies in PWA apps.
+    return;
+  }
+
+  const dbs = await window.indexedDB.databases();
+
+  if (!dbs.some(({
+    name
+  }) => name === dbName)) {
+    // Sections-db is not created; nothing to do here
+    return;
+  }
+
+  return new Promise((resolve, reject) => {
+    // IndexedDB fun:
+    const openDBRequest = indexedDB.open(dbName);
+
+    openDBRequest.onsuccess = e => {
+      const db = e.target.result;
+      const tx = db.transaction(SECTIONS_STORE, 'readwrite'); // When the transaction completes is when the operation is done:
+
+      tx.oncomplete = () => resolve();
+
+      tx.onerror = e => reject(e.target.error);
+
+      const os = tx.objectStore(SECTIONS_STORE);
+      const clearReq = os.clear();
+
+      clearReq.onerror = e => reject(e.target.error);
+    };
+
+    openDBRequest.onerror = e => {
+      reject(e.target.error);
+    };
+  });
+};
+/**
+ * Used to clear caches and 'sections-db' IndexedDB when a user logs out or a
+ * different user logs in to prevent someone from accessing a different user's
+ * caches. Should be able to be used in a non-PWA app.
+ */
+
+
+export async function clearSensitiveCaches(dbName = SECTIONS_DB) {
+  console.debug('Clearing sensitive caches');
+  const cacheKeys = await caches.keys();
+  return Promise.all([// (Resolves to 'false' because this can't detect if anything was deleted):
+  clearDB(dbName).then(() => false), // Remove caches if not in keepable list
+  ...cacheKeys.map(key => {
+    if (!KEEPABLE_CACHES.some(pattern => pattern.test(key))) {
+      return caches.delete(key);
+    }
+
+    return false;
+  })]).then(responses => {
+    // Return true if any caches have been cleared
+    // (caches.delete() returns true if a cache is deleted successfully)
+    // PWA apps can reload to restore their app shell cache
+    return responses.some(response => response);
+  });
+}

package/build/types/index.d.ts

@@ -2,3 +2,4 @@ export { OfflineProvider } from './lib/offline-provider';
 export { CacheableSection, useCacheableSection } from './lib/cacheable-section';
 export { useCachedSections } from './lib/cacheable-section-state';
 export { useOnlineStatus } from './lib/online-status';
+export { clearSensitiveCaches } from './lib/clear-sensitive-caches';

package/build/types/lib/clear-sensitive-caches.d.ts

@@ -0,0 +1,16 @@
+export declare const SECTIONS_DB = "sections-db";
+export declare const SECTIONS_STORE = "sections-store";
+declare global {
+    interface IDBFactory {
+        databases(): Promise<[{
+            name: string;
+            version: number;
+        }]>;
+    }
+}
+/**
+ * Used to clear caches and 'sections-db' IndexedDB when a user logs out or a
+ * different user logs in to prevent someone from accessing a different user's
+ * caches. Should be able to be used in a non-PWA app.
+ */
+export declare function clearSensitiveCaches(dbName?: string): Promise<any>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@dhis2/app-service-offline",
     "description": "A runtime service for online/offline detection and offline caching",
-    "version": "3.1.0",
+    "version": "3.2.0",
     "main": "./build/cjs/index.js",
     "module": "./build/es/index.js",
     "types": "build/types/index.d.ts",
@@ -33,7 +33,7 @@
         "coverage": "yarn test --coverage"
     },
     "peerDependencies": {
-        "@dhis2/app-service-alerts": "3.1.0",
+        "@dhis2/app-service-alerts": "3.2.0",
         "prop-types": "^15.7.2",
         "react": "^16.8.6",
         "react-dom": "^16.8.6"