zapo-js 0.1.1 → 0.2.0

package/dist/retry/replay.js

@@ -5,7 +5,7 @@ const device_sent_1 = require("../message/device-sent");
 const padding_1 = require("../message/padding");
 const _proto_1 = require("../proto.js");
 const jid_1 = require("../protocol/jid");
-const outbound_1 = require("./outbound");
+const codec_1 = require("./codec");
 const binary_1 = require("../transport/binary");
 const message_1 = require("../transport/node/builders/message");
 const helpers_1 = require("../transport/node/helpers");
@@ -15,18 +15,23 @@ class WaRetryReplayService {
         this.options = options;
     }
     async resendOutboundMessage(outbound, requesterJid, retryCount) {
-        const payload = (0, outbound_1.decodeRetryReplayPayload)(outbound.replayPayload);
+        const payload = outbound.replayPayload instanceof Uint8Array
+            ? (0, codec_1.decodeRetryReplayPayload)(outbound.replayPayload)
+            : outbound.replayPayload;
+        const requesterParsed = (0, jid_1.parseJidFull)(requesterJid);
+        const requesterAddress = requesterParsed.address;
+        const normalizedRequesterJid = requesterParsed.normalizedJid;
         if (payload.mode === 'plaintext') {
-            return this.resendPlaintextPayload(outbound, payload, requesterJid, retryCount);
+            return this.resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
         if (payload.mode === 'encrypted') {
-            return this.resendEncryptedPayload(outbound, payload, requesterJid, retryCount);
+            return this.resendEncryptedPayload(outbound, payload, requesterJid, normalizedRequesterJid, retryCount);
         }
-        return this.resendOpaquePayload(outbound, payload, requesterJid);
+        return this.resendOpaquePayload(outbound, payload, normalizedRequesterJid);
     }
-    async resendPlaintextPayload(outbound, payload, requesterJid, retryCount) {
+    async resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         if ((0, jid_1.isGroupOrBroadcastJid)(payload.to)) {
-            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid);
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
         let payloadUserJid;
         let requesterUserJid;
@@ -40,8 +45,8 @@ class WaRetryReplayService {
         if (payloadUserJid !== requesterUserJid) {
             return 'ineligible';
         }
-        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), payload.plaintext);
-        await this.messageClient.sendEncrypted({
+        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, payload.plaintext);
+        await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
@@ -51,15 +56,15 @@ class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendGroupPlaintextPayload(outbound, payload, requesterJid) {
+    async resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         const plaintext = (await this.maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid)) ??
             payload.plaintext;
-        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), plaintext);
+        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, plaintext);
         let deviceIdentity;
         if (encrypted.type === 'pkmsg') {
-            const signedIdentity = this.getCurrentSignedIdentity();
+            const signedIdentity = this.options.getCurrentSignedIdentity();
             if (!signedIdentity) {
-                this.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
+                this.options.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
                 return 'ineligible';
             }
             deviceIdentity = _proto_1.proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
@@ -69,22 +74,23 @@ class WaRetryReplayService {
             type: payload.type,
             id: outbound.messageId,
             requesterJid,
-            addressingMode: (0, jid_1.splitJid)(requesterJid).server === 'lid' ? 'lid' : 'pn',
+            addressingMode: requesterAddress.server === 'lid' ? 'lid' : 'pn',
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
+            retryCount,
             deviceIdentity
         });
-        await this.messageClient.sendMessageNode(retryNode);
+        await this.options.messageClient.sendMessageNode(retryNode);
         return 'resent';
     }
