@zapo-js/fake-server 0.3.0 → 1.1.0

package/dist/esm/protocol/iq/profile.js

@@ -0,0 +1,72 @@
+/** Builders/parsers for profile picture and status IQs. */
+import { buildIqResult } from './router.js';
+export function buildGetProfilePictureResult(iq, picture) {
+    const attrs = {};
+    if (picture.url)
+        attrs.url = picture.url;
+    if (picture.directPath)
+        attrs.direct_path = picture.directPath;
+    if (picture.id)
+        attrs.id = picture.id;
+    if (picture.type)
+        attrs.type = picture.type;
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'picture',
+                attrs
+            }
+        ]
+    };
+}
+export function buildSetProfilePictureResult(iq, newId) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'picture',
+                attrs: { id: newId }
+            }
+        ]
+    };
+}
+export function parseGetProfilePictureIq(iq) {
+    const targetJid = iq.attrs.target;
+    if (!targetJid)
+        return null;
+    let type = 'preview';
+    if (Array.isArray(iq.content)) {
+        const picture = iq.content.find((child) => child.tag === 'picture');
+        if (picture && picture.attrs.type === 'image') {
+            type = 'image';
+        }
+    }
+    return { targetJid, type };
+}
+export function parseSetProfilePictureIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const picture = iq.content.find((child) => child.tag === 'picture');
+    if (!picture || !(picture.content instanceof Uint8Array))
+        return null;
+    return {
+        targetJid: iq.attrs.target,
+        imageBytes: picture.content
+    };
+}
+export function parseSetStatusIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const status = iq.content.find((child) => child.tag === 'status');
+    if (!status)
+        return null;
+    if (typeof status.content === 'string')
+        return { text: status.content };
+    if (status.content instanceof Uint8Array) {
+        return { text: new TextDecoder().decode(status.content) };
+    }
+    return { text: '' };
+}

package/dist/esm/protocol/iq/router.js

@@ -0,0 +1,117 @@
+/** IQ matcher/dispatcher used by the fake server. */
+export class WaFakeIqRouter {
+    constructor() {
+        /** High-priority handlers override default ones for a test case. */
+        this.highPriorityHandlers = [];
+        this.handlers = [];
+        this.events = {};
+    }
+    register(handler, options = {}) {
+        const list = options.priority === 'high' ? this.highPriorityHandlers : this.handlers;
+        list.push(handler);
+        return () => {
+            const index = list.indexOf(handler);
+            if (index >= 0) {
+                list.splice(index, 1);
+            }
+        };
+    }
+    setEvents(events) {
+        this.events = events;
+    }
+    async route(iq) {
+        if (iq.tag !== 'iq') {
+            return null;
+        }
+        for (const handler of this.highPriorityHandlers) {
+            if (matches(iq, handler.matcher)) {
+                const response = await handler.respond(iq);
+                if (response !== null) {
+                    return response;
+                }
+            }
+        }
+        for (const handler of this.handlers) {
+            if (matches(iq, handler.matcher)) {
+                const response = await handler.respond(iq);
+                if (response !== null) {
+                    return response;
+                }
+            }
+        }
+        this.events.onUnhandled?.(iq);
+        return null;
+    }
+}
+function matches(iq, matcher) {
+    if (matcher.id !== undefined) {
+        if (iq.attrs.id !== matcher.id)
+            return false;
+    }
+    if (matcher.type !== undefined) {
+        if (iq.attrs.type !== matcher.type)
+            return false;
+    }
+    if (matcher.xmlns !== undefined) {
+        if (iq.attrs.xmlns !== matcher.xmlns)
+            return false;
+    }
+    if (matcher.childTag !== undefined) {
+        const children = Array.isArray(iq.content) ? iq.content : null;
+        if (!children || children.length === 0)
+            return false;
+        if (children[0].tag !== matcher.childTag)
+            return false;
+    }
+    return true;
+}
+export function buildIqResult(inbound, options = {}) {
+    const id = inbound.attrs.id;
+    if (!id) {
+        throw new Error('cannot build iq result for inbound iq without an id');
+    }
+    const attrs = {
+        type: 'result',
+        id
+    };
+    if (options.from !== undefined) {
+        attrs.from = options.from;
+    }
+    else if (typeof inbound.attrs.to === 'string') {
+        attrs.from = inbound.attrs.to;
+    }
+    return {
+        tag: 'iq',
+        attrs,
+        ...(options.content ? { content: options.content } : {})
+    };
+}
+export function buildIqError(inbound, options) {
+    const id = inbound.attrs.id;
+    if (!id) {
+        throw new Error('cannot build iq error for inbound iq without an id');
+    }
+    const attrs = {
+        type: 'error',
+        id
+    };
+    if (options.from !== undefined) {
+        attrs.from = options.from;
+    }
+    else if (typeof inbound.attrs.to === 'string') {
+        attrs.from = inbound.attrs.to;
+    }
+    return {
+        tag: 'iq',
+        attrs,
+        content: [
+            {
+                tag: 'error',
+                attrs: {
+                    code: String(options.code),
+                    ...(options.text !== undefined ? { text: options.text } : {})
+                }
+            }
+        ]
+    };
+}

