zapo-js 0.1.0 → 0.1.2

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

@@ -0,0 +1,467 @@
+import { WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_COLLECTION_STATES } from '../../protocol/constants.js';
+import { isGroupJid, isGroupOrBroadcastJid, normalizeDeviceJid, normalizeRecipientJid, toUserJid } from '../../protocol/jid.js';
+import { resolvePositive } from '../../util/coercion.js';
+import { toError } from '../../util/primitives.js';
+const WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES = new Set([
+    WA_APP_STATE_COLLECTION_STATES.SUCCESS,
+    WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
+]);
+const WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT = 256;
+export class WaAppStateMutationCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.messageStore = options.messageStore;
+        this.syncAppState = options.syncAppState;
+        this.archiveRangeLimit = resolvePositive(options.archiveRangeLimit, WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT, 'WaAppStateMutationCoordinatorOptions.archiveRangeLimit');
+        this.pendingMutations = new Map();
+        this.flushPromise = null;
+    }
+    async setChatMute(chatJid, muted, muteEndTimestampMs) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const normalizedMuteEnd = muteEndTimestampMs;
+        if (normalizedMuteEnd !== undefined &&
+            (!Number.isFinite(normalizedMuteEnd) ||
+                !Number.isSafeInteger(normalizedMuteEnd) ||
+                normalizedMuteEnd < 0)) {
+            throw new Error(`invalid muteEndTimestampMs: ${muteEndTimestampMs}`);
+        }
+        if (muted && normalizedMuteEnd === undefined) {
+            throw new Error('setChatMute requires muteEndTimestampMs when muted is true');
+        }
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.MUTE,
+            chatIndexJid,
+            value: {
+                muteAction: {
+                    muted,
+                    ...(normalizedMuteEnd === undefined
+                        ? {}
+                        : { muteEndTimestamp: normalizedMuteEnd })
+                }
+            },
+            timestamp
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setMessageStar(message, starred) {
+        const messageIndex = this.buildMessageMutationIndex(message);
+        const timestamp = Date.now();
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.STAR,
+            chatIndexJid: messageIndex.chatIndexJid,
+            value: {
+                starAction: {
+                    starred
+                }
+            },
+            timestamp,
+            indexPartsTail: messageIndex.indexPartsTail
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatRead(chatJid, read) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.MARK_CHAT_AS_READ,
+            chatIndexJid,
+            value: {
+                markChatAsReadAction: {
+                    read,
+                    messageRange
+                }
+            },
+            timestamp
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatPin(chatJid, pinned) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [
+            this.createSetMutation({
+                spec: WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned
+                    }
+                },
+                timestamp
+            })
+        ];
+        if (pinned) {
+            pending.push(await this.createArchiveMutation(chatIndexJid, false, timestamp));
+        }
+        await this.enqueueAndFlush(pending);
+    }
+    async setChatArchive(chatJid, archived) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [
+            await this.createArchiveMutation(chatIndexJid, archived, timestamp)
+        ];
+        if (archived) {
+            pending.push(this.createSetMutation({
+                spec: WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned: false
+                    }
+                },
+                timestamp
+            }));
+        }
+        await this.enqueueAndFlush(pending);
+    }
+    async clearChat(chatJid, options = {}) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const deleteStarred = options.deleteStarred === true;
+        const deleteMedia = options.deleteMedia === true;
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.CLEAR_CHAT,
+            chatIndexJid,
+            value: {
+                clearChatAction: {
+                    messageRange
+                }
+            },
+            timestamp,
+            indexPartsTail: [deleteStarred ? '1' : '0', deleteMedia ? '1' : '0']
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async deleteChat(chatJid, options = {}) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const deleteMedia = options.deleteMedia === true;
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.DELETE_CHAT,
+            chatIndexJid,
+            value: {
+                deleteChatAction: {
+                    messageRange
+                }
+            },
+            timestamp,
+            indexPartsTail: [deleteMedia ? '1' : '0']
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async deleteMessageForMe(message, options = {}) {
+        const messageIndex = this.buildMessageMutationIndex(message);
+        const timestamp = Date.now();
+        const deleteMedia = options.deleteMedia === true;
+        const messageTimestampMs = options.messageTimestampMs;
+        let messageTimestamp;
+        if (messageTimestampMs !== undefined) {
+            if (!Number.isFinite(messageTimestampMs) ||
+                !Number.isSafeInteger(messageTimestampMs) ||
+                messageTimestampMs < 0) {
+                throw new Error(`invalid messageTimestampMs: ${messageTimestampMs}`);
+            }
+            messageTimestamp = Math.floor(messageTimestampMs / 1000);
+        }
+        const mutation = this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.DELETE_MESSAGE_FOR_ME,
+            chatIndexJid: messageIndex.chatIndexJid,
+            value: {
+                deleteMessageForMeAction: {
+                    deleteMedia,
+                    ...(messageTimestamp === undefined ? {} : { messageTimestamp })
+                }
+            },
+            timestamp,
+            indexPartsTail: messageIndex.indexPartsTail
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatLock(chatJid, locked) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [];
+        if (locked) {
+            pending.push(await this.createArchiveMutation(chatIndexJid, false, timestamp));
+            pending.push(this.createSetMutation({
+                spec: WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned: false
+                    }
+                },
+                timestamp
+            }));
+        }
+        pending.push(this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.LOCK_CHAT,
+            chatIndexJid,
+            value: {
+                lockChatAction: {
+                    locked
+                }
+            },
+            timestamp
+        }));
+        await this.enqueueAndFlush(pending);
+    }
+    async flushMutations() {
+        if (this.flushPromise) {
+            return this.flushPromise;
+        }
+        const inFlight = this.flushPendingMutationsLoop();
+        this.flushPromise = inFlight;
+        try {
+            return await inFlight;
+        }
+        finally {
+            if (this.flushPromise === inFlight) {
+                this.flushPromise = null;
+            }
+        }
+    }
+    async enqueueAndFlush(mutations) {
+        for (const mutation of mutations) {
+            this.enqueueMutation(mutation);
+        }
+        await this.flushMutations();
+    }
+    enqueueMutation(mutation) {
+        const key = `${mutation.collection}\u0001${mutation.index}`;
+        if (this.pendingMutations.has(key)) {
+            this.pendingMutations.delete(key);
+        }
+        this.pendingMutations.set(key, mutation);
+    }
+    takePendingMutationsBatch() {
+        if (this.pendingMutations.size === 0) {
+            return [];
+        }
+        const batch = [...this.pendingMutations.values()];
+        this.pendingMutations.clear();
+        return batch;
+    }
+    async flushPendingMutationsLoop() {
+        while (true) {
+            const batch = this.takePendingMutationsBatch();
+            if (batch.length === 0) {
+                return;
+            }
+            this.logger.debug('app-state mutation flush start', {
+                pending: batch.length,
+                actions: this.describeMutationActions(batch)
+            });
+            const collections = [];
+            let syncResult;
+            try {
+                const seenCollections = new Set();
+                for (const mutation of batch) {
+                    if (seenCollections.has(mutation.collection)) {
+                        continue;
+                    }
+                    seenCollections.add(mutation.collection);
+                    collections.push(mutation.collection);
+                }
+                syncResult = await this.syncAppState({
+                    collections,
+                    pendingMutations: batch
+                });
+            }
+            catch (error) {
+                this.requeueMutations(batch);
+                this.logger.warn('app-state mutation flush failed', {
+                    pending: batch.length,
+                    actions: this.describeMutationActions(batch),
+                    message: toError(error).message
+                });
+                throw toError(error);
+            }
+            const stateByCollection = new Map();
+            for (const entry of syncResult.collections) {
+                stateByCollection.set(entry.collection, entry.state);
+            }
+            const failedCollections = collections.filter((collection) => {
+                const state = stateByCollection.get(collection);
+                return !state || !WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES.has(state);
+            });
+            if (failedCollections.length === 0) {
+                this.logger.debug('app-state mutation flush completed', {
+                    pending: batch.length
+                });
+                continue;
+            }
+            this.requeueMutations(batch.filter((mutation) => failedCollections.includes(mutation.collection)));
+            const error = new Error(`app-state mutation flush incomplete (${failedCollections.join(',')})`);
+            this.logger.warn('app-state mutation flush incomplete', {
+                pending: batch.length,
+                actions: this.describeMutationActions(batch),
+                failedCollections: failedCollections.join(','),
+                message: error.message
+            });
+            throw error;
+        }
+    }
+    requeueMutations(mutations) {
+        if (mutations.length === 0) {
+            return;
+        }
+        const existing = [...this.pendingMutations.values()];
+        this.pendingMutations.clear();
+        for (const mutation of mutations) {
+            this.enqueueMutation(mutation);
+        }
+        for (const mutation of existing) {
+            this.enqueueMutation(mutation);
+        }
+    }
+    createSetMutation(input) {
+        return {
+            collection: input.spec.collection,
+            operation: 'set',
+            index: this.buildMutationIndex(input.spec.action, input.chatIndexJid, input.indexPartsTail ?? []),
+            value: {
+                ...input.value,
+                timestamp: input.timestamp
+            },
+            version: input.spec.version,
+            timestamp: input.timestamp
+        };
+    }
+    async createArchiveMutation(chatIndexJid, archived, timestamp) {
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        return this.createSetMutation({
+            spec: WA_APP_STATE_CHAT_MUTATION_SPECS.ARCHIVE,
+            chatIndexJid,
+            value: {
+                archiveChatAction: {
+                    archived,
+                    messageRange
+                }
+            },
+            timestamp
+        });
+    }
+    async buildChatMessageRange(chatIndexJid) {
+        const records = await this.messageStore.listByThread(chatIndexJid, this.archiveRangeLimit);
+        const messages = [];
+        let lastMessageTimestamp;
+        let skippedMissingGroupParticipant = 0;
+        for (const record of records) {
+            const timestampSeconds = this.toOptionalTimestampSeconds(record.timestampMs);
+            const message = this.toChatMessageRangeMessage(record, chatIndexJid, timestampSeconds);
+            if (!message) {
+                skippedMissingGroupParticipant += 1;
+                continue;
+            }
+            if (timestampSeconds !== undefined &&
+                (lastMessageTimestamp === undefined || timestampSeconds > lastMessageTimestamp)) {
+                lastMessageTimestamp = timestampSeconds;
+            }
+            messages.push(message);
+        }
+        if (skippedMissingGroupParticipant > 0) {
+            this.logger.debug('app-state message range skipped invalid group messages', {
+                chatJid: chatIndexJid,
+                skippedMissingGroupParticipant
+            });
+        }
+        return {
+            ...(lastMessageTimestamp === undefined ? {} : { lastMessageTimestamp }),
+            messages
+        };
+    }
+    toChatMessageRangeMessage(record, chatIndexJid, timestampSeconds) {
+        const key = {
+            remoteJid: chatIndexJid,
+            fromMe: record.fromMe,
+            id: record.id
+        };
+        if (isGroupJid(chatIndexJid) && !record.fromMe) {
+            const participant = record.participantJid ?? record.senderJid;
+            if (!participant) {
+                return null;
+            }
+            key.participant = this.normalizeMessageRangeParticipant(participant);
+        }
+        return {
+            key,
+            ...(timestampSeconds === undefined ? {} : { timestamp: timestampSeconds })
+        };
+    }
+    normalizeMessageRangeParticipant(participantJid) {
+        const normalized = normalizeRecipientJid(participantJid);
+        if (isGroupOrBroadcastJid(normalized)) {
+            throw new Error(`invalid group/broadcast participant in message range: ${participantJid}`);
+        }
+        return normalizeDeviceJid(normalized);
+    }
+    toOptionalTimestampSeconds(timestampMs) {
+        if (timestampMs === undefined) {
+            return undefined;
+        }
+        if (!Number.isFinite(timestampMs) ||
+            !Number.isSafeInteger(timestampMs) ||
+            timestampMs < 0) {
+            return undefined;
+        }
+        return Math.floor(timestampMs / 1000);
+    }
+    normalizeChatMutationJid(chatJid) {
+        const normalized = normalizeRecipientJid(chatJid);
+        if (isGroupOrBroadcastJid(normalized)) {
+            return normalized;
+        }
+        return toUserJid(normalized);
+    }
+    buildMessageMutationIndex(message) {
+        const chatIndexJid = this.normalizeChatMutationJid(message.chatJid);
+        const messageId = message.id.trim();
+        if (messageId.length === 0) {
+            throw new Error('message id cannot be empty');
+        }
+        const fromMe = message.fromMe === true;
+        const participant = this.resolveMessageMutationParticipant(chatIndexJid, fromMe, message.participantJid);
+        return {
+            chatIndexJid,
+            indexPartsTail: [messageId, fromMe ? '1' : '0', participant]
+        };
+    }
+    resolveMessageMutationParticipant(chatIndexJid, fromMe, participantJid) {
+        if (fromMe || !isGroupOrBroadcastJid(chatIndexJid)) {
+            return '0';
+        }
+        if (!participantJid) {
+            throw new Error('participantJid is required for incoming message mutations in group/broadcast chats');
+        }
+        const normalized = normalizeRecipientJid(participantJid);
+        if (isGroupOrBroadcastJid(normalized)) {
+            throw new Error(`invalid participantJid for message mutation: ${participantJid}`);
+        }
+        return normalizeDeviceJid(normalized);
+    }
+    buildMutationIndex(action, chatIndexJid, indexPartsTail) {
+        return JSON.stringify([action, chatIndexJid, ...indexPartsTail]);
+    }
+    describeMutationActions(mutations) {
+        return mutations
+            .map((mutation) => {
+            try {
+                const parsed = JSON.parse(mutation.index);
+                if (Array.isArray(parsed) && typeof parsed[0] === 'string') {
+                    return `${mutation.collection}:${parsed[0]}`;
+                }
+            }
+            catch (error) {
+                void error;
+            }
+            return `${mutation.collection}:unknown`;
+        })
+            .join(',');
+    }
+}

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

