@mrlegendbot/baileys 1.2.3 → 1.2.4

package/lib/Store/index.js

@@ -0,0 +1,8 @@
+export * from './make-cache-manager-store.js';
+export * from './make-ordered-dictionary.js';
+export * from './object-repository.js';
+export * from './make-in-memory-store.js';
+export { default as makeInMemoryStore } from './make-in-memory-store.js';
+export { default as MakeCacheManagerStore } from './make-cache-manager-store.js';
+export { default as MakeOrderedDictionary } from './make-ordered-dictionary.js';
+export { default as ObjectRepository } from './object-repository.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(entry, this._array[i]);
+      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

@@ -0,0 +1,70 @@
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const cacheManager = require("cache-manager");
+import * as WAProto_1 from "../../WAProto/compiler.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 cacheManager.caching(store);
+  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));
+      if (data) return JSON.parse(data, Utils_1.BufferJSON.reviver);
+      return null;
+    } catch (error) {
+      logger.error(error);
+      return null;
+    }
+  };
+  const removeData = async file => {
+    try {
+      return await databaseConn.del(defaultKey(file));
+    } 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 => databaseConn.del(key)));
+    } catch {}
+  };
+  const creds = (await readData("creds")) || 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);
+        }
+      }
+    }
+  };
+}

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

