zapo-js 0.2.0 → 1.0.0

package/dist/esm/client/newsletter/messaging.js

@@ -0,0 +1,194 @@
+import { buildNewsletterMessageContent } from '../newsletter/content.js';
+import { ensureTosAccepted, runMex } from '../newsletter/mex.js';
+import { WA_NEWSLETTER_MUTE_TYPES, WA_NEWSLETTER_MUTE_VALUES } from '../../protocol/newsletter.js';
+import { WA_NEWSLETTER_NOTIFICATION_TAGS } from '../../protocol/notification.js';
+import { buildNewsletterMessageNode, buildNewsletterMessagesIq, buildNewsletterMessageUpdatesIq, buildNewsletterSubscribeLiveUpdatesIq, buildNewsletterViewReceiptNode } from '../../transport/node/builders/newsletter.js';
+import { findNodeChild } from '../../transport/node/helpers.js';
+async function buildContent(deps, content, ctx) {
+    return buildNewsletterMessageContent({
+        logger: deps.logger,
+        mediaTransfer: deps.mediaTransfer,
+        getMediaConn: deps.getMediaConn
+    }, content, ctx);
+}
+function toUploadSummary(built) {
+    if (!built.upload)
+        return undefined;
+    return {
+        url: built.upload.url,
+        directPath: built.upload.directPath,
+        fileSha256: built.upload.fileSha256,
+        fileLength: built.upload.fileLength,
+        metadataUrl: built.upload.metadataUrl
+    };
+}
+function buildDispatchNode(newsletterJid, stanzaId, built, edit, additionalAttributes) {
+    if (built.kind === 'poll-creation') {
+        if (edit) {
+            throw new Error('newsletter poll creation cannot be sent as an edit');
+        }
+        return buildNewsletterMessageNode({
+            kind: 'poll-creation',
+            to: newsletterJid,
+            id: stanzaId,
+            plaintext: built.plaintext,
+            additionalAttributes
+        });
+    }
+    if (built.kind === 'media') {
+        if (built.mediaType === null) {
+            throw new Error('newsletter media content missing mediaType attribute');
+        }
+        return buildNewsletterMessageNode(edit
+            ? {
+                kind: 'edit-media',
+                to: newsletterJid,
+                parentMessageId: edit.parentMessageId,
+                plaintext: built.plaintext,
+                mediaType: built.mediaType,
+                additionalAttributes
+            }
+            : {
+                kind: 'media',
+                to: newsletterJid,
+                id: stanzaId,
+                plaintext: built.plaintext,
+                mediaType: built.mediaType,
+                mediaHandle: built.upload?.handle,
+                additionalAttributes
+            });
+    }
+    return buildNewsletterMessageNode(edit
+        ? {
+            kind: 'edit-text',
+            to: newsletterJid,
+            parentMessageId: edit.parentMessageId,
+            plaintext: built.plaintext,
+            additionalAttributes
+        }
+        : {
+            kind: 'text',
+            to: newsletterJid,
+            id: stanzaId,
+            plaintext: built.plaintext,
+            additionalAttributes
+        });
+}
+export function createMessagingOps(deps) {
+    async function resolveStanzaId(provided) {
+        return provided ?? deps.generateStanzaId();
+    }
+    return {
+        send: async (newsletterJid, content, sendOptions) => {
+            const stanzaId = await resolveStanzaId(sendOptions?.stanzaId);
+            const built = await buildContent(deps, content, sendOptions?.contextInfo);
+            const node = buildDispatchNode(newsletterJid, stanzaId, built, null, sendOptions?.additionalAttributes);
+            const result = await deps.publishMessageNode(node);
+            return { ...result, upload: toUploadSummary(built) };
+        },
+        editMessage: async (newsletterJid, parentMessageId, content) => {
+            const built = await buildContent(deps, content);
+            if (built.kind === 'poll-creation') {
+                throw new Error('newsletter poll creations cannot be edited');
+            }
+            const node = buildDispatchNode(newsletterJid, parentMessageId, built, {
+                parentMessageId
+            });
+            const result = await deps.publishMessageNode(node);
+            return { ...result, upload: toUploadSummary(built) };
+        },
+        react: async (input) => {
+            const stanzaId = await resolveStanzaId(input.stanzaId);
+            await deps.sendNode(buildNewsletterMessageNode(input.revoke
+                ? {
+                    kind: 'reaction-revoke',
+                    to: input.newsletterJid,
+                    id: stanzaId,
+                    parentMessageServerId: input.parentMessageServerId
+                }
+                : {
+                    kind: 'reaction',
+                    to: input.newsletterJid,
+                    id: stanzaId,
+                    parentMessageServerId: input.parentMessageServerId,
+                    reactionCode: input.reactionCode
+                }));
+            return { stanzaId };
+        },
+        revoke: async (input) => {
+            const node = buildNewsletterMessageNode({
+                kind: 'revoke',
+                to: input.newsletterJid,
+                originalMessageId: input.originalMessageId
+            });
+            const result = await deps.publishMessageNode(node);
+            return { stanzaId: result.id };
+        },
+        votePoll: async (input) => {
+            const stanzaId = await resolveStanzaId(input.stanzaId);
+            await deps.sendNode(buildNewsletterMessageNode({
+                kind: 'poll-vote',
+                to: input.newsletterJid,
+                id: stanzaId,
+                parentMessageServerId: input.parentMessageServerId,
+                votes: input.votes,
+                contentType: input.contentType
+            }));
+            return { stanzaId };
+        },
+        sendViewReceipt: async (input) => {
+            const stanzaId = await resolveStanzaId(input.stanzaId);
+            await deps.sendNode(buildNewsletterViewReceiptNode({
+                to: input.newsletterJid,
+                id: stanzaId,
+                itemServerIds: input.itemServerIds
+            }));
+            return { stanzaId };
+        },
+        fetchMessages: async (input) => {
+            if (!deps.queryWithContext) {
+                throw new Error('newsletter fetchMessages requires queryWithContext');
+            }
+            return deps.queryWithContext('newsletter.fetch_messages', buildNewsletterMessagesIq(input));
+        },
+        fetchMessageUpdates: async (input) => {
+            if (!deps.queryWithContext) {
+                throw new Error('newsletter fetchMessageUpdates requires queryWithContext');
+            }
+            return deps.queryWithContext('newsletter.fetch_message_updates', buildNewsletterMessageUpdatesIq(input));
+        },
+        subscribeLiveUpdates: async (newsletterJid) => {
+            if (!deps.queryWithContext) {
+                throw new Error('newsletter subscribeLiveUpdates requires queryWithContext');
+            }
+            const response = await deps.queryWithContext('newsletter.subscribe_live_updates', buildNewsletterSubscribeLiveUpdatesIq(newsletterJid));
+            const liveUpdates = findNodeChild(response, WA_NEWSLETTER_NOTIFICATION_TAGS.LIVE_UPDATES);
+            const durationAttr = liveUpdates?.attrs.duration;
+            const parsed = durationAttr ? Number.parseInt(durationAttr, 10) : NaN;
+            if (!Number.isFinite(parsed) || parsed < 30 || parsed > 600) {
+                throw new Error(`newsletter subscribeLiveUpdates returned invalid duration: ${durationAttr}`);
+            }
+            return { durationSeconds: parsed };
+        },
+        follow: async (newsletterJid) => {
+            await ensureTosAccepted(deps, 'consumer');
+            await runMex(deps, 'JoinNewsletter', { newsletter_id: newsletterJid });
+        },
+        unfollow: async (newsletterJid) => {
+            await runMex(deps, 'LeaveNewsletter', { newsletter_id: newsletterJid });
+        },
+        mute: async (input) => {
+            const muteType = input.type === 'admin'
+                ? WA_NEWSLETTER_MUTE_TYPES.ADMIN_ACTIVITY
+                : WA_NEWSLETTER_MUTE_TYPES.FOLLOWER_ACTIVITY;
+            const value = input.mute ? WA_NEWSLETTER_MUTE_VALUES.ON : WA_NEWSLETTER_MUTE_VALUES.OFF;
+            await runMex(deps, 'UpdateNewsletterUserSetting', {
+                input: {
+                    newsletter_id: input.newsletterJid,
+                    type: muteType,
+                    value
+                }
+            });
+        }
+    };
+}

