zapo-js 0.1.0

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAuthSqliteStore = void 0;
+const _proto_1 = require("../../../proto.js");
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const coercion_1 = require("../../../util/coercion");
+class WaAuthSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
+    constructor(options) {
+        super(options, ['auth']);
+    }
+    async load() {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT
+                noise_pub_key,
+                noise_priv_key,
+                registration_id,
+                identity_pub_key,
+                identity_priv_key,
+                signed_prekey_id,
+                signed_prekey_pub_key,
+                signed_prekey_priv_key,
+                signed_prekey_signature,
+                adv_secret_key,
+                signed_identity,
+                me_jid,
+                me_lid,
+                me_display_name,
+                companion_enc_static,
+                platform,
+                server_static_key,
+                server_has_prekeys,
+                routing_info,
+                last_success_ts,
+                props_version,
+                ab_props_version,
+                connection_location,
+                account_creation_ts
+            FROM auth_credentials
+            WHERE session_id = ?`, [this.options.sessionId]);
+        if (!row) {
+            return null;
+        }
+        const signedIdentityBytes = (0, coercion_1.asOptionalBytes)(row.signed_identity);
+        return {
+            noiseKeyPair: {
+                pubKey: (0, coercion_1.asBytes)(row.noise_pub_key, 'noise_pub_key'),
+                privKey: (0, coercion_1.asBytes)(row.noise_priv_key, 'noise_priv_key')
+            },
+            registrationInfo: {
+                registrationId: (0, coercion_1.asNumber)(row.registration_id, 'registration_id'),
+                identityKeyPair: {
+                    pubKey: (0, coercion_1.asBytes)(row.identity_pub_key, 'identity_pub_key'),
+                    privKey: (0, coercion_1.asBytes)(row.identity_priv_key, 'identity_priv_key')
+                }
+            },
+            signedPreKey: {
+                keyId: (0, coercion_1.asNumber)(row.signed_prekey_id, 'signed_prekey_id'),
+                keyPair: {
+                    pubKey: (0, coercion_1.asBytes)(row.signed_prekey_pub_key, 'signed_prekey_pub_key'),
+                    privKey: (0, coercion_1.asBytes)(row.signed_prekey_priv_key, 'signed_prekey_priv_key')
+                },
+                signature: (0, coercion_1.asBytes)(row.signed_prekey_signature, 'signed_prekey_signature'),
+                uploaded: false
+            },
+            advSecretKey: (0, coercion_1.asBytes)(row.adv_secret_key, 'adv_secret_key'),
+            signedIdentity: signedIdentityBytes
+                ? _proto_1.proto.ADVSignedDeviceIdentity.decode(signedIdentityBytes)
+                : undefined,
+            meJid: (0, coercion_1.asOptionalString)(row.me_jid),
+            meLid: (0, coercion_1.asOptionalString)(row.me_lid),
+            meDisplayName: (0, coercion_1.asOptionalString)(row.me_display_name),
+            companionEncStatic: (0, coercion_1.asOptionalBytes)(row.companion_enc_static),
+            platform: (0, coercion_1.asOptionalString)(row.platform),
+            serverStaticKey: (0, coercion_1.asOptionalBytes)(row.server_static_key),
+            serverHasPreKeys: (0, coercion_1.toBoolOrUndef)(row.server_has_prekeys),
+            routingInfo: (0, coercion_1.asOptionalBytes)(row.routing_info),
+            lastSuccessTs: (0, coercion_1.asOptionalNumber)(row.last_success_ts),
+            propsVersion: (0, coercion_1.asOptionalNumber)(row.props_version),
+            abPropsVersion: (0, coercion_1.asOptionalNumber)(row.ab_props_version),
+            connectionLocation: (0, coercion_1.asOptionalString)(row.connection_location),
+            accountCreationTs: (0, coercion_1.asOptionalNumber)(row.account_creation_ts)
+        };
+    }
+    async save(credentials) {
+        await this.withTransaction(async (db) => {
+            db.run(`INSERT INTO auth_credentials (
+                    session_id,
+                    noise_pub_key,
+                    noise_priv_key,
+                    registration_id,
+                    identity_pub_key,
+                    identity_priv_key,
+                    signed_prekey_id,
+                    signed_prekey_pub_key,
+                    signed_prekey_priv_key,
+                    signed_prekey_signature,
+                    adv_secret_key,
+                    signed_identity,
+                    me_jid,
+                    me_lid,
+                    me_display_name,
+                    companion_enc_static,
+                    platform,
+                    server_static_key,
+                    server_has_prekeys,
+                    routing_info,
+                    last_success_ts,
+                    props_version,
+                    ab_props_version,
+                    connection_location,
+                    account_creation_ts
+                ) VALUES (
+                    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+                )
+                ON CONFLICT(session_id) DO UPDATE SET
+                    noise_pub_key=excluded.noise_pub_key,
+                    noise_priv_key=excluded.noise_priv_key,
+                    registration_id=excluded.registration_id,
+                    identity_pub_key=excluded.identity_pub_key,
+                    identity_priv_key=excluded.identity_priv_key,
+                    signed_prekey_id=excluded.signed_prekey_id,
+                    signed_prekey_pub_key=excluded.signed_prekey_pub_key,
+                    signed_prekey_priv_key=excluded.signed_prekey_priv_key,
+                    signed_prekey_signature=excluded.signed_prekey_signature,
+                    adv_secret_key=excluded.adv_secret_key,
+                    signed_identity=excluded.signed_identity,
+                    me_jid=excluded.me_jid,
+                    me_lid=excluded.me_lid,
+                    me_display_name=excluded.me_display_name,
+                    companion_enc_static=excluded.companion_enc_static,
+                    platform=excluded.platform,
+                    server_static_key=excluded.server_static_key,
+                    server_has_prekeys=excluded.server_has_prekeys,
+                    routing_info=excluded.routing_info,
+                    last_success_ts=excluded.last_success_ts,
+                    props_version=excluded.props_version,
+                    ab_props_version=excluded.ab_props_version,
+                    connection_location=excluded.connection_location,
+                    account_creation_ts=excluded.account_creation_ts`, [
+                this.options.sessionId,
+                credentials.noiseKeyPair.pubKey,
+                credentials.noiseKeyPair.privKey,
+                credentials.registrationInfo.registrationId,
+                credentials.registrationInfo.identityKeyPair.pubKey,
+                credentials.registrationInfo.identityKeyPair.privKey,
+                credentials.signedPreKey.keyId,
+                credentials.signedPreKey.keyPair.pubKey,
+                credentials.signedPreKey.keyPair.privKey,
+                credentials.signedPreKey.signature,
+                credentials.advSecretKey,
+                credentials.signedIdentity
+                    ? _proto_1.proto.ADVSignedDeviceIdentity.encode(credentials.signedIdentity).finish()
+                    : null,
+                credentials.meJid ?? null,
+                credentials.meLid ?? null,
+                credentials.meDisplayName ?? null,
+                credentials.companionEncStatic ?? null,
+                credentials.platform ?? null,
+                credentials.serverStaticKey ?? null,
+                credentials.serverHasPreKeys === undefined
+                    ? null
+                    : credentials.serverHasPreKeys
+                        ? 1
+                        : 0,
+                credentials.routingInfo ?? null,
+                credentials.lastSuccessTs ?? null,
+                credentials.propsVersion ?? null,
+                credentials.abPropsVersion ?? null,
+                credentials.connectionLocation ?? null,
+                credentials.accountCreationTs ?? null
+            ]);
+        });
+    }
+    async clear() {
+        await this.withTransaction(async (db) => {
+            db.run('DELETE FROM auth_credentials WHERE session_id = ?', [this.options.sessionId]);
+        });
+    }
+}
+exports.WaAuthSqliteStore = WaAuthSqliteStore;

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

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSqliteConnection = openSqliteConnection;
+const primitives_1 = require("../../../util/primitives");
+const runtime_1 = require("../../../util/runtime");
+const BETTER_SQLITE3_MODULE = 'better-sqlite3';
+const BUN_SQLITE_MODULE = 'bun:sqlite';
+const SQLITE_PRAGMA_TOKEN_PATTERN = /^[A-Za-z0-9_+-]+$/;
+const DEFAULT_SQLITE_PRAGMAS = Object.freeze({
+    journal_mode: 'WAL',
+    synchronous: 'normal',
+    busy_timeout: 5000
+});
+const ALLOWED_SQLITE_PRAGMAS = {
+    auto_vacuum: 'token_or_int',
+    busy_timeout: 'int',
+    cache_size: 'int',
+    foreign_keys: 'token_or_int',
+    journal_mode: 'token',
+    journal_size_limit: 'int',
+    legacy_alter_table: 'token_or_int',
+    locking_mode: 'token',
+    mmap_size: 'int',
+    page_size: 'int',
+    recursive_triggers: 'token_or_int',
+    secure_delete: 'token_or_int',
+    synchronous: 'token_or_int',
+    temp_store: 'token_or_int',
+    wal_autocheckpoint: 'int'
+};
+function asConstructor(loaded) {
+    if (typeof loaded === 'function') {
+        return loaded;
+    }
+    if (loaded && typeof loaded === 'object') {
+        const candidate = loaded.default;
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+    }
+    throw new Error('invalid sqlite driver export');
+}
+function statementFor(db, sql) {
+    const prepare = db.prepare ?? db.query;
+    if (!prepare) {
+        throw new Error('sqlite driver does not expose prepare/query method');
+    }
+    const statement = prepare.call(db, sql);
+    if (!statement ||
+        typeof statement.run !== 'function' ||
+        typeof statement.get !== 'function' ||
+        typeof statement.all !== 'function') {
+        throw new Error('invalid sqlite statement API');
+    }
+    return statement;
+}
+function wrapConnection(db, driver, onClose) {
+    const statementCache = new Map();
+    const cachedStatementFor = (sql) => {
+        const cached = statementCache.get(sql);
+        if (cached) {
+            return cached;
+        }
+        const statement = statementFor(db, sql);
+        statementCache.set(sql, statement);
+        return statement;
+    };
+    return {
+        driver,
+        exec(sql) {
+            db.exec(sql);
+        },
+        run(sql, params) {
+            const statement = cachedStatementFor(sql);
+            if (!params || params.length === 0) {
+                statement.run();
+                return;
+            }
+            statement.run(...params);
+        },
+        get(sql, params) {
+            const statement = cachedStatementFor(sql);
+            const row = !params || params.length === 0 ? statement.get() : statement.get(...params);
+            return row ?? null;
+        },
+        all(sql, params) {
+            const statement = cachedStatementFor(sql);
+            const rows = !params || params.length === 0 ? statement.all() : statement.all(...params);
+            return Array.isArray(rows) ? rows : [];
+        },
+        close() {
+            statementCache.clear();
+            try {
+                db.close();
+            }
+            finally {
+                onClose?.();
+            }
+        }
+    };
+}
+function pragmaEntries(options) {
+    return Object.entries(mergePragmas(options.pragmas));
+}
+function mergePragmas(pragmas) {
+    return {
+        ...DEFAULT_SQLITE_PRAGMAS,
+        ...(pragmas ?? {})
+    };
+}
+const ALLOWED_SQLITE_PRAGMA_LIST = Object.keys(ALLOWED_SQLITE_PRAGMAS).sort().join(', ');
+function normalizePragmaKey(rawKey) {
+    const key = rawKey.trim().toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(ALLOWED_SQLITE_PRAGMAS, key)) {
+        throw new Error(`unsupported sqlite pragma "${rawKey}". Allowed pragmas: ${ALLOWED_SQLITE_PRAGMA_LIST}`);
+    }
+    return key;
+}
+function normalizePragmaToken(key, rawValue) {
+    const value = rawValue.trim();
+    if (value.length === 0 || !SQLITE_PRAGMA_TOKEN_PATTERN.test(value)) {
+        throw new Error(`invalid sqlite pragma "${key}" value "${rawValue}". Allowed token pattern: ${SQLITE_PRAGMA_TOKEN_PATTERN}`);
+    }
+    return value;
+}
+function normalizePragmaValue(key, rawValue) {
+    const kind = ALLOWED_SQLITE_PRAGMAS[key];
+    if (kind === 'int') {
+        if (typeof rawValue !== 'number') {
+            throw new Error(`sqlite pragma "${key}" must be a number`);
+        }
+        return String((0, primitives_1.toSafeNumber)(rawValue, `sqlite pragma "${key}"`));
+    }
+    if (kind === 'token') {
+        if (typeof rawValue !== 'string') {
+            throw new Error(`sqlite pragma "${key}" must be a string token`);
+        }
+        return normalizePragmaToken(key, rawValue);
+    }
+    if (typeof rawValue === 'number') {
+        return String((0, primitives_1.toSafeNumber)(rawValue, `sqlite pragma "${key}"`));
+    }
+    return normalizePragmaToken(key, rawValue);
+}
+function applyPragmas(db, options) {
+    for (const [rawKey, rawValue] of pragmaEntries(options)) {
+        const key = normalizePragmaKey(rawKey);
+        const value = normalizePragmaValue(key, rawValue);
+        const statement = `${key}=${value}`;
+        if (db.pragma) {
+            db.pragma(statement);
+            continue;
+        }
+        db.exec(`PRAGMA ${statement}`);
+    }
+}
+function closeDatabaseSafely(db) {
+    try {
+        db.close();
+    }
+    catch {
+        return;
+    }
+}
+async function openBetterSqlite(options, onClose) {
+    let loaded;
+    try {
+        loaded = await Promise.resolve(`${BETTER_SQLITE3_MODULE}`).then(s => __importStar(require(s)));
+    }
+    catch {
+        throw new Error('optional dependency "better-sqlite3" is not installed. Install with: npm i better-sqlite3');
+    }
+    const Database = asConstructor(loaded);
+    const db = new Database(options.path);
+    try {
+        applyPragmas(db, options);
+    }
+    catch (error) {
+        closeDatabaseSafely(db);
+        throw error;
+    }
+    return wrapConnection(db, 'better-sqlite3', onClose);
+}
+async function openBunSqlite(options, onClose) {
+    let loaded;
+    try {
+        loaded = await Promise.resolve(`${BUN_SQLITE_MODULE}`).then(s => __importStar(require(s)));
+    }
+    catch {
+        throw new Error('bun runtime sqlite module "bun:sqlite" is unavailable. Run this in Bun or set storage.sqlite.driver to "better-sqlite3".');
+    }
+    if (!loaded || typeof loaded !== 'object') {
+        throw new Error('invalid bun sqlite module export');
+    }
+    const ctor = loaded.Database;
+    if (typeof ctor !== 'function') {
+        throw new Error('invalid bun sqlite module export');
+    }
+    const db = new ctor(options.path);
+    try {
+        applyPragmas(db, options);
+    }
+    catch (error) {
+        closeDatabaseSafely(db);
+        throw error;
+    }
+    return wrapConnection(db, 'bun', onClose);
+}
+function resolveDriver(requested) {
+    if (requested && requested !== 'auto') {
+        return requested;
+    }
+    return (0, runtime_1.isBunRuntime)() ? 'bun' : 'better-sqlite3';
+}
+async function openSqliteConnection(options) {
+    const driver = resolveDriver(options.driver);
+    const normalizedOptions = {
+        ...options,
+        driver,
+        pragmas: mergePragmas(options.pragmas)
+    };
+    const cacheKey = `${driver}|${options.path}|${Object.entries(normalizedOptions.pragmas ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(';')}`;
+    const cached = SQLITE_CONNECTION_CACHE.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const onClose = () => {
+        SQLITE_CONNECTION_CACHE.delete(cacheKey);
+    };
+    const created = driver === 'bun'
+        ? openBunSqlite(normalizedOptions, onClose)
+        : openBetterSqlite(normalizedOptions, onClose);
+    const guarded = created.catch((error) => {
+        SQLITE_CONNECTION_CACHE.delete(cacheKey);
+        throw error;
+    });
+    SQLITE_CONNECTION_CACHE.set(cacheKey, guarded);
+    return guarded;
+}
+const SQLITE_CONNECTION_CACHE = new Map();

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaContactSqliteStore = void 0;
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const coercion_1 = require("../../../util/coercion");
+function decodeContactRow(row) {
+    return {
+        jid: (0, coercion_1.asString)(row.jid, 'mailbox_contacts.jid'),
+        displayName: (0, coercion_1.asOptionalString)(row.display_name, 'mailbox_contacts.display_name'),
+        pushName: (0, coercion_1.asOptionalString)(row.push_name, 'mailbox_contacts.push_name'),
+        lid: (0, coercion_1.asOptionalString)(row.lid, 'mailbox_contacts.lid'),
+        phoneNumber: (0, coercion_1.asOptionalString)(row.phone_number, 'mailbox_contacts.phone_number'),
+        lastUpdatedMs: (0, coercion_1.asNumber)(row.last_updated_ms, 'mailbox_contacts.last_updated_ms')
+    };
+}
+class WaContactSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
+    constructor(options) {
+        super(options, ['mailbox']);
+    }
+    async upsert(record) {
+        const db = await this.getConnection();
+        db.run(`INSERT INTO mailbox_contacts (
+                session_id,
+                jid,
+                display_name,
+                push_name,
+                lid,
+                phone_number,
+                last_updated_ms
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, jid) DO UPDATE SET
+                display_name=COALESCE(excluded.display_name, mailbox_contacts.display_name),
+                push_name=COALESCE(excluded.push_name, mailbox_contacts.push_name),
+                lid=COALESCE(excluded.lid, mailbox_contacts.lid),
+                phone_number=COALESCE(excluded.phone_number, mailbox_contacts.phone_number),
+                last_updated_ms=excluded.last_updated_ms`, [
+            this.options.sessionId,
+            record.jid,
+            record.displayName ?? null,
+            record.pushName ?? null,
+            record.lid ?? null,
+            record.phoneNumber ?? null,
+            record.lastUpdatedMs
+        ]);
+    }
+    async getByJid(jid) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT jid, display_name, push_name, lid, phone_number, last_updated_ms
+             FROM mailbox_contacts
+             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
+        return row ? decodeContactRow(row) : null;
+    }
+    async deleteByJid(jid) {
+        const db = await this.getConnection();
+        db.run(`DELETE FROM mailbox_contacts
+             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_contacts WHERE session_id = ?', [this.options.sessionId]);
+    }
+}
+exports.WaContactSqliteStore = WaContactSqliteStore;

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaDeviceListSqliteStore = void 0;
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const coercion_1 = require("../../../util/coercion");
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    batchSize: 500
+});
+class WaDeviceListSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
+    constructor(options, ttlMs = DEFAULTS.ttlMs, batchSize) {
+        super(options, ['deviceList']);
+        this.ttlMs = ttlMs;
+        this.batchSize = (0, coercion_1.resolvePositive)(batchSize, DEFAULTS.batchSize, 'deviceList.sqlite.batchSize');
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertUserDevices(snapshot) {
+        const db = await this.getConnection();
+        this.upsertUserDevicesRow(db, snapshot);
+    }
+    async upsertUserDevicesBatch(snapshots) {
+        if (snapshots.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const snapshot of snapshots) {
+                this.upsertUserDevicesRow(db, snapshot);
+            }
+        });
+    }
+    async getUserDevices(userJid, nowMs = Date.now()) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT user_jid, device_jids_json, updated_at_ms, expires_at_ms
+             FROM device_list_cache
+             WHERE session_id = ? AND user_jid = ?`, [this.options.sessionId, userJid]);
+        if (!row) {
+            return null;
+        }
+        const expiresAtMs = (0, coercion_1.asNumber)(row.expires_at_ms, 'device_list_cache.expires_at_ms');
+        if (expiresAtMs <= nowMs) {
+            db.run(`DELETE FROM device_list_cache
+                 WHERE session_id = ? AND user_jid = ?`, [this.options.sessionId, userJid]);
+            return null;
+        }
+        return {
+            userJid: (0, coercion_1.asString)(row.user_jid, 'device_list_cache.user_jid'),
+            deviceJids: decodeDeviceJids(row.device_jids_json),
+            updatedAtMs: (0, coercion_1.asNumber)(row.updated_at_ms, 'device_list_cache.updated_at_ms')
+        };
+    }
+    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
+        if (userJids.length === 0) {
+            return [];
+        }
+        const uniqueUserJids = [...new Set(userJids)];
+        return this.withTransaction((db) => {
+            const activeByUserJid = new Map();
+            const expiredUserJids = [];
+            for (let start = 0; start < uniqueUserJids.length; start += this.batchSize) {
+                const end = Math.min(start + this.batchSize, uniqueUserJids.length);
+                const batchLength = end - start;
+                const placeholders = new Array(batchLength).fill('?').join(', ');
+                const params = [this.options.sessionId];
+                for (let index = start; index < end; index += 1) {
+                    params.push(uniqueUserJids[index]);
+                }
+                const rows = db.all(`SELECT user_jid, device_jids_json, updated_at_ms, expires_at_ms
+                     FROM device_list_cache
+                     WHERE session_id = ? AND user_jid IN (${placeholders})`, params);
+                for (const row of rows) {
+                    const userJid = (0, coercion_1.asString)(row.user_jid, 'device_list_cache.user_jid');
+                    const expiresAtMs = (0, coercion_1.asNumber)(row.expires_at_ms, 'device_list_cache.expires_at_ms');
+                    if (expiresAtMs <= nowMs) {
+                        expiredUserJids.push(userJid);
+                        continue;
+                    }
+                    activeByUserJid.set(userJid, {
+                        userJid,
+                        deviceJids: decodeDeviceJids(row.device_jids_json),
+                        updatedAtMs: (0, coercion_1.asNumber)(row.updated_at_ms, 'device_list_cache.updated_at_ms')
+                    });
+                }
+            }
+            if (expiredUserJids.length > 0) {
+                this.deleteUserDevicesByJids(db, expiredUserJids);
+            }
+            return userJids.map((userJid) => activeByUserJid.get(userJid) ?? null);
+        });
+    }
+    async deleteUserDevices(userJid) {
+        const db = await this.getConnection();
+        db.run(`DELETE FROM device_list_cache
+             WHERE session_id = ? AND user_jid = ?`, [this.options.sessionId, userJid]);
+        const row = db.get('SELECT changes() AS total', []);
+        return row ? Number(row.total) : 0;
+    }
+    async cleanupExpired(nowMs) {
+        const db = await this.getConnection();
+        db.run(`DELETE FROM device_list_cache
+             WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
+        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 device_list_cache WHERE session_id = ?', [this.options.sessionId]);
+    }
+    upsertUserDevicesRow(db, snapshot) {
+        db.run(`INSERT INTO device_list_cache (
+                session_id,
+                user_jid,
+                device_jids_json,
+                updated_at_ms,
+                expires_at_ms
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, user_jid) DO UPDATE SET
+                device_jids_json=excluded.device_jids_json,
+                updated_at_ms=excluded.updated_at_ms,
+                expires_at_ms=excluded.expires_at_ms`, [
+            this.options.sessionId,
+            snapshot.userJid,
+            JSON.stringify(snapshot.deviceJids),
+            snapshot.updatedAtMs,
+            snapshot.updatedAtMs + this.ttlMs
+        ]);
+    }
+    deleteUserDevicesByJids(db, userJids) {
+        if (userJids.length === 0) {
+            return;
+        }
+        for (let start = 0; start < userJids.length; start += this.batchSize) {
+            const end = Math.min(start + this.batchSize, userJids.length);
+            const batchLength = end - start;
+            const placeholders = new Array(batchLength).fill('?').join(', ');
+            const params = [this.options.sessionId];
+            for (let index = start; index < end; index += 1) {
+                params.push(userJids[index]);
+            }
+            db.run(`DELETE FROM device_list_cache
+                 WHERE session_id = ? AND user_jid IN (${placeholders})`, params);
+        }
+    }
+}
+exports.WaDeviceListSqliteStore = WaDeviceListSqliteStore;
+function decodeDeviceJids(raw) {
+    const json = (0, coercion_1.asString)(raw, 'device_list_cache.device_jids_json');
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed)) {
+        throw new Error('device_list_cache.device_jids_json must be an array');
+    }
+    return parsed.filter((entry) => {
+        if (typeof entry !== 'string') {
+            throw new Error('device_list_cache.device_jids_json entry must be string');
+        }
+        return true;
+    });
+}