@neelegirl/baileys 1.5.5 → 1.5.7

package/lib/Socket/usync.d.ts

@@ -0,0 +1,37 @@
+import { Boom } from '@hapi/boom'
+import { SocketConfig } from '../Types'
+import { BinaryNode } from '../WABinary'
+import { USyncQuery } from '../WAUSync'
+
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>
+    type: "md"
+    ws: import("./Client").WebSocketClient
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void
+        buffer(): void
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>
+        flush(force?: boolean | undefined): boolean
+        isBuffering(): boolean
+    }
+    authState: {
+        creds: import("../Types").AuthenticationCreds
+        keys: import("../Types").SignalKeyStoreWithTransaction
+    }
+    signalRepository: import("../Types").SignalRepository
+    user: import("../Types").Contact | undefined
+    generateMessageTag: () => string
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>
+    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<T_1>
+    waitForSocketOpen: () => Promise<void>
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>
+    sendNode: (frame: BinaryNode) => Promise<void>
+    logout: (msg?: string | undefined) => Promise<void>
+    end: (error: Error | undefined) => void
+    onUnexpectedError: (err: Error | Boom<any>, msg: string) => void
+    uploadPreKeys: (count?: number) => Promise<void>
+    uploadPreKeysToServerIfRequired: () => Promise<void>
+    requestPairingCode: (phoneNumber: string, code?: string) => Promise<string>
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>
+}

package/lib/Socket/usync.js

@@ -0,0 +1,83 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const boom_1 = require("@hapi/boom")
+const WABinary_1 = require("../WABinary")
+const socket_1 = require("./socket")
+
+const makeUSyncSocket = (config) => {
+    const Neele = socket_1.makeSocket(config)
+    const { generateMessageTag, query, } = Neele
+    
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol')
+        }
+        
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users
+        
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            }
+        })
+        
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        }
+        
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        }
+        
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        }
+        
+        const result = await query(iq)
+        
+        return usyncQuery.parseUSyncQueryResult(result)
+    }
+    return {
+        ...Neele,
+        executeUSyncQuery
+    }
+}
+
+module.exports = {
+  makeUSyncSocket
+}

package/lib/Store/index.d.ts

@@ -0,0 +1,4 @@
+export * from './make-cache-manager-store'
+export * from './make-in-memory-store'
+export * from './make-ordered-dictionary'
+export * from './object-repository'

package/lib/Store/index.js

@@ -0,0 +1,24 @@
+"use strict"
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+__exportStar(require("./make-cache-manager-store"), exports) 
+__exportStar(require("./make-in-memory-store"), exports) 
+__exportStar(require("./make-ordered-dictionary"), exports) 
+__exportStar(require("./object-repository"), exports) 

package/lib/Store/make-cache-manager-store.d.ts

@@ -0,0 +1,14 @@
+import { Store } from 'cache-manager'
+import { AuthenticationCreds } from '../Types'
+
+export declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>
+    saveCreds: () => Promise<void>
+    state: {
+        creds: AuthenticationCreds
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>
+            set: (data: any) => Promise<void>
+        }
+    }
+}>

package/lib/Store/make-cache-manager-store.js

@@ -0,0 +1,90 @@
+"use strict"
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const cache_manager_1 = require("cache-manager")
+const WAProto_1 = require("../../WAProto")
+const Utils_1 = require("../Utils")
+const logger_1 = __importDefault(require("../Utils/logger"))
+
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`
+    const databaseConn = await cache_manager_1.caching(store)
+    const writeData = async (file, data) => {
+        let ttl = undefined
+        if (file === 'creds') {
+            ttl = 63115200 // 2 years
+        }
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl)
+    }
+    const readData = async (file) => {
+        try {
+            const data = await databaseConn.get(defaultKey(file))
+            if (data) {
+                return JSON.parse(data, Utils_1.BufferJSON.reviver)
+            }
+            return null
+        }
+        catch (error) {
+            logger_1.default.error(error)
+            return null
+        }
+    }
+    const removeData = async (file) => {
+        try {
+            return await databaseConn.del(defaultKey(file))
+        }
+        catch (_a) {
+            logger_1.default.error(`Error removing ${file} from session ${sessionKey}`)
+        }
+    }
+    const clearState = async () => {
+        try {
+            const result = await databaseConn.store.keys(`${sessionKey}*`)
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)))
+        }
+        catch (err) {
+        }
+    }
+    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)()
+    return {
+        clearState,
+        saveCreds: () => writeData('creds', creds),
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {}
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`)
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+                        }
+                        data[id] = value
+                    }))
+                    return data
+                },
+                set: async (data) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tasks = []
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id]
+                            const key = `${category}-${id}`
+                            tasks.push(value ? writeData(key, value) : removeData(key))
+                        }
+                    }
+                    await Promise.all(tasks)
+                },
+            }
+        }
+    }
+}
+
+module.exports = {
+  makeCacheManagerAuthState
+}

