zapo-js 0.1.2 → 0.2.0

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

@@ -1,439 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaSignalSqliteStore = void 0;
-const jid_1 = require("../../../protocol/jid");
-const sqlite_1 = require("../../../signal/store/sqlite");
-const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
-const coercion_1 = require("../../../util/coercion");
-const DEFAULTS = Object.freeze({
-    preKeyBatchSize: 500,
-    hasSessionBatchSize: 250
-});
-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 WaSignalSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
-    constructor(options, storeOptions = {}) {
-        super(options, ['signal']);
-        this.preKeyBatchSize = (0, coercion_1.resolvePositive)(storeOptions.preKeyBatchSize, DEFAULTS.preKeyBatchSize, 'signal.sqlite.preKeyBatchSize');
-        this.hasSessionBatchSize = (0, coercion_1.resolvePositive)(storeOptions.hasSessionBatchSize, DEFAULTS.hasSessionBatchSize, 'signal.sqlite.hasSessionBatchSize');
-    }
-    async getRegistrationInfo() {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT registration_id, identity_pub_key, identity_priv_key
-             FROM signal_registration
-             WHERE session_id = ?`, [this.options.sessionId]);
-        return row ? (0, sqlite_1.decodeSignalRegistrationRow)(row) : null;
-    }
-    async setRegistrationInfo(info) {
-        const db = await this.getConnection();
-        db.run(`INSERT INTO signal_registration (
-                session_id,
-                registration_id,
-                identity_pub_key,
-                identity_priv_key
-            ) VALUES (?, ?, ?, ?)
-            ON CONFLICT(session_id) DO UPDATE SET
-                registration_id=excluded.registration_id,
-                identity_pub_key=excluded.identity_pub_key,
-                identity_priv_key=excluded.identity_priv_key`, [
-            this.options.sessionId,
-            info.registrationId,
-            info.identityKeyPair.pubKey,
-            info.identityKeyPair.privKey
-        ]);
-    }
-    async getSignedPreKey() {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT key_id, pub_key, priv_key, signature, uploaded
-             FROM signal_signed_prekey
-             WHERE session_id = ?`, [this.options.sessionId]);
-        return row ? (0, sqlite_1.decodeSignalSignedPreKeyRow)(row) : null;
-    }
-    async setSignedPreKey(record) {
-        const db = await this.getConnection();
-        db.run(`INSERT INTO signal_signed_prekey (
-                session_id,
-                key_id,
-                pub_key,
-                priv_key,
-                signature,
-                uploaded
-            ) VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id) DO UPDATE SET
-                key_id=excluded.key_id,
-                pub_key=excluded.pub_key,
-                priv_key=excluded.priv_key,
-                signature=excluded.signature,
-                uploaded=excluded.uploaded`, [
-            this.options.sessionId,
-            record.keyId,
-            record.keyPair.pubKey,
-            record.keyPair.privKey,
-            record.signature,
-            record.uploaded === true ? 1 : 0
-        ]);
-    }
-    async getSignedPreKeyById(keyId) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT key_id, pub_key, priv_key, signature, uploaded
-             FROM signal_signed_prekey
-             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-        return row ? (0, sqlite_1.decodeSignalSignedPreKeyRow)(row) : null;
-    }
-    async setSignedPreKeyRotationTs(value) {
-        const db = await this.getConnection();
-        this.ensureMetaRow(db);
-        db.run(`UPDATE signal_meta
-             SET signed_prekey_rotation_ts = ?
-             WHERE session_id = ?`, [value, this.options.sessionId]);
-    }
-    async getSignedPreKeyRotationTs() {
-        const db = await this.getConnection();
-        const meta = this.getMeta(db);
-        return meta.signedPreKeyRotationTs;
-    }
-    async putPreKey(record) {
-        const db = await this.getConnection();
-        this.ensureMetaRow(db);
-        this.upsertPreKey(db, record);
-        db.run(`UPDATE signal_meta
-             SET next_prekey_id = MAX(next_prekey_id, ?)
-             WHERE session_id = ?`, [record.keyId + 1, this.options.sessionId]);
-    }
-    async getOrGenPreKeys(count, generator) {
-        if (!Number.isSafeInteger(count) || count <= 0) {
-            throw new Error(`invalid prekey count: ${count}`);
-        }
-        return this.withTransaction(async (db) => {
-            this.ensureMetaRow(db);
-            const available = db
-                .all(`SELECT key_id, pub_key, priv_key, uploaded
-                     FROM signal_prekey
-                     WHERE session_id = ? AND uploaded = 0
-                     ORDER BY key_id ASC
-                     LIMIT ?`, [this.options.sessionId, count])
-                .map((row) => (0, sqlite_1.decodeSignalPreKeyRow)(row));
-            if (available.length < count) {
-                let nextPreKeyId = this.getMeta(db).nextPreKeyId;
-                while (available.length < count) {
-                    const requestedKeyId = nextPreKeyId;
-                    const generated = await generator(requestedKeyId);
-                    this.upsertPreKey(db, generated);
-                    available.push(generated);
-                    nextPreKeyId = Math.max(requestedKeyId + 1, generated.keyId + 1);
-                }
-                db.run(`UPDATE signal_meta
-                     SET next_prekey_id = ?
-                     WHERE session_id = ?`, [nextPreKeyId, this.options.sessionId]);
-            }
-            return available;
-        });
-    }
-    async getPreKeyById(keyId) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT key_id, pub_key, priv_key, uploaded
-             FROM signal_prekey
-             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-        return row ? (0, sqlite_1.decodeSignalPreKeyRow)(row) : null;
-    }
-    async getPreKeysById(keyIds) {
-        if (keyIds.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const uniqueKeyIds = [...new Set(keyIds)];
-        const byId = new Map();
-        for (let start = 0; start < uniqueKeyIds.length; start += this.preKeyBatchSize) {
-            const end = Math.min(start + this.preKeyBatchSize, uniqueKeyIds.length);
-            const batchLength = end - start;
-            const placeholders = repeatSqlToken('?', batchLength, ', ');
-            const params = [this.options.sessionId];
-            for (let index = start; index < end; index += 1) {
-                params.push(uniqueKeyIds[index]);
-            }
-            const rows = db.all(`SELECT key_id, pub_key, priv_key, uploaded
-                 FROM signal_prekey
-                 WHERE session_id = ? AND key_id IN (${placeholders})`, params);
-            for (const row of rows) {
-                const record = (0, sqlite_1.decodeSignalPreKeyRow)(row);
-                byId.set(record.keyId, record);
-            }
-        }
-        return keyIds.map((keyId) => byId.get(keyId) ?? null);
-    }
-    async consumePreKeyById(keyId) {
-        return this.withTransaction((db) => {
-            const row = db.get(`SELECT key_id, pub_key, priv_key, uploaded
-                 FROM signal_prekey
-                 WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-            if (!row) {
-                return null;
-            }
-            db.run(`DELETE FROM signal_prekey
-                 WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
-            return (0, sqlite_1.decodeSignalPreKeyRow)(row);
-        });
-    }
-    async getOrGenSinglePreKey(generator) {
-        const records = await this.getOrGenPreKeys(1, generator);
-        return records[0];
-    }
-    async markKeyAsUploaded(keyId) {
-        const db = await this.getConnection();
-        const meta = this.getMeta(db);
-        if (keyId < 0 || keyId >= meta.nextPreKeyId) {
-            throw new Error(`prekey ${keyId} is out of boundary`);
-        }
-        db.run(`UPDATE signal_prekey
-             SET uploaded = 1
-             WHERE session_id = ? AND key_id <= ?`, [this.options.sessionId, keyId]);
-    }
-    async setServerHasPreKeys(value) {
-        const db = await this.getConnection();
-        this.ensureMetaRow(db);
-        db.run(`UPDATE signal_meta
-             SET server_has_prekeys = ?
-             WHERE session_id = ?`, [value ? 1 : 0, this.options.sessionId]);
-    }
-    async getServerHasPreKeys() {
-        const db = await this.getConnection();
-        const meta = this.getMeta(db);
-        return meta.serverHasPreKeys;
-    }
-    async hasSession(address) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        return (db.get(`SELECT 1 AS has_session
-                 FROM signal_session
-                 WHERE session_id = ? AND user = ? AND server = ? AND device = ?
-                 LIMIT 1`, [this.options.sessionId, target.user, target.server, target.device]) !== null);
-    }
-    async hasSessions(addresses) {
-        if (addresses.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const targets = addresses.map((address) => (0, sqlite_1.toSignalAddressParts)(address));
-        const existingKeys = new Set();
-        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
-            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
-            const batchLength = end - start;
-            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
-            const params = [this.options.sessionId];
-            for (let index = start; index < end; index += 1) {
-                const target = targets[index];
-                params.push(target.user, target.server, target.device);
-            }
-            const rows = db.all(`SELECT user, server, device
-                 FROM signal_session
-                 WHERE session_id = ? AND (${filters})`, params);
-            for (const row of rows) {
-                existingKeys.add((0, jid_1.signalAddressKey)({
-                    user: (0, coercion_1.asString)(row.user, 'signal_session.user'),
-                    server: (0, coercion_1.asString)(row.server, 'signal_session.server'),
-                    device: (0, coercion_1.asNumber)(row.device, 'signal_session.device')
-                }));
-            }
-        }
-        return targets.map((target) => existingKeys.has((0, jid_1.signalAddressKey)(target)));
-    }
-    async getSession(address) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        const row = db.get(`SELECT user, server, device, record
-             FROM signal_session
-             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
-        return row ? (0, sqlite_1.decodeSignalSessionRecord)(row.record) : null;
-    }
-    async getSessionsBatch(addresses) {
-        if (addresses.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const targets = addresses.map((address) => (0, sqlite_1.toSignalAddressParts)(address));
-        const byAddressKey = new Map();
-        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
-            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
-            const batchLength = end - start;
-            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
-            const params = [this.options.sessionId];
-            for (let index = start; index < end; index += 1) {
-                const target = targets[index];
-                params.push(target.user, target.server, target.device);
-            }
-            const rows = db.all(`SELECT user, server, device, record
-                 FROM signal_session
-                 WHERE session_id = ? AND (${filters})`, params);
-            for (const row of rows) {
-                byAddressKey.set((0, jid_1.signalAddressKey)({
-                    user: (0, coercion_1.asString)(row.user, 'signal_session.user'),
-                    server: (0, coercion_1.asString)(row.server, 'signal_session.server'),
-                    device: (0, coercion_1.asNumber)(row.device, 'signal_session.device')
-                }), (0, sqlite_1.decodeSignalSessionRecord)(row.record));
-            }
-        }
-        return targets.map((target) => byAddressKey.get((0, jid_1.signalAddressKey)(target)) ?? null);
-    }
-    async setSession(address, session) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        this.upsertSession(db, target, session);
-    }
-    async setSessionsBatch(entries) {
-        if (entries.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (let index = 0; index < entries.length; index += 1) {
-                const entry = entries[index];
-                this.upsertSession(db, (0, sqlite_1.toSignalAddressParts)(entry.address), entry.session);
-            }
-        });
-    }
-    async deleteSession(address) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        db.run(`DELETE FROM signal_session
-             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
-    }
-    async getRemoteIdentity(address) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        const row = db.get(`SELECT identity_key
-             FROM signal_identity
-             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
-        return row ? (0, sqlite_1.decodeSignalRemoteIdentity)(row.identity_key) : null;
-    }
-    async getRemoteIdentities(addresses) {
-        if (addresses.length === 0) {
-            return [];
-        }
-        const db = await this.getConnection();
-        const targets = addresses.map((address) => (0, sqlite_1.toSignalAddressParts)(address));
-        const byAddressKey = new Map();
-        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
-            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
-            const batchLength = end - start;
-            const filters = repeatSqlToken('(user = ? AND server = ? AND device = ?)', batchLength, ' OR ');
-            const params = [this.options.sessionId];
-            for (let index = start; index < end; index += 1) {
-                const target = targets[index];
-                params.push(target.user, target.server, target.device);
-            }
-            const rows = db.all(`SELECT user, server, device, identity_key
-                 FROM signal_identity
-                 WHERE session_id = ? AND (${filters})`, params);
-            for (const row of rows) {
-                byAddressKey.set((0, jid_1.signalAddressKey)({
-                    user: (0, coercion_1.asString)(row.user, 'signal_identity.user'),
-                    server: (0, coercion_1.asString)(row.server, 'signal_identity.server'),
-                    device: (0, coercion_1.asNumber)(row.device, 'signal_identity.device')
-                }), (0, sqlite_1.decodeSignalRemoteIdentity)(row.identity_key));
-            }
-        }
-        return targets.map((target) => byAddressKey.get((0, jid_1.signalAddressKey)(target)) ?? null);
-    }
-    async setRemoteIdentity(address, identityKey) {
-        const db = await this.getConnection();
-        const target = (0, sqlite_1.toSignalAddressParts)(address);
-        this.upsertRemoteIdentity(db, target, identityKey);
-    }
-    async setRemoteIdentities(entries) {
-        if (entries.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const entry of entries) {
-                const target = (0, sqlite_1.toSignalAddressParts)(entry.address);
-                this.upsertRemoteIdentity(db, target, entry.identityKey);
-            }
-        });
-    }
-    async clear() {
-        await this.withTransaction((db) => {
-            db.run('DELETE FROM signal_registration WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM signal_signed_prekey WHERE session_id = ?', [
-                this.options.sessionId
-            ]);
-            db.run('DELETE FROM signal_prekey WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM signal_session WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM signal_identity WHERE session_id = ?', [this.options.sessionId]);
-            db.run('DELETE FROM signal_meta WHERE session_id = ?', [this.options.sessionId]);
-        });
-    }
-    upsertPreKey(db, record) {
-        db.run(`INSERT INTO signal_prekey (
-                session_id,
-                key_id,
-                pub_key,
-                priv_key,
-                uploaded
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, key_id) DO UPDATE SET
-                pub_key=excluded.pub_key,
-                priv_key=excluded.priv_key,
-                uploaded=excluded.uploaded`, [
-            this.options.sessionId,
-            record.keyId,
-            record.keyPair.pubKey,
-            record.keyPair.privKey,
-            record.uploaded === true ? 1 : 0
-        ]);
-    }
-    upsertSession(db, target, session) {
-        db.run(`INSERT INTO signal_session (
-                session_id,
-                user,
-                server,
-                device,
-                record
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
-                record=excluded.record`, [
-            this.options.sessionId,
-            target.user,
-            target.server,
-            target.device,
-            (0, sqlite_1.encodeSignalSessionRecord)(session)
-        ]);
-    }
-    ensureMetaRow(db) {
-        db.run(`INSERT INTO signal_meta (
-                session_id,
-                server_has_prekeys,
-                next_prekey_id
-            ) VALUES (?, 0, 1)
-            ON CONFLICT(session_id) DO NOTHING`, [this.options.sessionId]);
-    }
-    getMeta(db) {
-        this.ensureMetaRow(db);
-        const row = db.get(`SELECT server_has_prekeys, next_prekey_id, signed_prekey_rotation_ts
-             FROM signal_meta
-             WHERE session_id = ?`, [this.options.sessionId]);
-        return {
-            serverHasPreKeys: (0, coercion_1.toBoolOrUndef)(row.server_has_prekeys) === true,
-            nextPreKeyId: (0, coercion_1.asNumber)(row.next_prekey_id, 'signal_meta.next_prekey_id'),
-            signedPreKeyRotationTs: (0, coercion_1.asOptionalNumber)(row.signed_prekey_rotation_ts, 'signal_meta.signed_prekey_rotation_ts') ?? null
-        };
-    }
-    upsertRemoteIdentity(db, target, identityKey) {
-        db.run(`INSERT INTO signal_identity (
-                session_id,
-                user,
-                server,
-                device,
-                identity_key
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
-                identity_key=excluded.identity_key`, [this.options.sessionId, target.user, target.server, target.device, identityKey]);
-    }
-}
-exports.WaSignalSqliteStore = WaSignalSqliteStore;

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

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WA_SQLITE_DEFAULT_TABLE_NAMES = void 0;
-exports.resolveSqliteTableNames = resolveSqliteTableNames;
-exports.serializeSqliteTableNames = serializeSqliteTableNames;
-exports.createSqliteTableNameSqlResolver = createSqliteTableNameSqlResolver;
-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(', ');
-exports.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(exports.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);
-    }
-}
-function resolveSqliteTableNames(overrides) {
-    if (!overrides) {
-        return exports.WA_SQLITE_DEFAULT_TABLE_NAMES;
-    }
-    const entries = Object.entries(overrides);
-    if (entries.length === 0) {
-        return exports.WA_SQLITE_DEFAULT_TABLE_NAMES;
-    }
-    const resolved = {
-        ...exports.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);
-}
-function serializeSqliteTableNames(tableNames) {
-    return WA_SQLITE_TABLE_NAME_ORDER.map((table) => `${table}=${tableNames[table]}`).join(';');
-}
-function escapeRegexToken(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-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/store/providers/sqlite/thread.store.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaThreadSqliteStore = void 0;
-const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
-const THREAD_COLUMNS = 'jid, name, unread_count, archived, pinned, mute_end_ms, marked_as_unread, ephemeral_expiration';
-function decodeThreadRow(row) {
-    return {
-        jid: (0, coercion_1.asString)(row.jid, 'mailbox_threads.jid'),
-        name: (0, coercion_1.asOptionalString)(row.name, 'mailbox_threads.name'),
-        unreadCount: (0, coercion_1.asOptionalNumber)(row.unread_count, 'mailbox_threads.unread_count'),
-        archived: (0, coercion_1.toBoolOrUndef)(row.archived),
-        pinned: (0, coercion_1.asOptionalNumber)(row.pinned, 'mailbox_threads.pinned'),
-        muteEndMs: (0, coercion_1.asOptionalNumber)(row.mute_end_ms, 'mailbox_threads.mute_end_ms'),
-        markedAsUnread: (0, coercion_1.toBoolOrUndef)(row.marked_as_unread),
-        ephemeralExpiration: (0, coercion_1.asOptionalNumber)(row.ephemeral_expiration, 'mailbox_threads.ephemeral_expiration')
-    };
-}
-class WaThreadSqliteStore extends BaseSqliteStore_1.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, (0, collections_1.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
-        ]);
-    }
-}
-exports.WaThreadSqliteStore = WaThreadSqliteStore;

package/dist/types/appstate/store/sqlite.d.ts

@@ -1,7 +0,0 @@
-import type { WaAppStateStoreData, WaAppStateSyncKey } from '../types';
-type SqliteRow = Readonly<Record<string, unknown>>;
-export declare function encodeAppStateFingerprint(fingerprint: WaAppStateSyncKey['fingerprint']): Uint8Array | null;
-export declare function decodeAppStateFingerprint(raw: unknown): WaAppStateSyncKey['fingerprint'] | undefined;
-export declare function decodeAppStateSyncKeys(rows: readonly SqliteRow[]): readonly WaAppStateSyncKey[];
-export declare function decodeAppStateCollections(versionRows: readonly SqliteRow[], valueRows: readonly SqliteRow[]): WaAppStateStoreData['collections'];
-export {};

package/dist/types/crypto/core/constants.d.ts

@@ -1 +0,0 @@
-export declare const SERIALIZED_PUB_KEY_PREFIX = 5;

package/dist/types/retry/outbound.d.ts

@@ -1,4 +0,0 @@
-import type { WaRetryOutboundState, WaRetryReplayPayload } from './types';
-export declare function encodeRetryReplayPayload(payload: WaRetryReplayPayload): Uint8Array;
-export declare function decodeRetryReplayPayload(raw: Uint8Array): WaRetryReplayPayload;
-export declare function pickRetryStateMax(left: WaRetryOutboundState, right: WaRetryOutboundState): WaRetryOutboundState;

package/dist/types/store/providers/sqlite/BaseSqliteStore.d.ts

@@ -1,12 +0,0 @@
-import { type WaSqliteConnection } from '../../providers/sqlite/connection';
-import { type WaSqliteMigrationDomain } from '../../providers/sqlite/migrations';
-import type { WaSqliteStorageOptions } from '../../types';
-export declare abstract class BaseSqliteStore {
-    protected readonly options: WaSqliteStorageOptions;
-    private readonly migrationDomains;
-    private connectionPromise;
-    protected constructor(options: WaSqliteStorageOptions, migrationDomains: readonly WaSqliteMigrationDomain[]);
-    protected getConnection(): Promise<WaSqliteConnection>;
-    protected withTransaction<T>(run: (connection: WaSqliteConnection) => Promise<T> | T): Promise<T>;
-    destroy(): Promise<void>;
-}