zapo-js 0.1.0

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

@@ -0,0 +1,61 @@
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asNumber, asOptionalString, asString } from '../../../util/coercion.js';
+function decodeContactRow(row) {
+    return {
+        jid: asString(row.jid, 'mailbox_contacts.jid'),
+        displayName: asOptionalString(row.display_name, 'mailbox_contacts.display_name'),
+        pushName: asOptionalString(row.push_name, 'mailbox_contacts.push_name'),
+        lid: asOptionalString(row.lid, 'mailbox_contacts.lid'),
+        phoneNumber: asOptionalString(row.phone_number, 'mailbox_contacts.phone_number'),
+        lastUpdatedMs: asNumber(row.last_updated_ms, 'mailbox_contacts.last_updated_ms')
+    };
+}
+export class WaContactSqliteStore extends 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]);
+    }
+}

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

@@ -0,0 +1,155 @@
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asNumber, asString, resolvePositive } from '../../../util/coercion.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    batchSize: 500
+});
+export class WaDeviceListSqliteStore extends BaseSqliteStore {
+    constructor(options, ttlMs = DEFAULTS.ttlMs, batchSize) {
+        super(options, ['deviceList']);
+        this.ttlMs = ttlMs;
+        this.batchSize = 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 = 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: asString(row.user_jid, 'device_list_cache.user_jid'),
+            deviceJids: decodeDeviceJids(row.device_jids_json),
+            updatedAtMs: 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 = asString(row.user_jid, 'device_list_cache.user_jid');
+                    const expiresAtMs = 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: 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);
+        }
+    }
+}
+function decodeDeviceJids(raw) {
+    const json = 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;
+    });
+}

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

