@deffa5556/bail 1.0.6 → 1.0.9

package/cjs/lib/Store/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./make-in-memory-store.cjs"), exports);
+__exportStar(require("./make-ordered-dictionary.cjs"), exports);
+__exportStar(require("./object-repository.cjs"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * deffa-baileys — makeInMemoryStore
+ * Enhanced in-memory store: no limit, full tracking, auto-group-cache,
+ * presence TTL, search, stats, dan event hooks.
+ * by Deffa
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInMemoryStore = exports.waLabelAssociationKey = exports.waMessageID = exports.waChatKey = void 0;
+const keyed_db_1 = __importDefault(require("@adiwajshing/keyed-db"));
+const fs_1 = require("fs");
+const index_js_1 = require("../Types/index.cjs");
+const LabelAssociation_js_1 = require("../Types/LabelAssociation.cjs");
+const index_js_2 = require("../Defaults/index.cjs");
+const index_js_3 = require("../Utils/index.cjs");
+const index_js_4 = require("../WABinary/index.cjs");
+const make_ordered_dictionary_js_1 = require("./make-ordered-dictionary.cjs");
+const object_repository_js_1 = require("./object-repository.cjs");
+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)
+});
+exports.waChatKey = waChatKey;
+const waMessageID = (m) => m.key.id || '';
+exports.waMessageID = waMessageID;
+exports.waLabelAssociationKey = {
+    key: (la) => (la.type === LabelAssociation_js_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_js_1.makeOrderedDictionary)(exports.waMessageID);
+const makeInMemoryStore = (config = {}) => {
+    const socket = config.socket;
+    const chatKey = config.chatKey || (0, exports.waChatKey)(true);
+    const labelAssociationKey = config.labelAssociationKey || exports.waLabelAssociationKey;
+    const logger = config.logger || index_js_2.DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' });
+    // ── No-limit: maxMessages per JID (default: Infinity) ──────────
+    const maxMessages = config.maxMessages || Infinity;
+    // ── Presence TTL (default 5 menit) ─────────────────────────────
+    const presenceTTL = config.presenceTTL || 5 * 60 * 1000;
+    const KeyedDB = keyed_db_1.default?.default ?? keyed_db_1.default;
+    const chats = new KeyedDB(chatKey, c => c.id);
+    const messages = {}; // jid → ordered dict — NO LIMIT
+    const contacts = {};
+    const groupMetadata = {};
+    const presences = {}; // jid → { participant → { lastSeen, ... } }
+    const presenceTimers = {}; // jid+participant → timeout handle
+    const state = { connection: 'close' };
+    const labels = new object_repository_js_1.ObjectRepository();
+    const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key);
+    // ── Internal stats ──────────────────────────────────────────────
+    let _stats = {
+        totalMessages: 0,
+        totalChats: 0,
+        totalContacts: 0,
+        totalGroups: 0,
+        messagesUpserted: 0,
+        messagesDeleted: 0,
+        lastActivity: null,
+    };
+    // ── Event hooks (user bisa pasang callback) ─────────────────────
+    const _hooks = { onMessage: [], onChat: [], onContact: [], onPresence: [] };
+    const on = (event, cb) => { if (_hooks[event])
+        _hooks[event].push(cb); };
+    const _emit = (event, data) => { for (const cb of (_hooks[event] || [])) {
+        try {
+            cb(data);
+        }
+        catch (_) { }
+    } };
+    // ── Helpers ─────────────────────────────────────────────────────
+    const assertMessageList = (jid) => {
+        if (!messages[jid])
+            messages[jid] = makeMessagesDictionary();
+        return messages[jid];
+    };
+    const upsertMessage = (jid, msg, mode = 'append') => {
+        const list = assertMessageList(jid);
+        list.upsert(msg, mode);
+        // Trim jika ada limit (default: Infinity = tidak di-trim)
+        if (maxMessages !== Infinity && list.array.length > maxMessages) {
+            list.array.splice(0, list.array.length - maxMessages);
+        }
+        _stats.messagesUpserted++;
+        _stats.totalMessages = Object.values(messages).reduce((s, l) => s + l.array.length, 0);
+        _stats.lastActivity = new Date();
+        _emit('onMessage', { jid, msg });
+    };
+    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);
+        }
+        _stats.totalContacts = Object.keys(contacts).length;
+        return oldContacts;
+    };
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels)
+            labels.upsertById(label.id, label);
+    };
+    // ── Presence dengan TTL — otomatis hapus setelah timeout ───────
+    const setPresence = (jid, participant, data) => {
+        if (!presences[jid])
+            presences[jid] = {};
+        presences[jid][participant] = { ...data, _updatedAt: Date.now() };
+        _emit('onPresence', { jid, participant, data });
+        // Clear TTL lama kalau ada
+        const tKey = jid + '::' + participant;
+        if (presenceTimers[tKey])
+            clearTimeout(presenceTimers[tKey]);
+        presenceTimers[tKey] = setTimeout(() => {
+            if (presences[jid])
+                delete presences[jid][participant];
+            delete presenceTimers[tKey];
+        }, presenceTTL);
+    };
+    // ── Search messages ─────────────────────────────────────────────
+    const searchMessages = (query, jid = null) => {
+        const results = [];
+        const q = query.toLowerCase();
+        const jids = jid ? [jid] : Object.keys(messages);
+        for (const j of jids) {
+            const list = messages[j];
+            if (!list)
+                continue;
+            for (const msg of list.array) {
+                const text = msg.message?.conversation
+                    || msg.message?.extendedTextMessage?.text
+                    || msg.message?.imageMessage?.caption
+                    || msg.message?.videoMessage?.caption
+                    || '';
+                if (text.toLowerCase().includes(q))
+                    results.push({ jid: j, msg });
+            }
+        }
+        return results;
+    };
+    // ── Stats snapshot ──────────────────────────────────────────────
+    const getStats = () => ({
+        ..._stats,
+        totalMessages: Object.values(messages).reduce((s, l) => s + l.array.length, 0),
+        totalChats: chats.array?.length ?? 0,
+        totalContacts: Object.keys(contacts).length,
+        totalGroups: Object.keys(groupMetadata).length,
+        jidCount: Object.keys(messages).length,
+    });
+    // ── Bind ke event emitter ───────────────────────────────────────
+    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 (syncType === index_js_1.WAProto.HistorySync.HistorySyncType.ON_DEMAND)
+                return;
+            if (isLatest) {
+                chats.clear();
+                for (const id in messages)
+                    delete messages[id];
+            }
+            const chatsAdded = chats.insertIfAbsent(...newChats).length;
+            logger.debug({ chatsAdded }, 'synced chats');
+            const oldContacts = contactsUpsert(newContacts);
+            if (isLatest) {
+                for (const jid of oldContacts)
+                    delete contacts[jid];
+            }
+            logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts');
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJidAlt || msg.key.remoteJid;
+                upsertMessage(jid, msg, 'prepend');
+            }
+            logger.debug({ messages: newMessages.length }, 'synced messages');
+        });
+        ev.on('contacts.upsert', c => contactsUpsert(c));
+        ev.on('contacts.update', async (updates) => {
+            for (const update of updates) {
+                let contact = contacts[update.id];
+                if (!contact) {
+                    const contactHashes = await Promise.all(Object.keys(contacts).map(async (contactId) => {
+                        const { user } = (0, index_js_4.jidDecode)(contactId);
+                        return [contactId, (await (0, index_js_3.md5)(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)];
+                    }));
+                    contact = contacts[(contactHashes.find(([, b]) => b === update.id))?.[0] || ''];
+                }
+                if (contact) {
+                    if (update.imgUrl === 'changed') {
+                        contact.imgUrl = socket ? await socket?.profilePictureUrl(contact.id) : undefined;
+                    }
+                    else if (update.imgUrl === 'removed') {
+                        delete contact.imgUrl;
+                    }
+                    Object.assign(contacts[contact.id], contact);
+                }
+                else {
+                    logger.debug({ update }, 'got update for non-existant contact');
+                }
+            }
+        });
+        ev.on('chats.upsert', newChats => {
+            chats.upsert(...newChats);
+            _stats.totalChats = chats.array?.length ?? 0;
+            _emit('onChat', newChats);
+        });
+        ev.on('chats.update', updates => {
+            for (let update of updates) {
+                const result = chats.update(update.id, chat => {
+                    if (update.unreadCount > 0) {
+                        update = { ...update };
+                        update.unreadCount = (chat.unreadCount || 0) + update.unreadCount;
+                    }
+                    Object.assign(chat, update);
+                });
+                if (!result)
+                    logger.debug({ update }, 'got update for non-existant chat');
+            }
+        });
+        ev.on('labels.edit', (label) => {
+            if (label.deleted)
+                return labels.deleteById(label.id);
+            if (labels.count() < 20)
+                return labels.upsertById(label.id, label);
+            logger.error('Labels count exceed');
+        });
+        ev.on('labels.association', ({ type, association }) => {
+            if (type === 'add')
+                labelAssociations.upsert(association);
+            else if (type === 'remove')
+                labelAssociations.delete(association);
+            else
+                console.error(`unknown operation type [${type}]`);
+        });
+        ev.on('presence.update', ({ id, presences: update }) => {
+            for (const [participant, data] of Object.entries(update)) {
+                setPresence(id, participant, data);
+            }
+        });
+        ev.on('chats.delete', deletions => {
+            for (const item of deletions) {
+                if (chats.get(item))
+                    chats.deleteById(item);
+            }
+        });
+        ev.on('messages.upsert', ({ messages: newMessages, type }) => {
+            if (type === 'append' || type === 'notify') {
+                for (const msg of newMessages) {
+                    const jid = (0, index_js_4.jidNormalizedUser)(msg.key.remoteJidAlt || msg.key.remoteJid);
+                    upsertMessage(jid, msg, 'append');
+                    if (type === 'notify' && !chats.get(jid)) {
+                        ev.emit('chats.upsert', [{
+                                id: jid,
+                                conversationTimestamp: (0, index_js_3.toNumber)(msg.messageTimestamp),
+                                unreadCount: 1
+                            }]);
+                    }
+                }
+            }
+        });
+        ev.on('messages.update', updates => {
+            for (const { update, key } of updates) {
+                const list = assertMessageList((0, index_js_4.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];
+                if (list) {
+                    _stats.messagesDeleted += list.array.length;
+                    _stats.totalMessages -= list.array.length;
+                    list.clear();
+                }
+            }
+            else {
+                const jid = item.keys[0].remoteJidAlt || item.keys[0].remoteJid;
+                const list = messages[jid];
+                if (list) {
+                    const idSet = new Set(item.keys.map(k => k.id));
+                    const before = list.array.length;
+                    list.filter(m => !idSet.has(m.key.id));
+                    _stats.messagesDeleted += before - list.array.length;
+                    _stats.totalMessages -= before - list.array.length;
+                }
+            }
+        });
+        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)
+                return;
+            switch (action) {
+                case 'add':
+                    metadata.participants.push(...participants.map(p => ({ id: p.id, phoneNumber: p.phoneNumber, admin: p.admin })));
+                    break;
+                case 'demote':
+                case 'promote':
+                    for (const p of metadata.participants) {
+                        for (const pd of participants) {
+                            if (pd.id === p.id || pd.phoneNumber === p.phoneNumber) {
+                                p.admin = action === 'promote' ? 'admin' : null;
+                            }
+                        }
+                    }
+                    break;
+                case 'remove':
+                    const removeSet = new Set(participants.flatMap(p => [p.id, p.phoneNumber].filter(Boolean)));
+                    metadata.participants = metadata.participants.filter(p => !removeSet.has(p.id) && !removeSet.has(p.phoneNumber));
+                    break;
+            }
+            _stats.totalGroups = Object.keys(groupMetadata).length;
+        });
+        ev.on('message-receipt.update', updates => {
+            for (const { key, receipt } of updates) {
+                const obj = messages[key.remoteJidAlt || key.remoteJid];
+                const msg = obj?.get(key.id);
+                if (msg)
+                    (0, index_js_3.updateMessageWithReceipt)(msg, receipt);
+            }
+        });
+        ev.on('messages.reaction', reactions => {
+            for (const { key, reaction } of reactions) {
+                const obj = messages[key.remoteJidAlt || key.remoteJid];
+                const msg = obj?.get(key.id);
+                if (msg)
+                    (0, index_js_3.updateMessageWithReaction)(msg, reaction);
+            }
+        });
+    };
+    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(index_js_1.WAProto.WebMessageInfo.fromObject(msg), 'append');
+            }
+        }
+    };
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        // ── Enhanced API ─────────────────────────────────────────────
+        bind,
+        on,
+        getStats,
+        searchMessages,
+        loadMessages: async (jid, count, cursor) => {
+            const list = assertMessageList(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 msgs;
+            if (list && mode === 'before' && (!cursorKey || cursorValue)) {
+                if (cursorValue) {
+                    const msgIdx = list.array.findIndex(m => m.key.id === cursorKey?.id);
+                    msgs = list.array.slice(0, msgIdx);
+                }
+                else {
+                    msgs = list.array;
+                }
+                const diff = count - msgs.length;
+                if (diff < 0)
+                    msgs = msgs.slice(-count);
+            }
+            else {
+                msgs = [];
+            }
+            return msgs;
+        },
+        // Load semua pesan suatu JID tanpa limit
+        loadAllMessages: async (jid) => {
+            return messages[jid]?.array ?? [];
+        },
+        // Ambil N pesan terakhir
+        loadLastMessages: async (jid, n = 20) => {
+            return (messages[jid]?.array ?? []).slice(-n);
+        },
+        getLabels: () => labels,
+        getChatLabels: (chatId) => labelAssociations.filter(la => la.chatId === chatId).all(),
+        getMessageLabels: (messageId) => labelAssociations.filter(la => la.messageId === messageId).all().map(({ labelId }) => labelId),
+        loadMessage: async (jid, id) => messages[jid]?.get(id),
+        mostRecentMessage: async (jid) => messages[jid]?.array.slice(-1)[0],
+        fetchImageUrl: async (jid, sock) => {
+            const contact = contacts[jid];
+            if (!contact)
+                return sock?.profilePictureUrl(jid);
+            if (typeof contact.imgUrl === 'undefined')
+                contact.imgUrl = await sock?.profilePictureUrl(jid);
+            return contact.imgUrl;
+        },
+        fetchGroupMetadata: async (jid, sock) => {
+            if (!groupMetadata[jid]) {
+                const metadata = await sock?.groupMetadata(jid);
+                if (metadata) {
+                    groupMetadata[jid] = metadata;
+                    _stats.totalGroups = Object.keys(groupMetadata).length;
+                }
+            }
+            return groupMetadata[jid];
+        },
+        // Auto-fetch dan cache semua group yang diikuti
+        fetchAllGroupMetadata: async (sock) => {
+            if (!sock)
+                return groupMetadata;
+            const all = await sock.groupFetchAllParticipating();
+            for (const [jid, meta] of Object.entries(all))
+                groupMetadata[jid] = meta;
+            _stats.totalGroups = Object.keys(groupMetadata).length;
+            return groupMetadata;
+        },
+        fetchMessageReceipts: async ({ remoteJid, id }) => {
+            return messages[remoteJid]?.get(id)?.userReceipt;
+        },
+        // Cek apakah pesan sudah di-read oleh penerima
+        isMessageRead: (jid, id) => {
+            const msg = messages[jid]?.get(id);
+            return msg?.status >= 3; // 3 = READ
+        },
+        toJSON,
+        fromJSON,
+        writeToFile: (path) => (0, fs_1.writeFileSync)(path, JSON.stringify(toJSON())),
+        readFromFile: (path) => {
+            if ((0, fs_1.existsSync)(path)) {
+                logger.debug({ path }, 'reading from file');
+                fromJSON(JSON.parse((0, fs_1.readFileSync)(path, { encoding: 'utf-8' })));
+            }
+        },
+        // Clear semua data di store (reset total)
+        clear: () => {
+            chats.clear();
+            for (const id in messages)
+                delete messages[id];
+            for (const id in contacts)
+                delete contacts[id];
+            for (const id in groupMetadata)
+                delete groupMetadata[id];
+            for (const id in presences)
+                delete presences[id];
+            _stats = { totalMessages: 0, totalChats: 0, totalContacts: 0, totalGroups: 0, messagesUpserted: 0, messagesDeleted: 0, lastActivity: null };
+        },
+    };
+};
+exports.makeInMemoryStore = makeInMemoryStore;
+//# sourceMappingURL=make-in-memory-store.js.map

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOrderedDictionary = makeOrderedDictionary;
+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.splice(0, 0, 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.splice(0, array.length);
+            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 += 1;
+                }
+            }
+        },
+        toJSON: () => array,
+        fromJSON: (newItems) => {
+            array.splice(0, array.length, ...newItems);
+        }
+    };
+}
+//# sourceMappingURL=make-ordered-dictionary.js.map

package/cjs/lib/Store/object-repository.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectRepository = void 0;
+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) {
+        return this.entityMap.set(id, { ...entity });
+    }
+    deleteById(id) {
+        return this.entityMap.delete(id);
+    }
+    count() {
+        return this.entityMap.size;
+    }
+    toJSON() {
+        return this.findAll();
+    }
+}
+exports.ObjectRepository = ObjectRepository;
+//# sourceMappingURL=object-repository.js.map