zapo-js 0.1.2 → 0.2.0

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;
-        }
-    }
-}

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

@@ -1,77 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asNumber, asString } from '../../../util/coercion.js';
-const DEFAULT_PARTICIPANTS_TTL_MS = 5 * 60 * 1000;
-export class WaParticipantsSqliteStore extends BaseSqliteStore {
-    constructor(options, ttlMs = DEFAULT_PARTICIPANTS_TTL_MS) {
-        super(options, ['participants']);
-        this.ttlMs = ttlMs;
-    }
-    async upsertGroupParticipants(snapshot) {
-        const db = await this.getConnection();
-        db.run(`INSERT INTO group_participants_cache (
-                session_id,
-                group_jid,
-                participants_json,
-                updated_at_ms,
-                expires_at_ms
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, group_jid) DO UPDATE SET
-                participants_json=excluded.participants_json,
-                updated_at_ms=excluded.updated_at_ms,
-                expires_at_ms=excluded.expires_at_ms`, [
-            this.options.sessionId,
-            snapshot.groupJid,
-            JSON.stringify(snapshot.participants),
-            snapshot.updatedAtMs,
-            snapshot.updatedAtMs + this.ttlMs
-        ]);
-    }
-    async getGroupParticipants(groupJid, nowMs = Date.now()) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT group_jid, participants_json, updated_at_ms, expires_at_ms
-             FROM group_participants_cache
-             WHERE session_id = ? AND group_jid = ?`, [this.options.sessionId, groupJid]);
-        if (!row) {
-            return null;
-        }
-        const expiresAtMs = asNumber(row.expires_at_ms, 'group_participants_cache.expires_at_ms');
-        if (expiresAtMs <= nowMs) {
-            db.run(`DELETE FROM group_participants_cache
-                 WHERE session_id = ? AND group_jid = ?`, [this.options.sessionId, groupJid]);
-            return null;
-        }
-        return {
-            groupJid: asString(row.group_jid, 'group_participants_cache.group_jid'),
-            participants: decodeParticipants(row.participants_json),
-            updatedAtMs: asNumber(row.updated_at_ms, 'group_participants_cache.updated_at_ms')
-        };
-    }
-    async deleteGroupParticipants(groupJid) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM group_participants_cache
-             WHERE session_id = ? AND group_jid = ?`, [this.options.sessionId, groupJid]);
-        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 group_participants_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 group_participants_cache WHERE session_id = ?', [
-            this.options.sessionId
-        ]);
-    }
-}
-function decodeParticipants(raw) {
-    const json = asString(raw, 'group_participants_cache.participants_json');
-    const parsed = JSON.parse(json);
-    if (!Array.isArray(parsed)) {
-        throw new Error('group_participants_cache.participants_json must be an array');
-    }
-    return parsed.map((entry) => asString(entry, 'group_participants_cache.participants_json entry'));
-}

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

