@luvio/durable-store-idb 0.128.0

package/README.md

@@ -0,0 +1,23 @@
+# durable-store-idb
+
+An implementation of the Luvio DurableStore based on [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API).
+
+## Install
+
+```sh
+npm i @luvio/durable-store-idb
+```
+
+## Usage
+
+```js
+import { IndexedDbDurableStore } from '@luvio/durable-store-idb';
+
+const durableStore = new IndexedDbDurableStore();
+
+const luvio = new Luvio(
+  makeDurable(new Environment(new InMemoryStore(), networkAdapter), {
+    durableStore,
+  })
+);
+```

package/dist/IndexedDbDurableStore.d.ts

@@ -0,0 +1,21 @@
+import type { DurableStore, DurableStoreEntries, DurableStoreOperation, OnDurableStoreChangedListener } from '@luvio/environments';
+export declare class IndexedDbDurableStore implements DurableStore {
+    dbs: Map<string, IDBDatabase>;
+    listeners: Set<OnDurableStoreChangedListener>;
+    private static DB_NAME_PREFIX;
+    private buildDbName;
+    private getDb;
+    getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
+    batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
+    evictEntries(entryIds: string[], segment: string): Promise<void>;
+    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
+    /**
+     * Clears all entries from any of the IndexedDB stores used by this class.
+     *
+     * NOTE: this method isn't currently part of the DurableStore interface, but still
+     * useful to implement.
+     */
+    clearAllEntries(): Promise<void>;
+}

package/dist/durable-store-idb.js

