alipclutch-baileys 8.5.2 → 8.5.4

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

@@ -0,0 +1,83 @@
+"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 (0, 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);
+                },
+            }
+        }
+    };
+};
+exports.default = makeCacheManagerAuthState;

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

@@ -1,11 +1,11 @@
 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 { ILogger } from '../Utils/logger';
 import { ObjectRepository } from './object-repository';
 type WASocket = ReturnType<typeof makeMDSocket>;
 export declare const waChatKey: (pin: boolean) => {
@@ -17,7 +17,7 @@ export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>
 export type BaileysInMemoryStoreConfig = {
     chatKey?: Comparable<Chat, string>;
     labelAssociationKey?: Comparable<LabelAssociation, string>;
-    logger?: ILogger;
+    logger?: Logger;
     socket?: WASocket;
 };
 declare const _default: (config: BaileysInMemoryStoreConfig) => {
@@ -27,16 +27,16 @@ declare const _default: (config: BaileysInMemoryStoreConfig) => {
     };
     messages: {
         [_: string]: {
-            array: WAMessage[];
-            get: (id: string) => WAMessage | undefined;
-            upsert: (item: WAMessage, mode: "append" | "prepend") => void;
-            update: (item: WAMessage) => boolean;
-            remove: (item: WAMessage) => boolean;
-            updateAssign: (id: string, update: Partial<WAMessage>) => boolean;
+            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: WAMessage) => boolean) => void;
-            toJSON: () => WAMessage[];
-            fromJSON: (newItems: WAMessage[]) => void;
+            filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void;
+            toJSON: () => proto.IWebMessageInfo[];
+            fromJSON: (newItems: proto.IWebMessageInfo[]) => void;
         };
     };
     groupMetadata: {
@@ -52,7 +52,7 @@ declare const _default: (config: BaileysInMemoryStoreConfig) => {
     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<WAMessage[]>;
+    loadMessages: (jid: string, count: number, cursor: WAMessageCursor) => Promise<proto.IWebMessageInfo[]>;
     /**
      * Get all available labels for profile
      *
@@ -72,8 +72,8 @@ declare const _default: (config: BaileysInMemoryStoreConfig) => {
      * @returns Label IDs
      **/
     getMessageLabels: (messageId: string) => string[];
-    loadMessage: (jid: string, id: string) => Promise<WAMessage | undefined>;
-    mostRecentMessage: (jid: string) => Promise<WAMessage>;
+    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>;
@@ -84,16 +84,16 @@ declare const _default: (config: BaileysInMemoryStoreConfig) => {
         };
         messages: {
             [_: string]: {
-                array: WAMessage[];
-                get: (id: string) => WAMessage | undefined;
-                upsert: (item: WAMessage, mode: "append" | "prepend") => void;
-                update: (item: WAMessage) => boolean;
-                remove: (item: WAMessage) => boolean;
-                updateAssign: (id: string, update: Partial<WAMessage>) => boolean;
+                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: WAMessage) => boolean) => void;
-                toJSON: () => WAMessage[];
-                fromJSON: (newItems: WAMessage[]) => void;
+                filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void;
+                toJSON: () => proto.IWebMessageInfo[];
+                fromJSON: (newItems: proto.IWebMessageInfo[]) => void;
             };
         };
         labels: ObjectRepository<Label>;