package/dist/esm/protocol/iq/usync.js

@@ -0,0 +1,64 @@
+/** Builder for `usync` IQ result responses. */
+export function buildUsyncDevicesResult(inboundIq, users) {
+    const id = inboundIq.attrs.id;
+    if (!id) {
+        throw new Error('cannot build usync result without an inbound id');
+    }
+    const sid = extractUsyncSid(inboundIq) ?? `usync-${id}`;
+    const userNodes = users.map((user) => ({
+        tag: 'user',
+        attrs: { jid: user.userJid },
+        content: [
+            {
+                tag: 'devices',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-list',
+                        attrs: {},
+                        content: (user.deviceIds ?? [0]).map((deviceId) => ({
+                            tag: 'device',
+                            attrs: { id: String(deviceId) }
+                        }))
+                    }
+                ]
+            }
+        ]
+    }));
+    return {
+        tag: 'iq',
+        attrs: {
+            id,
+            from: inboundIq.attrs.to ?? 's.whatsapp.net',
+            type: 'result'
+        },
+        content: [
+            {
+                tag: 'usync',
+                attrs: {
+                    sid,
+                    mode: 'query',
+                    last: 'true',
+                    index: '0'
+                },
+                content: [
+                    {
+                        tag: 'list',
+                        attrs: {},
+                        content: userNodes
+                    }
+                ]
+            }
+        ]
+    };
+}
+function extractUsyncSid(iq) {
+    if (!Array.isArray(iq.content))
+        return undefined;
+    for (const child of iq.content) {
+        if (child.tag === 'usync' && typeof child.attrs.sid === 'string') {
+            return child.attrs.sid;
+        }
+    }
+    return undefined;
+}

package/dist/esm/protocol/push/app-state-key-share.js

@@ -0,0 +1,26 @@
+/** Builder for `APP_STATE_SYNC_KEY_SHARE` protocol messages. */
+import { proto } from '../../transport/protos.js';
+export function buildAppStateSyncKeyShareMessage(input) {
+    if (input.keys.length === 0) {
+        throw new Error('buildAppStateSyncKeyShareMessage requires at least one key');
+    }
+    return {
+        protocolMessage: {
+            type: proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+            appStateSyncKeyShare: {
+                keys: input.keys.map((key) => ({
+                    keyId: { keyId: key.keyId },
+                    keyData: {
+                        keyData: key.keyData,
+                        timestamp: key.timestamp ?? Date.now(),
+                        fingerprint: {
+                            rawId: key.fingerprint?.rawId ?? 0,
+                            currentIndex: key.fingerprint?.currentIndex ?? 0,
+                            deviceIndexes: [...(key.fingerprint?.deviceIndexes ?? [])]
+                        }
+                    }
+                }))
+            }
+        }
+    };
+}

package/dist/esm/protocol/push/call-failure.js

@@ -0,0 +1,27 @@
+export function buildCall(input) {
+    const attrs = {
+        id: input.id,
+        from: input.from
+    };
+    if (input.to !== undefined)
+        attrs.to = input.to;
+    if (input.t !== undefined)
+        attrs.t = String(input.t);
+    return {
+        tag: 'call',
+        attrs,
+        ...(input.children ? { content: input.children } : {})
+    };
+}
+export function buildFailure(input) {
+    const attrs = {
+        reason: input.reason,
+        ...(input.extraAttrs ?? {})
+    };
+    if (input.location !== undefined)
+        attrs.location = input.location;
+    return {
+        tag: 'failure',
+        attrs
+    };
+}

package/dist/esm/protocol/push/chatstate.js

