dcodeindra-baileyspro 2.3.9

package/lib/Socket/usync.d.ts

@@ -0,0 +1,36 @@
+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,71 @@
+"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 sock = socket_1.makeSocket(config)
+const { generateMessageTag, query, } = sock
+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 {
+...sock,
+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,20 @@
+"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,13 @@
+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,77 @@
+"use strict"
+var __importDefault = (this && this.__importDefault) || function (mod) {
+return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const WAProto_1 = require("../../WAProto")
+const Utils_1 = require("../Utils")
+const logger_1 = __importDefault(require("../Utils/logger"))
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+const { createCache } = await import('cache-manager')
+const defaultKey = (file) => `${sessionKey}:${file}`
+const databaseConn = createCache()
+const writeData = async (file, data) => {
+let ttl = undefined
+if (file === 'creds') {
+ttl = 63115200
+}
+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))
+return data ? JSON.parse(data, Utils_1.BufferJSON.reviver) : null
+} catch (error) {
+logger_1.default.error(error)
+return null
+}
+}
+const removeData = async (file) => {
+try {
+return await databaseConn.del(defaultKey(file))
+} catch {
+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((key) => databaseConn.del(key)))
+} catch {}
+}
+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) => {
+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,117 @@
+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, sock: WASocket | undefined) => Promise<string | null | undefined>
+fetchGroupMetadata: (jid: string, sock: 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
+}