-    async resendEncryptedPayload(outbound, payload, requesterJid, retryCount) {
+    async resendEncryptedPayload(outbound, payload, requesterJid, normalizedRequesterJid, retryCount) {
         if (payload.encType === 'skmsg') {
             return 'ineligible';
         }
-        if ((0, jid_1.normalizeDeviceJid)(payload.to) !== (0, jid_1.normalizeDeviceJid)(requesterJid)) {
+        if ((0, jid_1.normalizeDeviceJid)(payload.to) !== normalizedRequesterJid) {
             return 'ineligible';
         }
-        await this.messageClient.sendEncrypted({
+        await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: payload.encType,
             ciphertext: payload.ciphertext,
@@ -95,8 +101,11 @@ class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendOpaquePayload(outbound, payload, requesterJid) {
+    async resendOpaquePayload(outbound, payload, normalizedRequesterJid) {
         const decoded = (0, binary_1.decodeBinaryNode)(payload.node);
+        if (!this.isOpaqueReplayCompatible(decoded, normalizedRequesterJid)) {
+            return 'ineligible';
+        }
         const replayNode = decoded.attrs.id === outbound.messageId
             ? decoded
             : {
@@ -106,10 +115,7 @@ class WaRetryReplayService {
                     id: outbound.messageId
                 }
             };
-        if (!this.isOpaqueReplayCompatible(replayNode, requesterJid)) {
-            return 'ineligible';
-        }
-        await this.messageClient.sendMessageNode(replayNode);
+        await this.options.messageClient.sendMessageNode(replayNode);
         return 'resent';
     }
     async maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid) {
@@ -123,7 +129,7 @@ class WaRetryReplayService {
             return (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(wrapped).finish());
         }
         catch (error) {
-            this.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
+            this.options.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
                 requester: requesterJid,
                 to: payload.to,
                 message: (0, primitives_1.toError)(error).message
@@ -143,38 +149,35 @@ class WaRetryReplayService {
         }
         return false;
     }
-    get logger() {
-        return this.options.logger;
-    }
-    get messageClient() {
-        return this.options.messageClient;
-    }
-    get signalProtocol() {
-        return this.options.signalProtocol;
-    }
-    getCurrentSignedIdentity() {
-        return this.options.getCurrentSignedIdentity();
-    }
-    isOpaqueReplayCompatible(node, requesterJid) {
-        const requester = (0, jid_1.normalizeDeviceJid)(requesterJid);
+    isOpaqueReplayCompatible(node, normalizedRequesterJid) {
         const participantsNode = (0, helpers_1.findNodeChild)(node, 'participants');
         if (participantsNode) {
-            const toNodes = (0, helpers_1.getNodeChildrenByTag)(participantsNode, 'to');
-            if (toNodes.length !== 1) {
-                return false;
+            const participantsContent = Array.isArray(participantsNode.content)
+                ? participantsNode.content
+                : [];
+            let participantNode;
+            let participantCount = 0;
+            for (let index = 0; index < participantsContent.length; index++) {
+                const child = participantsContent[index];
+                if (child.tag !== 'to')
+                    continue;
+                participantCount++;
+                if (participantCount > 1)
+                    return false;
+                participantNode = child;
             }
-            const participantJid = toNodes[0].attrs.jid;
-            if (!participantJid) {
+            if (participantCount !== 1 || !participantNode)
                 return false;
-            }
-            return (0, jid_1.normalizeDeviceJid)(participantJid) === requester;
+            const participantJid = participantNode.attrs.jid;
+            if (!participantJid)
+                return false;
+            return (0, jid_1.normalizeDeviceJid)(participantJid) === normalizedRequesterJid;
         }
         if (node.attrs.participant) {
-            return (0, jid_1.normalizeDeviceJid)(node.attrs.participant) === requester;
-        }
-        if (node.attrs.to) {
-            return (0, jid_1.normalizeDeviceJid)(node.attrs.to) === requester;
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.participant) === normalizedRequesterJid;
         }
+        if (node.attrs.to)
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.to) === normalizedRequesterJid;
         return false;
     }
 }

package/dist/retry/tracker.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOutboundRetryTracker = createOutboundRetryTracker;
+const jid_1 = require("../protocol/jid");
+const codec_1 = require("./codec");
+const constants_1 = require("./constants");
+const primitives_1 = require("../util/primitives");
+function createOutboundRetryTracker(options) {
+    const { retryStore, logger } = options;
+    const retryTtlMs = retryStore.getTtlMs?.() ?? constants_1.RETRY_OUTBOUND_TTL_MS;
+    const supportsRawReplayPayload = retryStore.supportsRawReplayPayload?.() ?? false;
+    const normalizeEligibleRequesterDeviceJids = (values) => {
+        if (!values || values.length === 0) {
+            return undefined;
+        }
+        const deduped = new Set();
+        for (let index = 0; index < values.length; index += 1) {
+            const raw = values[index]?.trim();
+            if (!raw) {
+                continue;
+            }
+            try {
+                deduped.add((0, jid_1.normalizeDeviceJid)(raw));
+            }
+            catch {
+                continue;
+            }
+        }
+        if (deduped.size === 0) {
+            return undefined;
+        }
+        return Array.from(deduped);
+    };
+    const safeUpsertRetryOutboundRecord = async (record) => {
+        try {
+            await retryStore.upsertOutboundMessage(record);
+        }
+        catch (error) {
+            logger.warn('failed to persist retry outbound message record', {
+                messageId: record.messageId,
+                to: record.toJid,
+                mode: record.replayMode,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return false;
+        }
+        return true;
+    };
+    return {
+        track: async (hint, publish) => {
+            const nowMs = Date.now();
+            const replayMode = hint.replayPayload.mode;
+            const resolvedToJid = hint.toJid ?? (replayMode === 'opaque_node' ? '' : hint.replayPayload.to);
+            const replayPayload = supportsRawReplayPayload
+                ? hint.replayPayload
+                : (0, codec_1.encodeRetryReplayPayload)(hint.replayPayload);
+            let eligibleRequesterDeviceJids = normalizeEligibleRequesterDeviceJids(hint.eligibleRequesterDeviceJids);
+            if (!eligibleRequesterDeviceJids &&
+                resolvedToJid &&
+                !(0, jid_1.isGroupOrBroadcastJid)(resolvedToJid)) {
+                try {
+                    eligibleRequesterDeviceJids = [(0, jid_1.normalizeDeviceJid)(resolvedToJid)];
+                }
+                catch {
+                    eligibleRequesterDeviceJids = undefined;
+                }
+            }
+            const createRetryOutboundRecord = (messageId, updatedAtMs, expiresAtMs) => ({
+                messageId,
+                toJid: resolvedToJid,
+                participantJid: hint.participantJid,
+                recipientJid: hint.recipientJid,
+                eligibleRequesterDeviceJids,
+                deliveredRequesterDeviceJids: [],
+                messageType: hint.type,
+                replayMode,
+                replayPayload,
+                state: 'pending',
+                createdAtMs: nowMs,
+                updatedAtMs,
+                expiresAtMs
+            });
+            const result = await publish();
+            const persistedMessageId = result.id.trim();
+            if (!persistedMessageId) {
+                logger.warn('retry outbound record skipped: publish returned empty message id', {
+                    to: resolvedToJid,
+                    mode: replayMode
+                });
+                return result;
+            }
+            const persistedNowMs = Date.now();
+            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(persistedMessageId, persistedNowMs, persistedNowMs + retryTtlMs));
+            return result;
+        }
+    };
+}