zapo-js 0.1.0

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

@@ -0,0 +1,311 @@
+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';
+const INFO_BULLETIN_NOTIFICATION_TYPES = new Set([
+    'offline',
+    'offline_preview',
+    'priority_offline_complete',
+    'tos',
+    'thread_metadata',
+    'client_expiration'
+]);
+export class WaIncomingNodeCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.nodeHandlerRegistry = new Map();
+        this.registerDefaultIncomingHandlers();
+        this.mediaConnWarmupPromise = null;
+    }
+    async handleIncomingNode(node) {
+        this.logger.trace('wa client incoming node', {
+            tag: node.tag,
+            id: node.attrs.id,
+            type: node.attrs.type
+        });
+        const streamControlResult = parseStreamControlNode(node);
+        if (streamControlResult) {
+            await this.runtime.handleStreamControlResult(streamControlResult);
+            return;
+        }
+        if (await this.handleSuccessNode(node)) {
+            return;
+        }
+        if (await this.handleInfoBulletinNode(node)) {
+            return;
+        }
+        const handled = await this.dispatchIncomingNode(node);
+        if (handled) {
+            return;
+        }
+        this.runtime.emitUnhandledIncomingNode(createUnhandledIncomingNodeEvent(node));
+    }
+    registerIncomingHandler(registration) {
+        const handlersByTag = this.nodeHandlerRegistry.get(registration.tag);
+        const entry = {
+            subtype: registration.subtype,
+            handler: registration.handler
+        };
+        if (!handlersByTag) {
+            this.nodeHandlerRegistry.set(registration.tag, [entry]);
+        }
+        else if (registration.prepend) {
+            handlersByTag.unshift(entry);
+        }
+        else {
+            handlersByTag.push(entry);
+        }
+        return () => {
+            this.unregisterIncomingHandler(registration);
+        };
+    }
+    unregisterIncomingHandler(registration) {
+        const handlersByTag = this.nodeHandlerRegistry.get(registration.tag);
+        if (!handlersByTag || handlersByTag.length === 0) {
+            return false;
+        }
+        const index = handlersByTag.findIndex((entry) => entry.subtype === registration.subtype && entry.handler === registration.handler);
+        if (index === -1) {
+            return false;
+        }
+        handlersByTag.splice(index, 1);
+        if (handlersByTag.length === 0) {
+            this.nodeHandlerRegistry.delete(registration.tag);
+        }
+        return true;
+    }
+    async dispatchIncomingNode(node) {
+        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);
+                    }
+                    return true;
+                }
+            }
+            return this.runtime.tryResolvePendingNode(node);
+        }
+        if (this.runtime.tryResolvePendingNode(node)) {
+            return true;
+        }
+        const genericHandled = await this.runtime.handleGenericIncomingNode(node);
+        if (genericHandled) {
+            return true;
+        }
+        const handlers = this.getHandlersForNode(node);
+        if (handlers.length === 0) {
+            return false;
+        }
+        for (const handler of handlers) {
+            if (await handler(node)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    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({
+            tag: WA_NODE_TAGS.IQ,
+            subtype: WA_IQ_TYPES.SET,
+            handler: runtime.handleIncomingIqSetNode
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            handler: runtime.handleLinkCodeNotificationNode
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            subtype: WA_SIGNALING.COMPANION_REG_REFRESH_NOTIFICATION,
+            handler: runtime.handleCompanionRegRefreshNotificationNode
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            subtype: WA_NOTIFICATION_TYPES.GROUP,
+            handler: createIncomingGroupNotificationHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitGroupEvent: runtime.emitGroupEvent,
+                emitUnhandledStanza: runtime.emitUnhandledIncomingNode
+            })
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            handler: createIncomingNotificationHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitIncomingNotification: runtime.emitIncomingNotification,
+                emitUnhandledStanza: runtime.emitUnhandledIncomingNode,
+                syncAppState: runtime.syncAppState
+            })
+        });
+        this.registerIncomingHandler({
+            tag: WA_MESSAGE_TAGS.MESSAGE,
+            handler: runtime.handleIncomingMessageNode
+        });
+        this.registerIncomingHandler({
+            tag: WA_MESSAGE_TAGS.RECEIPT,
+            handler: createIncomingReceiptHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                handleIncomingRetryReceipt: runtime.handleIncomingRetryReceipt,
+                trackOutboundReceipt: runtime.trackOutboundReceipt,
+                emitIncomingReceipt: runtime.emitIncomingReceipt
+            })
+        });
+        this.registerIncomingHandler({
+            tag: 'presence',
+            handler: async (node) => {
+                runtime.emitIncomingPresence(createIncomingBaseEvent(node));
+                return true;
+            }
+        });
+        this.registerIncomingHandler({
+            tag: 'chatstate',
+            handler: async (node) => {
+                runtime.emitIncomingChatstate({
+                    ...createIncomingBaseEvent(node),
+                    participantJid: node.attrs.participant
+                });
+                return true;
+            }
+        });
+        this.registerIncomingHandler({
+            tag: 'call',
+            handler: async (node) => {
+                runtime.emitIncomingCall(createIncomingBaseEvent(node));
+                return true;
+            }
+        });
+        this.registerIncomingHandler({
+            tag: 'failure',
+            handler: createIncomingFailureHandler({
+                logger: this.logger,
+                emitIncomingFailure: runtime.emitIncomingFailure,
+                disconnect: runtime.disconnect,
+                clearStoredCredentials: runtime.clearStoredCredentials
+            })
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.ERROR,
+            handler: async (node) => {
+                runtime.emitIncomingErrorStanza(createIncomingBaseEvent(node));
+                return true;
+            }
+        });
+    }
+    async handleSuccessNode(node) {
+        if (node.tag !== WA_NODE_TAGS.SUCCESS) {
+            return false;
+        }
+        const persistAttributes = parseSuccessPersistAttributes(node, (error) => {
+            this.logger.warn('invalid companion_enc_static in success node', {
+                message: error.message
+            });
+        });
+        this.logger.info('received success node', {
+            t: node.attrs.t,
+            props: node.attrs.props,
+            abprops: node.attrs.abprops,
+            location: node.attrs.location,
+            hasCompanionEncStatic: persistAttributes.companionEncStatic !== undefined,
+            meLid: persistAttributes.meLid,
+            meDisplayName: persistAttributes.meDisplayName
+        });
+        this.runtime.emitSuccessNode(node);
+        if (persistAttributes.lastSuccessTs !== undefined) {
+            this.runtime.updateClockSkewFromSuccess(persistAttributes.lastSuccessTs);
+        }
+        await this.runtime.persistSuccessAttributes(persistAttributes);
+        this.scheduleMediaConnWarmup();
+        return true;
+    }
+    scheduleMediaConnWarmup() {
+        if (this.mediaConnWarmupPromise) {
+            return;
+        }
+        this.mediaConnWarmupPromise = (async () => {
+            try {
+                if (!this.runtime.shouldWarmupMediaConn()) {
+                    return;
+                }
+                await this.runtime.warmupMediaConn();
+                this.logger.debug('post-login media_conn warmup completed');
+            }
+            catch (error) {
+                this.logger.warn('post-login media_conn warmup failed', {
+                    message: toError(error).message
+                });
+            }
+            finally {
+                this.mediaConnWarmupPromise = null;
+            }
+        })();
+    }
+    async handleInfoBulletinNode(node) {
+        if (node.tag !== WA_NODE_TAGS.INFO_BULLETIN) {
+            return false;
+        }
+        let handled = false;
+        const ibType = node.attrs.type;
+        if (ibType && INFO_BULLETIN_NOTIFICATION_TYPES.has(ibType)) {
+            this.runtime.emitIncomingNotification(createInfoBulletinNotificationEvent(node, ibType, {
+                count: parseOptionalInt(node.attrs.count),
+                t: parseOptionalInt(node.attrs.t)
+            }));
+            handled = true;
+        }
+        const edgeRoutingNode = findNodeChild(node, WA_NODE_TAGS.EDGE_ROUTING);
+        if (edgeRoutingNode) {
+            const routingInfoNode = findNodeChild(edgeRoutingNode, WA_NODE_TAGS.ROUTING_INFO);
+            if (routingInfoNode) {
+                try {
+                    const routingInfo = decodeNodeContentBase64OrBytes(routingInfoNode.content, `ib.${WA_NODE_TAGS.EDGE_ROUTING}.${WA_NODE_TAGS.ROUTING_INFO}`);
+                    await this.runtime.persistRoutingInfo(routingInfo);
+                    this.logger.info('updated routing info from info bulletin', {
+                        byteLength: routingInfo.byteLength
+                    });
+                }
+                catch (error) {
+                    this.logger.warn('failed to process routing info from info bulletin', {
+                        message: toError(error).message
+                    });
+                }
+            }
+            handled = true;
+        }
+        const dirtyNodes = getNodeChildrenByTag(node, WA_NODE_TAGS.DIRTY);
+        const dirtyBits = this.runtime.parseDirtyBits(dirtyNodes);
+        if (dirtyBits.length > 0) {
+            void this.runtime.handleDirtyBits(dirtyBits).catch((error) => {
+                this.logger.warn('dirty bits sync failed', {
+                    message: toError(error).message
+                });
+            });
+            handled = true;
+        }
+        return handled;
+    }
+}