feat: Implement Mex (Meta Experiment) and Newsletter functionality from Baileys v7.0.0-rc.9

package.json

@@ -2,7 +2,7 @@
   "name": "whaileys",
   "version": "6.4.3",
   "description": "WhatsApp API",
-  "homepage": "https://github.com/canove/whaileys",
+  "homepage": "https://github.com/alltomatos/whaileys",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "keywords": [
@@ -32,7 +32,7 @@
   "author": "canove",
   "license": "MIT",
   "repository": {
-    "url": "git@github.com:canove/whaileys.git"
+    "url": "git@github.com:alltomatos/whaileys.git"
   },
   "dependencies": {
     "@hapi/boom": "^9.1.3",

src/Socket/index.ts

@@ -1,6 +1,6 @@
 import { DEFAULT_CONNECTION_CONFIG } from "../Defaults";
 import { UserFacingSocketConfig } from "../Types";
-import { makeBusinessSocket as _makeSocket } from "./business";
+import { makeNewsletterSocket as _makeSocket } from "./newsletter";
 
 // export the last socket layer
 const makeWASocket = (config: UserFacingSocketConfig) =>

src/Socket/mex.ts

@@ -0,0 +1,58 @@
+import { Boom } from '@hapi/boom'
+import type { BinaryNode } from '../WABinary'
+import { getBinaryNodeChild, S_WHATSAPP_NET } from '../WABinary'
+
+const wMexQuery = (
+    variables: Record<string, unknown>,
+    queryId: string,
+    query: (node: BinaryNode) => Promise<BinaryNode>,
+    generateMessageTag: () => string
+) => {
+    return query({
+        tag: 'iq',
+        attrs: {
+            id: generateMessageTag(),
+            type: 'get',
+            to: S_WHATSAPP_NET,
+            xmlns: 'w:mex'
+        },
+        content: [
+            {
+                tag: 'query',
+                attrs: { query_id: queryId },
+                content: Uint8Array.from(Buffer.from(JSON.stringify({ variables }), 'utf-8'))
+            }
+        ]
+    })
+}
+
+export const executeWMexQuery = async <T>(
+    variables: Record<string, unknown>,
+    queryId: string,
+    dataPath: string,
+    query: (node: BinaryNode) => Promise<BinaryNode>,
+    generateMessageTag: () => string
+): Promise<T> => {
+    const result = await wMexQuery(variables, queryId, query, generateMessageTag)
+    const child = getBinaryNodeChild(result, 'result')
+    if (child?.content) {
+        const data = JSON.parse(child.content.toString())
+
+        if (data.errors && data.errors.length > 0) {
+            const errorMessages = data.errors.map((err: Error) => err.message || 'Unknown error').join(', ')
+            const firstError = data.errors[0]
+            const errorCode = firstError.extensions?.error_code || 400
+            throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError })
+        }
+
+        const response = dataPath ? data?.data?.[dataPath] : data?.data
+        if (typeof response !== 'undefined') {
+            return response as T
+        }
+    }
+
+    const action = (dataPath || '').startsWith('xwa2_')
+        ? dataPath.substring(5).replace(/_/g, ' ')
+        : dataPath?.replace(/_/g, ' ')
+    throw new Boom(`Failed to ${action}, unexpected response structure.`, { statusCode: 400, data: result })
+}

src/Socket/newsletter.ts

