@alannxd/baileys 6.0.4 → 6.0.5

package/lib/Store/index.d.ts

@@ -1,3 +1,10 @@
-import makeCacheManagerAuthState from './make-cache-manager-store';
-import makeInMemoryStore from './make-in-memory-store';
-export { makeInMemoryStore, makeCacheManagerAuthState };
+export * from './make-cache-manager-store';
+export * from './make-in-memory-store';
+export * from './make-ordered-dictionary';
+export * from './object-repository';
+export * from './keyed-db
+export { default as makeCacheManagerStore } from './make-cache-manager-store';
+export { default as makeInMemoryStore } from './make-in-memory-store';
+export { default as makeOrderedDictionary } from './make-ordered-dictionary';
+export { default as objectRepository } from './object-repository';
+export { default as keyedDB} from './keyed-db';

package/lib/Store/index.js

@@ -1,10 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCacheManagerAuthState = exports.makeInMemoryStore = void 0;
-const make_cache_manager_store_1 = __importDefault(require("./make-cache-manager-store"));
-exports.makeCacheManagerAuthState = make_cache_manager_store_1.default;
-const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
-exports.makeInMemoryStore = make_in_memory_store_1.default;
+export * from './make-cache-manager-store.js';
+export * from './make-in-memory-store.js';
+export * from './make-ordered-dictionary.js';
+export * from './object-repository.js';
+export * from './keyed-db.js';
+export { default as makeCacheManagerStore } from './make-cache-manager-store.js';
+export { default as makeInMemoryStore } from './make-in-memory-store.js';
+export { default as makeOrderedDictionary } from './make-ordered-dictionary.js';
+export { default as objectRepository } from './object-repository.js';
+export { default as keyedDB } from './keyed-db.js';

package/lib/Store/keyed-db.d.ts

@@ -0,0 +1,22 @@
+declare class KeyedDB<T> {
+  private _compare: (a: string, b: string) => number;
+  private _idGetter: (item: T) => string;
+  private _array: T[];
+  private _dict: { [id: string]: T };
+  constructor(compareFn: (a: string, b: string) => number, idGetter: (item: T) => string);
+  get length(): number;
+  get(id: string): T | undefined;
+  insert(entry: T, mode?: 'insert'): boolean;
+  insertIfAbsent(...entries: T[]): T[];
+  upsert(...entries: T[]): T[];
+  update(id: string, updater: (item: T) => void): boolean;
+  updateAssign(id: string, update: Partial<T>): boolean;
+  deleteById(id: string): boolean;
+  clear(): void;
+  all(): T[];
+  filter(predicate: (item: T) => boolean): void;
+  count(): number;
+  toJSON(): T[];
+  fromJSON(array: T[]): void;
+}
+export default KeyedDB;

package/lib/Store/keyed-db.js

@@ -0,0 +1,108 @@
+export default class KeyedDB {
+    constructor(compareFn, idGetter) {
+        if (typeof compareFn !== "function" || typeof idGetter !== "function") {
+            throw new Error("KeyedDB requires compare and idGetter functions");
+        }
+        this._compare = compareFn;
+        this._idGetter = idGetter;
+        this._array = [];
+        this._dict = {};
+    }
+    get length() {
+        return this._array.length;
+    }
+    get(id) {
+        return this._dict[id];
+    }
+    insert(entry, mode = "insert") {
+        const id = this._idGetter(entry);
+        const existing = this._dict[id];
+        if (existing && mode === "insert") {
+            return false;
+        }
+        this._dict[id] = entry;
+        let inserted = false;
+        for (let i = 0; i < this._array.length; i++) {
+            const cmp = this._compare(this._idGetter(this._array[i]), id);
+            if (cmp < 0) {
+                this._array.splice(i, 0, entry);
+                inserted = true;
+                break;
+            }
+        }
+        if (!inserted) this._array.push(entry);
+        return true;
+    }
+    insertIfAbsent(...entries) {
+        const added = [];
+        for (const entry of entries) {
+            if (!this._dict[this._idGetter(entry)]) {
+                this.insert(entry);
+                added.push(entry);
+            }
+        }
+        return added;
+    }
+    upsert(...entries) {
+        const added = [];
+        for (const entry of entries) {
+            const id = this._idGetter(entry);
+            if (this._dict[id]) {
+                const idx = this._array.findIndex(e => this._idGetter(e) === id);
+                if (idx >= 0) this._array[idx] = entry;
+                this._dict[id] = entry;
+            } else {
+                this.insert(entry);
+                added.push(entry);
+            }
+        }
+        return added;
+    }
+    update(id, updater) {
+        const item = this._dict[id];
+        if (!item) return false;
+        updater(item);
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array[idx] = item;
+        return true;
+    }
+    updateAssign(id, update) {
+        const item = this._dict[id];
+        if (!item) return false;
+        Object.assign(item, update);
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array[idx] = item;
+        return true;
+    }
+    deleteById(id) {
+        if (!this._dict[id]) return false;
+        delete this._dict[id];
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array.splice(idx, 1);
+        return true;
+    }
+    clear() {
+        this._array = [];
+        this._dict = {};
+    }
+    all() {
+        return [...this._array];
+    }
+    filter(predicate) {
+        this._array = this._array.filter(predicate);
+        this._dict = {};
+        for (const entry of this._array) {
+            this._dict[this._idGetter(entry)] = entry;
+        }
+    }
+    count() {
+        return this._array.length;
+    }
+    toJSON() {
+        return this._array;
+    }
+    fromJSON(array) {
+        this.clear();
+        for (const entry of array) this.insert(entry);
+    }
+}

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

