zapo-js 0.1.0

package/dist/store/createStore.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStore = createStore;
+const noop_store_1 = require("./noop.store");
+const appstate_store_1 = require("./providers/memory/appstate.store");
+const contact_store_1 = require("./providers/memory/contact.store");
+const device_list_store_1 = require("./providers/memory/device-list.store");
+const message_store_1 = require("./providers/memory/message.store");
+const participants_store_1 = require("./providers/memory/participants.store");
+const retry_store_1 = require("./providers/memory/retry.store");
+const sender_key_store_1 = require("./providers/memory/sender-key.store");
+const signal_store_1 = require("./providers/memory/signal.store");
+const thread_store_1 = require("./providers/memory/thread.store");
+const appstate_store_2 = require("./providers/sqlite/appstate.store");
+const auth_store_1 = require("./providers/sqlite/auth.store");
+const contact_store_2 = require("./providers/sqlite/contact.store");
+const device_list_store_2 = require("./providers/sqlite/device-list.store");
+const message_store_2 = require("./providers/sqlite/message.store");
+const participants_store_2 = require("./providers/sqlite/participants.store");
+const retry_store_2 = require("./providers/sqlite/retry.store");
+const sender_key_store_2 = require("./providers/sqlite/sender-key.store");
+const signal_store_2 = require("./providers/sqlite/signal.store");
+const thread_store_2 = require("./providers/sqlite/thread.store");
+const coercion_1 = require("../util/coercion");
+const DEFAULT_PROVIDERS = {
+    auth: 'sqlite',
+    signal: 'sqlite',
+    senderKey: 'sqlite',
+    appState: 'sqlite',
+    messages: 'none',
+    threads: 'none',
+    contacts: 'none'
+};
+const DEFAULT_CACHE_PROVIDERS = {
+    retry: 'memory',
+    participants: 'memory',
+    deviceList: 'memory'
+};
+const DEFAULT_CACHE_TTLS_MS = {
+    retryMs: 7 * 24 * 60 * 60 * 1000,
+    participantsMs: 5 * 60 * 1000,
+    deviceListMs: 5 * 60 * 1000
+};
+const DEFAULT_SQLITE_BATCH_SIZES = {
+    deviceList: 500,
+    senderKeyDistribution: 250,
+    signalPreKey: 500,
+    signalHasSession: 250
+};
+function resolveStoreValue(sessionId, value, domainPath) {
+    if (!value) {
+        return null;
+    }
+    const resolved = typeof value === 'function' ? value(sessionId) : value;
+    if (!resolved) {
+        throw new Error(`${domainPath} must resolve to a store instance`);
+    }
+    return resolved;
+}
+function hasDestroy(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'destroy' in value &&
+        typeof value.destroy === 'function');
+}
+async function destroyIfSupported(value) {
+    if (!hasDestroy(value)) {
+        return;
+    }
+    await value.destroy();
+}
+function createStore(options) {
+    const providers = {
+        ...DEFAULT_PROVIDERS,
+        ...(options.providers ?? {})
+    };
+    const cacheProviders = {
+        ...DEFAULT_CACHE_PROVIDERS,
+        ...(options.cacheProviders ?? {})
+    };
+    const cacheTtlsMs = Object.freeze({
+        retry: (0, coercion_1.resolvePositive)(options.cacheTtlMs?.retryMs, DEFAULT_CACHE_TTLS_MS.retryMs, 'cacheTtlMs.retryMs'),
+        participants: (0, coercion_1.resolvePositive)(options.cacheTtlMs?.participantsMs, DEFAULT_CACHE_TTLS_MS.participantsMs, 'cacheTtlMs.participantsMs'),
+        deviceList: (0, coercion_1.resolvePositive)(options.cacheTtlMs?.deviceListMs, DEFAULT_CACHE_TTLS_MS.deviceListMs, 'cacheTtlMs.deviceListMs')
+    });
+    const sqliteBatchSizes = Object.freeze({
+        deviceList: (0, coercion_1.resolvePositive)(options.sqlite?.batchSizes?.deviceList, DEFAULT_SQLITE_BATCH_SIZES.deviceList, 'sqlite.batchSizes.deviceList'),
+        senderKeyDistribution: (0, coercion_1.resolvePositive)(options.sqlite?.batchSizes?.senderKeyDistribution, DEFAULT_SQLITE_BATCH_SIZES.senderKeyDistribution, 'sqlite.batchSizes.senderKeyDistribution'),
+        signalPreKey: (0, coercion_1.resolvePositive)(options.sqlite?.batchSizes?.signalPreKey, DEFAULT_SQLITE_BATCH_SIZES.signalPreKey, 'sqlite.batchSizes.signalPreKey'),
+        signalHasSession: (0, coercion_1.resolvePositive)(options.sqlite?.batchSizes?.signalHasSession, DEFAULT_SQLITE_BATCH_SIZES.signalHasSession, 'sqlite.batchSizes.signalHasSession')
+    });
+    const sessions = new Map();
+    let storeDestroyed = false;
+    return {
+        session(sessionId) {
+            if (storeDestroyed) {
+                throw new Error('store has been destroyed');
+            }
+            const normalizedSessionId = sessionId.trim();
+            if (normalizedSessionId.length === 0) {
+                throw new Error('sessionId must be a non-empty string');
+            }
+            const cached = sessions.get(normalizedSessionId);
+            if (cached) {
+                return cached;
+            }
+            const custom = options.custom;
+            const customCache = options.customCache;
+            const customAuth = resolveStoreValue(normalizedSessionId, custom?.auth, 'custom.auth');
+            const customSignal = resolveStoreValue(normalizedSessionId, custom?.signal, 'custom.signal');
+            const customSenderKey = resolveStoreValue(normalizedSessionId, custom?.senderKey, 'custom.senderKey');
+            const customAppState = resolveStoreValue(normalizedSessionId, custom?.appState, 'custom.appState');
+            const customRetry = resolveStoreValue(normalizedSessionId, customCache?.retry, 'customCache.retry');
+            const customParticipants = resolveStoreValue(normalizedSessionId, customCache?.participants, 'customCache.participants');
+            const customDeviceList = resolveStoreValue(normalizedSessionId, customCache?.deviceList, 'customCache.deviceList');
+            const customMessages = resolveStoreValue(normalizedSessionId, custom?.messages, 'custom.messages');
+            const customThreads = resolveStoreValue(normalizedSessionId, custom?.threads, 'custom.threads');
+            const customContacts = resolveStoreValue(normalizedSessionId, custom?.contacts, 'custom.contacts');
+            const memoryLimits = options.memory?.limits ?? {};
+            const requiresSqlite = !customAuth ||
+                (!customSignal && providers.signal === 'sqlite') ||
+                (!customSenderKey && providers.senderKey === 'sqlite') ||
+                (!customAppState && providers.appState === 'sqlite') ||
+                (!customRetry && cacheProviders.retry === 'sqlite') ||
+                (!customParticipants && cacheProviders.participants === 'sqlite') ||
+                (!customDeviceList && cacheProviders.deviceList === 'sqlite') ||
+                (!customMessages && providers.messages === 'sqlite') ||
+                (!customThreads && providers.threads === 'sqlite') ||
+                (!customContacts && providers.contacts === 'sqlite');
+            const sqlite = options.sqlite;
+            if (requiresSqlite && (!sqlite?.path || sqlite.path.trim().length === 0)) {
+                throw new Error('sqlite.path must be configured for unresolved sqlite domains.');
+            }
+            const sqliteOptions = sqlite && sqlite.path.trim().length > 0
+                ? {
+                    path: sqlite.path,
+                    sessionId: normalizedSessionId,
+                    driver: sqlite.driver ?? 'auto',
+                    pragmas: sqlite.pragmas
+                }
+                : null;
+            const authStore = customAuth ?? new auth_store_1.WaAuthSqliteStore(sqliteOptions);
+            const signalStore = customSignal ??
+                (providers.signal === 'memory'
+                    ? new signal_store_1.WaSignalMemoryStore({
+                        maxPreKeys: memoryLimits.signalPreKeys,
+                        maxSessions: memoryLimits.signalSessions,
+                        maxRemoteIdentities: memoryLimits.signalRemoteIdentities
+                    })
+                    : new signal_store_2.WaSignalSqliteStore(sqliteOptions, {
+                        preKeyBatchSize: sqliteBatchSizes.signalPreKey,
+                        hasSessionBatchSize: sqliteBatchSizes.signalHasSession
+                    }));
+            const senderKeyStore = customSenderKey ??
+                (providers.senderKey === 'memory'
+                    ? new sender_key_store_1.SenderKeyMemoryStore({
+                        maxSenderKeys: memoryLimits.senderKeys,
+                        maxSenderDistributions: memoryLimits.senderDistributions
+                    })
+                    : new sender_key_store_2.SenderKeySqliteStore(sqliteOptions, sqliteBatchSizes.senderKeyDistribution));
+            const appStateStore = customAppState ??
+                (providers.appState === 'memory'
+                    ? new appstate_store_1.WaAppStateMemoryStore(undefined, {
+                        maxSyncKeys: memoryLimits.appStateSyncKeys,
+                        maxCollectionEntries: memoryLimits.appStateCollectionEntries
+                    })
+                    : new appstate_store_2.WaAppStateSqliteStore(sqliteOptions));
+            const retryStore = customRetry ??
+                (cacheProviders.retry === 'memory'
+                    ? new retry_store_1.WaRetryMemoryStore(cacheTtlsMs.retry)
+                    : new retry_store_2.WaRetrySqliteStore(sqliteOptions, cacheTtlsMs.retry));
+            const participantsStore = customParticipants ??
+                (cacheProviders.participants === 'sqlite'
+                    ? new participants_store_2.WaParticipantsSqliteStore(sqliteOptions, cacheTtlsMs.participants)
+                    : cacheProviders.participants === 'memory'
+                        ? new participants_store_1.WaParticipantsMemoryStore(cacheTtlsMs.participants, {
+                            maxGroups: memoryLimits.participantsGroups
+                        })
+                        : noop_store_1.NOOP_PARTICIPANTS_STORE);
+            const deviceListStore = customDeviceList ??
+                (cacheProviders.deviceList === 'sqlite'
+                    ? new device_list_store_2.WaDeviceListSqliteStore(sqliteOptions, cacheTtlsMs.deviceList, sqliteBatchSizes.deviceList)
+                    : cacheProviders.deviceList === 'memory'
+                        ? new device_list_store_1.WaDeviceListMemoryStore(cacheTtlsMs.deviceList, {
+                            maxUsers: memoryLimits.deviceListUsers
+                        })
+                        : noop_store_1.NOOP_DEVICE_LIST_STORE);
+            const messageStore = customMessages ??
+                (providers.messages === 'sqlite'
+                    ? new message_store_2.WaMessageSqliteStore(sqliteOptions)
+                    : providers.messages === 'memory'
+                        ? new message_store_1.WaMessageMemoryStore({
+                            maxMessages: memoryLimits.messages
+                        })
+                        : noop_store_1.NOOP_MESSAGE_STORE);
+            const threadStore = customThreads ??
+                (providers.threads === 'sqlite'
+                    ? new thread_store_2.WaThreadSqliteStore(sqliteOptions)
+                    : providers.threads === 'memory'
+                        ? new thread_store_1.WaThreadMemoryStore({
+                            maxThreads: memoryLimits.threads
+                        })
+                        : noop_store_1.NOOP_THREAD_STORE);
+            const contactStore = customContacts ??
+                (providers.contacts === 'sqlite'
+                    ? new contact_store_2.WaContactSqliteStore(sqliteOptions)
+                    : providers.contacts === 'memory'
+                        ? new contact_store_1.WaContactMemoryStore({
+                            maxContacts: memoryLimits.contacts
+                        })
+                        : noop_store_1.NOOP_CONTACT_STORE);
+            let cachesDestroyed = false;
+            let sessionDestroyed = false;
+            const destroyCaches = async () => {
+                if (cachesDestroyed) {
+                    return;
+                }
+                cachesDestroyed = true;
+                await Promise.all([
+                    retryStore.clear(),
+                    participantsStore.clear(),
+                    deviceListStore.clear()
+                ]);
+                await Promise.all([
+                    destroyIfSupported(retryStore),
+                    destroyIfSupported(participantsStore),
+                    destroyIfSupported(deviceListStore)
+                ]);
+            };
+            const destroy = async () => {
+                if (sessionDestroyed) {
+                    return;
+                }
+                sessionDestroyed = true;
+                await destroyCaches();
+                await Promise.all([
+                    destroyIfSupported(authStore),
+                    destroyIfSupported(signalStore),
+                    destroyIfSupported(senderKeyStore),
+                    destroyIfSupported(appStateStore),
+                    destroyIfSupported(messageStore),
+                    destroyIfSupported(threadStore),
+                    destroyIfSupported(contactStore)
+                ]);
+            };
+            const session = {
+                auth: authStore,
+                signal: signalStore,
+                senderKey: senderKeyStore,
+                appState: appStateStore,
+                retry: retryStore,
+                participants: participantsStore,
+                deviceList: deviceListStore,
+                messages: messageStore,
+                threads: threadStore,
+                contacts: contactStore,
+                destroyCaches,
+                destroy
+            };
+            sessions.set(normalizedSessionId, session);
+            return session;
+        },
+        async destroyCaches() {
+            const activeSessions = [...sessions.values()];
+            for (const session of activeSessions) {
+                await session.destroyCaches();
+            }
+        },
+        async destroy() {
+            if (storeDestroyed) {
+                return;
+            }
+            storeDestroyed = true;
+            const activeSessions = [...sessions.values()];
+            sessions.clear();
+            for (const session of activeSessions) {
+                await session.destroy();
+            }
+        }
+    };
+}