@@ -0,0 +1,417 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
+import { toNumber, updateMessageWithPollUpdate, updateMessageWithReaction, updateMessageWithReceipt } from '../Utils/index.js';
+import { jidNormalizedUser } from '../WABinary/index.js';
+import KeyedDB from './keyed-db.js';
+import makeOrderedDictionary from './make-ordered-dictionary.js';
+import { ObjectRepository } from './object-repository.js';
+const waChatKey = pin => (c1, c2) => {
+  const pinnedDiff = pin ? Number(!!c2.pinned) - Number(!!c1.pinned) : 0;
+  if (pinnedDiff) return pinnedDiff;
+  const t1 = toNumber(c1.conversationTimestamp) || 0;
+  const t2 = toNumber(c2.conversationTimestamp) || 0;
+  if (t1 !== t2) return t2 - t1;
+  return (c1.id || '').localeCompare(c2.id || '');
+};
+const waMessageID = m => m.key?.id || '';
+const waLabelAssociationKey = (a1, a2) => (a1.type || '').localeCompare(a2.type || '') || (a1.chatId || '').localeCompare(a2.chatId || '') || (a1.labelId || '').localeCompare(a2.labelId || '');
+const labelAssociationId = a => (a.type || '') + ':' + (a.chatId || a.messageId || '') + ':' + (a.labelId || '');
+const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
+export const makeInMemoryStore = (config = {}) => {
+  const socket = config.socket;
+  const chatKeyCompare = config.chatKey || waChatKey(true);
+  const labelAssociationKeyCompare = config.labelAssociationKey || waLabelAssociationKey;
+  const logger = config.logger || DEFAULT_CONNECTION_CONFIG.logger?.child?.({
+    stream: 'in-mem-store'
+  });
+  const chats = new KeyedDB(chatKeyCompare, c => c.id);
+  const messages = {};
+  const contacts = {};
+  const groupMetadata = {};
+  const presences = {};
+  const state = {
+    connection: 'close'
+  };
+  const labels = new ObjectRepository();
+  const labelAssociations = new KeyedDB(labelAssociationKeyCompare, labelAssociationId);
+  const assertMessageList = jid => {
+    if (!messages[jid]) {
+      messages[jid] = makeMessagesDictionary();
+    }
+    return messages[jid];
+  };
+  const contactsUpsert = newContacts => {
+    const oldContacts = new Set(Object.keys(contacts));
+    for (const contact of newContacts) {
+      oldContacts.delete(contact.id);
+      contacts[contact.id] = Object.assign(contacts[contact.id] || {}, contact);
+    }
+    return oldContacts;
+  };
+  const labelsUpsert = newLabels => {
+    for (const label of newLabels) {
+      labels.upsertById(label.id, label);
+    }
+  };
+  const bind = ev => {
+    ev.on('connection.update', update => {
+      Object.assign(state, update);
+    });
+    ev.on('messaging-history.set', ({
+      chats: newChats,
+      contacts: newContacts,
+      messages: newMessages,
+      isLatest,
+      syncType
+    }) => {
+      if (isLatest) {
+        chats.clear();
+        for (const id of Object.keys(messages)) {
+          delete messages[id];
+        }
+      }
+      const chatsAdded = chats.insertIfAbsent(...newChats).length;
+      logger?.debug?.({
+        chatsAdded
+      }, 'synced chats');
+      const oldContacts = contactsUpsert(newContacts);
+      logger?.debug?.({
+        deletedContacts: oldContacts.size,
+        newContacts
+      }, 'synced contacts');
+      for (const msg of newMessages) {
+        const jid = jidNormalizedUser(msg.key.remoteJid);
+        const list = assertMessageList(jid);
+        list.upsert(msg, 'prepend');
+      }
+      logger?.debug?.({
+        messages: newMessages.length
+      }, 'synced messages');
+    });
+    ev.on('contacts.upsert', newContacts => {
+      contactsUpsert(newContacts);
+    });
+    ev.on('contacts.update', updates => {
+      for (const update of updates) {
+        let contact;
+        if (update.id && (contact = contacts[update.id])) {
+          Object.assign(contact, update);
+        } else {
+          logger?.debug?.({
+            update
+          }, 'got update for non-existant contact');
+        }
+      }
+    });
+    ev.on('chats.upsert', newChats => {
+      chats.upsert(...newChats);
+    });
+    ev.on('chats.update', updates => {
+      for (let update of updates) {
+        const existing = chats.get(update.id);
+        if (existing) {
+          chats.upsert(Object.assign(existing, update));
+        } else {
+          logger?.debug?.({
+            update
+          }, 'got update for non-existant chat');
+        }
+      }
+    });
+    ev.on('labels.edit', label => {
+      if (label.deleted) {
+        labels.deleteById(label.id);
+        return;
+      }
+      labels.upsertById(label.id, label);
+    });
+    ev.on('labels.association', ({
+      type,
+      association
+    }) => {
+      switch (type) {
+        case 'add':
+          labelAssociations.upsert(association);
+          break;
+        case 'remove':
+          labelAssociations.deleteById(labelAssociationId(association));
+          break;
+        default:
+          logger?.error?.(`unknown operation type ${type}`);
+      }
+    });
+    ev.on('presence.update', ({
+      id,
+      presences: update
+    }) => {
+      presences[id] = presences[id] || {};
+      Object.assign(presences[id], update);
+    });
+    ev.on('chats.delete', deletions => {
+      for (const item of deletions) {
+        if (chats.get(item)) {
+          chats.deleteById(item);
+        }
+      }
+    });
+    ev.on('messages.upsert', ({
+      messages: newMessages,
+      type
+    }) => {
+      switch (type) {
+        case 'append':
+        case 'notify':
+          for (const msg of newMessages) {
+            const jid = jidNormalizedUser(msg.key.remoteJid);
+            const list = assertMessageList(jid);
+            list.upsert(msg, 'append');
+            if (type === 'notify') {
+              if (!chats.get(jid)) {
+                ev.emit('chats.upsert', [{
+                  id: jid,
+                  conversationTimestamp: toNumber(msg.messageTimestamp),
+                  unreadCount: 1
+                }]);
+              }
+            }
+          }
+          break;
+      }
+    });
+    ev.on('messages.update', updates => {
+      for (const {
+        update,
+        key
+      } of updates) {
+        const list = assertMessageList(jidNormalizedUser(key.remoteJid));
+        if (update?.status) {
+          const listStatus = list.get(key.id)?.status;
+          if (listStatus && update.status <= listStatus) {
+            logger?.debug?.({
+              update,
+              storedStatus: listStatus
+            }, 'status stored newer then update');
+            delete update.status;
+          }
+        }
+        const result = list.updateAssign(key.id, update);
+        if (!result) {
+          logger?.debug?.({
+            update
+          }, 'got update for non-existent message');
+        }
+      }
+    });
+    ev.on('messages.delete', item => {
+      if ('all' in item) {
+        const list = messages[item.jid];
+        list?.clear();
+      } else {
+        const jid = item.keys[0].remoteJid;
+        const list = messages[jidNormalizedUser(jid)];
+        if (list) {
+          const idSet = new Set(item.keys.map(k => k.id));
+          list.filter(m => !idSet.has(m.key.id));
+        }
+      }
+    });
+    ev.on('messages.reaction', reactions => {
+      for (const {
+        key,
+        reaction
+      } of reactions) {
+        const obj = messages[jidNormalizedUser(key.remoteJid)];
+        const msg = obj?.get(key.id);
+        if (msg) {
+          updateMessageWithReaction(msg, reaction);
+        }
+      }
+    });
+    ev.on('message-receipt.update', updates => {
+      for (const {
+        key,
+        receipt
+      } of updates) {
+        const obj = messages[jidNormalizedUser(key.remoteJid)];
+        const msg = obj?.get(key.id);
+        if (msg) {
+          updateMessageWithReceipt(msg, receipt);
+        }
+      }
+    });
+    ev.on('groups.update', updates => {
+      for (const update of updates) {
+        const id = update.id;
+        if (groupMetadata[id]) {
+          Object.assign(groupMetadata[id], update);
+        } else {
+          logger?.debug?.({
+            update
+          }, 'got update for non-existant group metadata');
+        }
+      }
+    });
+    ev.on('group-participants.update', ({
+      id,
+      participants,
+      action
+    }) => {
+      const metadata = groupMetadata[id];
+      if (metadata) {
+        switch (action) {
+          case 'add':
+            metadata.participants.push(...participants.map(p => ({
+              id: p,
+              isAdmin: false,
+              isSuperAdmin: false
+            })));
+            break;
+          case 'demote':
+          case 'promote':
+            for (const participant of metadata.participants) {
+              if (participants.includes(participant.id)) {
+                participant.isAdmin = action === 'promote';
+              }
+            }
+            break;
+          case 'remove':
+            metadata.participants = metadata.participants.filter(p => !participants.includes(p.id));
+            break;
+        }
+      }
+    });
+    ev.on('groups.upsert', newGroups => {
+      for (const group of newGroups) {
+        groupMetadata[group.id] = group;
+      }
+    });
+  };
+  const toJSON = () => ({
+    chats,
+    contacts,
+    messages,
+    labels,
+    labelAssociations
+  });
+  const fromJSON = json => {
+    chats.upsert(...json.chats);
+    labelAssociations.upsert(...(json.labelAssociations || []));
+    contactsUpsert(Object.values(json.contacts));
+    labelsUpsert(Object.values(json.labels || {}));
+    for (const jid in json.messages) {
+      const list = assertMessageList(jid);
+      for (const msg of json.messages[jid]) {
+        list.upsert(msg, 'append');
+      }
+    }
+  };
+  const writeToFile = path => {
+    const data = JSON.stringify(toJSON(), BufferJSON_replacer);
+    writeFileSync(path, data);
+  };
+  const readFromFile = path => {
+    if (existsSync(path)) {
+      logger?.debug?.({
+        path
+      }, 'reading from file');
+      const jsonStr = readFileSync(path, {
+        encoding: 'utf-8'
+      });
+      const json = JSON.parse(jsonStr, BufferJSON_reviver);
+      fromJSON(json);
+    }
+  };
+  return {
+    chats,
+    contacts,
+    messages,
+    groupMetadata,
+    state,
+    presences,
+    labels,
+    labelAssociations,
+    bind,
+    loadMessages: async (jid, count, cursor) => {
+      const list = assertMessageList(jidNormalizedUser(jid));
+      const mode = !cursor || 'before' in cursor ? 'before' : 'after';
+      const cursorKey = cursor ? 'before' in cursor ? cursor.before : cursor.after : undefined;
+      const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined;
+      let messagesList;
+      if (list && mode === 'before' && (!cursorKey || cursorValue)) {
+        if (cursorValue) {
+          const msgIdx = list.array.findIndex(m => m.key.id === cursorKey?.id);
+          messagesList = list.array.slice(0, msgIdx);
+        } else {
+          messagesList = list.array;
+        }
+        return messagesList.slice(-count);
+      }
+      return [];
+    },
+    loadMessage: async (jid, id) => messages[jidNormalizedUser(jid)]?.get(id),
+    getMessage: (jid, id) => messages[jidNormalizedUser(jid)]?.get(id),
+    mostRecentMessage: async jid => {
+      const message = messages[jidNormalizedUser(jid)]?.array.slice(-1)[0];
+      return message;
+    },
+    fetchImageUrl: async (jid, sock) => {
+      const s = sock || socket;
+      const contact = contacts[jid];
+      if (!contact) {
+        return s?.profilePictureUrl(jid);
+      }
+      if (typeof contact.imgUrl === 'undefined') {
+        contact.imgUrl = await s?.profilePictureUrl(jid);
+      }
+      return contact.imgUrl;
+    },
+    fetchGroupMetadata: async (jid, sock) => {
+      const s = sock || socket;
+      if (!groupMetadata[jid]) {
+        const metadata = await s?.groupMetadata(jid);
+        if (metadata) {
+          groupMetadata[jid] = metadata;
+        }
+      }
+      return groupMetadata[jid];
+    },
+    fetchMessageReceipts: async ({
+      remoteJid,
+      id
+    }, sock) => {
+      const s = sock || socket;
+      const list = messages[jidNormalizedUser(remoteJid)];
+      const msg = list?.get(id);
+      return msg?.userReceipt;
+    },
+    toJSON,
+    fromJSON,
+    writeToFile,
+    readFromFile
+  };
+};
+function BufferJSON_replacer(_key, value) {
+  if (value?.type === 'Buffer' && Array.isArray(value?.data)) {
+    return value;
+  }
+  if (value instanceof Uint8Array || typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return {
+      type: 'Buffer',
+      data: Buffer.from(value).toString('base64'),
+      __enc: 'base64'
+    };
+  }
+  return value;
+}
+function BufferJSON_reviver(_key, value) {
+  if (value?.type === 'Buffer') {
+    if (value.__enc === 'base64' && typeof value.data === 'string') {
+      return Buffer.from(value.data, 'base64');
+    }
+    if (Array.isArray(value.data)) {
+      return Buffer.from(value.data);
+    }
+  }
+  return value;
+}
+export default makeInMemoryStore;

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