package/dist/esm/client/newsletter/mex.js

@@ -0,0 +1,37 @@
+import { buildTosQueryIq, buildTosUpdateIq, parseTosQueryResponse } from '../../transport/node/builders/tos.js';
+import { runMexQuery } from '../../transport/node/mex/client.js';
+import { toError } from '../../util/primitives.js';
+export async function runMex(deps, opKey, variables) {
+    return runMexQuery(deps.mexSocket, opKey, variables);
+}
+function resolveTosId(deps, kind) {
+    if (!deps.getAbPropString)
+        return null;
+    const propName = kind === 'creation'
+        ? 'newsletter_creation_tos_id'
+        : kind === 'consumer'
+            ? 'newsletter_tos_notice_id'
+            : 'newsletter_admin_invite_tos_id';
+    const id = deps.getAbPropString(propName);
+    return id.length > 0 ? id : null;
+}
+export async function ensureTosAccepted(deps, kind) {
+    const noticeId = resolveTosId(deps, kind);
+    if (!noticeId || !deps.queryWithContext)
+        return;
+    try {
+        const response = await deps.queryWithContext('newsletter.query_tos', buildTosQueryIq([noticeId]));
+        const parsed = parseTosQueryResponse(response);
+        const existing = parsed.notices.find((entry) => entry.id === noticeId);
+        if (existing?.accepted)
+            return;
+        await deps.queryWithContext('newsletter.accept_tos', buildTosUpdateIq([noticeId]));
+    }
+    catch (error) {
+        deps.logger.warn('newsletter tos auto-accept failed', {
+            kind,
+            noticeId,
+            message: toError(error).message
+        });
+    }
+}

