zapo-js 0.3.0 → 1.0.0

package/dist/client/newsletter/admin.js

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

package/dist/client/newsletter/content.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadNewsletterMedia = uploadNewsletterMedia;
+exports.buildNewsletterMessageContent = buildNewsletterMessageContent;
+const media_1 = require("../media");
+const constants_1 = require("../../media/constants");
+const sticker_pack_1 = require("../../media/sticker/sticker-pack");
+const context_info_1 = require("../../message/context-info");
+const content_1 = require("../../message/encode/content");
+const sticker_pack_2 = require("../../message/kinds/sticker-pack");
+const _proto_1 = require("../../proto.js");
+const message_1 = require("../../protocol/message");
+const bytes_1 = require("../../util/bytes");
+async function uploadNewsletterMedia(options, input) {
+    const upload = await (0, media_1.performPlaintextMediaUpload)({
+        mediaTransfer: options.mediaTransfer,
+        mediaConn: input.mediaConn,
+        logger: options.logger
+    }, {
+        source: input.media,
+        path: constants_1.NEWSLETTER_MEDIA_UPLOAD_PATHS[input.mediaKind],
+        mimetype: input.mimetype,
+        logLabel: 'sending newsletter media upload'
+    });
+    (0, media_1.assertMediaUploadStatus)(upload.status, 'newsletter media upload');
+    const parsed = (0, media_1.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
+            ? (0, bytes_1.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 message_1.WA_ENC_MEDIA_TYPES.IMAGE;
+    if (message.videoMessage)
+        return message.videoMessage.gifPlayback ? message_1.WA_ENC_MEDIA_TYPES.GIF : message_1.WA_ENC_MEDIA_TYPES.VIDEO;
+    if (message.audioMessage)
+        return message.audioMessage.ptt ? message_1.WA_ENC_MEDIA_TYPES.PTT : message_1.WA_ENC_MEDIA_TYPES.AUDIO;
+    if (message.documentMessage)
+        return message_1.WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (message.stickerMessage)
+        return message_1.WA_ENC_MEDIA_TYPES.STICKER;
+    if (message.stickerPackMessage)
+        return message_1.WA_ENC_MEDIA_TYPES.STICKER_PACK;
+    if (message.ptvMessage)
+        return message_1.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;
+}
+async function buildNewsletterMessageContent(options, content, ctx) {
+    if (typeof content === 'string') {
+        const message = (0, context_info_1.applyContextInfo)({ conversation: content }, ctx);
+        return {
+            kind: 'text',
+            plaintext: _proto_1.proto.Message.encode(message).finish(),
+            mediaType: null,
+            upload: null
+        };
+    }
+    if ((0, content_1.isSendTextMessage)(content)) {
+        const message = (0, context_info_1.applyContextInfo)({ extendedTextMessage: { text: content.text } }, ctx);
+        return {
+            kind: 'text',
+            plaintext: _proto_1.proto.Message.encode(message).finish(),
+            mediaType: null,
+            upload: null
+        };
+    }
+    if ((0, content_1.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') {
+            (0, sticker_pack_2.validateStickerPackInput)(content);
+            const upload = await uploadNewsletterMedia({ mediaTransfer: options.mediaTransfer, logger: options.logger }, {
+                mediaKind: 'sticker-pack',
+                media: (0, sticker_pack_1.createStickerPackZipStream)((0, sticker_pack_2.toStickerPackZipEntries)(content)),
+                mimetype: 'application/zip',
+                mediaConn
+            });
+            const stickerPackMessage = {
+                stickerPackId: content.stickerPackId,
+                name: content.name,
+                publisher: content.publisher,
+                stickers: (0, sticker_pack_2.toStickerPackProtoStickers)(content),
+                fileLength: upload.fileLength,
+                fileSha256: upload.fileSha256,
+                directPath: upload.directPath,
+                trayIconFileName: content.trayIcon.fileName,
+                stickerPackSize: upload.fileLength,
+                stickerPackOrigin: _proto_1.proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+                caption: content.caption,
+                packDescription: content.packDescription
+            };
+            const message = (0, context_info_1.applyContextInfo)({ stickerPackMessage }, ctx);
+            return {
+                kind: 'media',
+                plaintext: _proto_1.proto.Message.encode(message).finish(),
+                mediaType: message_1.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 = (0, context_info_1.applyContextInfo)(buildMediaProtoMessage(content, upload), ctx);
+        return {
+            kind: 'media',
+            plaintext: _proto_1.proto.Message.encode(message).finish(),
+            mediaType: resolveSendMediaKind(content),
+            upload
+        };
+    }
+    if ((0, content_1.isSendReactionMessage)(content) || (0, content_1.isSendRevokeMessage)(content)) {
+        throw new Error(`newsletter sends do not accept '${content.type}' content; use newsletter.react() or newsletter.revoke() instead`);
+    }
+    if ((0, content_1.isSendPollVoteMessage)(content)) {
+        throw new Error("newsletter sends do not accept 'poll-vote' content; use newsletter.votePoll() instead");
+    }
+    if ((0, content_1.isSendPollMessage)(content) || (0, content_1.isSendEventMessage)(content)) {
+        throw new Error(`newsletter sends do not accept typed '${content.type}' content; pass the raw Proto.IMessage instead`);
+    }
+    if ((0, content_1.isSendPinMessage)(content) ||
+        (0, content_1.isSendKeepMessage)(content) ||
+        (0, content_1.isSendEventResponseMessage)(content)) {
+        throw new Error(`newsletter sends do not accept '${content.type}' content`);
+    }
+    const protoMessage = (0, context_info_1.applyContextInfo)(content, ctx);
+    const inner = (0, content_1.unwrapMessage)(protoMessage);
+    if (inner.reactionMessage ||
+        inner.encReactionMessage ||
+        inner.pollUpdateMessage ||
+        inner.encEventResponseMessage ||
+        inner.encCommentMessage ||
+        inner.pinInChatMessage ||
+        inner.keepInChatMessage ||
+        inner.protocolMessage?.type === _proto_1.proto.Message.ProtocolMessage.Type.REVOKE) {
+        throw new Error('newsletter sends do not accept addon/update protobuf payloads; use the newsletter helpers instead');
+    }
+    const messageTypeAttr = (0, content_1.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_1.proto.Message.encode(protoMessage).finish(),
+        mediaType: mediaTypeAttr,
+        upload: null
+    };
+}

package/dist/client/newsletter/discovery.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiscoveryOps = createDiscoveryOps;
+const mex_1 = require("../newsletter/mex");
+const parse_1 = require("../newsletter/parse");
+const newsletter_1 = require("../../protocol/newsletter");
+/** Builds the discovery operation set. */
+function createDiscoveryOps(deps) {
+    async function fetchMetadata(key, keyType, opts) {
+        const data = await (0, mex_1.runMex)(deps, 'FetchNewsletter', {
+            input: {
+                key,
+                type: keyType,
+                view_role: opts?.viewRole ?? newsletter_1.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 (0, parse_1.parseNewsletterMetadata)(data.xwa2_newsletter);
+    }
+    return {
+        fetch: (jid, opts) => fetchMetadata(jid, newsletter_1.WA_NEWSLETTER_FETCH_KEY_TYPES.JID, opts),
+        fetchByInvite: (invite, opts) => fetchMetadata(invite, newsletter_1.WA_NEWSLETTER_FETCH_KEY_TYPES.INVITE, opts),
+        listSubscribed: async (opts) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchAllNewslettersMetadata', {
+                fetch_wamo_sub: opts?.fetchWamoSub ?? false,
+                fetch_status_metadata: false
+            });
+            return (data?.xwa2_newsletter_subscribed ?? []).map(parse_1.parseNewsletterMetadata);
+        },
+        searchDirectory: async (opts) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchNewsletterDirectorySearchResults', {
+                input: {
+                    search_text: opts?.searchText ?? '',
+                    categories: opts?.categories ?? [],
+                    limit: opts?.limit ?? 100,
+                    start_cursor: opts?.startCursor
+                },
+                fetch_status_metadata: false
+            });
+            return (0, parse_1.parseDirectorySearch)(data);
+        },
+        fetchRecommended: async (opts) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchRecommendedNewsletters', {
+                input: {
+                    limit: opts?.limit ?? 25,
+                    country_codes: opts?.countryCodes ?? []
+                },
+                fetch_status_metadata: false
+            });
+            return (0, parse_1.parseRecommended)(data);
+        },
+        fetchSimilar: async (newsletterJid, opts) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchSimilarNewsletters', {
+                input: {
+                    newsletter_id: newsletterJid,
+                    limit: opts?.limit ?? 10,
+                    country_codes: opts?.countryCodes ?? []
+                },
+                fetch_status_metadata: false
+            });
+            return (0, parse_1.parseSimilar)(data);
+        },
+        fetchDirectoryList: async (opts) => {
+            const data = await (0, mex_1.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 (0, parse_1.parseDirectoryList)(data);
+        },
+        fetchDirectoryCategoriesPreview: async (opts) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchNewsletterDirectoryCategoriesPreview', {
+                input: {
+                    categories: opts.categories,
+                    country_code: opts.countryCode || undefined,
+                    per_category_limit: opts.perCategoryLimit ?? 10
+                },
+                fetch_status_metadata: false
+            });
+            return (0, parse_1.parseDirectoryCategoriesPreview)(data);
+        },
+        fetchIsDomainPreviewable: async (domains) => {
+            const data = await (0, mex_1.runMex)(deps, 'FetchNewsletterIsDomainPreviewable', {
+                url_domains: domains
+            });
+            return (0, parse_1.parseDomainsPreviewable)(data);
+        },
+        fetchDehydrated: async (keyOrInvite, opts) => {
+            const isJid = keyOrInvite.endsWith('@newsletter');
+            const data = await (0, mex_1.runMex)(deps, 'FetchNewsletterDehydrated', {
+                input: {
+                    key: keyOrInvite,
+                    type: isJid ? 'JID' : 'INVITE',
+                    view_role: opts?.viewRole ?? newsletter_1.WA_NEWSLETTER_VIEW_ROLES.SUBSCRIBER
+                },
+                fetch_wamo_sub: opts?.fetchWamoSub ?? false
+            });
+            return (0, parse_1.parseDehydratedMetadata)(data);
+        }
+    };
+}