@@ -1,21 +1,27 @@
+import { parseParticipants as parseGroupEventParticipants } from '../events/group.js';
 import { WA_DEFAULTS } from '../../protocol/defaults.js';
 import { WA_GROUP_PARTICIPANT_TYPES } from '../../protocol/group.js';
 import { WA_NODE_TAGS, WA_XMLNS } from '../../protocol/nodes.js';
 import { buildCreateGroupIq, buildGroupParticipantChangeIq, buildLeaveGroupIq } from '../../transport/node/builders/group.js';
-import { findNodeChild, getNodeChildren, getNodeChildrenByTag, hasNodeChild } from '../../transport/node/helpers.js';
+import { findNodeChild, getNodeChildrenByTagFromChildren, hasNodeChild } from '../../transport/node/helpers.js';
 import { assertIqResult, buildIqNode } from '../../transport/node/query.js';
 function parseGroupParticipants(node) {
-    const participantNodes = getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT);
-    return participantNodes.map((p) => {
-        const type = p.attrs.type ?? WA_GROUP_PARTICIPANT_TYPES.REGULAR;
-        return {
-            jid: p.attrs.jid,
+    const parsed = parseGroupEventParticipants(node);
+    const participants = [];
+    for (const participant of parsed) {
+        if (!participant.jid) {
+            continue;
+        }
+        const type = participant.role ?? WA_GROUP_PARTICIPANT_TYPES.REGULAR;
+        participants.push({
+            jid: participant.jid,
             type,
             isAdmin: type === WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
                 type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
             isSuperAdmin: type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
-        };
-    });
+        });
+    }
+    return participants;
 }
 function parseGroupMetadata(node) {
     const groupNode = node.tag === WA_NODE_TAGS.GROUP ? node : findNodeChild(node, WA_NODE_TAGS.GROUP);
@@ -94,8 +100,12 @@ export function createGroupCoordinator(options) {
             ]);
             const result = await queryWithContext('group.list', node);
             assertIqResult(result, 'group.list');