@@ -0,0 +1,229 @@
+import type { NewsletterCreateResponse, SocketConfig, WAMediaUpload } from '../Types'
+import type { NewsletterMetadata, NewsletterUpdate } from '../Types'
+import { QueryIds, XWAPaths } from '../Types'
+import { generateProfilePicture } from '../Utils/messages-media'
+import { getBinaryNodeChild } from '../WABinary'
+import { makeBusinessSocket } from './business'
+import { executeWMexQuery as genericExecuteWMexQuery } from './mex'
+
+const parseNewsletterCreateResponse = (response: NewsletterCreateResponse): NewsletterMetadata => {
+	const { id, thread_metadata: thread, viewer_metadata: viewer } = response
+	return {
+		id: id,
+		owner: undefined,
+		name: thread.name.text,
+		creation_time: parseInt(thread.creation_time, 10),
+		description: thread.description.text,
+		invite: thread.invite,
+		subscribers: parseInt(thread.subscribers_count, 10),
+		verification: thread.verification,
+		picture: {
+			id: thread.picture.id,
+			directPath: thread.picture.direct_path
+		},
+		mute_state: viewer.mute
+	}
+}
+
+const parseNewsletterMetadata = (result: unknown): NewsletterMetadata | null => {
+	if (typeof result !== 'object' || result === null) {
+		return null
+	}
+
+	if ('id' in result && typeof (result as any).id === 'string') {
+		return result as NewsletterMetadata
+	}
+
+	if ('result' in result && typeof (result as any).result === 'object' && (result as any).result !== null && 'id' in (result as any).result) {
+		return (result as any).result as NewsletterMetadata
+	}
+
+	return null
+}
+
+export const makeNewsletterSocket = (config: SocketConfig) => {
+	const sock = makeBusinessSocket(config)
+	const { query, generateMessageTag } = sock
+
+	const executeWMexQuery = <T>(variables: Record<string, unknown>, queryId: string, dataPath: string): Promise<T> => {
+		return genericExecuteWMexQuery<T>(variables, queryId, dataPath, query, generateMessageTag)
+	}
+
+	const newsletterUpdate = async (jid: string, updates: NewsletterUpdate) => {
+		const variables = {
+			newsletter_id: jid,
+			updates: {
+				...updates,
+				settings: null
+			}
+		}
+		return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update')
+	}
+
+	return {
+		...sock,
+		newsletterCreate: async (name: string, description?: string): Promise<NewsletterMetadata> => {
+			const variables = {
+				input: {
+					name,
+					description: description ?? null
+				}
+			}
+			const rawResponse = await executeWMexQuery<NewsletterCreateResponse>(
+				variables,
+				QueryIds.CREATE,
+				XWAPaths.xwa2_newsletter_create
+			)
+			return parseNewsletterCreateResponse(rawResponse)
+		},
+
+		newsletterUpdate,
+
+		newsletterSubscribers: async (jid: string) => {
+			return executeWMexQuery<{ subscribers: number }>(
+				{ newsletter_id: jid },
+				QueryIds.SUBSCRIBERS,
+				XWAPaths.xwa2_newsletter_subscribers
+			)
+		},
+
+		newsletterMetadata: async (type: 'invite' | 'jid', key: string) => {
+			const variables = {
+				fetch_creation_time: true,
+				fetch_full_image: true,
+				fetch_viewer_metadata: true,
+				input: {
+					key,
+					type: type.toUpperCase()
+				}
+			}
+			const result = await executeWMexQuery<unknown>(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata)
+			return parseNewsletterMetadata(result)
+		},
+
+		newsletterFollow: (jid: string) => {
+			return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow)
+		},
+
+		newsletterUnfollow: (jid: string) => {
+			return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_unfollow)
+		},
+
+		newsletterMute: (jid: string) => {
+			return executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2)
+		},
+
+		newsletterUnmute: (jid: string) => {
+			return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2)
+		},
+
+		newsletterUpdateName: async (jid: string, name: string) => {
+			return await newsletterUpdate(jid, { name })
+		},
+
+		newsletterUpdateDescription: async (jid: string, description: string) => {
+			return await newsletterUpdate(jid, { description })
+		},
+
+		newsletterUpdatePicture: async (jid: string, content: WAMediaUpload) => {
+			const { img } = await generateProfilePicture(content)
+			return await newsletterUpdate(jid, { picture: img.toString('base64') })
+		},
+
+		newsletterRemovePicture: async (jid: string) => {
+			return await newsletterUpdate(jid, { picture: '' })
+		},
+
+		newsletterReactMessage: async (jid: string, serverId: string, reaction?: string) => {
+			await query({
+				tag: 'message',
+				attrs: {
+					to: jid,
+					...(reaction ? {} : { edit: '7' }),
+					type: 'reaction',
+					server_id: serverId,
+					id: generateMessageTag()
+				},
+				content: [
+					{
+						tag: 'reaction',
+						attrs: reaction ? { code: reaction } : {}
+					}
+				]
+			})
+		},
+
+		newsletterFetchMessages: async (jid: string, count: number, since: number, after: number) => {
+			const messageUpdateAttrs: { count: string; since?: string; after?: string } = {
+				count: count.toString()
+			}
+			if (typeof since === 'number') {
+				messageUpdateAttrs.since = since.toString()
+			}
+
+			if (after) {
+				messageUpdateAttrs.after = after.toString()
+			}
+
+			const result = await query({
+				tag: 'iq',
+				attrs: {
+					id: generateMessageTag(),
+					type: 'get',
+					xmlns: 'newsletter',
+					to: jid
+				},
+				content: [
+					{
+						tag: 'message_updates',
+						attrs: messageUpdateAttrs
+					}
+				]
+			})
+			return result
+		},
+
+		subscribeNewsletterUpdates: async (jid: string): Promise<{ duration: string } | null> => {
+			const result = await query({
+				tag: 'iq',
+				attrs: {
+					id: generateMessageTag(),
+					type: 'set',
+					xmlns: 'newsletter',
+					to: jid
+				},
+				content: [{ tag: 'live_updates', attrs: {}, content: [] }]
+			})
+			const liveUpdatesNode = getBinaryNodeChild(result, 'live_updates')
+			const duration = liveUpdatesNode?.attrs?.duration
+			return duration ? { duration: duration } : null
+		},
+
+		newsletterAdminCount: async (jid: string): Promise<number> => {
+			const response = await executeWMexQuery<{ admin_count: number }>(
+				{ newsletter_id: jid },
+				QueryIds.ADMIN_COUNT,
+				XWAPaths.xwa2_newsletter_admin_count
+			)
+			return response.admin_count
+		},
+
+		newsletterChangeOwner: async (jid: string, newOwnerJid: string) => {
+			await executeWMexQuery(
+				{ newsletter_id: jid, user_id: newOwnerJid },
+				QueryIds.CHANGE_OWNER,
+				XWAPaths.xwa2_newsletter_change_owner
+			)
+		},
+
+		newsletterDemote: async (jid: string, userJid: string) => {
+			await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote)
+		},
+
+		newsletterDelete: async (jid: string) => {
+			await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2)
+		}
+	}
+}
+
+export type NewsletterSocket = ReturnType<typeof makeNewsletterSocket>