package/dist/store/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaThreadSqliteStore = exports.WaMessageSqliteStore = exports.WaContactSqliteStore = exports.WaThreadMemoryStore = exports.WaMessageMemoryStore = exports.WaContactMemoryStore = exports.WaDeviceListMemoryStore = exports.WaParticipantsMemoryStore = exports.WaRetryMemoryStore = exports.SenderKeyMemoryStore = exports.WaSignalMemoryStore = exports.WaAppStateMemoryStore = exports.WaDeviceListSqliteStore = exports.WaParticipantsSqliteStore = exports.WaRetrySqliteStore = exports.SenderKeySqliteStore = exports.WaSignalSqliteStore = exports.createStore = exports.WaAppStateSqliteStore = exports.WaAuthSqliteStore = void 0;
+var auth_store_1 = require("./providers/sqlite/auth.store");
+Object.defineProperty(exports, "WaAuthSqliteStore", { enumerable: true, get: function () { return auth_store_1.WaAuthSqliteStore; } });
+var appstate_store_1 = require("./providers/sqlite/appstate.store");
+Object.defineProperty(exports, "WaAppStateSqliteStore", { enumerable: true, get: function () { return appstate_store_1.WaAppStateSqliteStore; } });
+var createStore_1 = require("./createStore");
+Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return createStore_1.createStore; } });
+var signal_store_1 = require("./providers/sqlite/signal.store");
+Object.defineProperty(exports, "WaSignalSqliteStore", { enumerable: true, get: function () { return signal_store_1.WaSignalSqliteStore; } });
+var sender_key_store_1 = require("./providers/sqlite/sender-key.store");
+Object.defineProperty(exports, "SenderKeySqliteStore", { enumerable: true, get: function () { return sender_key_store_1.SenderKeySqliteStore; } });
+var retry_store_1 = require("./providers/sqlite/retry.store");
+Object.defineProperty(exports, "WaRetrySqliteStore", { enumerable: true, get: function () { return retry_store_1.WaRetrySqliteStore; } });
+var participants_store_1 = require("./providers/sqlite/participants.store");
+Object.defineProperty(exports, "WaParticipantsSqliteStore", { enumerable: true, get: function () { return participants_store_1.WaParticipantsSqliteStore; } });
+var device_list_store_1 = require("./providers/sqlite/device-list.store");
+Object.defineProperty(exports, "WaDeviceListSqliteStore", { enumerable: true, get: function () { return device_list_store_1.WaDeviceListSqliteStore; } });
+var appstate_store_2 = require("./providers/memory/appstate.store");
+Object.defineProperty(exports, "WaAppStateMemoryStore", { enumerable: true, get: function () { return appstate_store_2.WaAppStateMemoryStore; } });
+var signal_store_2 = require("./providers/memory/signal.store");
+Object.defineProperty(exports, "WaSignalMemoryStore", { enumerable: true, get: function () { return signal_store_2.WaSignalMemoryStore; } });
+var sender_key_store_2 = require("./providers/memory/sender-key.store");
+Object.defineProperty(exports, "SenderKeyMemoryStore", { enumerable: true, get: function () { return sender_key_store_2.SenderKeyMemoryStore; } });
+var retry_store_2 = require("./providers/memory/retry.store");
+Object.defineProperty(exports, "WaRetryMemoryStore", { enumerable: true, get: function () { return retry_store_2.WaRetryMemoryStore; } });
+var participants_store_2 = require("./providers/memory/participants.store");
+Object.defineProperty(exports, "WaParticipantsMemoryStore", { enumerable: true, get: function () { return participants_store_2.WaParticipantsMemoryStore; } });
+var device_list_store_2 = require("./providers/memory/device-list.store");
+Object.defineProperty(exports, "WaDeviceListMemoryStore", { enumerable: true, get: function () { return device_list_store_2.WaDeviceListMemoryStore; } });
+var contact_store_1 = require("./providers/memory/contact.store");
+Object.defineProperty(exports, "WaContactMemoryStore", { enumerable: true, get: function () { return contact_store_1.WaContactMemoryStore; } });
+var message_store_1 = require("./providers/memory/message.store");
+Object.defineProperty(exports, "WaMessageMemoryStore", { enumerable: true, get: function () { return message_store_1.WaMessageMemoryStore; } });
+var thread_store_1 = require("./providers/memory/thread.store");
+Object.defineProperty(exports, "WaThreadMemoryStore", { enumerable: true, get: function () { return thread_store_1.WaThreadMemoryStore; } });
+var contact_store_2 = require("./providers/sqlite/contact.store");
+Object.defineProperty(exports, "WaContactSqliteStore", { enumerable: true, get: function () { return contact_store_2.WaContactSqliteStore; } });
+var message_store_2 = require("./providers/sqlite/message.store");
+Object.defineProperty(exports, "WaMessageSqliteStore", { enumerable: true, get: function () { return message_store_2.WaMessageSqliteStore; } });
+var thread_store_2 = require("./providers/sqlite/thread.store");
+Object.defineProperty(exports, "WaThreadSqliteStore", { enumerable: true, get: function () { return thread_store_2.WaThreadSqliteStore; } });

