@baileys-md/baileys 11.0.3 → 11.1.0

package/lib/Socket/usync.js

@@ -1,24 +1,28 @@
-import { Boom } from '@hapi/boom';
-import { S_WHATSAPP_NET } from '../WABinary/index.js';
-import { USyncQuery } from '../WAUSync/index.js';
-import { makeSocket } from './socket.js';
-export const makeUSyncSocket = (config) => {
-    const sock = makeSocket(config);
-    const { generateMessageTag, query } = sock;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
     const executeUSyncQuery = async (usyncQuery) => {
         if (usyncQuery.protocols.length === 0) {
-            throw new Boom('USyncQuery must have at least one protocol');
+            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 => {
+        const userNodes = validUsers.map((user) => {
             return {
                 tag: 'user',
                 attrs: {
-                    jid: !user.phone ? user.id : undefined
+                    jid: !user.phone ? user.id : undefined,
                 },
-                content: usyncQuery.protocols.map(a => a.getUserElement(user)).filter(a => a !== null)
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
             };
         });
         const listNode = {
@@ -29,14 +33,14 @@ export const makeUSyncSocket = (config) => {
         const queryNode = {
             tag: 'query',
             attrs: {},
-            content: usyncQuery.protocols.map(a => a.getQueryElement())
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
         };
         const iq = {
             tag: 'iq',
             attrs: {
-                to: S_WHATSAPP_NET,
+                to: WABinary_1.S_WHATSAPP_NET,
                 type: 'get',
-                xmlns: 'usync'
+                xmlns: 'usync',
             },
             content: [
                 {
@@ -46,18 +50,21 @@ export const makeUSyncSocket = (config) => {
                         mode: usyncQuery.mode,
                         sid: generateMessageTag(),
                         last: 'true',
-                        index: '0'
+                        index: '0',
                     },
-                    content: [queryNode, listNode]
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
                 }
-            ]
+            ],
         };
         const result = await query(iq);
         return usyncQuery.parseUSyncQueryResult(result);
     };
     return {
         ...sock,
-        executeUSyncQuery
+        executeUSyncQuery,
     };
 };
-//# sourceMappingURL=usync.js.map
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInMemoryStore = void 0;
+const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
+exports.makeInMemoryStore = make_in_memory_store_1.default;

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/{Utils → Store}/make-in-memory-store.js

@@ -1,26 +1,34 @@
-import * as WAProto_1 from "../../WAProto/index.js"
-import * as Defaults_1 from "../Defaults/index.js"
-import * as LabelAssociation_1 from "../Types/LabelAssociation.js"
-import * as Utils_1 from "../Utils/index.js"
-import * as WABinary_1 from "../WABinary/index.js"
-import * as object_repository_1 from "./object-repository.js"
-import * as make_ordered_dictionary_1 from "./make-ordered-dictionary.js"
-export const waChatKey = (pin) => ({
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waLabelAssociationKey = exports.waMessageID = exports.waChatKey = void 0;
+const WAProto_1 = require("../../WAProto");
+const Defaults_1 = require("../Defaults");
+const LabelAssociation_1 = require("../Types/LabelAssociation");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const make_ordered_dictionary_1 = __importDefault(require("./make-ordered-dictionary"));
+const object_repository_1 = require("./object-repository");
+const waChatKey = (pin) => ({
     key: (c) => (pin ? (c.pinned ? '1' : '0') : '') + (c.archived ? '0' : '1') + (c.conversationTimestamp ? c.conversationTimestamp.toString(16).padStart(8, '0') : '') + c.id,
     compare: (k1, k2) => k2.localeCompare(k1)
 });
-export const waMessageID = (m) => m.key.id || '';
-export const waLabelAssociationKey = {
+exports.waChatKey = waChatKey;
+const waMessageID = (m) => m.key.id || '';
+exports.waMessageID = waMessageID;
+exports.waLabelAssociationKey = {
     key: (la) => (la.type === LabelAssociation_1.LabelAssociationType.Chat ? la.chatId + la.labelId : la.chatId + la.messageId + la.labelId),
     compare: (k1, k2) => k2.localeCompare(k1)
 };
-const makeMessagesDictionary = () => (0, make_ordered_dictionary_1.makeOrderedDictionary)(waMessageID);
-export const makeInMemoryStore = async (config) => {
+const makeMessagesDictionary = () => (0, make_ordered_dictionary_1.default)(exports.waMessageID);
+exports.default = (config) => {
     const socket = config.socket;
-    const chatKey = config.chatKey || (0, waChatKey)(true);
-    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey;
+    const chatKey = config.chatKey || (0, exports.waChatKey)(true);
+    const labelAssociationKey = config.labelAssociationKey || exports.waLabelAssociationKey;
     const logger = config.logger || Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' });
-    const KeyedDB = ((await import ('@baileys-md/keyed-db')).default).default;
+    const KeyedDB = require('@baileys-md/keyed-db').default;
     const chats = new KeyedDB(chatKey, c => c.id);
     const messages = {};
     const contacts = {};
@@ -404,14 +412,14 @@ export const makeInMemoryStore = async (config) => {
         },
         toJSON,
         fromJSON,
-        writeToFile: async (path) => {
+        writeToFile: (path) => {
             // require fs here so that in case "fs" is not available -- the app does not crash
-            const { writeFileSync } = await import('fs');
+            const { writeFileSync } = require('fs');
             writeFileSync(path, JSON.stringify(toJSON()));
         },
-        readFromFile: async (path) => {
+        readFromFile: (path) => {
             // require fs here so that in case "fs" is not available -- the app does not crash
-            const { readFileSync, existsSync } = await import('fs');
+            const { readFileSync, existsSync } = require('fs');
             if (existsSync(path)) {
                 logger.debug({ path }, 'reading from file');
                 const jsonStr = readFileSync(path, { encoding: 'utf-8' });