zapo-js 0.1.0 → 0.1.2

package/dist/esm/client/coordinators/WaRetryCoordinator.js

@@ -1,6 +1,6 @@
 import { proto } from '../../proto.js';
 import { WA_MESSAGE_TAGS } from '../../protocol/constants.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, toUserJid } from '../../protocol/jid.js';
+import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid } from '../../protocol/jid.js';
 import { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON } from '../../retry/constants.js';
 import { pickRetryStateMax } from '../../retry/outbound.js';
 import { parseRetryReceiptRequest } from '../../retry/parse.js';
@@ -10,12 +10,16 @@ import { generatePreKeyPair } from '../../signal/registration/keygen.js';
 import { buildInboundRetryReceiptAckNode } from '../../transport/node/builders/message.js';
 import { buildRetryReceiptNode } from '../../transport/node/builders/retry.js';
 import { toError } from '../../util/primitives.js';
+const RETRY_CLEANUP_INTERVAL_MS = 30000;
 function getRetryReasonName(code) {
     if (code === undefined) {
         return undefined;
     }
-    const entry = Object.entries(RETRY_REASON).find(([, value]) => value === code);
-    return entry ? entry[0] : 'unknown';
+    for (const reasonName in RETRY_REASON) {
+        if (RETRY_REASON[reasonName] === code)
+            return reasonName;
+    }
+    return 'unknown';
 }
 function getRemoteRetryReasonLogFields(reason) {
     return {
@@ -26,6 +30,7 @@ function getRemoteRetryReasonLogFields(reason) {
 }
 export class WaRetryCoordinator {
     constructor(options) {
+        this.nextRetryCleanupAtMs = 0;
         this.logger = options.logger;
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
@@ -72,7 +77,7 @@ export class WaRetryCoordinator {
             return;
         }
         try {
-            await this.retryStore.cleanupExpired(Date.now());
+            await this.maybeCleanupRetryStore(Date.now());
             const request = parseRetryReceiptRequest(receiptNode);
             if (!request) {
                 return;
@@ -97,10 +102,7 @@ export class WaRetryCoordinator {
     }
     async prepareDecryptFailureRetry(context, error) {
         const nowMs = Date.now();
-        const [, registrationInfo] = await Promise.all([
-            this.retryStore.cleanupExpired(nowMs),
-            this.signalStore.getRegistrationInfo()
-        ]);
+        const registrationInfo = await this.signalStore.getRegistrationInfo();
         if (!registrationInfo) {
             this.logger.warn('retry receipt skipped: missing local registration info', {
                 id: context.stanzaId,
@@ -195,6 +197,21 @@ export class WaRetryCoordinator {
             });
             return null;
         }
+        let requesterAddress;
+        let requesterNormalizedDeviceJid;
+        try {
+            requesterAddress = parseSignalAddressFromJid(requesterJid);
+            requesterNormalizedDeviceJid = normalizeDeviceJid(requesterJid);
+        }
+        catch (error) {
+            this.logger.info('retry request rejected: invalid requester jid', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: toError(error).message
+            });
+            return null;
+        }
         if (request.retryCount >= MAX_RETRY_ATTEMPTS) {
             this.logger.info('retry request rejected: retry count exceeded', {
                 id: request.stanzaId,
@@ -214,7 +231,7 @@ export class WaRetryCoordinator {
             });
             return null;
         }
-        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid);
+        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!sessionReady) {
             this.logger.info('retry request rejected: missing compatible session', {
                 id: request.stanzaId,
@@ -225,7 +242,7 @@ export class WaRetryCoordinator {
             });
             return null;
         }
-        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid);
+        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!authorization.authorized) {
             this.logger.info('retry request rejected', {
                 id: request.stanzaId,
@@ -239,6 +256,8 @@ export class WaRetryCoordinator {
         }
         return {
             requesterJid,
+            requesterAddress,
+            requesterNormalizedDeviceJid,
             outbound
         };
     }
@@ -271,7 +290,7 @@ export class WaRetryCoordinator {
     }
     async runRetryTaskSerialized(messageId, task) {
         const previous = this.retryProcessingByMessageId.get(messageId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(async () => task());
+        const current = previous.then(task, task);
         const tracker = current.then(() => undefined, () => undefined);
         this.retryProcessingByMessageId.set(messageId, tracker);
         try {
@@ -311,18 +330,17 @@ export class WaRetryCoordinator {
                 : undefined
         };
     }
-    async updateLocalSessionFromRetryRequest(request, requesterJid) {
-        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid);
-        const address = parseSignalAddressFromJid(requesterJid);
-        const currentSession = await this.signalStore.getSession(address);
+    async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress);
+        const currentSession = await this.signalStore.getSession(requesterAddress);
         if (currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId) {
-            await this.signalStore.deleteSession(address);
+            await this.signalStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
-            if (!request.keyBundle.key) {
+            if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
                 return false;
             }
-            await this.signalProtocol.establishOutgoingSession(address, {
+            await this.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
                 identity: request.keyBundle.identity,
                 signedKey: {
@@ -337,23 +355,22 @@ export class WaRetryCoordinator {
             });
             return true;
         }
-        const hasSession = await this.signalProtocol.hasSession(address);
+        const hasSession = await this.signalProtocol.hasSession(requesterAddress);
         if (hasSession) {
             return true;
         }
-        const fetched = await this.fetchMissingPreKeysSession(requesterJid, request.regId);
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(address, fetched);
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return true;
     }
-    async markRetryRequesterSenderKeyAsStale(request, requesterJid) {
+    async markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress) {
         if (!isGroupOrBroadcastJid(request.from)) {
             return;
         }
         try {
-            const requesterAddress = parseSignalAddressFromJid(requesterJid);
             const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
                 requesterAddress
             ]);
@@ -371,12 +388,11 @@ export class WaRetryCoordinator {
             });
         }
     }
-    async fetchMissingPreKeysSession(requesterJid, requesterRegistrationId) {
+    async fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, requesterRegistrationId) {
         try {
-            const requesterAddress = parseSignalAddressFromJid(requesterJid);
             const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
                 {
-                    userJid: toUserJid(requesterJid),
+                    userJid: `${requesterAddress.user}@${requesterAddress.server}`,
                     devices: [
                         {
                             deviceId: requesterAddress.device,
@@ -393,8 +409,7 @@ export class WaRetryCoordinator {
                 });
                 return null;
             }
-            const requesterDeviceJid = normalizeDeviceJid(requesterJid);
-            const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterDeviceJid);
+            const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterNormalizedDeviceJid);
             if (!matched) {
                 this.logger.warn('missing prekeys fetch did not return requested device', {
                     requester: requesterJid,
@@ -412,7 +427,7 @@ export class WaRetryCoordinator {
             return null;
         }
     }
-    async authorizeRetryRequest(request, outbound, requesterJid) {
+    async authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         if (outbound.state === 'ineligible') {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
@@ -420,25 +435,29 @@ export class WaRetryCoordinator {
         if (!isGroupOutbound && (outbound.state === 'read' || outbound.state === 'played')) {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
-        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid);
+        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!requesterAuthorized) {
             return { authorized: false, reason: 'requester_device_not_authorized' };
         }
         return { authorized: true };
     }
-    async isRequesterAuthorizedDevice(requesterJid) {
+    async isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         try {
-            const requesterUser = toUserJid(requesterJid);
+            const requesterUser = `${requesterAddress.user}@${requesterAddress.server}`;
+            if (requesterNormalizedDeviceJid === normalizeDeviceJid(requesterUser)) {
+                return true;
+            }
             const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
             const target = synced.find((entry) => entry.jid === requesterUser);
-            const authorized = new Set();
-            authorized.add(normalizeDeviceJid(requesterUser));
-            if (target) {
-                for (let index = 0; index < target.deviceJids.length; index += 1) {
-                    authorized.add(normalizeDeviceJid(target.deviceJids[index]));
+            if (!target) {
+                return false;
+            }
+            for (let index = 0; index < target.deviceJids.length; index += 1) {
+                if (normalizeDeviceJid(target.deviceJids[index]) === requesterNormalizedDeviceJid) {
+                    return true;
                 }
             }
-            return authorized.has(normalizeDeviceJid(requesterJid));
+            return false;
         }
         catch (error) {
             this.logger.warn('retry authorization failed while syncing requester device list', {
@@ -487,4 +506,18 @@ export class WaRetryCoordinator {
             });
         }
     }
+    async maybeCleanupRetryStore(nowMs) {
+        if (nowMs < this.nextRetryCleanupAtMs) {
+            return;
+        }
+        this.nextRetryCleanupAtMs = nowMs + RETRY_CLEANUP_INTERVAL_MS;
+        try {
+            await this.retryStore.cleanupExpired(nowMs);
+        }
+        catch (error) {
+            this.logger.warn('retry store cleanup failed', {
+                message: toError(error).message
+            });
+        }
+    }
 }

package/dist/esm/client/dirty.js

@@ -1,10 +1,8 @@
-import { randomBytesAsync } from '../crypto/index.js';
 import { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_IQ_TYPES, WA_SUPPORTED_DIRTY_TYPES } from '../protocol/constants.js';
 import { toUserJid } from '../protocol/jid.js';
-import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../transport/node/builders/accountSync.js';
-import { getNodeChildren } from '../transport/node/helpers.js';
+import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../transport/node/builders/account-sync.js';
+import { getNodeChildrenTags } from '../transport/node/helpers.js';
 import { assertIqResult, parseIqError } from '../transport/node/query.js';
-import { bytesToHex } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const SUPPORTED_DIRTY_TYPES = new Set(WA_SUPPORTED_DIRTY_TYPES);
 const ACCOUNT_SYNC_PROTOCOL_SET = new Set(WA_ACCOUNT_SYNC_PROTOCOLS);
@@ -18,19 +16,13 @@ function parseDirtyBitNode(node, logger) {
         });
         return null;
     }
-    const protocols = getNodeChildren(node).map((child) => child.tag);
+    const protocols = getNodeChildrenTags(node);
     return {
         type,
         timestamp,
         protocols
     };
 }
-function splitDirtyBitsBySupport(dirtyBits) {
-    return {
-        supported: dirtyBits.filter((dirtyBit) => SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)),
-        unsupported: dirtyBits.filter((dirtyBit) => !SUPPORTED_DIRTY_TYPES.has(dirtyBit.type))
-    };
-}
 function resolveAccountSyncProtocols(protocols) {
     const selected = protocols.filter((protocol) => ACCOUNT_SYNC_PROTOCOL_SET.has(protocol));
     if (selected.length > 0) {
@@ -39,9 +31,15 @@ function resolveAccountSyncProtocols(protocols) {
     return WA_ACCOUNT_SYNC_PROTOCOLS;
 }
 export function parseDirtyBits(nodes, logger) {
-    return nodes
-        .map((node) => parseDirtyBitNode(node, logger))
-        .filter((dirtyBit) => dirtyBit !== null);
+    const parsed = [];
+    for (const node of nodes) {
+        const dirtyBit = parseDirtyBitNode(node, logger);
+        if (!dirtyBit) {
+            continue;
+        }
+        parsed.push(dirtyBit);
+    }
+    return parsed;
 }
 export async function handleDirtyBits(runtime, dirtyBits) {
     const meJid = runtime.getCurrentCredentials()?.meJid ?? null;
@@ -49,22 +47,33 @@ export async function handleDirtyBits(runtime, dirtyBits) {
         runtime.logger.trace('dirty bits skipped: session is not registered');
         return;
     }
-    const { supported, unsupported } = splitDirtyBitsBySupport(dirtyBits);
+    const supported = [];
+    const unsupported = [];
+    for (const dirtyBit of dirtyBits) {
+        if (SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)) {
+            supported.push(dirtyBit);
+            continue;
+        }
+        unsupported.push(dirtyBit);
+    }
     runtime.logger.info('handling dirty bits from info bulletin', {
         supported: supported.map((entry) => entry.type).join(','),
         unsupported: unsupported.map((entry) => entry.type).join(',')
     });
-    const handledSupported = (await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)))).flatMap((result, index) => {
+    const clearableDirtyBits = [...unsupported];
+    const settledSupported = await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)));
+    for (let index = 0; index < settledSupported.length; index += 1) {
+        const result = settledSupported[index];
         if (result.status === 'fulfilled') {
-            return [supported[index]];
+            clearableDirtyBits.push(supported[index]);
+            continue;
         }
         runtime.logger.warn('failed handling dirty bit', {
             type: supported[index].type,
             message: toError(result.reason).message
         });
-        return [];
-    });
-    await clearDirtyBits(runtime, unsupported.concat(handledSupported));
+    }
+    await clearDirtyBits(runtime, clearableDirtyBits);
 }
 async function handleDirtyBit(runtime, dirtyBit) {
     switch (dirtyBit.type) {
@@ -149,7 +158,7 @@ async function syncAccountDevicesDirtyBit(runtime) {
     }
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.devices',
-        node: buildAccountDevicesSyncIq(userJids, await generateUsyncSid()),
+        node: buildAccountDevicesSyncIq(userJids, await runtime.generateUsyncSid()),
         logMessage: 'account_sync devices synchronized',
         contextData: { meJid, targets: userJids.join(',') }
     });
@@ -213,9 +222,6 @@ async function syncNewsletterMetadataDirtyBit(runtime) {
     runtime.logger.info('newsletter_metadata dirty bit received (GraphQL/MEX sync intentionally disabled)');
     await runtime.queryWithContext('dirty.newsletter_metadata', buildNewsletterMetadataSyncIq(), WA_DEFAULTS.IQ_TIMEOUT_MS);
 }
-async function generateUsyncSid() {
-    return bytesToHex(await randomBytesAsync(8));
-}
 function resolveAccountSyncDeviceTargets(credentials) {
     if (!credentials?.meJid) {
         return [];

package/dist/esm/client/events/chat.js

@@ -75,8 +75,7 @@ export function parseChatEventFromAppStateMutation(mutation) {
             ...pickOptionalPrimitive('deviceAgentId', value.chatAssignment.deviceAgentID, 'string')
         };
     }
-    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ??
-        normalizeValueActionKey(syncActionValueKey);
+    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ?? normalizeValueActionKey(syncActionValueKey);
     if (!fallbackAction) {
         return null;
     }
@@ -201,10 +200,12 @@ function extractChatJid(parts) {
     return undefined;
 }
 function findPresentSyncActionValueKey(value) {
-    for (const [key, keyValue] of Object.entries(value)) {
+    const valueRecord = value;
+    for (const key in valueRecord) {
         if (key === 'timestamp') {
             continue;
         }
+        const keyValue = valueRecord[key];
         if (keyValue === null || keyValue === undefined) {
             continue;
         }

package/dist/esm/client/events/group.js

@@ -1,8 +1,8 @@
 import { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from '../../protocol/constants.js';
 import { WA_NODE_TAGS } from '../../protocol/nodes.js';
 import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
-import { parseOptionalInt } from '../../transport/stream/parse.js';
 import { TEXT_DECODER } from '../../util/bytes.js';
+import { parseOptionalInt } from '../../util/primitives.js';
 function readNodeTextContent(node) {
     if (!node) {
         return undefined;
@@ -15,31 +15,43 @@ function readNodeTextContent(node) {
     }
     return undefined;
 }
-function parseParticipants(node) {
-    return getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT).map((participantNode) => ({
-        jid: participantNode.attrs.jid,
-        role: participantNode.attrs.type,
-        lidJid: participantNode.attrs.lid,
-        phoneJid: participantNode.attrs.phone_number,
-        displayName: participantNode.attrs.display_name,
-        username: participantNode.attrs.username,
-        expirationSeconds: parseOptionalInt(participantNode.attrs.expiration)
-    }));
+export function parseParticipants(node) {
+    const participants = [];
+    for (const participantNode of getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT)) {
+        participants.push({
+            jid: participantNode.attrs.jid,
+            role: participantNode.attrs.type,
+            lidJid: participantNode.attrs.lid,
+            phoneJid: participantNode.attrs.phone_number,
+            displayName: participantNode.attrs.display_name,
+            username: participantNode.attrs.username,
+            expirationSeconds: parseOptionalInt(participantNode.attrs.expiration)
+        });
+    }
+    return participants;
 }
 function parseLinkedGroups(node) {
-    return getNodeChildrenByTag(node, WA_NODE_TAGS.GROUP).map((groupNode) => ({
-        jid: groupNode.attrs.jid,
-        subject: groupNode.attrs.subject,
-        subjectTimestampSeconds: parseOptionalInt(groupNode.attrs.s_t),
-        hiddenSubgroup: findNodeChild(groupNode, 'hidden_group') !== undefined
-    }));
+    const groups = [];
+    for (const groupNode of getNodeChildrenByTag(node, WA_NODE_TAGS.GROUP)) {
+        groups.push({
+            jid: groupNode.attrs.jid,
+            subject: groupNode.attrs.subject,
+            subjectTimestampSeconds: parseOptionalInt(groupNode.attrs.s_t),
+            hiddenSubgroup: findNodeChild(groupNode, 'hidden_group') !== undefined
+        });
+    }
+    return groups;
 }
 function parseMembershipRequests(node) {
-    return getNodeChildrenByTag(node, 'requested_user').map((requestNode) => ({
-        jid: requestNode.attrs.jid,
-        username: requestNode.attrs.username,
-        phoneJid: requestNode.attrs.phone_number
-    }));
+    const requests = [];
+    for (const requestNode of getNodeChildrenByTag(node, 'requested_user')) {
+        requests.push({
+            jid: requestNode.attrs.jid,
+            username: requestNode.attrs.username,
+            phoneJid: requestNode.attrs.phone_number
+        });
+    }
+    return requests;
 }
 function parseSubgroupSuggestion(node) {
     const subjectNode = findNodeChild(node, WA_NODE_TAGS.SUBJECT);
@@ -65,9 +77,15 @@ function parseSubgroupSuggestion(node) {
     };
 }
 function parseSubgroupSuggestions(node) {
-    return getNodeChildrenByTag(node, 'sub_group_suggestion')
-        .map(parseSubgroupSuggestion)
-        .filter((suggestion) => suggestion !== null);
+    const suggestions = [];
+    for (const suggestionNode of getNodeChildrenByTag(node, 'sub_group_suggestion')) {
+        const suggestion = parseSubgroupSuggestion(suggestionNode);
+        if (!suggestion) {
+            continue;
+        }
+        suggestions.push(suggestion);
+    }
+    return suggestions;
 }
 function createBaseGroupEvent(notificationNode, actionNode) {
     return {
@@ -136,8 +154,7 @@ function parseCreateGroupAction(notificationNode, actionNode) {
             ephemeralDuration: parseOptionalInt(findNodeChild(groupNode, WA_NODE_TAGS.EPHEMERAL)?.attrs.expiration),
             disappearingTrigger: findNodeChild(groupNode, WA_NODE_TAGS.EPHEMERAL)?.attrs.trigger,
             membershipApprovalEnabled: groupJoinNode?.attrs.state === 'on',
-            allowNonAdminSubGroupCreation: findNodeChild(groupNode, WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !==
-                undefined,
+            allowNonAdminSubGroupCreation: findNodeChild(groupNode, WA_GROUP_NOTIFICATION_TAGS.ALLOW_NON_ADMIN_SUB_GROUP_CREATION) !== undefined,
             linkedParentGroupJid: findNodeChild(groupNode, 'linked_parent')?.attrs.jid ??
                 findNodeChild(groupNode, 'parent')?.attrs.jid
         }
@@ -224,7 +241,12 @@ function parseGroupActionNode(notificationNode, actionNode) {
             };
         }
         case WA_GROUP_NOTIFICATION_TAGS.LOCKED:
-            return { ...baseEvent, action: 'restrict', enabled: true, mode: actionNode.attrs.threshold };
+            return {
+                ...baseEvent,
+                action: 'restrict',
+                enabled: true,
+                mode: actionNode.attrs.threshold
+            };
         case WA_GROUP_NOTIFICATION_TAGS.UNLOCKED:
             return { ...baseEvent, action: 'restrict', enabled: false };
         case WA_GROUP_NOTIFICATION_TAGS.ANNOUNCEMENT:

package/dist/esm/client/history-sync.js

@@ -1,8 +1,7 @@
 import { promisify } from 'node:util';
 import { unzip } from 'node:zlib';
 import { proto } from '../proto.js';
-import { decodeProtoBytes } from '../util/base64.js';
-import { toBytesView } from '../util/bytes.js';
+import { decodeProtoBytes, toBytesView } from '../util/bytes.js';
 import { longToNumber } from '../util/primitives.js';
 const unzipAsync = promisify(unzip);
 const HANDLED_SYNC_TYPES = new Set([
@@ -28,15 +27,58 @@ export async function processHistorySyncNotification(deps, notification) {
         pushnames: historySync.pushnames.length
     });
     const nowMs = Date.now();
+    const contacts = [];
+    for (const pn of historySync.pushnames) {
+        if (!pn.id) {
+            continue;
+        }
+        contacts.push({
+            jid: pn.id,
+            pushName: pn.pushname ?? undefined,
+            lastUpdatedMs: nowMs
+        });
+    }
+    const threads = [];
+    const messages = [];
     let messagesCount = 0;
-    const conversationPromises = [];
     for (const conversation of historySync.conversations) {
-        conversationPromises.push(persistConversation(deps, conversation, nowMs).then((count) => {
-            messagesCount += count;
-        }));
+        const threadJid = conversation.id;
+        if (!threadJid) {
+            deps.logger.debug('skipping history sync conversation without thread jid');
+            continue;
+        }
+        threads.push({
+            jid: threadJid,
+            name: conversation.name ?? undefined,
+            unreadCount: conversation.unreadCount ?? undefined,
+            archived: conversation.archived ?? undefined,
+            pinned: conversation.pinned ?? undefined,
+            muteEndMs: longToNumber(conversation.muteEndTime) || undefined,
+            markedAsUnread: conversation.markedAsUnread ?? undefined,
+            ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
+        });
+        for (const histMsg of conversation.messages ?? []) {
+            const webMsg = histMsg.message;
+            if (!webMsg?.key?.id) {
+                continue;
+            }
+            const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
+            messages.push({
+                id: webMsg.key.id,
+                threadJid,
+                senderJid: webMsg.key.participant ?? undefined,
+                fromMe: webMsg.key.fromMe === true,
+                timestampMs: timestampMs || undefined,
+                messageBytes: webMsg.message
+                    ? proto.Message.encode(webMsg.message).finish()
+                    : undefined
+            });
+            messagesCount += 1;
+        }
     }
-    const pushnamePromise = persistPushnames(deps, historySync.pushnames, nowMs);
-    await Promise.all([...conversationPromises, pushnamePromise]);
+    await deps.contactStore.upsertBatch(contacts);
+    await deps.threadStore.upsertBatch(threads);
+    await deps.messageStore.upsertBatch(messages);
     const event = {
         syncType,
         messagesCount,
@@ -65,55 +107,3 @@ async function downloadHistorySyncBlob(deps, notification) {
         fileEncSha256
     });
 }
-async function persistConversation(deps, conversation, _nowMs) {
-    const threadJid = conversation.id;
-    if (!threadJid) {
-        deps.logger.debug('skipping history sync conversation without thread jid');
-        return 0;
-    }
-    const messages = conversation.messages ?? [];
-    const messageRecords = [];
-    for (const histMsg of messages) {
-        const webMsg = histMsg.message;
-        if (!webMsg?.key?.id) {
-            continue;
-        }
-        const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
-        const messageBytes = webMsg.message
-            ? proto.Message.encode(webMsg.message).finish()
-            : undefined;
-        messageRecords.push({
-            id: webMsg.key.id,
-            threadJid,
-            senderJid: webMsg.key.participant ?? undefined,
-            fromMe: webMsg.key.fromMe === true,
-            timestampMs: timestampMs || undefined,
-            messageBytes
-        });
-    }
-    const threadPromise = deps.threadStore.upsert({
-        jid: threadJid,
-        name: conversation.name ?? undefined,
-        unreadCount: conversation.unreadCount ?? undefined,
-        archived: conversation.archived ?? undefined,
-        pinned: conversation.pinned ?? undefined,
-        muteEndMs: longToNumber(conversation.muteEndTime) || undefined,
-        markedAsUnread: conversation.markedAsUnread ?? undefined,
-        ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
-    });
-    const messagePromises = messageRecords.map((record) => deps.messageStore.upsert(record));
-    await Promise.all([threadPromise, ...messagePromises]);
-    return messageRecords.length;
-}
-async function persistPushnames(deps, pushnames, nowMs) {
-    if (pushnames.length === 0) {
-        return;
-    }
-    await Promise.all(pushnames
-        .filter((pn) => !!pn.id)
-        .map((pn) => deps.contactStore.upsert({
-        jid: pn.id,
-        pushName: pn.pushname ?? undefined,
-        lastUpdatedMs: nowMs
-    })));
-}