@@ -0,0 +1,23 @@
+/** Builder for inbound `<chatstate/>` stanzas. */
+export function buildChatstate(input) {
+    const attrs = { from: input.from };
+    if (input.participant !== undefined) {
+        attrs.participant = input.participant;
+    }
+    let stateChild;
+    if (input.state.kind === 'composing') {
+        const childAttrs = {};
+        if (input.state.media !== undefined) {
+            childAttrs.media = input.state.media;
+        }
+        stateChild = { tag: 'composing', attrs: childAttrs };
+    }
+    else {
+        stateChild = { tag: 'paused', attrs: {} };
+    }
+    return {
+        tag: 'chatstate',
+        attrs,
+        content: [stateChild]
+    };
+}

package/dist/esm/protocol/push/error-stanza.js

@@ -0,0 +1,13 @@
+export function buildIncomingErrorStanza(input) {
+    const attrs = {
+        code: String(input.code)
+    };
+    if (input.text !== undefined)
+        attrs.text = input.text;
+    if (input.from !== undefined)
+        attrs.from = input.from;
+    return {
+        tag: 'error',
+        attrs
+    };
+}

package/dist/esm/protocol/push/history-sync.js

@@ -0,0 +1,111 @@
+/** History-sync message builders (inline and external blob variants). */
+import { promisify } from 'node:util';
+import { deflate } from 'node:zlib';
+import { proto } from '../../transport/protos.js';
+const deflateAsync = promisify(deflate);
+export async function buildHistorySyncMessage(input = {}) {
+    const syncType = input.syncType ?? proto.Message.HistorySyncType.INITIAL_BOOTSTRAP;
+    const conversations = (input.conversations ?? []).map((conversation) => ({
+        id: conversation.id,
+        name: conversation.name,
+        unreadCount: conversation.unreadCount,
+        archived: conversation.archived,
+        pinned: conversation.pinned,
+        muteEndTime: conversation.muteEndTime,
+        markedAsUnread: conversation.markedAsUnread,
+        ephemeralExpiration: conversation.ephemeralExpiration,
+        messages: (conversation.messages ?? []).map((histMsg) => ({
+            message: {
+                key: {
+                    id: histMsg.id,
+                    fromMe: histMsg.fromMe ?? false,
+                    remoteJid: conversation.id,
+                    participant: histMsg.participant
+                },
+                messageTimestamp: histMsg.timestamp,
+                message: histMsg.message
+            }
+        }))
+    }));
+    const pushnames = (input.pushnames ?? []).map((entry) => ({
+        id: entry.id,
+        pushname: entry.pushname
+    }));
+    const historySync = proto.HistorySync.encode({
+        syncType: syncType,
+        chunkOrder: input.chunkOrder ?? 0,
+        progress: input.progress ?? 100,
+        conversations,
+        pushnames,
+        nctSalt: input.nctSalt
+    }).finish();
+    const compressed = await deflateAsync(historySync);
+    return {
+        protocolMessage: {
+            type: proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION,
+            historySyncNotification: {
+                syncType,
+                chunkOrder: input.chunkOrder ?? 0,
+                progress: input.progress ?? 100,
+                initialHistBootstrapInlinePayload: new Uint8Array(compressed)
+            }
+        }
+    };
+}
+export async function encodeHistorySyncPlaintext(input = {}) {
+    const syncType = input.syncType ?? proto.Message.HistorySyncType.INITIAL_BOOTSTRAP;
+    const conversations = (input.conversations ?? []).map((conversation) => ({
+        id: conversation.id,
+        name: conversation.name,
+        unreadCount: conversation.unreadCount,
+        archived: conversation.archived,
+        pinned: conversation.pinned,
+        muteEndTime: conversation.muteEndTime,
+        markedAsUnread: conversation.markedAsUnread,
+        ephemeralExpiration: conversation.ephemeralExpiration,
+        messages: (conversation.messages ?? []).map((histMsg) => ({
+            message: {
+                key: {
+                    id: histMsg.id,
+                    fromMe: histMsg.fromMe ?? false,
+                    remoteJid: conversation.id,
+                    participant: histMsg.participant
+                },
+                messageTimestamp: histMsg.timestamp,
+                message: histMsg.message
+            }
+        }))
+    }));
+    const pushnames = (input.pushnames ?? []).map((entry) => ({
+        id: entry.id,
+        pushname: entry.pushname
+    }));
+    const historySync = proto.HistorySync.encode({
+        syncType: syncType,
+        chunkOrder: input.chunkOrder ?? 0,
+        progress: input.progress ?? 100,
+        conversations,
+        pushnames,
+        nctSalt: input.nctSalt
+    }).finish();
+    const compressed = await deflateAsync(historySync);
+    return new Uint8Array(compressed);
+}
+export function buildHistorySyncExternalMessage(input) {
+    const syncType = input.syncType ?? proto.Message.HistorySyncType.INITIAL_BOOTSTRAP;
+    return {
+        protocolMessage: {
+            type: proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION,
+            historySyncNotification: {
+                syncType,
+                chunkOrder: input.chunkOrder ?? 0,
+                progress: input.progress ?? 100,
+                directPath: input.directPath,
+                mediaKey: input.mediaKey,
+                fileSha256: input.fileSha256,
+                fileEncSha256: input.fileEncSha256,
+                fileLength: input.fileLength
+            }
+        }
+    };
+}