package/dist/store/noop.store.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_PARTICIPANTS_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = void 0;
+const EMPTY_STORE_LIST = Object.freeze([]);
+const DEFAULT_PARTICIPANTS_CACHE_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_DEVICE_LIST_CACHE_TTL_MS = 5 * 60 * 1000;
+exports.NOOP_MESSAGE_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getById: async (_id) => null,
+    listByThread: async (_threadJid, _limit, _beforeTimestampMs) => EMPTY_STORE_LIST,
+    deleteById: async (_id) => 0,
+    clear: async () => { }
+});
+exports.NOOP_THREAD_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getByJid: async (_jid) => null,
+    list: async (_limit) => EMPTY_STORE_LIST,
+    deleteByJid: async (_jid) => 0,
+    clear: async () => { }
+});
+exports.NOOP_CONTACT_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getByJid: async (_jid) => null,
+    deleteByJid: async (_jid) => 0,
+    clear: async () => { }
+});
+exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
+    getTtlMs: () => DEFAULT_PARTICIPANTS_CACHE_TTL_MS,
+    upsertGroupParticipants: async (_snapshot) => { },
+    getGroupParticipants: async (_groupJid, _nowMs) => null,
+    deleteGroupParticipants: async (_groupJid) => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});
+exports.NOOP_DEVICE_LIST_STORE = Object.freeze({
+    getTtlMs: () => DEFAULT_DEVICE_LIST_CACHE_TTL_MS,
+    upsertUserDevices: async (_snapshot) => { },
+    upsertUserDevicesBatch: async (_snapshots) => { },
+    getUserDevices: async (_userJid, _nowMs) => null,
+    getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
+    deleteUserDevices: async (_userJid) => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});