src/Types/Newsletter.ts

@@ -0,0 +1,79 @@
+export enum XWAPaths {
+    xwa2_newsletter_create = 'xwa2_newsletter_create',
+    xwa2_newsletter_subscribers = 'xwa2_newsletter_subscribers',
+    xwa2_newsletter_view = 'xwa2_newsletter_view',
+    xwa2_newsletter_metadata = 'xwa2_newsletter',
+    xwa2_newsletter_admin_count = 'xwa2_newsletter_admin',
+    xwa2_newsletter_mute_v2 = 'xwa2_newsletter_mute_v2',
+    xwa2_newsletter_unmute_v2 = 'xwa2_newsletter_unmute_v2',
+    xwa2_newsletter_follow = 'xwa2_newsletter_follow',
+    xwa2_newsletter_unfollow = 'xwa2_newsletter_unfollow',
+    xwa2_newsletter_change_owner = 'xwa2_newsletter_change_owner',
+    xwa2_newsletter_demote = 'xwa2_newsletter_demote',
+    xwa2_newsletter_delete_v2 = 'xwa2_newsletter_delete_v2'
+}
+export enum QueryIds {
+    CREATE = '8823471724422422',
+    UPDATE_METADATA = '24250201037901610',
+    METADATA = '6563316087068696',
+    SUBSCRIBERS = '9783111038412085',
+    FOLLOW = '7871414976211147',
+    UNFOLLOW = '7238632346214362',
+    MUTE = '29766401636284406',
+    UNMUTE = '9864994326891137',
+    ADMIN_COUNT = '7130823597031706',
+    CHANGE_OWNER = '7341777602580933',
+    DEMOTE = '6551828931592903',
+    DELETE = '30062808666639665'
+}
+export type NewsletterUpdate = {
+    name?: string
+    description?: string
+    picture?: string
+}
+export interface NewsletterCreateResponse {
+    id: string
+    state: { type: string }
+    thread_metadata: {
+        creation_time: string
+        description: { id: string; text: string; update_time: string }
+        handle: string | null
+        invite: string
+        name: { id: string; text: string; update_time: string }
+        picture: { direct_path: string; id: string; type: string }
+        preview: { direct_path: string; id: string; type: string }
+        subscribers_count: string
+        verification: 'VERIFIED' | 'UNVERIFIED'
+    }
+    viewer_metadata: {
+        mute: 'ON' | 'OFF'
+        role: NewsletterViewRole
+    }
+}
+export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER'
+export interface NewsletterMetadata {
+    id: string
+    owner?: string
+    name: string
+    description?: string
+    invite?: string
+    creation_time?: number
+    subscribers?: number
+    picture?: {
+        url?: string
+        directPath?: string
+        mediaKey?: string
+        id?: string
+    }
+    verification?: 'VERIFIED' | 'UNVERIFIED'
+    reaction_codes?: {
+        code: string
+        count: number
+    }[]
+    mute_state?: 'ON' | 'OFF'
+    thread_metadata?: {
+        creation_time?: number
+        name?: string
+        description?: string
+    }
+}