zapo-js 0.1.2 → 0.3.0

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

@@ -1,74 +0,0 @@
-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();
-        this.upsertContactRow(db, record);
-    }
-    async upsertBatch(records) {
-        if (records.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const record of records) {
-                this.upsertContactRow(db, record);
-            }
-        });
-    }
-    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]);
-    }
-    upsertContactRow(db, record) {
-        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
-        ]);
-    }
-}

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

@@ -1,127 +0,0 @@
-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');
-    }
-    async upsertUserDevicesBatch(snapshots) {
-        if (snapshots.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const snapshot of snapshots) {
-                this.upsertUserDevicesRow(db, snapshot);
-            }
-        });
-    }
-    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 = '?, '.repeat(batchLength).slice(0, -2);
-                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 = '?, '.repeat(batchLength).slice(0, -2);
-            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');
-    }
-    const deviceJids = new Array(parsed.length);
-    for (let index = 0; index < parsed.length; index += 1) {
-        deviceJids[index] = asString(parsed[index], 'device_list_cache.device_jids_json entry');
-    }
-    return deviceJids;
-}

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

@@ -1,132 +0,0 @@
-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();
-        this.upsertMessageRow(db, record);
-    }
-    async upsertBatch(records) {
-        if (records.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const record of records) {
-                this.upsertMessageRow(db, record);
-            }
-        });
-    }
-    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]);
-    }
-    upsertMessageRow(db, record) {
-        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
-        ]);
-    }
-}

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

@@ -1,347 +0,0 @@
-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 /UNIQUE constraint failed: [A-Za-z_][A-Za-z0-9_]*\.id/.test(error.message);
-}
-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;
-        }
-    }
-}