zapo-js 0.2.0 → 1.0.0

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

@@ -0,0 +1,162 @@
+import { ensureTosAccepted, runMex } from '../newsletter/mex.js';
+import { parseAdminCapabilities, parseAdminInfo, parseAdminInviteResult, parseFollowers, parseNewsletterMetadata, parsePendingInvites, parsePollVoters, parseReactionSenders } from '../newsletter/parse.js';
+import { buildTosQueryIq, buildTosUpdateIq, parseTosQueryResponse } from '../../transport/node/builders/tos.js';
+import { assertIqResult } from '../../transport/node/query.js';
+import { bytesToBase64 } from '../../util/bytes.js';
+/** Builds the admin operation set. */
+export function createAdminOps(deps) {
+    return {
+        create: async (input) => {
+            await ensureTosAccepted(deps, 'creation');
+            const data = await runMex(deps, 'CreateNewsletter', {
+                input: {
+                    name: input.name,
+                    description: input.description,
+                    picture: input.picture ? bytesToBase64(input.picture) : undefined
+                }
+            });
+            if (!data?.xwa2_newsletter_create) {
+                throw new Error('newsletter create returned no envelope');
+            }
+            return parseNewsletterMetadata(data.xwa2_newsletter_create);
+        },
+        update: async (newsletterJid, input) => {
+            const updates = {};
+            if (input.name !== undefined)
+                updates.name = input.name;
+            if (input.description !== undefined)
+                updates.description = input.description;
+            if (input.picture !== undefined) {
+                updates.picture = input.picture === null ? null : bytesToBase64(input.picture);
+            }
+            if (input.reactionCodesSetting !== undefined) {
+                updates.reaction_codes = { value: input.reactionCodesSetting };
+            }
+            const data = await runMex(deps, 'UpdateNewsletter', {
+                newsletter_id: newsletterJid,
+                updates
+            });
+            if (!data?.xwa2_newsletter_update) {
+                throw new Error('newsletter update returned no envelope');
+            }
+            return parseNewsletterMetadata(data.xwa2_newsletter_update);
+        },
+        delete: async (newsletterJid) => {
+            await runMex(deps, 'DeleteNewsletter', { newsletter_id: newsletterJid });
+        },
+        fetchAdminInfo: async (newsletterJid) => {
+            const data = await runMex(deps, 'FetchNewsletterAdminInfo', {
+                newsletter_id: newsletterJid
+            });
+            return parseAdminInfo(data);
+        },
+        fetchAdminCapabilities: async (newsletterJid) => {
+            const data = await runMex(deps, 'FetchNewsletterAdminCapabilities', {
+                newsletter_id: newsletterJid
+            });
+            return parseAdminCapabilities(data);
+        },
+        fetchFollowers: async (newsletterJid, opts) => {
+            const data = await runMex(deps, 'FetchNewsletterFollowers', {
+                input: {
+                    newsletter_id: newsletterJid,
+                    count: opts?.count ?? 50
+                }
+            });
+            return parseFollowers(data);
+        },
+        fetchInsights: (newsletterJid, metrics) => {
+            if (metrics.length === 0) {
+                throw new Error('newsletter fetchInsights requires at least one metric request');
+            }
+            return runMex(deps, 'FetchNewsletterInsights', {
+                input: {
+                    newsletter_id: newsletterJid,
+                    metrics
+                }
+            });
+        },
+        fetchReports: () => runMex(deps, 'FetchNewsletterReports', {}),
+        fetchPendingInvites: async (newsletterJid) => {
+            const data = await runMex(deps, 'FetchNewsletterPendingInvites', {
+                newsletter_id: newsletterJid
+            });
+            return parsePendingInvites(data);
+        },
+        fetchEnforcements: (newsletterJid) => runMex(deps, 'FetchNewsletterEnforcements', { newsletter_id: newsletterJid }),
+        fetchPollVoters: async (input) => {
+            const data = await runMex(deps, 'FetchNewsletterPollVoters', {
+                input: {
+                    newsletter_id: input.newsletterJid,
+                    server_id: String(input.messageServerId),
+                    vote_hash: input.voteHash,
+                    limit: input.limit ?? 50
+                }
+            });
+            return parsePollVoters(data);
+        },
+        fetchMessageReactionSenders: async (input) => {
+            const data = await runMex(deps, 'FetchNewsletterMessageReactionSenderList', {
+                input: {
+                    id: input.newsletterJid,
+                    server_id: String(input.messageServerId)
+                }
+            });
+            return parseReactionSenders(data);
+        },
+        logExposures: async (exposures) => {
+            await runMex(deps, 'LogNewsletterExposures', {
+                input: {
+                    exposures: exposures.map((e) => ({
+                        newsletter_id: e.newsletterJid,
+                        capability: e.capability
+                    }))
+                }
+            });
+        },
+        changeOwner: async (input) => {
+            await runMex(deps, 'ChangeNewsletterOwner', {
+                newsletter_id: input.newsletterJid,
+                user_id: input.userJid
+            });
+        },
+        demoteAdmin: async (input) => {
+            await runMex(deps, 'DemoteNewsletterAdmin', {
+                newsletter_id: input.newsletterJid,
+                user_id: input.userJid
+            });
+        },
+        createAdminInvite: async (input) => {
+            const data = await runMex(deps, 'CreateNewsletterAdminInvite', {
+                newsletter_id: input.newsletterJid,
+                user_id: input.userJid
+            });
+            return parseAdminInviteResult(data);
+        },
+        acceptAdminInvite: async (newsletterJid) => {
+            await ensureTosAccepted(deps, 'admin_invite');
+            await runMex(deps, 'AcceptNewsletterAdminInvite', { newsletter_id: newsletterJid });
+        },
+        revokeAdminInvite: async (input) => {
+            await runMex(deps, 'RevokeNewsletterAdminInvite', {
+                newsletter_id: input.newsletterJid,
+                user_id: input.userJid
+            });
+        },
+        queryTosState: async (noticeIds) => {
+            if (!deps.queryWithContext) {
+                throw new Error('newsletter queryTosState requires queryWithContext');
+            }
+            const response = await deps.queryWithContext('newsletter.query_tos', buildTosQueryIq(noticeIds));
+            assertIqResult(response, 'newsletter.query_tos');
+            return parseTosQueryResponse(response);
+        },
+        acceptTos: async (noticeIds) => {
+            if (!deps.queryWithContext) {
+                throw new Error('newsletter acceptTos requires queryWithContext');
+            }
+            const response = await deps.queryWithContext('newsletter.accept_tos', buildTosUpdateIq(noticeIds));
+            assertIqResult(response, 'newsletter.accept_tos');
+        }
+    };
+}

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

