zapo-js 0.1.2 → 0.2.0

package/dist/esm/store/providers/sqlite/table-names.js

@@ -1,107 +0,0 @@
-const SQLITE_TABLE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const WA_SQLITE_TABLE_NAME_ORDER = Object.freeze([
-    'wa_migrations',
-    'auth_credentials',
-    'signal_meta',
-    'signal_registration',
-    'signal_signed_prekey',
-    'signal_prekey',
-    'signal_session',
-    'signal_identity',
-    'sender_keys',
-    'sender_key_distribution',
-    'appstate_sync_keys',
-    'appstate_collection_versions',
-    'appstate_collection_index_values',
-    'retry_outbound_messages',
-    'retry_inbound_counters',
-    'mailbox_messages',
-    'mailbox_threads',
-    'mailbox_contacts',
-    'group_participants_cache',
-    'device_list_cache'
-]);
-const WA_SQLITE_ALLOWED_TABLE_NAME_SET = new Set(WA_SQLITE_TABLE_NAME_ORDER);
-const WA_SQLITE_ALLOWED_TABLE_NAME_LIST = WA_SQLITE_TABLE_NAME_ORDER.join(', ');
-export const WA_SQLITE_DEFAULT_TABLE_NAMES = Object.freeze({
-    wa_migrations: 'wa_migrations',
-    auth_credentials: 'auth_credentials',
-    signal_meta: 'signal_meta',
-    signal_registration: 'signal_registration',
-    signal_signed_prekey: 'signal_signed_prekey',
-    signal_prekey: 'signal_prekey',
-    signal_session: 'signal_session',
-    signal_identity: 'signal_identity',
-    sender_keys: 'sender_keys',
-    sender_key_distribution: 'sender_key_distribution',
-    appstate_sync_keys: 'appstate_sync_keys',
-    appstate_collection_versions: 'appstate_collection_versions',
-    appstate_collection_index_values: 'appstate_collection_index_values',
-    retry_outbound_messages: 'retry_outbound_messages',
-    retry_inbound_counters: 'retry_inbound_counters',
-    mailbox_messages: 'mailbox_messages',
-    mailbox_threads: 'mailbox_threads',
-    mailbox_contacts: 'mailbox_contacts',
-    group_participants_cache: 'group_participants_cache',
-    device_list_cache: 'device_list_cache'
-});
-const DEFAULT_SQLITE_TABLE_NAME_SERIALIZATION = serializeSqliteTableNames(WA_SQLITE_DEFAULT_TABLE_NAMES);
-function normalizeTableName(table, rawValue) {
-    const value = rawValue.trim();
-    if (value.length === 0) {
-        throw new Error(`sqlite tableNames.${table} must be a non-empty string`);
-    }
-    if (!SQLITE_TABLE_NAME_PATTERN.test(value)) {
-        throw new Error(`sqlite tableNames.${table} must match ${SQLITE_TABLE_NAME_PATTERN.toString()}`);
-    }
-    return value;
-}
-function assertNoDuplicateTableNames(tableNames) {
-    const seen = new Set();
-    for (const table of WA_SQLITE_TABLE_NAME_ORDER) {
-        const mapped = tableNames[table];
-        const normalizedMapped = mapped.toLowerCase();
-        if (seen.has(normalizedMapped)) {
-            throw new Error(`sqlite tableNames contains duplicate target "${mapped}"`);
-        }
-        seen.add(normalizedMapped);
-    }
-}
-export function resolveSqliteTableNames(overrides) {
-    if (!overrides) {
-        return WA_SQLITE_DEFAULT_TABLE_NAMES;
-    }
-    const entries = Object.entries(overrides);
-    if (entries.length === 0) {
-        return WA_SQLITE_DEFAULT_TABLE_NAMES;
-    }
-    const resolved = {
-        ...WA_SQLITE_DEFAULT_TABLE_NAMES
-    };
-    for (const [table, rawName] of entries) {
-        if (!WA_SQLITE_ALLOWED_TABLE_NAME_SET.has(table)) {
-            throw new Error(`unsupported sqlite tableNames key "${table}". Allowed table names: ${WA_SQLITE_ALLOWED_TABLE_NAME_LIST}`);
-        }
-        if (typeof rawName !== 'string') {
-            throw new Error(`sqlite tableNames.${table} must be a string`);
-        }
-        const tableName = table;
-        resolved[tableName] = normalizeTableName(tableName, rawName);
-    }
-    assertNoDuplicateTableNames(resolved);
-    return Object.freeze(resolved);
-}
-export function serializeSqliteTableNames(tableNames) {
-    return WA_SQLITE_TABLE_NAME_ORDER.map((table) => `${table}=${tableNames[table]}`).join(';');
-}
-function escapeRegexToken(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-export function createSqliteTableNameSqlResolver(tableNames) {
-    const serialized = serializeSqliteTableNames(tableNames);
-    if (serialized === DEFAULT_SQLITE_TABLE_NAME_SERIALIZATION) {
-        return (sql) => sql;
-    }
-    const pattern = new RegExp(`\\b(?:${WA_SQLITE_TABLE_NAME_ORDER.map(escapeRegexToken).join('|')})\\b`, 'g');
-    return (sql) => sql.replace(pattern, (token) => tableNames[token] ?? token);
-}

package/dist/esm/store/providers/sqlite/thread.store.js

@@ -1,85 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asOptionalNumber, asOptionalString, asString, toBoolOrUndef } from '../../../util/coercion.js';
-import { normalizeQueryLimit } from '../../../util/collections.js';
-const THREAD_COLUMNS = 'jid, name, unread_count, archived, pinned, mute_end_ms, marked_as_unread, ephemeral_expiration';
-function decodeThreadRow(row) {
-    return {
-        jid: asString(row.jid, 'mailbox_threads.jid'),
-        name: asOptionalString(row.name, 'mailbox_threads.name'),
-        unreadCount: asOptionalNumber(row.unread_count, 'mailbox_threads.unread_count'),
-        archived: toBoolOrUndef(row.archived),
-        pinned: asOptionalNumber(row.pinned, 'mailbox_threads.pinned'),
-        muteEndMs: asOptionalNumber(row.mute_end_ms, 'mailbox_threads.mute_end_ms'),
-        markedAsUnread: toBoolOrUndef(row.marked_as_unread),
-        ephemeralExpiration: asOptionalNumber(row.ephemeral_expiration, 'mailbox_threads.ephemeral_expiration')
-    };
-}
-export class WaThreadSqliteStore extends BaseSqliteStore {
-    constructor(options) {
-        super(options, ['mailbox']);
-    }
-    async upsert(record) {
-        const db = await this.getConnection();
-        this.upsertThreadRow(db, record);
-    }
-    async upsertBatch(records) {
-        if (records.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const record of records) {
-                this.upsertThreadRow(db, record);
-            }
-        });
-    }
-    async getByJid(jid) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT ${THREAD_COLUMNS}
-             FROM mailbox_threads
-             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
-        return row ? decodeThreadRow(row) : null;
-    }
-    async list(limit) {
-        const db = await this.getConnection();
-        const rows = db.all(`SELECT ${THREAD_COLUMNS}
-             FROM mailbox_threads
-             WHERE session_id = ?
-             LIMIT ?`, [this.options.sessionId, normalizeQueryLimit(limit, 100)]);
-        return rows.map(decodeThreadRow);
-    }
-    async deleteByJid(jid) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM mailbox_threads
-             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
-        const row = db.get('SELECT changes() AS total', []);
-        return row ? Number(row.total) : 0;
-    }
-    async clear() {
-        const db = await this.getConnection();
-        db.run('DELETE FROM mailbox_threads WHERE session_id = ?', [this.options.sessionId]);
-    }
-    upsertThreadRow(db, record) {
-        db.run(`INSERT INTO mailbox_threads (
-                session_id, jid, name, unread_count, archived, pinned,
-                mute_end_ms, marked_as_unread, ephemeral_expiration
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, jid) DO UPDATE SET
-                name=COALESCE(excluded.name, mailbox_threads.name),
-                unread_count=COALESCE(excluded.unread_count, mailbox_threads.unread_count),
-                archived=COALESCE(excluded.archived, mailbox_threads.archived),
-                pinned=COALESCE(excluded.pinned, mailbox_threads.pinned),
-                mute_end_ms=COALESCE(excluded.mute_end_ms, mailbox_threads.mute_end_ms),
-                marked_as_unread=COALESCE(excluded.marked_as_unread, mailbox_threads.marked_as_unread),
-                ephemeral_expiration=COALESCE(excluded.ephemeral_expiration, mailbox_threads.ephemeral_expiration)`, [
-            this.options.sessionId,
-            record.jid,
-            record.name ?? null,
-            record.unreadCount ?? null,
-            record.archived === undefined ? null : record.archived ? 1 : 0,
-            record.pinned ?? null,
-            record.muteEndMs ?? null,
-            record.markedAsUnread === undefined ? null : record.markedAsUnread ? 1 : 0,
-            record.ephemeralExpiration ?? null
-        ]);
-    }
-}

