zapo-js 0.1.0

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

@@ -0,0 +1,85 @@
+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;
+    }
+    getTtlMs() {
+        return this.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.filter((entry) => {
+        if (typeof entry !== 'string') {
+            throw new Error('group_participants_cache.participants_json entry must be string');
+        }
+        return true;
+    });
+}

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

@@ -0,0 +1,144 @@
+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) => {
+            const outboundCount = this.countRows(db, 'retry_outbound_messages', nowMs);
+            const inboundCount = this.countRows(db, 'retry_inbound_counters', nowMs);
+            db.run(`DELETE FROM retry_outbound_messages
+                 WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
+            db.run(`DELETE FROM retry_inbound_counters
+                 WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
+            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
+            ]);
+        });
+    }
+    countRows(db, table, nowMs) {
+        const row = db.get(`SELECT COUNT(*) AS total
+             FROM ${table}
+             WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
+        if (!row) {
+            return 0;
+        }
+        return asNumber(row.total, `${table}.count`);
+    }
+}

package/dist/esm/store/providers/sqlite/sender-key.store.js

@@ -0,0 +1,203 @@
+import { decodeSenderKeyDistributionRow, decodeSenderKeyRecord, decodeSqliteCount, encodeSenderKeyRecord, toSignalAddressParts } from '../../../signal/store/sqlite.js';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asNumber, asString, resolvePositive } from '../../../util/coercion.js';
+const DEFAULTS = Object.freeze({
+    distributionBatchSize: 250
+});
+export class SenderKeySqliteStore extends BaseSqliteStore {
+    constructor(options, distributionBatchSize) {
+        super(options, ['senderKey']);
+        this.distributionBatchSize = resolvePositive(distributionBatchSize, DEFAULTS.distributionBatchSize, 'senderKey.sqlite.distributionBatchSize');
+    }
+    async upsertSenderKey(record) {
+        const db = await this.getConnection();
+        const sender = toSignalAddressParts(record.sender);
+        db.run(`INSERT INTO sender_keys (
+                session_id,
+                group_id,
+                sender_user,
+                sender_server,
+                sender_device,
+                record
+            ) VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, group_id, sender_user, sender_server, sender_device) DO UPDATE SET
+                record=excluded.record`, [
+            this.options.sessionId,
+            record.groupId,
+            sender.user,
+            sender.server,
+            sender.device,
+            encodeSenderKeyRecord(record)
+        ]);
+    }
+    async upsertSenderKeyDistribution(record) {
+        const db = await this.getConnection();
+        const sender = toSignalAddressParts(record.sender);
+        this.upsertSenderKeyDistributionRow(db, record, sender);
+    }
+    async upsertSenderKeyDistributions(records) {
+        if (records.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const record of records) {
+                const sender = toSignalAddressParts(record.sender);
+                this.upsertSenderKeyDistributionRow(db, record, sender);
+            }
+        });
+    }
+    async getGroupSenderKeyList(groupId) {
+        const db = await this.getConnection();
+        const senderRows = db.all(`SELECT group_id, sender_user, sender_server, sender_device, record
+             FROM sender_keys
+             WHERE session_id = ? AND group_id = ?`, [this.options.sessionId, groupId]);
+        const distributionRows = db.all(`SELECT group_id, sender_user, sender_server, sender_device, key_id, timestamp_ms
+             FROM sender_key_distribution
+             WHERE session_id = ? AND group_id = ?`, [this.options.sessionId, groupId]);
+        return {
+            skList: senderRows.map((row) => decodeSenderKeyRecord(row.record, asString(row.group_id, 'sender_keys.group_id'), {
+                user: asString(row.sender_user, 'sender_keys.sender_user'),
+                server: asString(row.sender_server, 'sender_keys.sender_server'),
+                device: asNumber(row.sender_device, 'sender_keys.sender_device')
+            })),
+            skDistribList: distributionRows.map((row) => decodeSenderKeyDistributionRow(row))
+        };
+    }
+    async getDeviceSenderKey(groupId, sender) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(sender);
+        const row = db.get(`SELECT group_id, sender_user, sender_server, sender_device, record
+             FROM sender_keys
+             WHERE session_id = ?
+               AND group_id = ?
+               AND sender_user = ?
+               AND sender_server = ?
+               AND sender_device = ?`, [this.options.sessionId, groupId, target.user, target.server, target.device]);
+        if (!row) {
+            return null;
+        }
+        return decodeSenderKeyRecord(row.record, asString(row.group_id, 'sender_keys.group_id'), {
+            user: asString(row.sender_user, 'sender_keys.sender_user'),
+            server: asString(row.sender_server, 'sender_keys.sender_server'),
+            device: asNumber(row.sender_device, 'sender_keys.sender_device')
+        });
+    }
+    async getDeviceSenderKeyDistribution(groupId, sender) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(sender);
+        const row = db.get(`SELECT group_id, sender_user, sender_server, sender_device, key_id, timestamp_ms
+             FROM sender_key_distribution
+             WHERE session_id = ?
+               AND group_id = ?
+               AND sender_user = ?
+               AND sender_server = ?
+               AND sender_device = ?`, [this.options.sessionId, groupId, target.user, target.server, target.device]);
+        return row ? decodeSenderKeyDistributionRow(row) : null;
+    }
+    async getDeviceSenderKeyDistributions(groupId, senders) {
+        if (senders.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const targets = senders.map((sender) => toSignalAddressParts(sender));
+        const map = new Map();
+        for (let start = 0; start < targets.length; start += this.distributionBatchSize) {
+            const end = Math.min(start + this.distributionBatchSize, targets.length);
+            const batchLength = end - start;
+            const filters = new Array(batchLength)
+                .fill('(sender_user = ? AND sender_server = ? AND sender_device = ?)')
+                .join(' OR ');
+            const params = [this.options.sessionId, groupId];
+            for (let index = start; index < end; index += 1) {
+                const target = targets[index];
+                params.push(target.user, target.server, target.device);
+            }
+            const rows = db.all(`SELECT group_id, sender_user, sender_server, sender_device, key_id, timestamp_ms
+                 FROM sender_key_distribution
+                 WHERE session_id = ? AND group_id = ? AND (${filters})`, params);
+            for (const row of rows) {
+                map.set(this.distributionRowKey(row), decodeSenderKeyDistributionRow(row));
+            }
+        }
+        return targets.map((target) => {
+            return (map.get(this.distributionTargetKey(target.user, target.server, target.device)) ??
+                null);
+        });
+    }
+    async deleteDeviceSenderKey(target, groupId) {
+        const sender = toSignalAddressParts(target);
+        return this.withTransaction((db) => {
+            const senderCount = this.countDelete(db, 'sender_keys', sender, groupId);
+            const distributionCount = this.countDelete(db, 'sender_key_distribution', sender, groupId);
+            return senderCount + distributionCount;
+        });
+    }
+    async markForgetSenderKey(groupId, participants) {
+        if (participants.length === 0) {
+            return 0;
+        }
+        return this.withTransaction(async (db) => {
+            let deleted = 0;
+            for (const participant of participants) {
+                const sender = toSignalAddressParts(participant);
+                deleted += this.countDelete(db, 'sender_keys', sender, groupId);
+                deleted += this.countDelete(db, 'sender_key_distribution', sender, groupId);
+            }
+            return deleted;
+        });
+    }
+    async clear() {
+        await this.withTransaction((db) => {
+            db.run('DELETE FROM sender_keys WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM sender_key_distribution WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
+        });
+    }
+    countDelete(db, table, target, groupId) {
+        const whereWithGroup = 'session_id = ? AND sender_user = ? AND sender_server = ? AND sender_device = ? AND group_id = ?';
+        const whereAllGroups = 'session_id = ? AND sender_user = ? AND sender_server = ? AND sender_device = ?';
+        const countRow = db.get(`SELECT COUNT(*) AS count
+             FROM ${table}
+             WHERE ${groupId ? whereWithGroup : whereAllGroups}`, groupId
+            ? [this.options.sessionId, target.user, target.server, target.device, groupId]
+            : [this.options.sessionId, target.user, target.server, target.device]);
+        const count = decodeSqliteCount(countRow, `${table}.count`);
+        if (count === 0) {
+            return 0;
+        }
+        db.run(`DELETE FROM ${table}
+             WHERE ${groupId ? whereWithGroup : whereAllGroups}`, groupId
+            ? [this.options.sessionId, target.user, target.server, target.device, groupId]
+            : [this.options.sessionId, target.user, target.server, target.device]);
+        return count;
+    }
+    upsertSenderKeyDistributionRow(db, record, sender) {
+        db.run(`INSERT INTO sender_key_distribution (
+                session_id,
+                group_id,
+                sender_user,
+                sender_server,
+                sender_device,
+                key_id,
+                timestamp_ms
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, group_id, sender_user, sender_server, sender_device) DO UPDATE SET
+                key_id=excluded.key_id,
+                timestamp_ms=excluded.timestamp_ms`, [
+            this.options.sessionId,
+            record.groupId,
+            sender.user,
+            sender.server,
+            sender.device,
+            record.keyId,
+            record.timestampMs
+        ]);
+    }
+    distributionRowKey(row) {
+        return this.distributionTargetKey(asString(row.sender_user, 'sender_key_distribution.sender_user'), asString(row.sender_server, 'sender_key_distribution.sender_server'), asNumber(row.sender_device, 'sender_key_distribution.sender_device'));
+    }
+    distributionTargetKey(user, server, device) {
+        return `${user}|${server}|${device}`;
+    }
+}