@@ -105,7 +105,7 @@ declare const _default: (config: BaileysInMemoryStoreConfig) => {
             [id: string]: Contact;
         };
         messages: {
-            [id: string]: WAMessage[];
+            [id: string]: proto.IWebMessageInfo[];
         };
         labels: {
             [labelId: string]: Label;

package/lib/Store/make-in-memory-store.js

@@ -74,11 +74,7 @@ exports.default = (config) => {
         ev.on('connection.update', update => {
             Object.assign(state, update);
         });
-        ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
-            if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
-                return; // FOR NOW,
-                //TODO: HANDLE
-            }
+        ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest }) => {
             if (isLatest) {
                 chats.clear();
                 for (const id in messages) {
@@ -191,14 +187,16 @@ exports.default = (config) => {
                         const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
                         const list = assertMessageList(jid);
                         list.upsert(msg, 'append');
-                        if (type === 'notify' && !chats.get(jid)) {
-                            ev.emit('chats.upsert', [
-                                {
-                                    id: jid,
-                                    conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
-                                    unreadCount: 1
-                                }
-                            ]);
+                        if (type === 'notify') {
+                            if (!chats.get(jid)) {
+                                ev.emit('chats.upsert', [
+                                    {
+                                        id: jid,
+                                        conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
+                                        unreadCount: 1
+                                    }
+                                ]);
+                            }
                         }
                     }
                     break;
@@ -420,19 +418,9 @@ exports.default = (config) => {
             const { readFileSync, existsSync } = require('fs');
             if (existsSync(path)) {
                 logger.debug({ path }, 'reading from file');
-                try {
-                    const jsonStr = readFileSync(path, { encoding: 'utf-8' });
-                    if (jsonStr.trim().length) {
-                        const json = JSON.parse(jsonStr);
-                        fromJSON(json);
-                    }
-                    else {
-                        logger.warn({ path }, 'skipping empty json file');
-                    }
-                }
-                catch (err) {
-                    logger.warn({ path, err }, 'failed to parse json from file');
-                }
+                const jsonStr = readFileSync(path, { encoding: 'utf-8' });
+                const json = JSON.parse(jsonStr);
+                fromJSON(json);
             }
         }
     };

package/lib/Store/make-ordered-dictionary.d.ts

@@ -1,7 +1,7 @@
 declare function makeOrderedDictionary<T>(idGetter: (item: T) => string): {
     array: T[];
     get: (id: string) => T | undefined;
-    upsert: (item: T, mode: "append" | "prepend") => void;
+    upsert: (item: T, mode: 'append' | 'prepend') => void;
     update: (item: T) => boolean;
     remove: (item: T) => boolean;
     updateAssign: (id: string, update: Partial<T>) => boolean;

package/lib/Store/make-ordered-dictionary.js

@@ -56,9 +56,9 @@ function makeOrderedDictionary(idGetter) {
         },
         clear: () => {
             array.splice(0, array.length);
-            for (const key of Object.keys(dict)) {
+            Object.keys(dict).forEach(key => {
                 delete dict[key];
-            }
+            });
         },
         filter: (contain) => {
             let i = 0;

package/lib/Types/Auth.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import type { proto } from '../../WAProto';
+import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
 export type KeyPair = {
@@ -55,7 +57,12 @@ export type AuthenticationCreds = SignalCreds & {
     /** number of times history & app state has been synced */
     accountSyncCounter: number;
     accountSettings: AccountSettings;
+    deviceId: string;
+    phoneId: string;
+    identityId: Buffer;
     registered: boolean;
+    backupToken: Buffer;
+    registration: RegistrationOptions;
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;

package/lib/Types/Call.d.ts

@@ -1,4 +1,4 @@
-export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate';
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
 export type WACallEvent = {
     chatId: string;
     from: string;

package/lib/Types/Chat.d.ts

@@ -3,13 +3,10 @@ import type { AccountSettings } from './Auth';
 import type { BufferedEventData } from './Events';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
-import type { MinimalMessage, WAMessageKey } from './Message';
+import type { MinimalMessage } from './Message';
 /** privacy settings in WhatsApp Web */
 export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
-export type WAPrivacyCallValue = 'all' | 'known';
-export type WAPrivacyMessagesValue = 'all' | 'contacts';
 export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
-export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
 export type WAReadReceiptsValue = 'all' | 'none';
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
 export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
@@ -19,10 +16,6 @@ export interface PresenceData {
     lastKnownPresence: WAPresence;
     lastSeen?: number;
 }
-export type BotListInfo = {
-    jid: string;
-    personaId: string;
-};
 export type ChatMutation = {
     syncAction: proto.ISyncActionData;
     index: string[];
@@ -66,12 +59,12 @@ export type ChatModification = {
     /** mute for duration, or provide timestamp of mute to remove*/
     mute: number | null;
 } | {
-    clear: boolean;
-} | {
-    deleteForMe: {
-        deleteMedia: boolean;
-        key: WAMessageKey;
-        timestamp: number;
+    clear: 'all' | {
+        messages: {
+            id: string;
+            fromMe?: boolean;
+            timestamp: number;
+        }[];
     };
 } | {
     star: {

package/lib/Types/Contact.d.ts

@@ -1,10 +1,6 @@
 export interface Contact {
-    /** ID either in lid or jid format **/
     id: string;
-    /** ID in Lid (anonymous) format (@lid) **/
     lid?: string;
-    /** ID in Phone Number format (@s.whatsapp.net)  **/
-    jid?: string;
     /** name of the contact, you have saved on your WA */
     name?: string;
     /** name of the contact, the contact has set on their own on WA */
@@ -18,6 +14,6 @@ export interface Contact {
      * null => if the profile picture has not been set (default profile picture)
      * any other string => url of the profile picture
      */
-    imgUrl?: string | null;
+    imgUrl?: string | null | 'changed';
     status?: string;
 }

package/lib/Types/Events.d.ts

@@ -4,12 +4,11 @@ import { AuthenticationCreds } from './Auth';
 import { WACallEvent } from './Call';
 import { Chat, ChatUpdate, PresenceData } from './Chat';
 import { Contact } from './Contact';
-import { GroupMetadata, ParticipantAction, RequestJoinAction, RequestJoinMethod } from './GroupMetadata';
+import { GroupMetadata, ParticipantAction } from './GroupMetadata';
 import { Label } from './Label';
 import { LabelAssociation } from './LabelAssociation';
 import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message';
 import { ConnectionState } from './State';
-import { NewsletterSettingsUpdate, SubscriberAction, NewsletterViewRole } from './Newsletter';
 export type BaileysEventMap = {
     /** connection state has been updated -- WS closed, opened, connecting etc. */
     'connection.update': Partial<ConnectionState>;
@@ -20,10 +19,7 @@ export type BaileysEventMap = {
         chats: Chat[];
         contacts: Contact[];
         messages: WAMessage[];
-        isLatest?: boolean;
-        progress?: number | null;
-        syncType?: proto.HistorySync.HistorySyncType;
-        peerDataRequestSessionId?: string | null;
+        isLatest: boolean;
     };
     /** upsert chats */
     'chats.upsert': Chat[];
@@ -62,12 +58,10 @@ export type BaileysEventMap = {
     /**
      * add/update the given messages. If they were received while the connection was online,
      * the update will have type: "notify"
-     * if requestId is provided, then the messages was received from the phone due to it being unavailable
      *  */
     'messages.upsert': {
         messages: WAMessage[];
         type: MessageUpsertType;
-        requestId?: string;
     };
     /** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
     'messages.reaction': {
@@ -84,39 +78,6 @@ export type BaileysEventMap = {
         participants: string[];
         action: ParticipantAction;
     };
-    'group.join-request': {
-        id: string;
-        author: string;
-        participant: string;
-        action: RequestJoinAction;
-        method: RequestJoinMethod;
-    };
-    'newsletter.reaction': {
-        id: string;
-        server_id: string;
-        reaction: {
-            code?: string;
-            count?: number;
-            removed?: boolean;
-        };
-    };
-    'newsletter.view': {
-        id: string;
-        server_id: string;
-        count: number;
-    };
-    /**don't handles subscribe/unsubscribe actions */
-    'newsletter-participants.update': {
-        id: string;
-        author: string;
-        user: string;
-        new_role: NewsletterViewRole;
-        action: SubscriberAction;
-    };
-    'newsletter-settings.update': {
-        id: string;
-        update: NewsletterSettingsUpdate;
-    };
     'blocklist.set': {
         blocklist: string[];
     };
@@ -145,9 +106,6 @@ export type BufferedEventData = {
         };
         empty: boolean;
         isLatest: boolean;
-        progress?: number | null;
-        syncType?: proto.HistorySync.HistorySyncType;
-        peerDataRequestSessionId?: string;
     };
     chatUpserts: {
         [jid: string]: Chat;

package/lib/Types/GroupMetadata.d.ts

@@ -3,30 +3,21 @@ export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
-    jid?: string;
-    lid?: string;
 });
-export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
-export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
-export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
 export interface GroupMetadata {
     id: string;
-    /** group uses 'lid' or 'pn' to send messages */
-    addressingMode: 'pn' | 'lid';
     owner: string | undefined;
-    ownerLid?: string | undefined;
     subject: string;
+    addressingMode: "pn" | "lid";
     /** group subject owner */
     subjectOwner?: string;
-    subjectOwnerLid?: string;
     /** group subject modification date */
     subjectTime?: number;
     creation?: number;
     desc?: string;
     descOwner?: string;
-    descOwnerLid?: string;
     descId?: string;
-    descTime?: number;
     /** if this group is part of a community, it returns the jid of the community to which it belongs */
     linkedParent?: string;
     /** is set when the group only allows admins to change group settings */

package/lib/Types/Label.js

@@ -24,4 +24,4 @@ var LabelColor;
     LabelColor[LabelColor["Color18"] = 17] = "Color18";
     LabelColor[LabelColor["Color19"] = 18] = "Color19";
     LabelColor[LabelColor["Color20"] = 19] = "Color20";
-})(LabelColor || (exports.LabelColor = LabelColor = {}));
+})(LabelColor = exports.LabelColor || (exports.LabelColor = {}));

package/lib/Types/LabelAssociation.js

@@ -6,4 +6,4 @@ var LabelAssociationType;
 (function (LabelAssociationType) {
     LabelAssociationType["Chat"] = "label_jid";
     LabelAssociationType["Message"] = "label_message";
-})(LabelAssociationType || (exports.LabelAssociationType = LabelAssociationType = {}));
+})(LabelAssociationType = exports.LabelAssociationType || (exports.LabelAssociationType = {}));