@@ -0,0 +1,69 @@
+export default function makeOrderedDictionary(idGetter) {
+  const array = [];
+  const dict = {};
+  const get = id => dict[id];
+  const update = item => {
+    const id = idGetter(item);
+    const idx = array.findIndex(i => idGetter(i) === id);
+    if (idx >= 0) {
+      array[idx] = item;
+      dict[id] = item;
+    }
+    return false;
+  };
+  const upsert = (item, mode) => {
+    const id = idGetter(item);
+    if (get(id)) {
+      update(item);
+    } else {
+      if (mode === 'append') array.push(item);else array.unshift(item);
+      dict[id] = item;
+    }
+  };
+  const remove = item => {
+    const id = idGetter(item);
+    const idx = array.findIndex(i => idGetter(i) === id);
+    if (idx >= 0) {
+      array.splice(idx, 1);
+      delete dict[id];
+      return true;
+    }
+    return false;
+  };
+  return {
+    array,
+    get,
+    upsert,
+    update,
+    remove,
+    updateAssign: (id, update) => {
+      const item = get(id);
+      if (item) {
+        Object.assign(item, update);
+        delete dict[id];
+        dict[idGetter(item)] = item;
+        return true;
+      }
+      return false;
+    },
+    clear: () => {
+      array.length = 0;
+      for (const key of Object.keys(dict)) delete dict[key];
+    },
+    filter: contain => {
+      let i = 0;
+      while (i < array.length) {
+        if (!contain(array[i])) {
+          delete dict[idGetter(array[i])];
+          array.splice(i, 1);
+        } else {
+          i++;
+        }
+      }
+    },
+    toJSON: () => array,
+    fromJSON: newItems => {
+      array.splice(0, array.length, ...newItems);
+    }
+  };
+}

package/lib/Store/object-repository.js

@@ -0,0 +1,27 @@
+export class ObjectRepository {
+  constructor(entities = {}) {
+    this.entityMap = new Map(Object.entries(entities));
+  }
+  findById(id) {
+    return this.entityMap.get(id);
+  }
+  findAll() {
+    return Array.from(this.entityMap.values());
+  }
+  upsertById(id, entity) {
+    this.entityMap.set(id, {
+      ...entity
+    });
+    return this;
+  }
+  deleteById(id) {
+    return this.entityMap.delete(id);
+  }
+  count() {
+    return this.entityMap.size;
+  }
+  toJSON() {
+    return this.findAll();
+  }
+}
+export default ObjectRepository;

package/lib/Types/Auth.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=Auth.js.map

package/lib/Types/Bussines.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=Bussines.js.map