package/dist/store/providers/memory/appstate.store.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAppStateMemoryStore = void 0;
+const constants_1 = require("../../../appstate/constants");
+const utils_1 = require("../../../appstate/utils");
+const bytes_1 = require("../../../util/bytes");
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
+    syncKeys: 4096,
+    collectionEntries: 50000
+});
+function toBoundedMap(entries, maxEntries) {
+    const map = new Map();
+    for (const [key, value] of entries) {
+        (0, collections_1.setBoundedMapEntry)(map, key, value, maxEntries);
+    }
+    return map;
+}
+class WaAppStateMemoryStore {
+    constructor(initial, options = {}) {
+        this.keys = new Map();
+        this.collections = new Map();
+        this.maxSyncKeys = (0, coercion_1.resolvePositive)(options.maxSyncKeys, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.syncKeys, 'WaAppStateMemoryStoreOptions.maxSyncKeys');
+        this.maxCollectionEntries = (0, coercion_1.resolvePositive)(options.maxCollectionEntries, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.collectionEntries, 'WaAppStateMemoryStoreOptions.maxCollectionEntries');
+        if (initial) {
+            for (const key of initial.keys) {
+                (0, collections_1.setBoundedMapEntry)(this.keys, (0, utils_1.keyIdToHex)(key.keyId), key, this.maxSyncKeys);
+            }
+            for (const [collectionName, collection] of Object.entries(initial.collections)) {
+                if (!collection) {
+                    continue;
+                }
+                this.collections.set(collectionName, {
+                    version: collection.version,
+                    hash: collection.hash,
+                    indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
+                });
+            }
+        }
+    }
+    async exportData() {
+        const keys = Array.from(this.keys.values());
+        const collections = {};
+        for (const [collection, state] of this.collections.entries()) {
+            collections[collection] = {
+                version: state.version,
+                hash: state.hash,
+                indexValueMap: Object.fromEntries(state.indexValueMap.entries())
+            };
+        }
+        return {
+            keys,
+            collections
+        };
+    }
+    async upsertSyncKeys(keys) {
+        let inserted = 0;
+        for (const key of keys) {
+            const keyHex = (0, utils_1.keyIdToHex)(key.keyId);
+            const existing = this.keys.get(keyHex);
+            if (existing && (0, bytes_1.uint8Equal)(existing.keyData, key.keyData)) {
+                continue;
+            }
+            (0, collections_1.setBoundedMapEntry)(this.keys, keyHex, key, this.maxSyncKeys);
+            inserted += 1;
+        }
+        return inserted;
+    }
+    async getSyncKey(keyId) {
+        return this.keys.get((0, utils_1.keyIdToHex)(keyId)) ?? null;
+    }
+    async getSyncKeyData(keyId) {
+        return this.keys.get((0, utils_1.keyIdToHex)(keyId))?.keyData ?? null;
+    }
+    async getActiveSyncKey() {
+        return (0, utils_1.pickActiveSyncKey)(this.keys.values());
+    }
+    async getCollectionState(collection) {
+        let state = this.collections.get(collection);
+        if (!state) {
+            state = {
+                version: 0,
+                hash: constants_1.APP_STATE_EMPTY_LT_HASH,
+                indexValueMap: new Map()
+            };
+            this.collections.set(collection, state);
+        }
+        return state;
+    }
+    async setCollectionStates(updates) {
+        for (const update of updates) {
+            this.collections.set(update.collection, {
+                version: update.version,
+                hash: update.hash,
+                indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)
+            });
+        }
+    }
+    async clear() {
+        this.keys.clear();
+        this.collections.clear();
+    }
+}
+exports.WaAppStateMemoryStore = WaAppStateMemoryStore;

