zapo-js 0.1.0

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaRetrySqliteStore = void 0;
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const coercion_1 = require("../../../util/coercion");
+const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+class WaRetrySqliteStore extends BaseSqliteStore_1.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: (0, coercion_1.asString)(row.message_id, 'retry_outbound_messages.message_id'),
+            toJid: (0, coercion_1.asString)(row.to_jid, 'retry_outbound_messages.to_jid'),
+            participantJid: (0, coercion_1.asOptionalString)(row.participant_jid, 'retry_outbound_messages.participant_jid'),
+            recipientJid: (0, coercion_1.asOptionalString)(row.recipient_jid, 'retry_outbound_messages.recipient_jid'),
+            messageType: (0, coercion_1.asString)(row.message_type, 'retry_outbound_messages.message_type'),
+            replayMode: (0, coercion_1.asString)(row.replay_mode, 'retry_outbound_messages.replay_mode'),
+            replayPayload: (0, coercion_1.asBytes)(row.replay_payload, 'retry_outbound_messages.replay_payload'),
+            state: (0, coercion_1.asString)(row.state, 'retry_outbound_messages.state'),
+            createdAtMs: (0, coercion_1.asNumber)(row.created_at_ms, 'retry_outbound_messages.created_at_ms'),
+            updatedAtMs: (0, coercion_1.asNumber)(row.updated_at_ms, 'retry_outbound_messages.updated_at_ms'),
+            expiresAtMs: (0, coercion_1.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 (0, coercion_1.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 (0, coercion_1.asNumber)(row.total, `${table}.count`);
+    }
+}
+exports.WaRetrySqliteStore = WaRetrySqliteStore;

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeySqliteStore = void 0;
+const sqlite_1 = require("../../../signal/store/sqlite");
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const coercion_1 = require("../../../util/coercion");
+const DEFAULTS = Object.freeze({
+    distributionBatchSize: 250
+});
+class SenderKeySqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
+    constructor(options, distributionBatchSize) {
+        super(options, ['senderKey']);
+        this.distributionBatchSize = (0, coercion_1.resolvePositive)(distributionBatchSize, DEFAULTS.distributionBatchSize, 'senderKey.sqlite.distributionBatchSize');
+    }
+    async upsertSenderKey(record) {
+        const db = await this.getConnection();
+        const sender = (0, sqlite_1.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,
+            (0, sqlite_1.encodeSenderKeyRecord)(record)
+        ]);
+    }
+    async upsertSenderKeyDistribution(record) {
+        const db = await this.getConnection();
+        const sender = (0, sqlite_1.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 = (0, sqlite_1.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) => (0, sqlite_1.decodeSenderKeyRecord)(row.record, (0, coercion_1.asString)(row.group_id, 'sender_keys.group_id'), {
+                user: (0, coercion_1.asString)(row.sender_user, 'sender_keys.sender_user'),
+                server: (0, coercion_1.asString)(row.sender_server, 'sender_keys.sender_server'),
+                device: (0, coercion_1.asNumber)(row.sender_device, 'sender_keys.sender_device')
+            })),
+            skDistribList: distributionRows.map((row) => (0, sqlite_1.decodeSenderKeyDistributionRow)(row))
+        };
+    }
+    async getDeviceSenderKey(groupId, sender) {
+        const db = await this.getConnection();
+        const target = (0, sqlite_1.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 (0, sqlite_1.decodeSenderKeyRecord)(row.record, (0, coercion_1.asString)(row.group_id, 'sender_keys.group_id'), {
+            user: (0, coercion_1.asString)(row.sender_user, 'sender_keys.sender_user'),
+            server: (0, coercion_1.asString)(row.sender_server, 'sender_keys.sender_server'),
+            device: (0, coercion_1.asNumber)(row.sender_device, 'sender_keys.sender_device')
+        });
+    }
+    async getDeviceSenderKeyDistribution(groupId, sender) {
+        const db = await this.getConnection();
+        const target = (0, sqlite_1.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 ? (0, sqlite_1.decodeSenderKeyDistributionRow)(row) : null;
+    }
+    async getDeviceSenderKeyDistributions(groupId, senders) {
+        if (senders.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const targets = senders.map((sender) => (0, sqlite_1.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), (0, sqlite_1.decodeSenderKeyDistributionRow)(row));
+            }
+        }
+        return targets.map((target) => {
+            return (map.get(this.distributionTargetKey(target.user, target.server, target.device)) ??
+                null);
+        });
+    }
+    async deleteDeviceSenderKey(target, groupId) {
+        const sender = (0, sqlite_1.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 = (0, sqlite_1.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 = (0, sqlite_1.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((0, coercion_1.asString)(row.sender_user, 'sender_key_distribution.sender_user'), (0, coercion_1.asString)(row.sender_server, 'sender_key_distribution.sender_server'), (0, coercion_1.asNumber)(row.sender_device, 'sender_key_distribution.sender_device'));
+    }
+    distributionTargetKey(user, server, device) {
+        return `${user}|${server}|${device}`;
+    }
+}
+exports.SenderKeySqliteStore = SenderKeySqliteStore;