package/dist/retry/outbound.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeRetryReplayPayload = encodeRetryReplayPayload;
-exports.decodeRetryReplayPayload = decodeRetryReplayPayload;
-exports.pickRetryStateMax = pickRetryStateMax;
-const bytes_1 = require("../util/bytes");
-function requireObject(value) {
-    if (!value || typeof value !== 'object') {
-        throw new Error('invalid retry replay payload');
-    }
-    return value;
-}
-function requireString(value, field) {
-    if (typeof value !== 'string') {
-        throw new Error(`invalid retry replay payload field: ${field}`);
-    }
-    return value;
-}
-function encodeRetryReplayPayload(payload) {
-    const serialized = payload.mode === 'plaintext'
-        ? {
-            mode: payload.mode,
-            to: payload.to,
-            type: payload.type,
-            plaintext: (0, bytes_1.bytesToBase64)(payload.plaintext)
-        }
-        : payload.mode === 'encrypted'
-            ? {
-                mode: payload.mode,
-                to: payload.to,
-                type: payload.type,
-                encType: payload.encType,
-                ciphertext: (0, bytes_1.bytesToBase64)(payload.ciphertext),
-                participant: payload.participant
-            }
-            : {
-                mode: payload.mode,
-                node: (0, bytes_1.bytesToBase64)(payload.node)
-            };
-    return bytes_1.TEXT_ENCODER.encode(JSON.stringify(serialized));
-}
-function decodeRetryReplayPayload(raw) {
-    const json = JSON.parse(bytes_1.TEXT_DECODER.decode(raw));
-    const parsed = requireObject(json);
-    const mode = requireString(parsed.mode, 'mode');
-    if (mode === 'plaintext') {
-        return {
-            mode,
-            to: requireString(parsed.to, 'to'),
-            type: requireString(parsed.type, 'type'),
-            plaintext: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
-        };
-    }
-    if (mode === 'encrypted') {
-        const encType = requireString(parsed.encType, 'encType');
-        if (encType !== 'msg' && encType !== 'pkmsg' && encType !== 'skmsg') {
-            throw new Error(`invalid retry encrypted encType: ${encType}`);
-        }
-        return {
-            mode,
-            to: requireString(parsed.to, 'to'),
-            type: requireString(parsed.type, 'type'),
-            encType,
-            ciphertext: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
-            participant: parsed.participant === undefined
-                ? undefined
-                : requireString(parsed.participant, 'participant')
-        };
-    }
-    if (mode === 'opaque_node') {
-        return {
-            mode,
-            node: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.node, 'node'), 'retry.node')
-        };
-    }
-    throw new Error(`invalid retry replay payload mode: ${mode}`);
-}
-const RETRY_STATE_RANK = {
-    pending: 0,
-    delivered: 1,
-    read: 2,
-    played: 3,
-    ineligible: 4
-};
-function pickRetryStateMax(left, right) {
-    return RETRY_STATE_RANK[left] >= RETRY_STATE_RANK[right] ? left : right;
-}

