@sixcore/baileys 1.0.0 → 1.0.2

package/src/Socket/groups.ts

@@ -1,361 +0,0 @@
-import { proto } from '../../WAProto/index.js'
-import type { GroupMetadata, GroupParticipant, ParticipantAction, SocketConfig, WAMessageKey } from '../Types'
-import { WAMessageAddressingMode, WAMessageStubType } from '../Types'
-import { generateMessageIDV2, unixTimestampSeconds } from '../Utils'
-import {
-	type BinaryNode,
-	getBinaryNodeChild,
-	getBinaryNodeChildren,
-	getBinaryNodeChildString,
-	isLidUser,
-	isPnUser,
-	jidEncode,
-	jidNormalizedUser
-} from '../WABinary'
-import { makeChatsSocket } from './chats'
-
-export const makeGroupsSocket = (config: SocketConfig) => {
-	const sock = makeChatsSocket(config)
-	const { authState, ev, query, upsertMessage } = sock
-
-	const groupQuery = async (jid: string, type: 'get' | 'set', content: BinaryNode[]) =>
-		query({
-			tag: 'iq',
-			attrs: {
-				type,
-				xmlns: 'w:g2',
-				to: jid
-			},
-			content
-		})
-
-	const groupMetadata = async (jid: string) => {
-		const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }])
-		return extractGroupMetadata(result)
-	}
-
-	const groupFetchAllParticipating = async () => {
-		const result = await query({
-			tag: 'iq',
-			attrs: {
-				to: '@g.us',
-				xmlns: 'w:g2',
-				type: 'get'
-			},
-			content: [
-				{
-					tag: 'participating',
-					attrs: {},
-					content: [
-						{ tag: 'participants', attrs: {} },
-						{ tag: 'description', attrs: {} }
-					]
-				}
-			]
-		})
-		const data: { [_: string]: GroupMetadata } = {}
-		const groupsChild = getBinaryNodeChild(result, 'groups')
-		if (groupsChild) {
-			const groups = getBinaryNodeChildren(groupsChild, 'group')
-			for (const groupNode of groups) {
-				const meta = extractGroupMetadata({
-					tag: 'result',
-					attrs: {},
-					content: [groupNode]
-				})
-				data[meta.id] = meta
-			}
-		}
-
-		// TODO: properly parse LID / PN DATA
-		sock.ev.emit('groups.update', Object.values(data))
-
-		return data
-	}
-
-	sock.ws.on('CB:ib,,dirty', async (node: BinaryNode) => {
-		const { attrs } = getBinaryNodeChild(node, 'dirty')!
-		if (attrs.type !== 'groups') {
-			return
-		}
-
-		await groupFetchAllParticipating()
-		await sock.cleanDirtyBits('groups')
-	})
-
-	return {
-		...sock,
-		groupMetadata,
-		groupCreate: async (subject: string, participants: string[]) => {
-			const key = generateMessageIDV2()
-			const result = await groupQuery('@g.us', 'set', [
-				{
-					tag: 'create',
-					attrs: {
-						subject,
-						key
-					},
-					content: participants.map(jid => ({
-						tag: 'participant',
-						attrs: { jid }
-					}))
-				}
-			])
-			return extractGroupMetadata(result)
-		},
-		groupLeave: async (id: string) => {
-			await groupQuery('@g.us', 'set', [
-				{
-					tag: 'leave',
-					attrs: {},
-					content: [{ tag: 'group', attrs: { id } }]
-				}
-			])
-		},
-		groupUpdateSubject: async (jid: string, subject: string) => {
-			await groupQuery(jid, 'set', [
-				{
-					tag: 'subject',
-					attrs: {},
-					content: Buffer.from(subject, 'utf-8')
-				}
-			])
-		},
-		groupRequestParticipantsList: async (jid: string) => {
-			const result = await groupQuery(jid, 'get', [
-				{
-					tag: 'membership_approval_requests',
-					attrs: {}
-				}
-			])
-			const node = getBinaryNodeChild(result, 'membership_approval_requests')
-			const participants = getBinaryNodeChildren(node, 'membership_approval_request')
-			return participants.map(v => v.attrs)
-		},
-		groupRequestParticipantsUpdate: async (jid: string, participants: string[], action: 'approve' | 'reject') => {
-			const result = await groupQuery(jid, 'set', [
-				{
-					tag: 'membership_requests_action',
-					attrs: {},
-					content: [
-						{
-							tag: action,
-							attrs: {},
-							content: participants.map(jid => ({
-								tag: 'participant',
-								attrs: { jid }
-							}))
-						}
-					]
-				}
-			])
-			const node = getBinaryNodeChild(result, 'membership_requests_action')
-			const nodeAction = getBinaryNodeChild(node, action)
-			const participantsAffected = getBinaryNodeChildren(nodeAction, 'participant')
-			return participantsAffected.map(p => {
-				return { status: p.attrs.error || '200', jid: p.attrs.jid }
-			})
-		},
-		groupParticipantsUpdate: async (jid: string, participants: string[], action: ParticipantAction) => {
-			const result = await groupQuery(jid, 'set', [
-				{
-					tag: action,
-					attrs: {},
-					content: participants.map(jid => ({
-						tag: 'participant',
-						attrs: { jid }
-					}))
-				}
-			])
-			const node = getBinaryNodeChild(result, action)
-			const participantsAffected = getBinaryNodeChildren(node, 'participant')
-			return participantsAffected.map(p => {
-				return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p }
-			})
-		},
-		groupUpdateDescription: async (jid: string, description?: string) => {
-			const metadata = await groupMetadata(jid)
-			const prev = metadata.descId ?? null
-
-			await groupQuery(jid, 'set', [
-				{
-					tag: 'description',
-					attrs: {
-						...(description ? { id: generateMessageIDV2() } : { delete: 'true' }),
-						...(prev ? { prev } : {})
-					},
-					content: description ? [{ tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }] : undefined
-				}
-			])
-		},
-		groupInviteCode: async (jid: string) => {
-			const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }])
-			const inviteNode = getBinaryNodeChild(result, 'invite')
-			return inviteNode?.attrs.code
-		},
-		groupRevokeInvite: async (jid: string) => {
-			const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }])
-			const inviteNode = getBinaryNodeChild(result, 'invite')
-			return inviteNode?.attrs.code
-		},
-		groupAcceptInvite: async (code: string) => {
-			const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }])
-			const result = getBinaryNodeChild(results, 'group')
-			return result?.attrs.jid
-		},
-
-		/**
-		 * revoke a v4 invite for someone
-		 * @param groupJid group jid
-		 * @param invitedJid jid of person you invited
-		 * @returns true if successful
-		 */
-		groupRevokeInviteV4: async (groupJid: string, invitedJid: string) => {
-			const result = await groupQuery(groupJid, 'set', [
-				{ tag: 'revoke', attrs: {}, content: [{ tag: 'participant', attrs: { jid: invitedJid } }] }
-			])
-			return !!result
-		},
-
-		/**
-		 * accept a GroupInviteMessage
-		 * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
-		 * @param inviteMessage the message to accept
-		 */
-		groupAcceptInviteV4: ev.createBufferedFunction(
-			async (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => {
-				key = typeof key === 'string' ? { remoteJid: key } : key
-				const results = await groupQuery(inviteMessage.groupJid!, 'set', [
-					{
-						tag: 'accept',
-						attrs: {
-							code: inviteMessage.inviteCode!,
-							expiration: inviteMessage.inviteExpiration!.toString(),
-							admin: key.remoteJid!
-						}
-					}
-				])
-
-				// if we have the full message key
-				// update the invite message to be expired
-				if (key.id) {
-					// create new invite message that is expired
-					inviteMessage = proto.Message.GroupInviteMessage.fromObject(inviteMessage)
-					inviteMessage.inviteExpiration = 0
-					inviteMessage.inviteCode = ''
-					ev.emit('messages.update', [
-						{
-							key,
-							update: {
-								message: {
-									groupInviteMessage: inviteMessage
-								}
-							}
-						}
-					])
-				}
-
-				// generate the group add message
-				await upsertMessage(
-					{
-						key: {
-							remoteJid: inviteMessage.groupJid,
-							id: generateMessageIDV2(sock.user?.id),
-							fromMe: false,
-							participant: key.remoteJid
-						},
-						messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
-						messageStubParameters: [JSON.stringify(authState.creds.me)],
-						participant: key.remoteJid,
-						messageTimestamp: unixTimestampSeconds()
-					},
-					'notify'
-				)
-
-				return results.attrs.from
-			}
-		),
-		groupGetInviteInfo: async (code: string) => {
-			const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }])
-			return extractGroupMetadata(results)
-		},
-		groupToggleEphemeral: async (jid: string, ephemeralExpiration: number) => {
-			const content: BinaryNode = ephemeralExpiration
-				? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
-				: { tag: 'not_ephemeral', attrs: {} }
-			await groupQuery(jid, 'set', [content])
-		},
-		groupSettingUpdate: async (jid: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked') => {
-			await groupQuery(jid, 'set', [{ tag: setting, attrs: {} }])
-		},
-		groupMemberAddMode: async (jid: string, mode: 'admin_add' | 'all_member_add') => {
-			await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }])
-		},
-		groupJoinApprovalMode: async (jid: string, mode: 'on' | 'off') => {
-			await groupQuery(jid, 'set', [
-				{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }
-			])
-		},
-		groupFetchAllParticipating
-	}
-}
-
-export const extractGroupMetadata = (result: BinaryNode) => {
-	const group = getBinaryNodeChild(result, 'group')!
-	const descChild = getBinaryNodeChild(group, 'description')
-	let desc: string | undefined
-	let descId: string | undefined
-	let descOwner: string | undefined
-	let descOwnerPn: string | undefined
-	let descTime: number | undefined
-	if (descChild) {
-		desc = getBinaryNodeChildString(descChild, 'body')
-		descOwner = descChild.attrs.participant ? jidNormalizedUser(descChild.attrs.participant) : undefined
-		descOwnerPn = descChild.attrs.participant_pn ? jidNormalizedUser(descChild.attrs.participant_pn) : undefined
-		descTime = +descChild.attrs.t!
-		descId = descChild.attrs.id
-	}
-
-	const groupId = group.attrs.id!.includes('@') ? group.attrs.id : jidEncode(group.attrs.id!, 'g.us')
-	const eph = getBinaryNodeChild(group, 'ephemeral')?.attrs.expiration
-	const memberAddMode = getBinaryNodeChildString(group, 'member_add_mode') === 'all_member_add'
-	const metadata: GroupMetadata = {
-		id: groupId!,
-		notify: group.attrs.notify,
-		addressingMode: group.attrs.addressing_mode === 'lid' ? WAMessageAddressingMode.LID : WAMessageAddressingMode.PN,
-		subject: group.attrs.subject!,
-		subjectOwner: group.attrs.s_o,
-		subjectOwnerPn: group.attrs.s_o_pn,
-		subjectTime: +group.attrs.s_t!,
-		size: group.attrs.size ? +group.attrs.size : getBinaryNodeChildren(group, 'participant').length,
-		creation: +group.attrs.creation!,
-		owner: group.attrs.creator ? jidNormalizedUser(group.attrs.creator) : undefined,
-		ownerPn: group.attrs.creator_pn ? jidNormalizedUser(group.attrs.creator_pn) : undefined,
-		owner_country_code: group.attrs.creator_country_code,
-		desc,
-		descId,
-		descOwner,
-		descOwnerPn,
-		descTime,
-		linkedParent: getBinaryNodeChild(group, 'linked_parent')?.attrs.jid || undefined,
-		restrict: !!getBinaryNodeChild(group, 'locked'),
-		announce: !!getBinaryNodeChild(group, 'announcement'),
-		isCommunity: !!getBinaryNodeChild(group, 'parent'),
-		isCommunityAnnounce: !!getBinaryNodeChild(group, 'default_sub_group'),
-		joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
-		memberAddMode,
-		participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-			// TODO: Store LID MAPPINGS
-			return {
-				id: attrs.jid!,
-				phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-				lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
-				admin: (attrs.type || null) as GroupParticipant['admin']
-			}
-		}),
-		ephemeralDuration: eph ? +eph : undefined
-	}
-	return metadata
-}
-
-export type GroupsSocket = ReturnType<typeof makeGroupsSocket>

package/src/Socket/index.ts

@@ -1,22 +0,0 @@
-import { DEFAULT_CONNECTION_CONFIG } from '../Defaults'
-import type { UserFacingSocketConfig } from '../Types'
-import { makeCommunitiesSocket } from './communities'
-
-// export the last socket layer
-const makeWASocket = (config: UserFacingSocketConfig) => {
-	const newConfig = {
-		...DEFAULT_CONNECTION_CONFIG,
-		...config
-	}
-
-	// If the user hasn't provided their own history sync function,
-	// let's create a default one that respects the syncFullHistory flag.
-	// TODO: Change
-	if (config.shouldSyncHistoryMessage === undefined) {
-		newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory
-	}
-
-	return makeCommunitiesSocket(newConfig)
-}
-
-export default makeWASocket