package/dist/esm/protocol/push/message.js

@@ -0,0 +1,38 @@
+/** Builder for inbound encrypted `<message/>` stanzas. */
+export function buildMessage(input) {
+    const attrs = {
+        id: input.id,
+        from: input.from,
+        t: String(input.t ?? Math.floor(Date.now() / 1000)),
+        type: input.type ?? 'text'
+    };
+    if (input.participant !== undefined)
+        attrs.participant = input.participant;
+    if (input.notify !== undefined)
+        attrs.notify = input.notify;
+    if (input.offline !== undefined)
+        attrs.offline = String(input.offline);
+    const children = input.enc.map((enc) => {
+        const encAttrs = {
+            v: '2',
+            type: enc.type
+        };
+        if (enc.mediatype !== undefined)
+            encAttrs.mediatype = enc.mediatype;
+        return {
+            tag: 'enc',
+            attrs: encAttrs,
+            content: enc.ciphertext
+        };
+    });
+    if (input.extraChildren) {
+        for (const extra of input.extraChildren) {
+            children.push(extra);
+        }
+    }
+    return {
+        tag: 'message',
+        attrs,
+        content: children
+    };
+}

package/dist/esm/protocol/push/notification.js

@@ -0,0 +1,29 @@
+/** Builders for inbound notification stanzas. */
+export function buildNotification(input) {
+    const attrs = {
+        id: input.id,
+        type: input.type,
+        from: input.from ?? 's.whatsapp.net',
+        ...(input.extraAttrs ?? {})
+    };
+    if (input.t !== undefined)
+        attrs.t = String(input.t);
+    if (input.participant !== undefined)
+        attrs.participant = input.participant;
+    return {
+        tag: 'notification',
+        attrs,
+        ...(input.content ? { content: input.content } : {})
+    };
+}
+export function buildGroupNotification(input) {
+    // Group notifications use wire type `w:gp2`.
+    return buildNotification({
+        id: input.id,
+        type: 'w:gp2',
+        from: input.groupJid,
+        participant: input.participant,
+        t: input.t,
+        content: input.children
+    });
+}

package/dist/esm/protocol/push/presence.js

@@ -0,0 +1,14 @@
+/** Builder for inbound `<presence/>` stanzas. */
+export function buildIncomingPresence(input) {
+    const attrs = {
+        from: input.from,
+        type: input.type ?? 'available'
+    };
+    if (input.last !== undefined) {
+        attrs.last = typeof input.last === 'number' ? String(input.last) : input.last;
+    }
+    return {
+        tag: 'presence',
+        attrs
+    };
+}

package/dist/esm/protocol/push/receipt.js

@@ -0,0 +1,21 @@
+/** Builder for inbound `<receipt/>` stanzas. */
+export function buildReceipt(input) {
+    const attrs = {
+        id: input.id,
+        from: input.from
+    };
+    if (input.type !== undefined && input.type !== 'delivery') {
+        attrs.type = input.type;
+    }
+    if (input.t !== undefined)
+        attrs.t = String(input.t);
+    if (input.participant !== undefined)
+        attrs.participant = input.participant;
+    if (input.recipient !== undefined)
+        attrs.recipient = input.recipient;
+    return {
+        tag: 'receipt',
+        attrs,
+        ...(input.content ? { content: input.content } : {})
+    };
+}