package/dist/store/providers/sqlite/BaseSqliteStore.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSqliteStore = void 0;
-const connection_1 = require("../../providers/sqlite/connection");
-const migrations_1 = require("../../providers/sqlite/migrations");
-class BaseSqliteStore {
-    constructor(options, migrationDomains) {
-        this.options = options;
-        this.migrationDomains = migrationDomains;
-        this.connectionPromise = null;
-    }
-    async getConnection() {
-        if (!this.connectionPromise) {
-            this.connectionPromise = (0, connection_1.openSqliteConnection)(this.options).then((connection) => (0, migrations_1.ensureSqliteMigrations)(connection, this.migrationDomains).then(() => connection));
-        }
-        return this.connectionPromise;
-    }
-    async withTransaction(run) {
-        const db = await this.getConnection();
-        db.exec('BEGIN');
-        try {
-            const result = await run(db);
-            db.exec('COMMIT');
-            return result;
-        }
-        catch (error) {
-            db.exec('ROLLBACK');
-            throw error;
-        }
-    }
-    async destroy() {
-        const connectionPromise = this.connectionPromise;
-        this.connectionPromise = null;
-        if (!connectionPromise) {
-            return;
-        }
-        const connection = await connectionPromise;
-        connection.close();
-    }
-}
-exports.BaseSqliteStore = BaseSqliteStore;

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