@@ -0,0 +1,208 @@
+/**
+ * Helper methods to make working with IDB more promise-based.  Also simplifies
+ * IDB schema concepts to just having a single "kvp" store per DB.
+ */
+function idbTransactionToPromise(transaction) {
+    if (transaction === null) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve(undefined);
+        transaction.onabort = () => reject(transaction.error);
+        transaction.onerror = () => reject(transaction.error);
+    });
+}
+function idbRequestToPromise(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Checks if the given database exists in indexedDB.  If this method cannot determine
+ * if a database exists (because the "indexedDB.databases" API isn't implemented) this
+ * returns undefined
+ */
+async function doesDbExist(dbName) {
+    // firefox doesn't support listing all databases (yet),
+    // so have to check if API is available
+    if (typeof indexedDB.databases === 'undefined') {
+        return undefined;
+    }
+    else {
+        const dbs = await indexedDB.databases();
+        return dbs.find((db) => db.name === dbName) !== undefined;
+    }
+}
+const COMMON_STORE_NAME = 'kvp';
+async function getDb(dbName, createIfNotExist) {
+    const exists = await doesDbExist(dbName);
+    if (exists === false && !createIfNotExist) {
+        return undefined;
+    }
+    const request = indexedDB.open(dbName);
+    request.onupgradeneeded = () => request.result.createObjectStore(COMMON_STORE_NAME);
+    return idbRequestToPromise(request);
+}
+// eslint-disable-next-line no-undef
+function getStore(db, transactionMode) {
+    return db.transaction(COMMON_STORE_NAME, transactionMode).objectStore(COMMON_STORE_NAME);
+}
+// eslint-disable-next-line no-undef
+function get(keys, db) {
+    const store = getStore(db, 'readonly');
+    return Promise.all(keys.map((key) => idbRequestToPromise(store.get(key))));
+}
+async function getAll(db) {
+    const store = getStore(db, 'readonly');
+    const keysPromise = idbRequestToPromise(store.getAllKeys());
+    const valuesPromise = idbRequestToPromise(store.getAll());
+    const [keys, values] = await Promise.all([keysPromise, valuesPromise]);
+    return keys.map((key, index) => ({ key, value: values[index] }));
+}
+function set(entries, db) {
+    const store = getStore(db, 'readwrite');
+    entries.forEach((entry) => store.put(entry.value, entry.key));
+    return idbTransactionToPromise(store.transaction);
+}
+// eslint-disable-next-line no-undef
+function del(keys, db) {
+    const store = getStore(db, 'readwrite');
+    keys.forEach((key) => store.delete(key));
+    return idbTransactionToPromise(store.transaction);
+}
+function clear(db) {
+    const store = getStore(db, 'readwrite');
+    store.clear();
+    return idbTransactionToPromise(store.transaction);
+}
+
+// using a type to ensure we use correct segment name without taking runtime dep
+const DEFAULT_SEGMENT_NAME = 'DEFAULT';
+class IndexedDbDurableStore {
+    constructor() {
+        this.dbs = new Map();
+        this.listeners = new Set();
+    }
+    buildDbName(segment) {
+        return `${IndexedDbDurableStore.DB_NAME_PREFIX}${segment}`;
+    }
+    async getDb(segment, createIfNotExist) {
+        const dbName = this.buildDbName(segment);
+        // first check if db is memoized
+        const memoizedDb = this.dbs.get(dbName);
+        if (memoizedDb) {
+            return memoizedDb;
+        }
+        const db = await getDb(dbName, createIfNotExist);
+        if (db === undefined) {
+            return undefined;
+        }
+        // memoize the db
+        this.dbs.set(dbName, db);
+        return db;
+    }
+    async getEntries(entryIds, segment) {
+        const db = await this.getDb(segment, false);
+        if (db === undefined) {
+            return undefined;
+        }
+        const rows = await get(entryIds, db);
+        const returnEntries = {};
+        for (let i = 0, len = rows.length; i < len; i++) {
+            const row = rows[i];
+            const key = entryIds[i];
+            if (row !== undefined) {
+                returnEntries[key] = row;
+            }
+        }
+        return returnEntries;
+    }
+    async getAllEntries(segment) {
+        const db = await this.getDb(segment, false);
+        if (db === undefined) {
+            return undefined;
+        }
+        const rows = await getAll(db);
+        const returnEntries = {};
+        for (let i = 0, len = rows.length; i < len; i++) {
+            const row = rows[i];
+            const { key, value } = row;
+            returnEntries[key] = value;
+        }
+        return returnEntries;
+    }
+    async setEntries(entries, segment) {
+        const db = await this.getDb(segment, true);
+        const rows = [];
+        const keys = Object.keys(entries);
+        for (const key of keys) {
+            rows.push({ key, value: entries[key] });
+        }
+        // we told getDb to createIfNotExist so we know db will be defined
+        await set(rows, db);
+        this.listeners.forEach((listener) => {
+            listener([{ ids: keys, segment, type: 'setEntries' }]);
+        });
+    }
+    async batchOperations(operations) {
+        // TODO - this could be optimized to do all evicts and sets in the same
+        // call to idb
+        for (const operation of operations) {
+            if (operation.type === 'evictEntries') {
+                await this.evictEntries(operation.ids, operation.segment);
+            }
+            else if (operation.type === 'setEntries') {
+                await this.setEntries(operation.entries, operation.segment);
+            }
+        }
+    }
+    async evictEntries(entryIds, segment) {
+        const db = await this.getDb(segment, true);
+        // we told getDb to createIfNotExist so we know db will be defined
+        await del(entryIds, db);
+        this.listeners.forEach((listener) => {
+            listener([{ ids: entryIds, segment, type: 'evictEntries' }]);
+        });
+    }
+    registerOnChangedListener(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+            return Promise.resolve();
+        };
+    }
+    /**
+     * Clears all entries from any of the IndexedDB stores used by this class.
+     *
+     * NOTE: this method isn't currently part of the DurableStore interface, but still
+     * useful to implement.
+     */
+    async clearAllEntries() {
+        const dbsToClear = [];
+        // firefox doesn't support listing all databases (yet),
+        // so we clear the default segment (it contains all the
+        // data)
+        if (typeof indexedDB.databases === 'undefined') {
+            dbsToClear.push(this.buildDbName(DEFAULT_SEGMENT_NAME));
+        }
+        else {
+            const dbs = await indexedDB.databases();
+            dbs.forEach((db) => {
+                var _a;
+                if (((_a = db.name) === null || _a === void 0 ? void 0 : _a.startsWith(IndexedDbDurableStore.DB_NAME_PREFIX)) === true) {
+                    dbsToClear.push(db.name);
+                }
+            });
+        }
+        await Promise.all(dbsToClear.map((dbName) => getDb(dbName, false).then((db) => {
+            if (db !== undefined) {
+                clear(db);
+            }
+        })));
+        dbsToClear.forEach((dbName) => this.dbs.delete(dbName));
+    }
+}
+IndexedDbDurableStore.DB_NAME_PREFIX = 'durable-store-idb-';
+
+export { IndexedDbDurableStore };

package/dist/idbPromise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Helper methods to make working with IDB more promise-based.  Also simplifies
+ * IDB schema concepts to just having a single "kvp" store per DB.
+ */
+export declare type KeyValue<T = unknown> = {
+    key: IDBValidKey;
+    value: T;
+};
+export declare function getDb(dbName: string, createIfNotExist: boolean): Promise<IDBDatabase | undefined>;
+export declare function get<T = unknown>(keys: IDBValidKey[], db: IDBDatabase): Promise<T[]>;
+export declare function getAll<T = unknown>(db: IDBDatabase): Promise<KeyValue<T>[]>;
+export declare function set<T = unknown>(entries: KeyValue<T>[], db: IDBDatabase): Promise<void>;
+export declare function del(keys: IDBValidKey[], db: IDBDatabase): Promise<void>;
+export declare function clear(db: IDBDatabase): Promise<void>;

package/dist/main.d.ts

@@ -0,0 +1 @@
+export { IndexedDbDurableStore } from './IndexedDbDurableStore';

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@luvio/durable-store-idb",
+    "version": "0.128.0",
+    "description": "IndexedDB-based implementation of the Luvio DurableStore",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/luvio.git",
+        "directory": "packages/@luvio/durable-store-idb"
+    },
+    "license": "MIT",
+    "main": "dist/durable-store-idb.js",
+    "module": "dist/durable-store-idb.js",
+    "types": "dist/main.d.ts",
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build": "rollup --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test": "jest",
+        "test:debug": "node --inspect-brk ../../../node_modules/jest/bin/jest.js --config ./jest.config.js --runInBand",
+        "test:size": "bundlesize",
+        "watch": "yarn build --watch"
+    },
+    "devDependencies": {
+        "@luvio/environments": "0.128.0",
+        "fake-indexeddb": "^4.0.1"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "bundlesize": [
+        {
+            "path": "./dist/durable-store-idb.js",
+            "maxSize": "3 kB",
+            "compression": "brotli"
+        }
+    ],
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "packages/@luvio/durable-store-idb/dist"
+                ]
+            }
+        }
+    }
+}