-            const groupNodes = getNodeChildren(result).flatMap((child) => getNodeChildrenByTag(child, WA_NODE_TAGS.GROUP));
-            return groupNodes.map(parseGroupMetadata);
+            const groupNodes = getNodeChildrenByTagFromChildren(result, WA_NODE_TAGS.GROUP);
+            const metadata = [];
+            for (const groupNode of groupNodes) {
+                metadata.push(parseGroupMetadata(groupNode));
+            }
+            return metadata;
         },
         queryGroupInviteInfo: async (code) => {
             const node = buildIqNode('get', WA_DEFAULTS.GROUP_SERVER, WA_XMLNS.GROUPS, [

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

@@ -1,8 +1,8 @@
 import { createIncomingBaseEvent, createIncomingFailureHandler, createIncomingGroupNotificationHandler, createIncomingNotificationHandler, createIncomingReceiptHandler, createInfoBulletinNotificationEvent, createUnhandledIncomingNodeEvent } from '../incoming.js';
 import { WA_IQ_TYPES, WA_MESSAGE_TAGS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_SIGNALING } from '../../protocol/constants.js';
 import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
-import { parseOptionalInt, parseStreamControlNode, parseSuccessPersistAttributes } from '../../transport/stream/parse.js';
-import { toError } from '../../util/primitives.js';
+import { parseStreamControlNode, parseSuccessPersistAttributes } from '../../transport/stream/parse.js';
+import { parseOptionalInt, toError } from '../../util/primitives.js';
 const INFO_BULLETIN_NOTIFICATION_TYPES = new Set([
     'offline',
     'offline_preview',
@@ -77,14 +77,20 @@ export class WaIncomingNodeCoordinator {
         return true;
     }
     async dispatchIncomingNode(node) {
+        const handlersByTag = this.nodeHandlerRegistry.get(node.tag);
+        const nodeSubtype = node.attrs.type;
         if (node.tag === WA_MESSAGE_TAGS.RECEIPT) {
-            const handlers = this.getHandlersForNode(node);
-            for (const handler of handlers) {
-                if (await handler(node)) {
-                    if (!this.isRetryReceiptType(node.attrs.type)) {
-                        this.runtime.tryResolvePendingNode(node);
+            if (handlersByTag && handlersByTag.length > 0) {
+                for (const entry of handlersByTag) {
+                    if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
+                        continue;
+                    }
+                    if (await entry.handler(node)) {
+                        if (!this.isRetryReceiptType(nodeSubtype)) {
+                            this.runtime.tryResolvePendingNode(node);
+                        }
+                        return true;
                     }
-                    return true;
                 }
             }
             return this.runtime.tryResolvePendingNode(node);
@@ -96,12 +102,14 @@ export class WaIncomingNodeCoordinator {
         if (genericHandled) {
             return true;
         }
-        const handlers = this.getHandlersForNode(node);
-        if (handlers.length === 0) {
+        if (!handlersByTag || handlersByTag.length === 0) {
             return false;
         }
-        for (const handler of handlers) {
-            if (await handler(node)) {
+        for (const entry of handlersByTag) {
+            if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
+                continue;
+            }
+            if (await entry.handler(node)) {
                 return true;
             }
         }
@@ -110,21 +118,6 @@ export class WaIncomingNodeCoordinator {
     isRetryReceiptType(type) {
         return type === 'retry' || type === 'enc_rekey_retry';
     }
-    getHandlersForNode(node) {
-        const handlersByTag = this.nodeHandlerRegistry.get(node.tag);
-        if (!handlersByTag || handlersByTag.length === 0) {
-            return [];
-        }
-        const nodeSubtype = node.attrs.type;
-        const handlers = [];
-        for (const entry of handlersByTag) {
-            if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
-                continue;
-            }
-            handlers.push(entry.handler);
-        }
-        return handlers;
-    }
     registerDefaultIncomingHandlers() {
         const runtime = this.runtime;
         this.registerIncomingHandler({