zapo-js 0.1.1 → 0.2.0

package/dist/client/coordinators/WaAppStateMutationCoordinator.js

@@ -0,0 +1,471 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAppStateMutationCoordinator = void 0;
+const constants_1 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const coercion_1 = require("../../util/coercion");
+const primitives_1 = require("../../util/primitives");
+const WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES = new Set([
+    constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS,
+    constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
+]);
+const WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT = 256;
+class WaAppStateMutationCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.messageStore = options.messageStore;
+        this.syncAppState = options.syncAppState;
+        this.archiveRangeLimit = (0, coercion_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.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: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned: false
+                    }
+                },
+                timestamp
+            }));
+        }
+        pending.push(this.createSetMutation({
+            spec: constants_1.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: (0, primitives_1.toError)(error).message
+                });
+                throw (0, primitives_1.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: constants_1.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 ((0, jid_1.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 = (0, jid_1.normalizeRecipientJid)(participantJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            throw new Error(`invalid group/broadcast participant in message range: ${participantJid}`);
+        }
+        return (0, jid_1.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 = (0, jid_1.normalizeRecipientJid)(chatJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            return normalized;
+        }
+        return (0, jid_1.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 || !(0, jid_1.isGroupOrBroadcastJid)(chatIndexJid)) {
+            return '0';
+        }
+        if (!participantJid) {
+            throw new Error('participantJid is required for incoming message mutations in group/broadcast chats');
+        }
+        const normalized = (0, jid_1.normalizeRecipientJid)(participantJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            throw new Error(`invalid participantJid for message mutation: ${participantJid}`);
+        }
+        return (0, jid_1.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(',');
+    }
+}
+exports.WaAppStateMutationCoordinator = WaAppStateMutationCoordinator;