@@ -1,254 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaAppStateSqliteStore = void 0;
-const constants_1 = require("../../../appstate/constants");
-const sqlite_1 = require("../../../appstate/store/sqlite");
-const utils_1 = require("../../../appstate/utils");
-const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
-const bytes_1 = require("../../../util/bytes");
-const coercion_1 = require("../../../util/coercion");
-function repeatSqlToken(token, count, separator) {
-    if (count <= 1) {
-        return token;
-    }
-    let out = token;
-    for (let index = 1; index < count; index += 1) {
-        out += separator + token;
-    }
-    return out;
-}
-class WaAppStateSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
-    constructor(options) {
-        super(options, ['appState']);
-    }
-    async exportData() {
-        const db = await this.getConnection();
-        const keyRows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
-             FROM appstate_sync_keys
-             WHERE session_id = ?`, [this.options.sessionId]);
-        const versionRows = db.all(`SELECT collection, version, hash
-             FROM appstate_collection_versions
-             WHERE session_id = ?`, [this.options.sessionId]);
-        const valueRows = db.all(`SELECT collection, index_mac_hex, value_mac
-             FROM appstate_collection_index_values
-             WHERE session_id = ?`, [this.options.sessionId]);
-        return {
-            keys: (0, sqlite_1.decodeAppStateSyncKeys)(keyRows),
-            collections: (0, sqlite_1.decodeAppStateCollections)(versionRows, valueRows)
-        };
-    }
-    async upsertSyncKeys(keys) {
-        let inserted = 0;
-        await this.withTransaction((db) => {
-            for (const key of keys) {
-                const existing = db.get(`SELECT key_data
-                     FROM appstate_sync_keys
-                     WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, key.keyId]);
-                if (existing &&
-                    (0, bytes_1.uint8Equal)((0, coercion_1.asBytes)(existing.key_data, 'appstate_sync_keys.key_data'), key.keyData)) {
-                    continue;
-                }
-                db.run(`INSERT INTO appstate_sync_keys (
-                        session_id,
-                        key_id,
-                        key_data,
-                        timestamp,
-                        fingerprint,
-                        key_epoch
-                    ) VALUES (?, ?, ?, ?, ?, ?)
-                    ON CONFLICT(session_id, key_id) DO UPDATE SET
-                        key_data=excluded.key_data,
-                        timestamp=excluded.timestamp,
-                        fingerprint=excluded.fingerprint,
-                        key_epoch=excluded.key_epoch`, [
-                    this.options.sessionId,
-                    key.keyId,
-                    key.keyData,
-                    key.timestamp,
-                    (0, sqlite_1.encodeAppStateFingerprint)(key.fingerprint),
-                    (0, utils_1.keyEpoch)(key.keyId)
-                ]);
-                inserted += 1;
-            }
-        });
-        return inserted;
-    }
-    async getSyncKey(keyId) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT key_id, key_data, timestamp, fingerprint
-             FROM appstate_sync_keys
-             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-        if (!row) {
-            return null;
-        }
-        return {
-            keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
-            keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
-            timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
-            fingerprint: (0, sqlite_1.decodeAppStateFingerprint)(row.fingerprint)
-        };
-    }
-    async getSyncKeyData(keyId) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT key_data
-             FROM appstate_sync_keys
-             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-        if (!row) {
-            return null;
-        }
-        return (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data');
-    }
-    async getSyncKeyDataBatch(keyIds) {
-        if (keyIds.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const uniqueKeyIds = [
-            ...new Map(keyIds.map((keyId) => [(0, bytes_1.bytesToHex)(keyId), keyId])).values()
-        ];
-        const placeholders = repeatSqlToken('?', uniqueKeyIds.length, ', ');
-        const params = [this.options.sessionId, ...uniqueKeyIds];
-        const rows = db.all(`SELECT key_id, key_data
-             FROM appstate_sync_keys
-             WHERE session_id = ? AND key_id IN (${placeholders})`, params);
-        const byKeyHex = new Map();
-        for (const row of rows) {
-            byKeyHex.set((0, bytes_1.bytesToHex)((0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id')), (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'));
-        }
-        return keyIds.map((keyId) => byKeyHex.get((0, bytes_1.bytesToHex)(keyId)) ?? null);
-    }
-    async getActiveSyncKey() {
-        const db = await this.getConnection();
-        const rows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
-             FROM appstate_sync_keys
-             WHERE session_id = ?`, [this.options.sessionId]);
-        const keys = [];
-        for (const row of rows) {
-            const key = {
-                keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
-                keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
-                timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
-                fingerprint: (0, sqlite_1.decodeAppStateFingerprint)(row.fingerprint)
-            };
-            keys.push(key);
-        }
-        return (0, utils_1.pickActiveSyncKey)(keys);
-    }
-    async getCollectionState(collection) {
-        const db = await this.getConnection();
-        const versionRow = db.get(`SELECT version, hash
-             FROM appstate_collection_versions
-             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
-        if (!versionRow) {
-            return {
-                initialized: false,
-                version: 0,
-                hash: constants_1.APP_STATE_EMPTY_LT_HASH,
-                indexValueMap: new Map()
-            };
-        }
-        const valueRows = db.all(`SELECT index_mac_hex, value_mac
-             FROM appstate_collection_index_values
-             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
-        const indexValueMap = new Map();
-        for (const row of valueRows) {
-            indexValueMap.set((0, coercion_1.asString)(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), (0, coercion_1.asBytes)(row.value_mac, 'appstate_collection_index_values.value_mac'));
-        }
-        return {
-            initialized: true,
-            version: (0, coercion_1.asNumber)(versionRow.version, 'appstate_collection_versions.version'),
-            hash: (0, coercion_1.asBytes)(versionRow.hash, 'appstate_collection_versions.hash'),
-            indexValueMap
-        };
-    }
-    async getCollectionStates(collections) {
-        if (collections.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const uniqueCollections = [...new Set(collections)];
-        const placeholders = repeatSqlToken('?', uniqueCollections.length, ', ');
-        const params = [this.options.sessionId, ...uniqueCollections];
-        const versionRows = db.all(`SELECT collection, version, hash
-             FROM appstate_collection_versions
-             WHERE session_id = ? AND collection IN (${placeholders})`, params);
-        const valueRows = db.all(`SELECT collection, index_mac_hex, value_mac
-             FROM appstate_collection_index_values
-             WHERE session_id = ? AND collection IN (${placeholders})`, params);
-        const versionsByCollection = new Map();
-        for (const row of versionRows) {
-            const collection = (0, coercion_1.asString)(row.collection, 'appstate_collection_versions.collection');
-            versionsByCollection.set(collection, {
-                version: (0, coercion_1.asNumber)(row.version, 'appstate_collection_versions.version'),
-                hash: (0, coercion_1.asBytes)(row.hash, 'appstate_collection_versions.hash')
-            });
-        }
-        const indexValueMaps = new Map();
-        for (const row of valueRows) {
-            const collection = (0, coercion_1.asString)(row.collection, 'appstate_collection_index_values.collection');
-            const map = indexValueMaps.get(collection);
-            const targetMap = map ?? new Map();
-            targetMap.set((0, coercion_1.asString)(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), (0, coercion_1.asBytes)(row.value_mac, 'appstate_collection_index_values.value_mac'));
-            if (!map) {
-                indexValueMaps.set(collection, targetMap);
-            }
-        }
-        return collections.map((collection) => {
-            const version = versionsByCollection.get(collection);
-            if (!version) {
-                return {
-                    initialized: false,
-                    version: 0,
-                    hash: constants_1.APP_STATE_EMPTY_LT_HASH,
-                    indexValueMap: new Map()
-                };
-            }
-            return {
-                initialized: true,
-                version: version.version,
-                hash: version.hash,
-                indexValueMap: indexValueMaps.get(collection) ?? new Map()
-            };
-        });
-    }
-    async setCollectionStates(updates) {
-        if (updates.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const update of updates) {
-                db.run(`INSERT INTO appstate_collection_versions (
-                        session_id,
-                        collection,
-                        version,
-                        hash
-                    ) VALUES (?, ?, ?, ?)
-                    ON CONFLICT(session_id, collection) DO UPDATE SET
-                        version=excluded.version,
-                        hash=excluded.hash`, [this.options.sessionId, update.collection, update.version, update.hash]);
-                db.run(`DELETE FROM appstate_collection_index_values
-                     WHERE session_id = ? AND collection = ?`, [this.options.sessionId, update.collection]);
-                for (const [indexMacHex, valueMac] of update.indexValueMap.entries()) {
-                    db.run(`INSERT INTO appstate_collection_index_values (
-                            session_id,
-                            collection,
-                            index_mac_hex,
-                            value_mac
-                        ) VALUES (?, ?, ?, ?)`, [this.options.sessionId, update.collection, indexMacHex, valueMac]);
-                }
-            }
-        });
-    }
-    async clear() {
-        await this.withTransaction((db) => {
-            db.run('DELETE FROM appstate_sync_keys WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM appstate_collection_versions WHERE session_id = ?', [
-                this.options.sessionId
-            ]);
-            db.run('DELETE FROM appstate_collection_index_values WHERE session_id = ?', [
-                this.options.sessionId
-            ]);
-        });
-    }
-}
-exports.WaAppStateSqliteStore = WaAppStateSqliteStore;