package/dist/esm/client/newsletter/parse.js

@@ -0,0 +1,200 @@
+import { WA_NEWSLETTER_MUTE_TYPES, WA_NEWSLETTER_MUTE_VALUES, WA_NEWSLETTER_STATE_TYPES } from '../../protocol/newsletter.js';
+import { tryAsNumber } from '../../util/coercion.js';
+function asUndef(value) {
+    return value === null ? undefined : value;
+}
+function parsePicture(raw) {
+    if (!raw)
+        return undefined;
+    if (!raw.id && !raw.direct_path)
+        return undefined;
+    return { id: raw.id, directPath: raw.direct_path };
+}
+function parseAdminProfile(raw) {
+    if (!raw?.name)
+        return null;
+    return {
+        id: raw.id,
+        name: raw.name,
+        pictureId: raw.picture?.id,
+        pictureDirectPath: raw.picture?.direct_path
+    };
+}
+function parsePageInfo(raw) {
+    if (!raw)
+        return undefined;
+    return {
+        hasNextPage: raw.hasNextPage,
+        hasPreviousPage: raw.hasPreviousPage,
+        startCursor: raw.startCursor,
+        endCursor: raw.endCursor
+    };
+}
+export function parseNewsletterMetadata(envelope) {
+    const meta = envelope?.thread_metadata;
+    const viewer = envelope?.viewer_metadata;
+    const name = meta?.name;
+    const description = meta?.description;
+    let mutedAdmin;
+    let mutedFollower;
+    for (const setting of viewer?.settings ?? []) {
+        if (setting?.type === WA_NEWSLETTER_MUTE_TYPES.ADMIN_ACTIVITY) {
+            mutedAdmin = setting.value === WA_NEWSLETTER_MUTE_VALUES.ON;
+        }
+        else if (setting?.type === WA_NEWSLETTER_MUTE_TYPES.FOLLOWER_ACTIVITY) {
+            mutedFollower = setting.value === WA_NEWSLETTER_MUTE_VALUES.ON;
+        }
+    }
+    return {
+        jid: envelope?.id ?? '',
+        state: envelope?.state?.type ?? WA_NEWSLETTER_STATE_TYPES.ACTIVE,
+        creationTime: asUndef(tryAsNumber(meta?.creation_time)),
+        name: name?.text,
+        nameUpdateTime: asUndef(tryAsNumber(name?.update_time)),
+        description: description?.text,
+        descriptionUpdateTime: asUndef(tryAsNumber(description?.update_time)),
+        picture: parsePicture(meta?.picture),
+        preview: parsePicture(meta?.preview),
+        invite: meta?.invite,
+        handle: meta?.handle,
+        subscribersCount: asUndef(tryAsNumber(meta?.subscribers_count)),
+        verification: meta?.verification,
+        viewerRole: viewer?.role,
+        mutedAdmin,
+        mutedFollower
+    };
+}
+export function parseAdminInfo(data) {
+    const admin = data?.xwa2_newsletter_admin;
+    if (!admin)
+        return { adminProfile: null };
+    return {
+        adminCount: admin.admin_count,
+        adminProfile: parseAdminProfile(admin.admin_profile)
+    };
+}
+export function parseAdminCapabilities(data) {
+    return new Set(data?.xwa2_newsletter_admin?.capabilities ?? []);
+}
+export function parsePendingInvites(data) {
+    const invites = data?.xwa2_newsletter_admin?.pending_admin_invites ?? [];
+    const result = [];
+    for (const invite of invites) {
+        const id = invite?.user?.pn ?? invite?.user?.id;
+        if (id)
+            result.push(id);
+    }
+    return result;
+}
+export function parseFollowers(data) {
+    const followersWrap = data?.xwa2_newsletter_followers?.followers;
+    const followers = [];
+    for (const edge of followersWrap?.edges ?? []) {
+        const node = edge?.node;
+        if (!node?.id)
+            continue;
+        followers.push({
+            id: node.id,
+            displayName: node.display_name,
+            role: edge.role,
+            phoneJid: node.pn,
+            username: node.username_info?.username,
+            followTime: asUndef(tryAsNumber(edge.follow_time)),
+            adminProfile: parseAdminProfile(edge.admin_profile)
+        });
+    }
+    return { followers };
+}
+function parseDirectoryResponse(root) {
+    return {
+        results: (root?.result ?? []).map(parseNewsletterMetadata),
+        pageInfo: parsePageInfo(root?.page_info)
+    };
+}
+export function parseDirectorySearch(data) {
+    return parseDirectoryResponse(data?.xwa2_newsletters_directory_search);
+}
+export function parseDirectoryList(data) {
+    return parseDirectoryResponse(data?.xwa2_newsletters_directory_list);
+}
+export function parseRecommended(data) {
+    return parseDirectoryResponse(data?.xwa2_newsletters_recommended).results;
+}
+export function parseSimilar(data) {
+    return parseDirectoryResponse(data?.xwa2_newsletters_similar).results;
+}
+export function parseDomainsPreviewable(data) {
+    const map = new Map();
+    for (const preview of data?.xwa2_newsletter_message_integrity?.url_previews ?? []) {
+        if (preview?.url_domain) {
+            map.set(preview.url_domain, preview.is_previewable === true);
+        }
+    }
+    return map;
+}
+export function parseDirectoryCategoriesPreview(data) {
+    const result = [];
+    for (const entry of data?.xwa2_newsletters_directory_category_preview?.result ?? []) {
+        if (!entry?.category)
+            continue;
+        result.push({
+            category: entry.category,
+            categoryTitle: entry.category_title,
+            newsletters: (entry.newsletters ?? []).map(parseNewsletterMetadata)
+        });
+    }
+    return result;
+}
+export function parseDehydratedMetadata(data) {
+    const node = data?.xwa2_newsletter;
+    const meta = node?.thread_metadata;
+    return {
+        jid: node?.id ?? '',
+        subscribersCount: asUndef(tryAsNumber(meta?.subscribers_count)),
+        verification: meta?.verification,
+        reactionCodesSetting: meta?.settings?.reaction_codes?.value,
+        wamoSubPlanId: meta?.wamo_sub?.plan_id,
+        wamoSubStatus: node?.viewer_metadata?.wamo_sub_status
+    };
+}
+export function parseAdminInviteResult(data) {
+    const root = data?.xwa2_newsletter_admin_invite_create;
+    return {
+        inviteId: root?.id,
+        expirationTime: asUndef(tryAsNumber(root?.invite_expiration_time))
+    };
+}
+export function parseReactionSenders(data) {
+    const reactions = data?.xwa2_newsletters_reaction_sender_list?.reactions ?? [];
+    return reactions.map((entry) => {
+        const senders = [];
+        for (const edge of entry?.sender_list?.edges ?? []) {
+            if (!edge?.node?.id)
+                continue;
+            senders.push({
+                id: edge.node.id,
+                profileUrl: edge.node.profile_pic_direct_path
+            });
+        }
+        return { reactionCode: entry?.reaction_code ?? '', senders };
+    });
+}
+export function parsePollVoters(data) {
+    const map = new Map();
+    for (const group of data?.voter_list?.votes ?? []) {
+        if (!group?.vote_hash)
+            continue;
+        const voters = [];
+        for (const edge of group.voter_list?.edges ?? []) {
+            if (!edge?.node?.id)
+                continue;
+            const time = tryAsNumber(edge.action_time);
+            voters.push({
+                id: edge.node.id,
+                time: time !== null ? Math.floor(time / 1000000) : undefined
+            });
+        }
+        map.set(group.vote_hash, voters);
+    }
+    return map;
+}

