@instantdb/core 0.22.57 → 0.22.58

package/__tests__/src/Reactor.test.js

@@ -12,12 +12,21 @@ import * as instatx from '../../src/instatx';
 import zenecaAttrs from './data/zeneca/attrs.json';
 import zenecaTriples from './data/zeneca/triples.json';
 import uuid from '../../src/utils/uuid';
+import { weakHash } from '../../src';
 
 const zenecaIdToAttr = zenecaAttrs.reduce((res, x) => {
   res[x.id] = x;
   return res;
 }, {});
 
+async function waitForLoaded(reactor) {
+  await reactor.querySubs.waitForMetaToLoad();
+  await reactor.kv.waitForMetaToLoad();
+  await reactor.kv.waitForKeyToLoad('pendingMutations');
+  await reactor.querySubs.flush();
+  await reactor.kv.flush();
+}
+
 test('querySubs round-trips', async () => {
   const appId = uuid();
   const reactor = new Reactor({ appId });
@@ -25,7 +34,7 @@ test('querySubs round-trips', async () => {
   reactor._setAttrs(zenecaAttrs);
   const q = { users: {} };
 
-  await reactor.querySubs.waitForLoaded();
+  await waitForLoaded(reactor);
 
   const resultOne = new Promise((resolve, reject) => {
     reactor.subscribeQuery(q, (res) => {
@@ -63,14 +72,15 @@ test('querySubs round-trips', async () => {
     'nicolegf',
   ]);
 
-  await reactor.querySubs.waitForSync();
+  await waitForLoaded(reactor);
 
   // Create a new reactor
   const reactor2 = new Reactor({ appId });
   reactor2._initStorage(IndexedDBStorage);
   reactor2._setAttrs(zenecaAttrs);
 
-  await reactor2.querySubs.waitForLoaded();
+  await waitForLoaded(reactor2);
+  await reactor2.querySubs.waitForKeyToLoad(weakHash(q));
 
   // Check that it pull the data from indexedDB
   const res = await new Promise((resolve, reject) => {
@@ -165,7 +175,7 @@ test('rewrite mutations works with multiple transactions', () => {
       op: 'transact',
       'tx-steps': steps,
     };
-    reactor.pendingMutations.set((prev) => {
+    reactor._updatePendingMutations((prev) => {
       prev.set(k, mut);
       return prev;
     });
@@ -174,7 +184,7 @@ test('rewrite mutations works with multiple transactions', () => {
   // rewrite them with the new server attributes
   const rewrittenMutations = reactor._rewriteMutations(
     zenecaIdToAttr,
-    reactor.pendingMutations.currentValue,
+    reactor._pendingMutations(),
   );
 
   const serverSteps = instaml.transform({ attrs: zenecaIdToAttr }, ops);
@@ -191,7 +201,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
   const q = { users: {} };
   const joe_id = 'ce942051-2d74-404a-9c7d-4aa3f2d54ae4';
 
-  await reactor.querySubs.waitForLoaded();
+  await waitForLoaded(reactor);
 
   let data = null;
 
@@ -216,7 +226,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
     ],
   });
 
-  await reactor.querySubs.waitForSync();
+  await reactor.querySubs.flush();
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe',
@@ -234,7 +244,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
 
   reactor.pushTx(ops2);
 
-  await reactor.querySubs.waitForSync();
+  await reactor.querySubs.flush();
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe2',
@@ -243,7 +253,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
     'nicolegf',
   ]);
 
-  const [eventId2] = reactor.pendingMutations.currentValue.keys();
+  const [eventId2] = reactor._pendingMutations().keys();
 
   // second optimistic
   const ops3 = [
@@ -254,7 +264,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
 
   reactor.pushTx(ops3);
 
-  await reactor.querySubs.waitForSync();
+  await reactor.querySubs.flush();
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe3',
@@ -263,7 +273,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
     'nicolegf',
   ]);
 
-  const [_, eventId3] = reactor.pendingMutations.currentValue.keys();
+  const [_, eventId3] = reactor._pendingMutations().keys();
 
   // confirmation from server for first optimistic
   reactor._handleReceive(1, {
@@ -272,7 +282,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
     'tx-id': 100,
   });
 
-  await reactor.querySubs.waitForSync();
+  await waitForLoaded(reactor);
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe3',
@@ -304,7 +314,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
   });
 
   // make sure it doesn’t override local results
-  await reactor.querySubs.waitForSync();
+  await waitForLoaded(reactor);
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe3',
@@ -320,7 +330,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
     'tx-id': 101,
   });
 
-  await reactor.querySubs.waitForSync();
+  await waitForLoaded(reactor);
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe3',
@@ -330,7 +340,7 @@ test('optimisticTx is not overwritten by refresh-ok', async () => {
   ]);
 
   // make sure it still doesn’t override local results
-  await reactor.querySubs.waitForSync();
+  await waitForLoaded(reactor);
 
   expect(data.data.users.map((x) => x.handle)).toEqual([
     'joe3',
@@ -353,7 +363,7 @@ test("we don't cleanup mutations we're still waiting on", async () => {
   const q = { users: {} };
   const joe_id = 'ce942051-2d74-404a-9c7d-4aa3f2d54ae4';
 
-  await reactor.pendingMutations.waitForLoaded();
+  await waitForLoaded(reactor);
 
   // Add two transactions
   const ops1 = [
@@ -372,9 +382,9 @@ test("we don't cleanup mutations we're still waiting on", async () => {
 
   reactor.pushTx(ops2);
 
-  await reactor.pendingMutations.waitForSync();
+  await reactor.kv.flush();
 
-  const [ev1, ev2] = reactor.pendingMutations.currentValue.keys();
+  const [ev1, ev2] = reactor._pendingMutations().keys();
 
   // Mark one as received
   reactor._handleReceive(1, {
@@ -389,9 +399,75 @@ test("we don't cleanup mutations we're still waiting on", async () => {
   // Cleanup shouldn't remove the mutation we're still waiting on
   await reactor._cleanupPendingMutationsTimeout();
 
-  const remainingKeys = new Array(
-    ...reactor.pendingMutations.currentValue.keys(),
-  );
+  const remainingKeys = new Array(...reactor._pendingMutations().keys());
 
   expect(remainingKeys).toStrictEqual([ev2]);
 });
+
+test('getLocalId always returns the same id', async () => {
+  const appId = uuid();
+
+  const idbs = new Map();
+
+  // Class that reuses the same underlying storage for indexeddb.
+  // This will make fake-indexeddb act more like the browser, otherwise
+  // we get a fresh in-memory store each time we call indexedDB.open
+  class IDBStorage {
+    constructor(appId, dbName) {
+      if (idbs.get(dbName)) {
+        return idbs.get(dbName);
+      }
+      const idb = new IndexedDBStorage(appId, dbName);
+      idbs.set(dbName, idb);
+      return idb;
+    }
+  }
+
+  const reactor = new Reactor({
+    appId,
+    pendingTxCleanupTimeout: 1,
+    pendingMutationCleanupThreshold: 0,
+  });
+
+  reactor._initStorage(IDBStorage);
+
+  const promises = [];
+
+  const ids = new Set();
+
+  for (const _ of [...new Array(1000)]) {
+    const p = reactor.getLocalId('id').then((id) => ids.add(id));
+    promises.push(p);
+  }
+
+  await Promise.all(promises);
+
+  expect(ids.size).toBe(1);
+  await reactor.querySubs.flush();
+
+  await reactor.kv.flush();
+
+  const reactor2 = new Reactor({
+    appId,
+    pendingTxCleanupTimeout: 1,
+    pendingMutationCleanupThreshold: 0,
+  });
+
+  async function idbSnapshot(idb, { includeMeta }) {
+    const keys = await idb.getAllKeys();
+    const res = {};
+    for (const key of keys) {
+      if (key === '__meta' && !includeMeta) {
+        continue;
+      }
+      res[key] = await idb.getItem(key);
+    }
+    return res;
+  }
+
+  reactor2._initStorage(IDBStorage);
+
+  const id = await reactor2.getLocalId('id');
+
+  expect(id).toStrictEqual([...ids][0]);
+});

package/__tests__/src/utils/PersistedObject.test.ts

@@ -0,0 +1,383 @@
+import 'fake-indexeddb/auto';
+import { test, expect, describe } from 'vitest';
+import { PersistedObject } from '../../../src/utils/PersistedObject';
+import { IndexedDBStorage } from '../../../src';
+import { randomUUID } from 'crypto';
+import createLogger from '../../../src/utils/log';
+
+async function idbSnapshot(idb, { includeMeta }) {
+  const keys = await idb.getAllKeys();
+  const res = {};
+  for (const key of keys) {
+    if (key === '__meta' && !includeMeta) {
+      continue;
+    }
+    res[key] = await idb.getItem(key);
+  }
+  return res;
+}
+
+const devNullLogger = createLogger(false, () => ({}));
+
+test('PersistedObject saves values to storage', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  const PO = new PersistedObject<string, string, string>({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 'none',
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (_v) => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  PO.updateInPlace((prev) => {
+    prev.a = 'b';
+  });
+
+  await PO.flush();
+
+  const snapshot = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot).toStrictEqual({ a: 'b' });
+});
+
+test('PersistedObject merges existing values', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  let storageV;
+  let memoryV;
+  const PO = new PersistedObject<string, string, string>({
+    persister: idb,
+    merge: (_k, storage, memory) => {
+      storageV = storage;
+      memoryV = memory;
+      return 'merged-value';
+    },
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (_v) => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  PO.updateInPlace((prev) => {
+    prev.a = 'b';
+  });
+
+  await PO.flush();
+
+  // We don't run merge if there was nothing in the store
+  expect(storageV).toBeUndefined();
+  expect(memoryV).toBeUndefined();
+  expect(PO.currentValue.a).toEqual('b');
+
+  const snapshot = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot).toStrictEqual({ a: 'b' });
+
+  let storageV2;
+  let memoryV2;
+  const PO2 = new PersistedObject<string, string, string>({
+    persister: idb,
+    merge: (_k, storage, memory) => {
+      storageV2 = storage;
+      memoryV2 = memory;
+      return 'merged-value-2';
+    },
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (_v) => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  PO2.updateInPlace((prev) => {
+    prev.a = 'c';
+  });
+
+  await PO2.flush();
+
+  expect(storageV2).toEqual('b');
+  expect(memoryV2).toEqual('c');
+  expect(PO2.currentValue.a).toEqual('merged-value-2');
+
+  const snapshot2 = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot2).toStrictEqual({ a: 'merged-value-2' });
+});
+
+test('PersistedObject notifies you when it loads a key from storage', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  const PO = new PersistedObject({
+    persister: idb,
+    merge: (_k, _storage, _memory) => 'merged',
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: () => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+});
+
+test('PersistedObject garbage collects when we exceed max items', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  const PO = new PersistedObject({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 'new',
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: () => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: 3,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  for (const [i, k] of Object.entries(['a', 'b', 'c', 'd', 'e'])) {
+    PO.updateInPlace((prev) => {
+      prev[k] = parseInt(i, 10) + 1;
+    });
+    await PO.flush();
+  }
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot = await idbSnapshot(idb, { includeMeta: false });
+
+  // We don't get rid of live keys
+  expect(PO.currentValue).toStrictEqual({ a: 1, b: 2, c: 3, d: 4, e: 5 });
+  expect(snapshot).toStrictEqual({
+    a: 1,
+    b: 2,
+    c: 3,
+    d: 4,
+    e: 5,
+  });
+
+  PO.unloadKey('e');
+
+  await PO.flush();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot2 = await idbSnapshot(idb, { includeMeta: false });
+
+  // It does get rid of unloaded keys
+  expect(PO.currentValue).toStrictEqual({ a: 1, b: 2, c: 3, d: 4 });
+  expect(snapshot2).toStrictEqual({ a: 1, b: 2, c: 3, d: 4 });
+
+  // Simulate a reload of the page
+  const PO2 = new PersistedObject({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 'new',
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: () => 0,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: 3,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  await PO2.waitForMetaToLoad();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO2._gc();
+  const snapshot3 = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot3).toStrictEqual({ b: 2, c: 3, d: 4 });
+});
+
+test('PersistedObject garbage collects when we exceed max size', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  const PO = new PersistedObject<string, number, number>({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 0,
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (v) => v,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: 100,
+    },
+  });
+
+  for (const [i, k] of [
+    [10, 'a'],
+    [20, 'b'],
+    [50, 'c'],
+    [50, 'd'],
+    [50, 'e'],
+  ]) {
+    PO.updateInPlace((prev) => {
+      prev[k] = i as number;
+    });
+    await PO.flush();
+  }
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot = await idbSnapshot(idb, { includeMeta: false });
+
+  // We don't get rid of live keys
+  expect(PO.currentValue).toStrictEqual({ a: 10, b: 20, c: 50, d: 50, e: 50 });
+  expect(snapshot).toStrictEqual({
+    a: 10,
+    b: 20,
+    c: 50,
+    d: 50,
+    e: 50,
+  });
+
+  PO.unloadKey('e');
+
+  await PO.flush();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot2 = await idbSnapshot(idb, { includeMeta: false });
+
+  // It does get rid of unloaded keys
+  expect(PO.currentValue).toStrictEqual({ a: 10, b: 20, c: 50, d: 50 });
+  expect(snapshot2).toStrictEqual({ a: 10, b: 20, c: 50, d: 50 });
+
+  // Simulate a reload of the page
+  const PO2 = new PersistedObject<string, number, number>({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 0,
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (v) => v,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: Number.MAX_SAFE_INTEGER,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: 100,
+    },
+  });
+
+  await PO2.waitForMetaToLoad();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO2._gc();
+  const snapshot3 = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot3).toStrictEqual({ c: 50, d: 50 });
+});
+
+test('PersistedObject garbage collects when we exceed max age', async () => {
+  const idb = new IndexedDBStorage(randomUUID(), 'querySubs');
+  const PO = new PersistedObject<string, number, number>({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 0,
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (v) => v,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: 0,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  for (const [i, k] of [
+    [10, 'a'],
+    [20, 'b'],
+    [50, 'c'],
+    [50, 'd'],
+    [50, 'e'],
+  ]) {
+    PO.updateInPlace((prev) => {
+      prev[k] = i as number;
+    });
+    await PO.flush();
+  }
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot = await idbSnapshot(idb, { includeMeta: false });
+
+  // We don't get rid of live keys
+  expect(PO.currentValue).toStrictEqual({ a: 10, b: 20, c: 50, d: 50, e: 50 });
+  expect(snapshot).toStrictEqual({
+    a: 10,
+    b: 20,
+    c: 50,
+    d: 50,
+    e: 50,
+  });
+
+  PO.unloadKey('e');
+
+  await PO.flush();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO._gc();
+
+  const snapshot2 = await idbSnapshot(idb, { includeMeta: false });
+
+  // It does get rid of unloaded keys
+  expect(PO.currentValue).toStrictEqual({ a: 10, b: 20, c: 50, d: 50 });
+  expect(snapshot2).toStrictEqual({ a: 10, b: 20, c: 50, d: 50 });
+
+  // Simulate a reload of the page
+  const PO2 = new PersistedObject<string, number, number>({
+    persister: idb,
+    merge: (_k, storage, memory) => storage || memory || 0,
+    serialize: (_k, x) => x,
+    parse: (_k, x) => x,
+    objectSize: (v) => v,
+    logger: devNullLogger,
+    saveThrottleMs: 0,
+    gc: {
+      maxAgeMs: 0,
+      maxEntries: Number.MAX_SAFE_INTEGER,
+      maxSize: Number.MAX_SAFE_INTEGER,
+    },
+  });
+
+  await PO2.waitForMetaToLoad();
+
+  // @ts-expect-error: allow access to private fields for test
+  await PO2._gc();
+  const snapshot3 = await idbSnapshot(idb, { includeMeta: false });
+
+  expect(snapshot3).toStrictEqual({});
+});

package/dist/commonjs/InMemoryStorage.d.ts

@@ -0,0 +1,11 @@
+import { StorageInterface, StorageInterfaceStoreName } from './utils/PersistedObject.js';
+export default class InMemoryStorage extends StorageInterface {
+    private store;
+    constructor(appId: string, dbName: StorageInterfaceStoreName);
+    getItem(k: any): Promise<any>;
+    setItem(k: any, v: any): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+//# sourceMappingURL=InMemoryStorage.d.ts.map

package/dist/commonjs/InMemoryStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryStorage.d.ts","sourceRoot":"","sources":["../../src/InMemoryStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,gBAAgB;IAC3D,OAAO,CAAC,KAAK,CAAmB;gBACpB,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB;IAKtD,OAAO,CAAC,CAAC,KAAA;IAIT,OAAO,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;IAIZ,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAI/B,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG7C"}

package/dist/commonjs/InMemoryStorage.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PersistedObject_js_1 = require("./utils/PersistedObject.js");
+class InMemoryStorage extends PersistedObject_js_1.StorageInterface {
+    constructor(appId, dbName) {
+        super(appId, dbName);
+        this.store = new Map();
+    }
+    getItem(k) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.store.get(k)) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    setItem(k, v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.store.set(k, v);
+        });
+    }
+    getAllKeys() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [...this.store.keys()];
+        });
+    }
+    multiSet(keyValuePairs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [k, v] of keyValuePairs) {
+                this.setItem(k, v);
+            }
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.store.delete(key);
+        });
+    }
+}
+exports.default = InMemoryStorage;
+//# sourceMappingURL=InMemoryStorage.js.map

package/dist/commonjs/InMemoryStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryStorage.js","sourceRoot":"","sources":["../../src/InMemoryStorage.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,mEAGoC;AAEpC,MAAqB,eAAgB,SAAQ,qCAAgB;IAE3D,YAAY,KAAa,EAAE,MAAiC;QAC1D,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;IACzB,CAAC;IAEK,OAAO,CAAC,CAAC;;;YACb,OAAO,MAAA,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,mCAAI,IAAI,CAAC;QACnC,CAAC;KAAA;IAEK,OAAO,CAAC,CAAC,EAAE,CAAC;;YAChB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACvB,CAAC;KAAA;IAEK,UAAU;;YACd,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAChC,CAAC;KAAA;IAEK,QAAQ,CAAC,aAAmC;;YAChD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,aAAa,EAAE,CAAC;gBACnC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;KAAA;IAEK,UAAU,CAAC,GAAW;;YAC1B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;KAAA;CACF;AA5BD,kCA4BC","sourcesContent":["import {\n  StorageInterface,\n  StorageInterfaceStoreName,\n} from './utils/PersistedObject.js';\n\nexport default class InMemoryStorage extends StorageInterface {\n  private store: Map<string, any>;\n  constructor(appId: string, dbName: StorageInterfaceStoreName) {\n    super(appId, dbName);\n    this.store = new Map();\n  }\n\n  async getItem(k) {\n    return this.store.get(k) ?? null;\n  }\n\n  async setItem(k, v) {\n    this.store.set(k, v);\n  }\n\n  async getAllKeys(): Promise<string[]> {\n    return [...this.store.keys()];\n  }\n\n  async multiSet(keyValuePairs: Array<[string, any]>): Promise<void> {\n    for (const [k, v] of keyValuePairs) {\n      this.setItem(k, v);\n    }\n  }\n\n  async removeItem(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n}\n"]}