@@ -0,0 +1,119 @@
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asOptionalBytes, asOptionalNumber, asOptionalString, asString } from '../../../util/coercion.js';
+import { normalizeQueryLimit } from '../../../util/collections.js';
+function decodeMessageRow(row) {
+    return {
+        id: asString(row.message_id, 'mailbox_messages.message_id'),
+        threadJid: asString(row.thread_jid, 'mailbox_messages.thread_jid'),
+        senderJid: asOptionalString(row.sender_jid, 'mailbox_messages.sender_jid'),
+        participantJid: asOptionalString(row.participant_jid, 'mailbox_messages.participant_jid'),
+        fromMe: Number(row.from_me) === 1,
+        timestampMs: asOptionalNumber(row.timestamp_ms, 'mailbox_messages.timestamp_ms'),
+        encType: asOptionalString(row.enc_type, 'mailbox_messages.enc_type'),
+        plaintext: asOptionalBytes(row.plaintext, 'mailbox_messages.plaintext'),
+        messageBytes: asOptionalBytes(row.message_bytes, 'mailbox_messages.message_bytes')
+    };
+}
+export class WaMessageSqliteStore extends BaseSqliteStore {
+    constructor(options) {
+        super(options, ['mailbox']);
+    }
+    async upsert(record) {
+        const db = await this.getConnection();
+        db.run(`INSERT INTO mailbox_messages (
+                session_id,
+                message_id,
+                thread_jid,
+                sender_jid,
+                participant_jid,
+                from_me,
+                timestamp_ms,
+                enc_type,
+                plaintext,
+                message_bytes
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, message_id) DO UPDATE SET
+                thread_jid=excluded.thread_jid,
+                sender_jid=excluded.sender_jid,
+                participant_jid=excluded.participant_jid,
+                from_me=excluded.from_me,
+                timestamp_ms=excluded.timestamp_ms,
+                enc_type=excluded.enc_type,
+                plaintext=excluded.plaintext,
+                message_bytes=excluded.message_bytes`, [
+            this.options.sessionId,
+            record.id,
+            record.threadJid,
+            record.senderJid ?? null,
+            record.participantJid ?? null,
+            record.fromMe ? 1 : 0,
+            record.timestampMs ?? null,
+            record.encType ?? null,
+            record.plaintext ?? null,
+            record.messageBytes ?? null
+        ]);
+    }
+    async getById(id) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT
+                message_id,
+                thread_jid,
+                sender_jid,
+                participant_jid,
+                from_me,
+                timestamp_ms,
+                enc_type,
+                plaintext,
+                message_bytes
+             FROM mailbox_messages
+             WHERE session_id = ? AND message_id = ?`, [this.options.sessionId, id]);
+        return row ? decodeMessageRow(row) : null;
+    }
+    async listByThread(threadJid, limit, beforeTimestampMs) {
+        const db = await this.getConnection();
+        const normalizedLimit = normalizeQueryLimit(limit, 50);
+        const rows = beforeTimestampMs === undefined
+            ? db.all(`SELECT
+                          message_id,
+                          thread_jid,
+                          sender_jid,
+                          participant_jid,
+                          from_me,
+                          timestamp_ms,
+                          enc_type,
+                          plaintext,
+                          message_bytes
+                       FROM mailbox_messages
+                       WHERE session_id = ? AND thread_jid = ?
+                       ORDER BY timestamp_ms DESC, message_id DESC
+                       LIMIT ?`, [this.options.sessionId, threadJid, normalizedLimit])
+            : db.all(`SELECT
+                          message_id,
+                          thread_jid,
+                          sender_jid,
+                          participant_jid,
+                          from_me,
+                          timestamp_ms,
+                          enc_type,
+                          plaintext,
+                          message_bytes
+                       FROM mailbox_messages
+                       WHERE session_id = ?
+                         AND thread_jid = ?
+                         AND timestamp_ms < ?
+                       ORDER BY timestamp_ms DESC, message_id DESC
+                       LIMIT ?`, [this.options.sessionId, threadJid, beforeTimestampMs, normalizedLimit]);
+        return rows.map(decodeMessageRow);
+    }
+    async deleteById(id) {
+        const db = await this.getConnection();
+        db.run(`DELETE FROM mailbox_messages
+             WHERE session_id = ? AND message_id = ?`, [this.options.sessionId, id]);
+        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_messages WHERE session_id = ?', [this.options.sessionId]);
+    }
+}

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

@@ -0,0 +1,347 @@
+const SQLITE_MIGRATIONS = [
+    {
+        id: '0001_auth_credentials_schema',
+        domain: 'auth',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS auth_credentials (
+                    session_id TEXT PRIMARY KEY,
+                    noise_pub_key BLOB NOT NULL,
+                    noise_priv_key BLOB NOT NULL,
+                    registration_id INTEGER NOT NULL,
+                    identity_pub_key BLOB NOT NULL,
+                    identity_priv_key BLOB NOT NULL,
+                    signed_prekey_id INTEGER NOT NULL,
+                    signed_prekey_pub_key BLOB NOT NULL,
+                    signed_prekey_priv_key BLOB NOT NULL,
+                    signed_prekey_signature BLOB NOT NULL,
+                    adv_secret_key BLOB NOT NULL,
+                    signed_identity BLOB,
+                    me_jid TEXT,
+                    me_lid TEXT,
+                    me_display_name TEXT,
+                    companion_enc_static BLOB,
+                    platform TEXT,
+                    server_static_key BLOB,
+                    server_has_prekeys INTEGER,
+                    routing_info BLOB,
+                    last_success_ts INTEGER,
+                    props_version INTEGER,
+                    ab_props_version INTEGER,
+                    connection_location TEXT,
+                    account_creation_ts INTEGER
+                );
+            `);
+        }
+    },
+    {
+        id: '0001_signal_schema',
+        domain: 'signal',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS signal_meta (
+                    session_id TEXT PRIMARY KEY,
+                    server_has_prekeys INTEGER NOT NULL DEFAULT 0,
+                    next_prekey_id INTEGER NOT NULL DEFAULT 1
+                );
+
+                CREATE TABLE IF NOT EXISTS signal_registration (
+                    session_id TEXT PRIMARY KEY,
+                    registration_id INTEGER NOT NULL,
+                    identity_pub_key BLOB NOT NULL,
+                    identity_priv_key BLOB NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS signal_signed_prekey (
+                    session_id TEXT PRIMARY KEY,
+                    key_id INTEGER NOT NULL,
+                    pub_key BLOB NOT NULL,
+                    priv_key BLOB NOT NULL,
+                    signature BLOB NOT NULL,
+                    uploaded INTEGER NOT NULL DEFAULT 0
+                );
+
+                CREATE TABLE IF NOT EXISTS signal_prekey (
+                    session_id TEXT NOT NULL,
+                    key_id INTEGER NOT NULL,
+                    pub_key BLOB NOT NULL,
+                    priv_key BLOB NOT NULL,
+                    uploaded INTEGER NOT NULL DEFAULT 0,
+                    PRIMARY KEY (session_id, key_id)
+                );
+
+                CREATE TABLE IF NOT EXISTS signal_session (
+                    session_id TEXT NOT NULL,
+                    user TEXT NOT NULL,
+                    server TEXT NOT NULL,
+                    device INTEGER NOT NULL,
+                    record BLOB NOT NULL,
+                    PRIMARY KEY (session_id, user, server, device)
+                );
+
+                CREATE TABLE IF NOT EXISTS signal_identity (
+                    session_id TEXT NOT NULL,
+                    user TEXT NOT NULL,
+                    server TEXT NOT NULL,
+                    device INTEGER NOT NULL,
+                    identity_key BLOB NOT NULL,
+                    PRIMARY KEY (session_id, user, server, device)
+                );
+            `);
+        }
+    },
+    {
+        id: '0001_sender_key_schema',
+        domain: 'senderKey',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS sender_keys (
+                    session_id TEXT NOT NULL,
+                    group_id TEXT NOT NULL,
+                    sender_user TEXT NOT NULL,
+                    sender_server TEXT NOT NULL,
+                    sender_device INTEGER NOT NULL,
+                    record BLOB NOT NULL,
+                    PRIMARY KEY (session_id, group_id, sender_user, sender_server, sender_device)
+                );
+
+                CREATE TABLE IF NOT EXISTS sender_key_distribution (
+                    session_id TEXT NOT NULL,
+                    group_id TEXT NOT NULL,
+                    sender_user TEXT NOT NULL,
+                    sender_server TEXT NOT NULL,
+                    sender_device INTEGER NOT NULL,
+                    key_id INTEGER NOT NULL,
+                    timestamp_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, group_id, sender_user, sender_server, sender_device)
+                );
+            `);
+        }
+    },
+    {
+        id: '0001_appstate_schema',
+        domain: 'appState',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS appstate_sync_keys (
+                    session_id TEXT NOT NULL,
+                    key_id BLOB NOT NULL,
+                    key_data BLOB NOT NULL,
+                    timestamp INTEGER NOT NULL,
+                    fingerprint BLOB,
+                    key_epoch INTEGER,
+                    PRIMARY KEY (session_id, key_id)
+                );
+
+                CREATE TABLE IF NOT EXISTS appstate_collection_versions (
+                    session_id TEXT NOT NULL,
+                    collection TEXT NOT NULL,
+                    version INTEGER NOT NULL,
+                    hash BLOB NOT NULL,
+                    PRIMARY KEY (session_id, collection)
+                );
+
+                CREATE TABLE IF NOT EXISTS appstate_collection_index_values (
+                    session_id TEXT NOT NULL,
+                    collection TEXT NOT NULL,
+                    index_mac_hex TEXT NOT NULL,
+                    value_mac BLOB NOT NULL,
+                    PRIMARY KEY (session_id, collection, index_mac_hex)
+                );
+            `);
+        }
+    },
+    {
+        id: '0003_retry_message_schema',
+        domain: 'retry',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS retry_outbound_messages (
+                    session_id TEXT NOT NULL,
+                    message_id TEXT NOT NULL,
+                    to_jid TEXT NOT NULL,
+                    participant_jid TEXT,
+                    recipient_jid TEXT,
+                    message_type TEXT NOT NULL,
+                    replay_mode TEXT NOT NULL,
+                    replay_payload BLOB NOT NULL,
+                    state TEXT NOT NULL,
+                    created_at_ms INTEGER NOT NULL,
+                    updated_at_ms INTEGER NOT NULL,
+                    expires_at_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, message_id)
+                );
+
+                CREATE INDEX IF NOT EXISTS retry_outbound_messages_by_expiry
+                    ON retry_outbound_messages (session_id, expires_at_ms);
+                CREATE INDEX IF NOT EXISTS retry_outbound_messages_by_state
+                    ON retry_outbound_messages (session_id, state);
+
+                CREATE TABLE IF NOT EXISTS retry_inbound_counters (
+                    session_id TEXT NOT NULL,
+                    message_id TEXT NOT NULL,
+                    requester_jid TEXT NOT NULL,
+                    retry_count INTEGER NOT NULL,
+                    updated_at_ms INTEGER NOT NULL,
+                    expires_at_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, message_id, requester_jid)
+                );
+
+                CREATE INDEX IF NOT EXISTS retry_inbound_counters_by_expiry
+                    ON retry_inbound_counters (session_id, expires_at_ms);
+            `);
+        }
+    },
+    {
+        id: '0004_mailbox_schema',
+        domain: 'mailbox',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS mailbox_messages (
+                    session_id TEXT NOT NULL,
+                    message_id TEXT NOT NULL,
+                    thread_jid TEXT NOT NULL,
+                    sender_jid TEXT,
+                    participant_jid TEXT,
+                    from_me INTEGER NOT NULL,
+                    timestamp_ms INTEGER,
+                    enc_type TEXT,
+                    plaintext BLOB,
+                    message_bytes BLOB,
+                    PRIMARY KEY (session_id, message_id)
+                );
+
+                CREATE INDEX IF NOT EXISTS mailbox_messages_by_thread_timestamp
+                    ON mailbox_messages (session_id, thread_jid, timestamp_ms DESC);
+
+                CREATE TABLE IF NOT EXISTS mailbox_threads (
+                    session_id TEXT NOT NULL,
+                    jid TEXT NOT NULL,
+                    name TEXT,
+                    unread_count INTEGER,
+                    archived INTEGER,
+                    pinned INTEGER,
+                    mute_end_ms INTEGER,
+                    marked_as_unread INTEGER,
+                    ephemeral_expiration INTEGER,
+                    PRIMARY KEY (session_id, jid)
+                );
+
+                CREATE TABLE IF NOT EXISTS mailbox_contacts (
+                    session_id TEXT NOT NULL,
+                    jid TEXT NOT NULL,
+                    display_name TEXT,
+                    push_name TEXT,
+                    lid TEXT,
+                    phone_number TEXT,
+                    last_updated_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, jid)
+                );
+            `);
+        }
+    },
+    {
+        id: '0005_participants_cache_schema',
+        domain: 'participants',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS group_participants_cache (
+                    session_id TEXT NOT NULL,
+                    group_jid TEXT NOT NULL,
+                    participants_json TEXT NOT NULL,
+                    updated_at_ms INTEGER NOT NULL,
+                    expires_at_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, group_jid)
+                );
+
+                CREATE INDEX IF NOT EXISTS group_participants_cache_by_expiry
+                    ON group_participants_cache (session_id, expires_at_ms);
+            `);
+        }
+    },
+    {
+        id: '0006_device_list_cache_schema',
+        domain: 'deviceList',
+        up: (db) => {
+            db.exec(`
+                CREATE TABLE IF NOT EXISTS device_list_cache (
+                    session_id TEXT NOT NULL,
+                    user_jid TEXT NOT NULL,
+                    device_jids_json TEXT NOT NULL,
+                    updated_at_ms INTEGER NOT NULL,
+                    expires_at_ms INTEGER NOT NULL,
+                    PRIMARY KEY (session_id, user_jid)
+                );
+
+                CREATE INDEX IF NOT EXISTS device_list_cache_by_expiry
+                    ON device_list_cache (session_id, expires_at_ms);
+            `);
+        }
+    },
+    {
+        id: '0007_signal_signed_prekey_rotation_ts',
+        domain: 'signal',
+        up: (db) => {
+            db.exec(`
+                ALTER TABLE signal_meta
+                ADD COLUMN signed_prekey_rotation_ts INTEGER;
+            `);
+        }
+    }
+];
+function isMigrationAlreadyAppliedRace(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.includes('UNIQUE constraint failed: wa_migrations.id');
+}
+function ensureMigrationTable(db) {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS wa_migrations (
+            id TEXT PRIMARY KEY,
+            applied_at INTEGER NOT NULL
+        );
+    `);
+}
+function hasMigration(db, id) {
+    const row = db.get(`SELECT id
+         FROM wa_migrations
+         WHERE id = ?`, [id]);
+    return !!row;
+}
+function hasDomain(domainSet, migration) {
+    return domainSet.has(migration.domain);
+}
+export async function ensureSqliteMigrations(db, domains) {
+    ensureMigrationTable(db);
+    const domainSet = new Set(domains);
+    if (domainSet.size === 0) {
+        return;
+    }
+    for (const migration of SQLITE_MIGRATIONS) {
+        if (!hasDomain(domainSet, migration)) {
+            continue;
+        }
+        if (hasMigration(db, migration.id)) {
+            continue;
+        }
+        db.exec('BEGIN');
+        try {
+            if (hasMigration(db, migration.id)) {
+                db.exec('COMMIT');
+                continue;
+            }
+            db.run(`INSERT INTO wa_migrations (id, applied_at)
+                 VALUES (?, ?)`, [migration.id, Date.now()]);
+            migration.up(db);
+            db.exec('COMMIT');
+        }
+        catch (error) {
+            db.exec('ROLLBACK');
+            if (isMigrationAlreadyAppliedRace(error)) {
+                continue;
+            }
+            throw error;
+        }
+    }
+}