@@ -1,13 +1,19 @@
-import { AuthenticationCreds } from '../Types';
-declare const makeCacheManagerAuthState: (store: Storage, sessionKey: string) => Promise<{
-    clearState: () => Promise<void>;
-    saveCreds: () => Promise<void>;
-    state: {
-        creds: AuthenticationCreds;
-        keys: {
-            get: (type: string, ids: string[]) => Promise<{}>;
-            set: (data: any) => Promise<void>;
-        };
+import { Store } from 'cache-manager';
+import { proto as WAProto } from '../../WAProto';
+
+interface AuthState {
+  clearState: () => Promise<void>;
+  saveCreds: () => Promise<void>;
+  state: {
+    creds: any;
+    keys: {
+      get: (type: string, ids: string[]) => Promise<{ [id: string]: any }>;
+      set: (data: { [category: string]: { [id: string]: any } }) => Promise<void>;
     };
-}>;
+  };
+}
+
+declare function makeCacheManagerAuthState(store: Store, sessionKey: string): Promise<AuthState>;
+
 export default makeCacheManagerAuthState;
+export { makeCacheManagerAuthState };

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

@@ -1,71 +1,74 @@
-"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) => {
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const cacheManager = require("cache-manager");
+
+import * as WAProto_1 from "../../WAProto/index.js";
+import * as Utils_1 from "../Utils/index.js";
+import logger from "../Utils/logger.js";
+
+export default async function makeCacheManagerAuthState(store, sessionKey) {
     const defaultKey = (file) => `${sessionKey}:${file}`;
-    const databaseConn = await (0, cache_manager_1.caching)(store);
+    const databaseConn = await cacheManager.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);
+        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);
-            }
+            if (data) return JSON.parse(data, Utils_1.BufferJSON.reviver);
             return null;
-        }
-        catch (error) {
-            logger_1.default.error(error);
+        } catch (error) {
+            logger.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}`);
+        } catch {
+            logger.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) {
-        }
+            await Promise.all(result.map(async (key) => databaseConn.del(key)));
+        } catch {}
     };
-    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
+
+    const creds = (await readData("creds")) || Utils_1.initAuthCreds();
+
     return {
         clearState,
-        saveCreds: () => writeData('creds', creds),
+        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;
-                    }));
+                    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]) {
@@ -75,9 +78,8 @@ const makeCacheManagerAuthState = async (store, sessionKey) => {
                         }
                     }
                     await Promise.all(tasks);
-                },
+                }
             }
         }
     };
-};
-exports.default = makeCacheManagerAuthState;
+}

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

@@ -1,118 +1,39 @@
-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;
-};
-declare const _default: (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;
-};
-export default _default;
+import { proto as WAProto } from '../../WAProto';
+import { LabelAssociationType } from '../Types/LabelAssociation';
+
+interface StoreConfig {
+  socket: any;
+  chatKey?: any;
+  labelAssociationKey?: any;
+  logger?: any;
+}
+
+interface Store {
+  chats: any;
+  contacts: any;
+  messages: any;
+  groupMetadata: any;
+  state: any;
+  presences: any;
+  labels: any;
+  labelAssociations: any;
+  bind: (ev: any) => void;
+  loadMessages: (jid: string, count: number, cursor: any) => Promise<any[]>;
+  getLabels: () => any[];
+  getChatLabels: (chatId: string) => any[];
+  getMessageLabels: (messageId: string) => any[];
+  loadMessage: (jid: string, id: string) => Promise<any>;
+  mostRecentMessage: (jid: string) => Promise<any>;
+  fetchImageUrl: (jid: string, sock: any) => Promise<string | undefined>;
+  fetchGroupMetadata: (jid: string, sock: any) => Promise<any>;
+  fetchMessageReceipts: (opts: { remoteJid: string; id: string }) => Promise<any[] | undefined>;
+  toJSON: () => any;
+  fromJSON: (json: any) => void;
+  writeToFile: (path: string) => void;
+  readFromFile: (path: string) => void;
+}
+
+declare function makeStore(config: StoreConfig): Store;
+
+export default makeStore;
+export { makeStore, waChatKey, waMessageID, waLabelAssociationKey };