@@ -0,0 +1,249 @@
+import { assertMediaUploadStatus, parseMediaUploadJsonBody, performPlaintextMediaUpload } from '../media.js';
+import { NEWSLETTER_MEDIA_UPLOAD_PATHS } from '../../media/constants.js';
+import { createStickerPackZipStream } from '../../media/sticker/sticker-pack.js';
+import { applyContextInfo } from '../../message/context-info.js';
+import { isSendEventMessage, isSendEventResponseMessage, isSendKeepMessage, isSendMediaMessage, isSendPinMessage, isSendPollMessage, isSendPollVoteMessage, isSendReactionMessage, isSendRevokeMessage, isSendTextMessage, resolveMessageTypeAttr, unwrapMessage } from '../../message/encode/content.js';
+import { toStickerPackProtoStickers, toStickerPackZipEntries, validateStickerPackInput } from '../../message/kinds/sticker-pack.js';
+import { proto } from '../../proto.js';
+import { WA_ENC_MEDIA_TYPES } from '../../protocol/message.js';
+import { base64ToBytes } from '../../util/bytes.js';
+export async function uploadNewsletterMedia(options, input) {
+    const upload = await performPlaintextMediaUpload({
+        mediaTransfer: options.mediaTransfer,
+        mediaConn: input.mediaConn,
+        logger: options.logger
+    }, {
+        source: input.media,
+        path: NEWSLETTER_MEDIA_UPLOAD_PATHS[input.mediaKind],
+        mimetype: input.mimetype,
+        logLabel: 'sending newsletter media upload'
+    });
+    assertMediaUploadStatus(upload.status, 'newsletter media upload');
+    const parsed = parseMediaUploadJsonBody(upload.responseBytes, 'newsletter media upload');
+    if (!parsed.url || !parsed.direct_path) {
+        throw new Error('newsletter media upload response missing url/direct_path');
+    }
+    return {
+        url: parsed.url,
+        directPath: parsed.direct_path,
+        handle: parsed.handle,
+        metadataUrl: parsed.metadata_url,
+        thumbnailDirectPath: parsed.thumbnail_info?.thumbnail_direct_path,
+        thumbnailSha256: parsed.thumbnail_info?.thumbnail_sha256
+            ? base64ToBytes(parsed.thumbnail_info.thumbnail_sha256)
+            : undefined,
+        fileSha256: upload.fileSha256,
+        fileLength: upload.byteLength,
+        mediaId: upload.mediaId
+    };
+}
+function resolveSendMediaKind(content) {
+    if (content.type === 'video' && content.gifPlayback)
+        return 'gif';
+    if (content.type === 'audio' && content.ptt)
+        return 'ptt';
+    return content.type;
+}
+function pickMediaTypeFromMessage(message) {
+    if (message.imageMessage)
+        return WA_ENC_MEDIA_TYPES.IMAGE;
+    if (message.videoMessage)
+        return message.videoMessage.gifPlayback ? WA_ENC_MEDIA_TYPES.GIF : WA_ENC_MEDIA_TYPES.VIDEO;
+    if (message.audioMessage)
+        return message.audioMessage.ptt ? WA_ENC_MEDIA_TYPES.PTT : WA_ENC_MEDIA_TYPES.AUDIO;
+    if (message.documentMessage)
+        return WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (message.stickerMessage)
+        return WA_ENC_MEDIA_TYPES.STICKER;
+    if (message.stickerPackMessage)
+        return WA_ENC_MEDIA_TYPES.STICKER_PACK;
+    if (message.ptvMessage)
+        return WA_ENC_MEDIA_TYPES.PTV;
+    return null;
+}
+function buildMediaProtoMessage(content, upload) {
+    const common = {
+        url: upload.url,
+        directPath: upload.directPath,
+        mimetype: 'mimetype' in content ? content.mimetype : undefined,
+        fileSha256: upload.fileSha256,
+        fileLength: upload.fileLength
+    };
+    switch (content.type) {
+        case 'image':
+            return {
+                imageMessage: {
+                    ...content,
+                    ...common,
+                    type: undefined,
+                    media: undefined
+                }
+            };
+        case 'video':
+            return {
+                videoMessage: {
+                    ...content,
+                    ...common,
+                    type: undefined,
+                    media: undefined
+                }
+            };
+        case 'ptv':
+            return {
+                ptvMessage: {
+                    ...content,
+                    ...common,
+                    type: undefined,
+                    media: undefined
+                }
+            };
+        case 'audio':
+            return {
+                audioMessage: {
+                    ...content,
+                    ...common,
+                    type: undefined,
+                    media: undefined
+                }
+            };
+        case 'document':
+            return {
+                documentMessage: {
+                    ...content,
+                    ...common,
+                    type: undefined,
+                    media: undefined
+                }
+            };
+        case 'sticker':
+            return {
+                stickerMessage: {
+                    ...content,
+                    ...common,
+                    mimetype: common.mimetype ?? 'image/webp',
+                    type: undefined,
+                    media: undefined
+                }
+            };
+    }
+}
+function toUploadMedia(media) {
+    if (media instanceof Uint8Array)
+        return media;
+    if (media instanceof ArrayBuffer)
+        return new Uint8Array(media);
+    return media;
+}
+export async function buildNewsletterMessageContent(options, content, ctx) {
+    if (typeof content === 'string') {
+        const message = applyContextInfo({ conversation: content }, ctx);
+        return {
+            kind: 'text',
+            plaintext: proto.Message.encode(message).finish(),
+            mediaType: null,
+            upload: null
+        };
+    }
+    if (isSendTextMessage(content)) {
+        const message = applyContextInfo({ extendedTextMessage: { text: content.text } }, ctx);
+        return {
+            kind: 'text',
+            plaintext: proto.Message.encode(message).finish(),
+            mediaType: null,
+            upload: null
+        };
+    }
+    if (isSendMediaMessage(content)) {
+        if (!options.mediaTransfer || !options.getMediaConn) {
+            throw new Error('newsletter media send requires mediaTransfer and getMediaConn dependencies');
+        }
+        const mediaConn = await options.getMediaConn();
+        if (content.type === 'sticker-pack') {
+            validateStickerPackInput(content);
+            const upload = await uploadNewsletterMedia({ mediaTransfer: options.mediaTransfer, logger: options.logger }, {
+                mediaKind: 'sticker-pack',
+                media: createStickerPackZipStream(toStickerPackZipEntries(content)),
+                mimetype: 'application/zip',
+                mediaConn
+            });
+            const stickerPackMessage = {
+                stickerPackId: content.stickerPackId,
+                name: content.name,
+                publisher: content.publisher,
+                stickers: toStickerPackProtoStickers(content),
+                fileLength: upload.fileLength,
+                fileSha256: upload.fileSha256,
+                directPath: upload.directPath,
+                trayIconFileName: content.trayIcon.fileName,
+                stickerPackSize: upload.fileLength,
+                stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+                caption: content.caption,
+                packDescription: content.packDescription
+            };
+            const message = applyContextInfo({ stickerPackMessage }, ctx);
+            return {
+                kind: 'media',
+                plaintext: proto.Message.encode(message).finish(),
+                mediaType: WA_ENC_MEDIA_TYPES.STICKER_PACK,
+                upload
+            };
+        }
+        const explicitMimetype = 'mimetype' in content && content.mimetype ? content.mimetype : null;
+        const resolvedMimetype = explicitMimetype ?? (content.type === 'sticker' ? 'image/webp' : null);
+        if (!resolvedMimetype) {
+            throw new Error(`newsletter media send requires explicit mimetype for ${content.type} content`);
+        }
+        const upload = await uploadNewsletterMedia({ mediaTransfer: options.mediaTransfer, logger: options.logger }, {
+            mediaKind: resolveSendMediaKind(content),
+            media: toUploadMedia(content.media),
+            mimetype: resolvedMimetype,
+            mediaConn
+        });
+        const message = applyContextInfo(buildMediaProtoMessage(content, upload), ctx);
+        return {
+            kind: 'media',
+            plaintext: proto.Message.encode(message).finish(),
+            mediaType: resolveSendMediaKind(content),
+            upload
+        };
+    }
+    if (isSendReactionMessage(content) || isSendRevokeMessage(content)) {
+        throw new Error(`newsletter sends do not accept '${content.type}' content; use newsletter.react() or newsletter.revoke() instead`);
+    }
+    if (isSendPollVoteMessage(content)) {
+        throw new Error("newsletter sends do not accept 'poll-vote' content; use newsletter.votePoll() instead");
+    }
+    if (isSendPollMessage(content) || isSendEventMessage(content)) {
+        throw new Error(`newsletter sends do not accept typed '${content.type}' content; pass the raw Proto.IMessage instead`);
+    }
+    if (isSendPinMessage(content) ||
+        isSendKeepMessage(content) ||
+        isSendEventResponseMessage(content)) {
+        throw new Error(`newsletter sends do not accept '${content.type}' content`);
+    }
+    const protoMessage = applyContextInfo(content, ctx);
+    const inner = unwrapMessage(protoMessage);
+    if (inner.reactionMessage ||
+        inner.encReactionMessage ||
+        inner.pollUpdateMessage ||
+        inner.encEventResponseMessage ||
+        inner.encCommentMessage ||
+        inner.pinInChatMessage ||
+        inner.keepInChatMessage ||
+        inner.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE) {
+        throw new Error('newsletter sends do not accept addon/update protobuf payloads; use the newsletter helpers instead');
+    }
+    const messageTypeAttr = resolveMessageTypeAttr(protoMessage);
+    const isPollCreation = messageTypeAttr === 'poll' &&
+        Boolean(inner.pollCreationMessage ||
+            inner.pollCreationMessageV2 ||
+            inner.pollCreationMessageV3 ||
+            inner.pollCreationMessageV5);
+    const mediaTypeAttr = pickMediaTypeFromMessage(protoMessage);
+    return {
+        kind: isPollCreation ? 'poll-creation' : mediaTypeAttr ? 'media' : 'text',
+        plaintext: proto.Message.encode(protoMessage).finish(),
+        mediaType: mediaTypeAttr,
+        upload: null
+    };
+}

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