package/dist/store/providers/memory/contact.store.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaContactMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
+    contacts: 20000
+});
+class WaContactMemoryStore {
+    constructor(options = {}) {
+        this.contacts = new Map();
+        this.maxContacts = (0, coercion_1.resolvePositive)(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
+    }
+    async upsert(record) {
+        (0, collections_1.setBoundedMapEntry)(this.contacts, record.jid, record, this.maxContacts);
+    }
+    async getByJid(jid) {
+        return this.contacts.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.contacts.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.contacts.clear();
+    }
+}
+exports.WaContactMemoryStore = WaContactMemoryStore;

package/dist/store/providers/memory/device-list.store.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaDeviceListMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxUsers: 16384
+});
+class WaDeviceListMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        this.records = new Map();
+        this.ttlMs = ttlMs;
+        this.maxUsers = (0, coercion_1.resolvePositive)(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertUserDevices(snapshot) {
+        (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
+            ...snapshot,
+            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+        }, this.maxUsers);
+    }
+    async upsertUserDevicesBatch(snapshots) {
+        for (const snapshot of snapshots) {
+            (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
+                ...snapshot,
+                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+            }, this.maxUsers);
+        }
+    }
+    async getUserDevices(userJid, nowMs = Date.now()) {
+        const record = this.records.get(userJid);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= nowMs) {
+            this.records.delete(userJid);
+            return null;
+        }
+        return {
+            userJid: record.userJid,
+            deviceJids: record.deviceJids,
+            updatedAtMs: record.updatedAtMs
+        };
+    }
+    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
+        return userJids.map((userJid) => {
+            const record = this.records.get(userJid);
+            if (!record) {
+                return null;
+            }
+            if (record.expiresAtMs <= nowMs) {
+                this.records.delete(userJid);
+                return null;
+            }
+            return {
+                userJid: record.userJid,
+                deviceJids: record.deviceJids,
+                updatedAtMs: record.updatedAtMs
+            };
+        });
+    }
+    async deleteUserDevices(userJid) {
+        return this.records.delete(userJid) ? 1 : 0;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [userJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.records.delete(userJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+}
+exports.WaDeviceListMemoryStore = WaDeviceListMemoryStore;

package/dist/store/providers/memory/message.store.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMessageMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const collections_2 = require("../../../util/collections");
+const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
+    messages: 50000
+});
+class WaMessageMemoryStore {
+    constructor(options = {}) {
+        this.messages = new Map();
+        this.maxMessages = (0, coercion_1.resolvePositive)(options.maxMessages, DEFAULT_MESSAGE_MEMORY_STORE_LIMITS.messages, 'WaMessageMemoryStoreOptions.maxMessages');
+    }
+    async upsert(record) {
+        (0, collections_2.setBoundedMapEntry)(this.messages, record.id, record, this.maxMessages);
+    }
+    async getById(id) {
+        return this.messages.get(id) ?? null;
+    }
+    async listByThread(threadJid, limit, beforeTimestampMs) {
+        const normalizedLimit = (0, collections_1.normalizeQueryLimit)(limit, 50);
+        const records = [];
+        for (const record of this.messages.values()) {
+            if (record.threadJid !== threadJid) {
+                continue;
+            }
+            if (beforeTimestampMs !== undefined &&
+                (record.timestampMs === undefined || record.timestampMs >= beforeTimestampMs)) {
+                continue;
+            }
+            records.push(record);
+        }
+        records.sort((left, right) => (right.timestampMs ?? 0) - (left.timestampMs ?? 0));
+        return records.length <= normalizedLimit ? records : records.slice(0, normalizedLimit);
+    }
+    async deleteById(id) {
+        return this.messages.delete(id) ? 1 : 0;
+    }
+    async clear() {
+        this.messages.clear();
+    }
+}
+exports.WaMessageMemoryStore = WaMessageMemoryStore;