@alannxd/baileys 6.0.6 → 6.0.9

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.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.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;
+}