@@ -0,0 +1,112 @@
+import { runMex } from '../newsletter/mex.js';
+import { parseDehydratedMetadata, parseDirectoryCategoriesPreview, parseDirectoryList, parseDirectorySearch, parseDomainsPreviewable, parseNewsletterMetadata, parseRecommended, parseSimilar } from '../newsletter/parse.js';
+import { WA_NEWSLETTER_FETCH_KEY_TYPES, WA_NEWSLETTER_VIEW_ROLES } from '../../protocol/newsletter.js';
+/** Builds the discovery operation set. */
+export function createDiscoveryOps(deps) {
+    async function fetchMetadata(key, keyType, opts) {
+        const data = await runMex(deps, 'FetchNewsletter', {
+            input: {
+                key,
+                type: keyType,
+                view_role: opts?.viewRole ?? WA_NEWSLETTER_VIEW_ROLES.SUBSCRIBER
+            },
+            fetch_viewer_metadata: opts?.fetchViewerMetadata ?? true,
+            fetch_full_image: opts?.fetchFullImage ?? keyType !== 'INVITE',
+            fetch_creation_time: opts?.fetchCreationTime ?? true,
+            fetch_wamo_sub: opts?.fetchWamoSub ?? false,
+            fetch_status_metadata: false
+        });
+        if (!data?.xwa2_newsletter) {
+            throw new Error('newsletter fetch returned no envelope');
+        }
+        return parseNewsletterMetadata(data.xwa2_newsletter);
+    }
+    return {
+        fetch: (jid, opts) => fetchMetadata(jid, WA_NEWSLETTER_FETCH_KEY_TYPES.JID, opts),
+        fetchByInvite: (invite, opts) => fetchMetadata(invite, WA_NEWSLETTER_FETCH_KEY_TYPES.INVITE, opts),
+        listSubscribed: async (opts) => {
+            const data = await runMex(deps, 'FetchAllNewslettersMetadata', {
+                fetch_wamo_sub: opts?.fetchWamoSub ?? false,
+                fetch_status_metadata: false
+            });
+            return (data?.xwa2_newsletter_subscribed ?? []).map(parseNewsletterMetadata);
+        },
+        searchDirectory: async (opts) => {
+            const data = await runMex(deps, 'FetchNewsletterDirectorySearchResults', {
+                input: {
+                    search_text: opts?.searchText ?? '',
+                    categories: opts?.categories ?? [],
+                    limit: opts?.limit ?? 100,
+                    start_cursor: opts?.startCursor
+                },
+                fetch_status_metadata: false
+            });
+            return parseDirectorySearch(data);
+        },
+        fetchRecommended: async (opts) => {
+            const data = await runMex(deps, 'FetchRecommendedNewsletters', {
+                input: {
+                    limit: opts?.limit ?? 25,
+                    country_codes: opts?.countryCodes ?? []
+                },
+                fetch_status_metadata: false
+            });
+            return parseRecommended(data);
+        },
+        fetchSimilar: async (newsletterJid, opts) => {
+            const data = await runMex(deps, 'FetchSimilarNewsletters', {
+                input: {
+                    newsletter_id: newsletterJid,
+                    limit: opts?.limit ?? 10,
+                    country_codes: opts?.countryCodes ?? []
+                },
+                fetch_status_metadata: false
+            });
+            return parseSimilar(data);
+        },
+        fetchDirectoryList: async (opts) => {
+            const data = await runMex(deps, 'FetchNewsletterDirectoryList', {
+                input: {
+                    view: opts.view,
+                    filters: {
+                        country_codes: opts.countryCodes ?? [],
+                        categories: opts.categories ?? []
+                    },
+                    limit: opts.limit ?? 25,
+                    start_cursor: opts.startCursor
+                },
+                fetch_status_metadata: false
+            });
+            return parseDirectoryList(data);
+        },
+        fetchDirectoryCategoriesPreview: async (opts) => {
+            const data = await runMex(deps, 'FetchNewsletterDirectoryCategoriesPreview', {
+                input: {
+                    categories: opts.categories,
+                    country_code: opts.countryCode || undefined,
+                    per_category_limit: opts.perCategoryLimit ?? 10
+                },
+                fetch_status_metadata: false
+            });
+            return parseDirectoryCategoriesPreview(data);
+        },
+        fetchIsDomainPreviewable: async (domains) => {
+            const data = await runMex(deps, 'FetchNewsletterIsDomainPreviewable', {
+                url_domains: domains
+            });
+            return parseDomainsPreviewable(data);
+        },
+        fetchDehydrated: async (keyOrInvite, opts) => {
+            const isJid = keyOrInvite.endsWith('@newsletter');
+            const data = await runMex(deps, 'FetchNewsletterDehydrated', {
+                input: {
+                    key: keyOrInvite,
+                    type: isJid ? 'JID' : 'INVITE',
+                    view_role: opts?.viewRole ?? WA_NEWSLETTER_VIEW_ROLES.SUBSCRIBER
+                },
+                fetch_wamo_sub: opts?.fetchWamoSub ?? false
+            });
+            return parseDehydratedMetadata(data);
+        }
+    };
+}