package/dist/esm/client/persistence/WriteBehindPersistence.js

@@ -25,7 +25,15 @@ function mergeContact(previous, incoming) {
 export class WriteBehindPersistence {
     constructor(stores, logger, options = {}) {
         this.logger = logger;
+        this.stores = stores;
+        this.options = options;
         this.flushTimeoutMs = options.flushTimeoutMs ?? 5000;
+        this.queues = this.buildQueues();
+        this.destroyed = false;
+    }
+    buildQueues() {
+        const stores = this.stores;
+        const options = this.options;
         const queueOptions = (domain) => ({
             maxPendingKeys: options.maxPendingKeys ?? 4096,
             maxWriteConcurrency: options.maxWriteConcurrency ?? 4,
@@ -51,18 +59,36 @@ export class WriteBehindPersistence {
                 });
             }
         });
-        this.queues = {
-            messages: new BackgroundQueue((_key, value) => stores.messageStore.upsert(value), queueOptions('messages')),
+        return {
+            messages: new BackgroundQueue((_key, value) => stores.messageStore.upsert(value), {
+                ...queueOptions('messages'),
+                batchWriter: (entries) => stores.messageStore.upsertBatch(entries.map((e) => e.value))
+            }),
             threads: new BackgroundQueue((_key, value) => stores.threadStore.upsert(value), {
                 ...queueOptions('threads'),
-                coalesce: (previous, incoming) => mergeThread(previous, incoming)
+                coalesce: (previous, incoming) => mergeThread(previous, incoming),
+                batchWriter: (entries) => stores.threadStore.upsertBatch(entries.map((e) => e.value))
             }),
             contacts: new BackgroundQueue((_key, value) => stores.contactStore.upsert(value), {
                 ...queueOptions('contacts'),
-                coalesce: (previous, incoming) => mergeContact(previous, incoming)
+                coalesce: (previous, incoming) => mergeContact(previous, incoming),
+                batchWriter: (entries) => stores.contactStore.upsertBatch(entries.map((e) => e.value))
             })
         };
     }
+    /**
+     * Re-arm the queues after a previous {@link destroy} call. Idempotent —
+     * a no-op when the persistence is already live. Used by `WaClient.connect`
+     * to recover from a logout/clear-stored-state cycle without leaking the
+     * old destroyed queues into the next session.
+     */
+    restart() {
+        if (!this.destroyed) {
+            return;
+        }
+        this.queues = this.buildQueues();
+        this.destroyed = false;
+    }
     persistMessage(record) {
         this.queues.messages.enqueue(`msg:${record.id}`, record);
     }
@@ -103,6 +129,7 @@ export class WriteBehindPersistence {
             this.queues.threads.destroy(timeoutMs),
             this.queues.contacts.destroy(timeoutMs)
         ]);
+        this.destroyed = true;
         const result = this.toDrainResult(messages, threads, contacts);
         if (result.remaining > 0) {
             this.logger.warn('write-behind destroy finished with pending writes', {