package/lib/Store/make-in-memory-store.d.ts

@@ -0,0 +1,123 @@
+import type KeyedDB from '@adiwajshing/keyed-db'
+import type { Comparable } from '@adiwajshing/keyed-db/lib/Types'
+import type { Logger } from 'pino'
+import { proto } from '../../WAProto'
+import type makeMDSocket from '../Socket'
+import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata, PresenceData, WAMessage, WAMessageCursor, WAMessageKey } from '../Types'
+import { Label } from '../Types/Label'
+import { LabelAssociation } from '../Types/LabelAssociation'
+import { ObjectRepository } from './object-repository'
+
+type WASocket = ReturnType<typeof makeMDSocket>
+
+export declare const waChatKey: (pin: boolean) => {
+    key: (c: Chat) => string
+    compare: (k1: string, k2: string) => number
+}
+
+export declare const waMessageID: (m: WAMessage) => string
+
+export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>
+
+export type BaileysInMemoryStoreConfig = {
+    chatKey?: Comparable<Chat, string>
+    labelAssociationKey?: Comparable<LabelAssociation, string>
+    logger?: Logger
+    socket?: WASocket
+}
+
+export declare const makeInMemoryStore: (config: BaileysInMemoryStoreConfig) => {
+    chats: KeyedDB<Chat, string>
+    contacts: {
+        [_: string]: Contact
+    }
+    messages: {
+        [_: string]: {
+            array: proto.IWebMessageInfo[]
+            get: (id: string) => proto.IWebMessageInfo | undefined
+            upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
+            update: (item: proto.IWebMessageInfo) => boolean
+            remove: (item: proto.IWebMessageInfo) => boolean
+            updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
+            clear: () => void
+            filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
+            toJSON: () => proto.IWebMessageInfo[]
+            fromJSON: (newItems: proto.IWebMessageInfo[]) => void
+        }
+    }
+    groupMetadata: {
+        [_: string]: GroupMetadata
+    }
+    state: ConnectionState
+    presences: {
+        [id: string]: {
+            [participant: string]: PresenceData
+        }
+    }
+    labels: ObjectRepository<Label>
+    labelAssociations: KeyedDB<LabelAssociation, string>
+    bind: (ev: BaileysEventEmitter) => void
+    /** loads messages from the store, if not found -- uses the legacy connection */
+    loadMessages: (jid: string, count: number, cursor: WAMessageCursor) => Promise<proto.IWebMessageInfo[]>
+    /**
+     * Get all available labels for profile
+     *
+     * Keep in mind that the list is formed from predefined tags and tags
+     * that were "caught" during their editing.
+     */
+    getLabels: () => ObjectRepository<Label>
+    /**
+     * Get labels for chat
+     *
+     * @returns Label IDs
+     **/
+    getChatLabels: (chatId: string) => LabelAssociation[]
+    /**
+     * Get labels for message
+     *
+     * @returns Label IDs
+     **/
+    getMessageLabels: (messageId: string) => string[]
+    loadMessage: (jid: string, id: string) => Promise<proto.IWebMessageInfo | undefined>
+    mostRecentMessage: (jid: string) => Promise<proto.IWebMessageInfo>
+    fetchImageUrl: (jid: string, Neele: WASocket | undefined) => Promise<string | null | undefined>
+    fetchGroupMetadata: (jid: string, Neele: WASocket | undefined) => Promise<GroupMetadata>
+    fetchMessageReceipts: ({ remoteJid, id }: WAMessageKey) => Promise<proto.IUserReceipt[] | null | undefined>
+    toJSON: () => {
+        chats: KeyedDB<Chat, string>
+        contacts: {
+            [_: string]: Contact
+        }
+        messages: {
+            [_: string]: {
+                array: proto.IWebMessageInfo[]
+                get: (id: string) => proto.IWebMessageInfo | undefined
+                upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
+                update: (item: proto.IWebMessageInfo) => boolean
+                remove: (item: proto.IWebMessageInfo) => boolean
+                updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
+                clear: () => void
+                filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
+                toJSON: () => proto.IWebMessageInfo[]
+                fromJSON: (newItems: proto.IWebMessageInfo[]) => void
+            }
+        }
+        labels: ObjectRepository<Label>
+        labelAssociations: KeyedDB<LabelAssociation, string>
+    }
+    fromJSON: (json: {
+        chats: Chat[]
+        contacts: {
+            [id: string]: Contact
+        }
+        messages: {
+            [id: string]: proto.IWebMessageInfo[]
+        }
+        labels: {
+            [labelId: string]: Label
+        }
+        labelAssociations: LabelAssociation[]
+    }) => void
+    writeToFile: (path: string) => void
+    readFromFile: (path: string) => void
+}