@@ -1,141 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asBytes, asNumber, asOptionalString, asString } from '../../../util/coercion.js';
-const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-export class WaRetrySqliteStore extends BaseSqliteStore {
-    constructor(options, ttlMs = DEFAULT_RETRY_TTL_MS) {
-        super(options, ['retry']);
-        this.ttlMs = ttlMs;
-    }
-    getTtlMs() {
-        return this.ttlMs;
-    }
-    async upsertOutboundMessage(record) {
-        const db = await this.getConnection();
-        db.run(`INSERT INTO retry_outbound_messages (
-                session_id,
-                message_id,
-                to_jid,
-                participant_jid,
-                recipient_jid,
-                message_type,
-                replay_mode,
-                replay_payload,
-                state,
-                created_at_ms,
-                updated_at_ms,
-                expires_at_ms
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, message_id) DO UPDATE SET
-                to_jid=excluded.to_jid,
-                participant_jid=excluded.participant_jid,
-                recipient_jid=excluded.recipient_jid,
-                message_type=excluded.message_type,
-                replay_mode=excluded.replay_mode,
-                replay_payload=excluded.replay_payload,
-                state=excluded.state,
-                created_at_ms=excluded.created_at_ms,
-                updated_at_ms=excluded.updated_at_ms,
-                expires_at_ms=excluded.expires_at_ms`, [
-            this.options.sessionId,
-            record.messageId,
-            record.toJid,
-            record.participantJid ?? null,
-            record.recipientJid ?? null,
-            record.messageType,
-            record.replayMode,
-            record.replayPayload,
-            record.state,
-            record.createdAtMs,
-            record.updatedAtMs,
-            record.expiresAtMs
-        ]);
-    }
-    async getOutboundMessage(messageId) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT
-                message_id,
-                to_jid,
-                participant_jid,
-                recipient_jid,
-                message_type,
-                replay_mode,
-                replay_payload,
-                state,
-                created_at_ms,
-                updated_at_ms,
-                expires_at_ms
-            FROM retry_outbound_messages
-            WHERE session_id = ? AND message_id = ?`, [this.options.sessionId, messageId]);
-        if (!row) {
-            return null;
-        }
-        return {
-            messageId: asString(row.message_id, 'retry_outbound_messages.message_id'),
-            toJid: asString(row.to_jid, 'retry_outbound_messages.to_jid'),
-            participantJid: asOptionalString(row.participant_jid, 'retry_outbound_messages.participant_jid'),
-            recipientJid: asOptionalString(row.recipient_jid, 'retry_outbound_messages.recipient_jid'),
-            messageType: asString(row.message_type, 'retry_outbound_messages.message_type'),
-            replayMode: asString(row.replay_mode, 'retry_outbound_messages.replay_mode'),
-            replayPayload: asBytes(row.replay_payload, 'retry_outbound_messages.replay_payload'),
-            state: asString(row.state, 'retry_outbound_messages.state'),
-            createdAtMs: asNumber(row.created_at_ms, 'retry_outbound_messages.created_at_ms'),
-            updatedAtMs: asNumber(row.updated_at_ms, 'retry_outbound_messages.updated_at_ms'),
-            expiresAtMs: asNumber(row.expires_at_ms, 'retry_outbound_messages.expires_at_ms')
-        };
-    }
-    async updateOutboundMessageState(messageId, state, updatedAtMs, expiresAtMs) {
-        const db = await this.getConnection();
-        db.run(`UPDATE retry_outbound_messages
-             SET state = ?, updated_at_ms = ?, expires_at_ms = ?
-             WHERE session_id = ? AND message_id = ?`, [state, updatedAtMs, expiresAtMs, this.options.sessionId, messageId]);
-    }
-    async incrementInboundCounter(messageId, requesterJid, updatedAtMs, expiresAtMs) {
-        const db = await this.getConnection();
-        db.run(`INSERT INTO retry_inbound_counters (
-                session_id,
-                message_id,
-                requester_jid,
-                retry_count,
-                updated_at_ms,
-                expires_at_ms
-            ) VALUES (?, ?, ?, 1, ?, ?)
-            ON CONFLICT(session_id, message_id, requester_jid) DO UPDATE SET
-                retry_count=retry_inbound_counters.retry_count + 1,
-                updated_at_ms=excluded.updated_at_ms,
-                expires_at_ms=excluded.expires_at_ms`, [this.options.sessionId, messageId, requesterJid, updatedAtMs, expiresAtMs]);
-        const row = db.get(`SELECT retry_count
-             FROM retry_inbound_counters
-             WHERE session_id = ? AND message_id = ? AND requester_jid = ?`, [this.options.sessionId, messageId, requesterJid]);
-        if (!row) {
-            return 1;
-        }
-        return asNumber(row.retry_count, 'retry_inbound_counters.retry_count');
-    }
-    async cleanupExpired(nowMs) {
-        return this.withTransaction(async (db) => {
-            db.run(`DELETE FROM retry_outbound_messages
-                 WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
-            const outboundCountRow = db.get('SELECT changes() AS total', []);
-            const outboundCount = outboundCountRow
-                ? asNumber(outboundCountRow.total, 'retry_outbound_messages.changes')
-                : 0;
-            db.run(`DELETE FROM retry_inbound_counters
-                 WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
-            const inboundCountRow = db.get('SELECT changes() AS total', []);
-            const inboundCount = inboundCountRow
-                ? asNumber(inboundCountRow.total, 'retry_inbound_counters.changes')
-                : 0;
-            return outboundCount + inboundCount;
-        });
-    }
-    async clear() {
-        await this.withTransaction((db) => {
-            db.run('DELETE FROM retry_outbound_messages WHERE session_id = ?', [
-                this.options.sessionId
-            ]);
-            db.run('DELETE FROM retry_inbound_counters WHERE session_id = ?', [
-                this.options.sessionId
-            ]);
-        });
-    }
-}