wa-multi-mongodb 3.10.2 → 3.10.3

package/dist/cjs/Socket/index.js

@@ -0,0 +1,875 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAllGroupMetadataCache = exports.clearSessionGroupMetadataCache = exports.clearGroupMetadataCache = exports.getGroupMetadata = exports.setGroupCacheConfig = exports.getSessionStatus = exports.getPairingCodeSessions = exports.reconnectAllPairingCodeSessions = exports.reconnect = exports.setCredentialsDir = exports.setMongoDBNames = exports.loadSessionsFromMongo = exports.onPairingCode = exports.onMessageUpdate = exports.onConnecting = exports.onDisconnected = exports.onConnected = exports.onQRUpdated = exports.onMessageReceived = exports.loadSessionsFromStorage = exports.getSession = exports.getAllSessionSync = exports.getAllSession = exports.deleteSession = exports.startWhatsapp = exports.startSessionWithPairingCode = exports.startSession = exports.setMongoURI = void 0;
+exports.setMongoCollection = setMongoCollection;
+const baileys_1 = __importStar(require("baileys"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const qrcode_1 = __importDefault(require("qrcode"));
+const pino_1 = __importDefault(require("pino"));
+const Defaults_1 = require("../Defaults");
+const save_media_1 = require("../Utils/save-media");
+const Utils_1 = require("../Utils");
+const Error_1 = require("../Error");
+const message_status_1 = require("../Utils/message-status");
+const mongodb_1 = require("mongodb");
+const mongo_auth_state_1 = require("../Utils/mongo-auth-state");
+const create_delay_1 = require("../Utils/create-delay");
+const sessions = new Map();
+const callback = new Map();
+const retryCount = new Map();
+// Tambahkan Map untuk melacak session yang menggunakan pairing code
+const pairingCodeSessions = new Map();
+const P = (0, pino_1.default)({
+    level: "silent",
+});
+// Tambahkan variabel global untuk koneksi MongoDB dan collection
+let mongoClient;
+let authCollection = null;
+let mongoURI = process.env.MONGODB_URI || "mongodb://localhost:27017";
+/**
+ * Set MongoDB URI for connection
+ * This function will be used to configure MongoDB connection with just the URI
+ *
+ * @param uri MongoDB connection URI
+ */
+const setMongoURI = (uri) => __awaiter(void 0, void 0, void 0, function* () {
+    mongoURI = uri;
+    // Configure group cache MongoDB connection as well
+    yield Utils_1.groupCache.setMongoURI(uri);
+    // Reset MongoDB client and collection to ensure they are recreated with new URI
+    if (mongoClient) {
+        try {
+            yield mongoClient.close();
+        }
+        catch (error) {
+            console.error("Error closing existing MongoDB connection:", error);
+        }
+        mongoClient = undefined;
+        authCollection = null;
+    }
+    // MongoDB URI configured successfully - removed console.log for npm package
+});
+exports.setMongoURI = setMongoURI;
+function setMongoCollection(collection) {
+    authCollection = collection;
+}
+function initMongo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!authCollection) {
+            if (!mongoClient) {
+                mongoClient = new mongodb_1.MongoClient(mongoURI);
+                yield mongoClient.connect();
+            }
+            // Gunakan variabel dari CREDENTIALS
+            const dbName = Defaults_1.CREDENTIALS.MONGO_DB_NAME;
+            const collectionName = Defaults_1.CREDENTIALS.MONGO_COLLECTION_NAME;
+            authCollection = mongoClient.db(dbName).collection(collectionName);
+            // console.log(`MongoDB initialized with database "${dbName}" and collection "${collectionName}"`);
+        }
+    });
+}
+const startSession = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (sessionId = "mysession", options = { printQR: true }) {
+    if (isSessionExistAndRunning(sessionId))
+        throw new Error_1.WhatsappError(Defaults_1.Messages.sessionAlreadyExist(sessionId));
+    yield initMongo();
+    const { version } = yield (0, baileys_1.fetchLatestBaileysVersion)();
+    const startSocket = () => __awaiter(void 0, void 0, void 0, function* () {
+        const { state, saveCreds } = yield (0, mongo_auth_state_1.useMongoAuthState)(sessionId, authCollection);
+        const sock = (0, baileys_1.default)({
+            version,
+            auth: state,
+            logger: P,
+            markOnlineOnConnect: false,
+            browser: baileys_1.Browsers.ubuntu("Chrome"),
+            // Configure caching group metadata using our hybrid implementation with session ID
+            cachedGroupMetadata: (jid) => __awaiter(void 0, void 0, void 0, function* () {
+                return yield Utils_1.groupCache.get(sessionId, jid);
+            })
+        });
+        sessions.set(sessionId, Object.assign({}, sock));
+        try {
+            sock.ev.process((events) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+                if (events["connection.update"]) {
+                    const update = events["connection.update"];
+                    const { connection, lastDisconnect } = update;
+                    if (update.qr) {
+                        // Print QR to console if requested
+                        if (options.printQR) {
+                            qrcode_1.default.toString(update.qr, {
+                                type: 'terminal',
+                                small: true,
+                                margin: 1
+                            }, (err, qrString) => {
+                                if (!err) {
+                                    console.log(qrString);
+                                }
+                            });
+                        }
+                        // Send QR data raw to callback for frontend processing
+                        (_a = callback.get(Defaults_1.CALLBACK_KEY.ON_QR)) === null || _a === void 0 ? void 0 : _a({
+                            sessionId,
+                            qr: update.qr
+                        });
+                        (_b = options.onQRUpdated) === null || _b === void 0 ? void 0 : _b.call(options, update.qr);
+                    }
+                    if (connection == "connecting") {
+                        (_c = callback.get(Defaults_1.CALLBACK_KEY.ON_CONNECTING)) === null || _c === void 0 ? void 0 : _c(sessionId);
+                        (_d = options.onConnecting) === null || _d === void 0 ? void 0 : _d.call(options);
+                    }
+                    if (connection === "close") {
+                        const code = (_f = (_e = lastDisconnect === null || lastDisconnect === void 0 ? void 0 : lastDisconnect.error) === null || _e === void 0 ? void 0 : _e.output) === null || _f === void 0 ? void 0 : _f.statusCode;
+                        let retryAttempt = (_g = retryCount.get(sessionId)) !== null && _g !== void 0 ? _g : 0;
+                        let shouldRetry;
+                        if (code != baileys_1.DisconnectReason.loggedOut && retryAttempt < 10) {
+                            shouldRetry = true;
+                        }
+                        if (shouldRetry) {
+                            retryAttempt++;
+                            retryCount.set(sessionId, retryAttempt);
+                            startSocket();
+                        }
+                        else {
+                            retryCount.delete(sessionId);
+                            // For pairing code sessions, preserve data for future reconnection
+                            if (pairingCodeSessions.has(sessionId)) {
+                                yield softDeleteSession(sessionId, true);
+                            }
+                            else {
+                                // For regular sessions, completely delete
+                                yield softDeleteSession(sessionId, false);
+                            }
+                            (_h = callback.get(Defaults_1.CALLBACK_KEY.ON_DISCONNECTED)) === null || _h === void 0 ? void 0 : _h(sessionId);
+                            (_j = options.onDisconnected) === null || _j === void 0 ? void 0 : _j.call(options);
+                        }
+                    }
+                    if (connection == "open") {
+                        retryCount.delete(sessionId);
+                        (_k = callback.get(Defaults_1.CALLBACK_KEY.ON_CONNECTED)) === null || _k === void 0 ? void 0 : _k(sessionId);
+                        (_l = options.onConnected) === null || _l === void 0 ? void 0 : _l.call(options);
+                    }
+                }
+                if (events["creds.update"]) {
+                    yield saveCreds();
+                }
+                // Menangani event update data grup
+                if (events["groups.update"]) {
+                    const updates = events["groups.update"];
+                    for (const update of updates) {
+                        try {
+                            // Dapatkan metadata grup terbaru dan simpan ke cache dengan sessionId
+                            const metadata = yield sock.groupMetadata(update.id);
+                            yield Utils_1.groupCache.set(sessionId, update.id, metadata);
+                        }
+                        catch (error) {
+                            console.error(`Error updating group metadata in cache: ${error}`);
+                        }
+                    }
+                }
+                // Menangani event perubahan peserta grup
+                if (events["group-participants.update"]) {
+                    const update = events["group-participants.update"];
+                    try {
+                        // Dapatkan metadata grup terbaru dan simpan ke cache dengan sessionId
+                        const metadata = yield sock.groupMetadata(update.id);
+                        yield Utils_1.groupCache.set(sessionId, update.id, metadata);
+                    }
+                    catch (error) {
+                        console.error(`Error updating group participants in cache: ${error}`);
+                    }
+                }
+                if (events["messages.update"]) {
+                    const msg = events["messages.update"][0];
+                    const data = Object.assign({ sessionId: sessionId, messageStatus: (0, message_status_1.parseMessageStatusCodeToReadable)(msg.update.status) }, msg);
+                    (_m = callback.get(Defaults_1.CALLBACK_KEY.ON_MESSAGE_UPDATED)) === null || _m === void 0 ? void 0 : _m(sessionId, data);
+                    (_o = options.onMessageUpdated) === null || _o === void 0 ? void 0 : _o.call(options, data);
+                }
+                if (events["messages.upsert"]) {
+                    const messages = events["messages.upsert"].messages || [];
+                    for (const rawMsg of messages) {
+                        // Skip protocol messages and system messages
+                        if ((_p = rawMsg.message) === null || _p === void 0 ? void 0 : _p.protocolMessage) {
+                            continue;
+                        }
+                        // Skip messages without content
+                        if (!rawMsg.message || Object.keys(rawMsg.message).length === 0) {
+                            continue;
+                        }
+                        const msg = rawMsg;
+                        msg.sessionId = sessionId;
+                        msg.saveImage = (path) => (0, save_media_1.saveImageHandler)(msg, path);
+                        msg.saveVideo = (path) => (0, save_media_1.saveVideoHandler)(msg, path);
+                        msg.saveDocument = (path) => (0, save_media_1.saveDocumentHandler)(msg, path);
+                        msg.saveAudio = (path) => (0, save_media_1.saveAudioHandler)(msg, path);
+                        (_q = callback.get(Defaults_1.CALLBACK_KEY.ON_MESSAGE_RECEIVED)) === null || _q === void 0 ? void 0 : _q(Object.assign({}, msg));
+                        (_r = options.onMessageReceived) === null || _r === void 0 ? void 0 : _r.call(options, msg);
+                    }
+                }
+            }));
+            return sock;
+        }
+        catch (error) {
+            // console.log("SOCKET ERROR", error);
+            return sock;
+        }
+    });
+    return startSocket();
+});
+exports.startSession = startSession;
+/**
+ * Start WhatsApp session using pairing code method
+ * This is the recommended way to create sessions with pairing code
+ *
+ * @param sessionId Unique session identifier
+ * @param phoneNumber Phone number with country code (without + prefix)
+ * @param options Optional configuration for the session
+ * @returns Promise<WASocket> The WhatsApp socket instance
+ */
+const startSessionWithPairingCode = (sessionId_1, phoneNumber_1, ...args_1) => __awaiter(void 0, [sessionId_1, phoneNumber_1, ...args_1], void 0, function* (sessionId, phoneNumber, options = {}) {
+    if (isSessionExistAndRunning(sessionId))
+        throw new Error_1.WhatsappError(Defaults_1.Messages.sessionAlreadyExist(sessionId));
+    // Simpan informasi session pairing code untuk auto-reconnect
+    pairingCodeSessions.set(sessionId, { phoneNumber, options });
+    yield initMongo();
+    const { version } = yield (0, baileys_1.fetchLatestBaileysVersion)();
+    const startSocket = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const { state, saveCreds } = yield (0, mongo_auth_state_1.useMongoAuthState)(sessionId, authCollection);
+        const sock = (0, baileys_1.default)({
+            version,
+            auth: state,
+            logger: P,
+            markOnlineOnConnect: false,
+            browser: baileys_1.Browsers.ubuntu("Chrome"),
+            // Opsi tambahan untuk meningkatkan kompatibilitas
+            linkPreviewImageThumbnailWidth: 300,
+            generateHighQualityLinkPreview: true,
+            syncFullHistory: false, // Sinkronisasi hanya riwayat baru
+            connectTimeoutMs: 60000, // Timeout koneksi ditingkatkan
+            printQRInTerminal: false, // QR tidak dicetak untuk pairing code
+            // Configure caching group metadata using our hybrid implementation with session ID
+            cachedGroupMetadata: (jid) => __awaiter(void 0, void 0, void 0, function* () {
+                return yield Utils_1.groupCache.get(sessionId, jid);
+            })
+        });
+        sessions.set(sessionId, Object.assign({}, sock));
+        try {
+            if (!sock.authState.creds.registered) {
+                // Pastikan kita mendapatkan kode pairing dan menampilkannya dengan jelas
+                try {
+                    // Tambahkan delay untuk memastikan state sudah siap
+                    yield new Promise(resolve => setTimeout(resolve, 2000));
+                    // Hapus awalan + dari nomor telepon jika ada
+                    const phoneNumberFormatted = phoneNumber.replace(/^\+/, '');
+                    // Memanggil fungsi requestPairingCode dengan nomor telepon yang sudah dibersihkan
+                    const code = yield sock.requestPairingCode(phoneNumberFormatted);
+                    // Pastikan kode ada dan merupakan string
+                    if (code && typeof code === 'string') {
+                        console.log(`Pairing code untuk session ${sessionId}: ${code}`);
+                        // Panggil callback yang terdaftar
+                        (_a = callback.get(Defaults_1.CALLBACK_KEY.ON_PAIRING_CODE)) === null || _a === void 0 ? void 0 : _a(sessionId, code);
+                        (_b = options.onPairingCode) === null || _b === void 0 ? void 0 : _b.call(options, code);
+                    }
+                    else {
+                        console.error("Error: Kode pairing tidak valid atau kosong");
+                    }
+                }
+                catch (error) {
+                    console.error("Error saat meminta kode pairing:", error);
+                    throw new Error_1.WhatsappError(`Gagal mendapatkan kode pairing: ${error.message || String(error)}`);
+                }
+            }
+            sock.ev.process((events) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+                if (events["connection.update"]) {
+                    const update = events["connection.update"];
+                    const { connection, lastDisconnect } = update;
+                    if (update.qr) {
+                        // Send QR data raw to callback for frontend processing
+                        (_a = callback.get(Defaults_1.CALLBACK_KEY.ON_QR)) === null || _a === void 0 ? void 0 : _a({
+                            sessionId,
+                            qr: update.qr
+                        });
+                    }
+                    if (connection == "connecting") {
+                        (_b = callback.get(Defaults_1.CALLBACK_KEY.ON_CONNECTING)) === null || _b === void 0 ? void 0 : _b(sessionId);
+                        (_c = options.onConnecting) === null || _c === void 0 ? void 0 : _c.call(options);
+                    }
+                    if (connection === "close") {
+                        const code = (_e = (_d = lastDisconnect === null || lastDisconnect === void 0 ? void 0 : lastDisconnect.error) === null || _d === void 0 ? void 0 : _d.output) === null || _e === void 0 ? void 0 : _e.statusCode;
+                        let retryAttempt = (_f = retryCount.get(sessionId)) !== null && _f !== void 0 ? _f : 0;
+                        let shouldRetry;
+                        if (code != baileys_1.DisconnectReason.loggedOut && retryAttempt < 10) {
+                            shouldRetry = true;
+                        }
+                        if (shouldRetry) {
+                            retryAttempt++;
+                            retryCount.set(sessionId, retryAttempt);
+                            // Untuk session pairing code, coba reconnect dengan metode yang tepat
+                            try {
+                                // Tunggu sebentar sebelum reconnect
+                                yield (0, create_delay_1.createDelay)(2000);
+                                startSocket();
+                            }
+                            catch (reconnectError) {
+                                console.error(`Auto-reconnect failed for session ${sessionId}:`, reconnectError.message);
+                                // Jika reconnect gagal beberapa kali, coba dengan pairing code lagi (jika masih dalam 3 attempt pertama)
+                                if (retryAttempt <= 3 && pairingCodeSessions.has(sessionId)) {
+                                    const sessionInfo = pairingCodeSessions.get(sessionId);
+                                    // Bersihkan session lama
+                                    sessions.delete(sessionId);
+                                    // Coba mulai ulang dengan pairing code baru
+                                    setTimeout(() => {
+                                        startSocket().catch(err => {
+                                            console.error(`Failed to restart with pairing code for session ${sessionId}:`, err);
+                                        });
+                                    }, 3000);
+                                }
+                                else {
+                                    // Jika sudah terlalu banyak gagal, panggil startSocket biasa
+                                    startSocket();
+                                }
+                            }
+                        }
+                        else {
+                            retryCount.delete(sessionId);
+                            // For pairing code sessions, preserve data for future reconnection
+                            if (pairingCodeSessions.has(sessionId)) {
+                                yield softDeleteSession(sessionId, true);
+                                // Don't remove from pairing code tracking completely to allow manual reconnection
+                            }
+                            else {
+                                pairingCodeSessions.delete(sessionId); // Only delete from tracking if it's not a pairing code session
+                                yield softDeleteSession(sessionId, false);
+                            }
+                            (_g = callback.get(Defaults_1.CALLBACK_KEY.ON_DISCONNECTED)) === null || _g === void 0 ? void 0 : _g(sessionId);
+                            (_h = options.onDisconnected) === null || _h === void 0 ? void 0 : _h.call(options);
+                        }
+                    }
+                    if (connection == "open") {
+                        retryCount.delete(sessionId);
+                        (_j = callback.get(Defaults_1.CALLBACK_KEY.ON_CONNECTED)) === null || _j === void 0 ? void 0 : _j(sessionId);
+                        (_k = options.onConnected) === null || _k === void 0 ? void 0 : _k.call(options);
+                    }
+                }
+                if (events["creds.update"]) {
+                    yield saveCreds();
+                }
+                // Menangani event update data grup
+                if (events["groups.update"]) {
+                    const updates = events["groups.update"];
+                    for (const update of updates) {
+                        try {
+                            // Dapatkan metadata grup terbaru dan simpan ke cache dengan sessionId
+                            const metadata = yield sock.groupMetadata(update.id);
+                            yield Utils_1.groupCache.set(sessionId, update.id, metadata);
+                        }
+                        catch (error) {
+                            console.error(`Error updating group metadata in cache: ${error}`);
+                        }
+                    }
+                }
+                // Menangani event perubahan peserta grup
+                if (events["group-participants.update"]) {
+                    const update = events["group-participants.update"];
+                    try {
+                        // Dapatkan metadata grup terbaru dan simpan ke cache dengan sessionId
+                        const metadata = yield sock.groupMetadata(update.id);
+                        yield Utils_1.groupCache.set(sessionId, update.id, metadata);
+                    }
+                    catch (error) {
+                        console.error(`Error updating group participants in cache: ${error}`);
+                    }
+                }
+                if (events["messages.update"]) {
+                    const msg = events["messages.update"][0];
+                    const data = Object.assign({ sessionId: sessionId, messageStatus: (0, message_status_1.parseMessageStatusCodeToReadable)(msg.update.status) }, msg);
+                    (_l = callback.get(Defaults_1.CALLBACK_KEY.ON_MESSAGE_UPDATED)) === null || _l === void 0 ? void 0 : _l(sessionId, data);
+                    (_m = options.onMessageUpdated) === null || _m === void 0 ? void 0 : _m.call(options, data);
+                }
+                if (events["messages.upsert"]) {
+                    const messages = events["messages.upsert"].messages || [];
+                    for (const rawMsg of messages) {
+                        // Skip protocol messages and system messages
+                        if ((_o = rawMsg.message) === null || _o === void 0 ? void 0 : _o.protocolMessage) {
+                            continue;
+                        }
+                        // Skip messages without content
+                        if (!rawMsg.message || Object.keys(rawMsg.message).length === 0) {
+                            continue;
+                        }
+                        const msg = rawMsg;
+                        msg.sessionId = sessionId;
+                        msg.saveImage = (path) => (0, save_media_1.saveImageHandler)(msg, path);
+                        msg.saveVideo = (path) => (0, save_media_1.saveVideoHandler)(msg, path);
+                        msg.saveDocument = (path) => (0, save_media_1.saveDocumentHandler)(msg, path);
+                        msg.saveAudio = (path) => (0, save_media_1.saveAudioHandler)(msg, path);
+                        (_p = callback.get(Defaults_1.CALLBACK_KEY.ON_MESSAGE_RECEIVED)) === null || _p === void 0 ? void 0 : _p(Object.assign({}, msg));
+                        (_q = options.onMessageReceived) === null || _q === void 0 ? void 0 : _q.call(options, msg);
+                    }
+                }
+            }));
+            return sock;
+        }
+        catch (error) {
+            // console.log("SOCKET ERROR", error);
+            return sock;
+        }
+    });
+    return startSocket();
+});
+exports.startSessionWithPairingCode = startSessionWithPairingCode;
+/**
+ * @deprecated Use startSession method instead
+ */
+exports.startWhatsapp = exports.startSession;
+/**
+ * Soft delete session - removes from memory but preserves MongoDB data for pairing code sessions
+ * @param sessionId Session ID to soft delete
+ */
+const softDeleteSession = (sessionId_1, ...args_1) => __awaiter(void 0, [sessionId_1, ...args_1], void 0, function* (sessionId, preserveData = false) {
+    const session = (0, exports.getSession)(sessionId);
+    try {
+        yield (session === null || session === void 0 ? void 0 : session.logout());
+    }
+    catch (error) { }
+    session === null || session === void 0 ? void 0 : session.end(undefined);
+    sessions.delete(sessionId);
+    // Only completely remove from MongoDB if not preserving data or not a pairing code session
+    if (!preserveData && !pairingCodeSessions.has(sessionId)) {
+        if (authCollection) {
+            try {
+                yield authCollection.deleteOne({ sessionId });
+            }
+            catch (error) {
+                console.error(`Error deleting session ${sessionId} from MongoDB:`, error);
+            }
+        }
+    }
+    else if (pairingCodeSessions.has(sessionId)) {
+        // Preserving MongoDB data for pairing code session
+    }
+    // Hapus cache grup untuk session ini
+    try {
+        yield Utils_1.groupCache.clearSessionCache(sessionId);
+    }
+    catch (error) {
+        console.error(`Error clearing group cache for session ${sessionId}:`, error);
+    }
+    // Legacy: hapus juga dari file system jika ada
+    const dir = path_1.default.resolve(Defaults_1.CREDENTIALS.DIR_NAME, sessionId + Defaults_1.CREDENTIALS.PREFIX);
+    if (fs_1.default.existsSync(dir)) {
+        fs_1.default.rmSync(dir, { force: true, recursive: true });
+    }
+});
+const deleteSession = (sessionId) => __awaiter(void 0, void 0, void 0, function* () {
+    const session = (0, exports.getSession)(sessionId);
+    try {
+        yield (session === null || session === void 0 ? void 0 : session.logout());
+    }
+    catch (error) { }
+    session === null || session === void 0 ? void 0 : session.end(undefined);
+    sessions.delete(sessionId);
+    // Hapus tracking pairing code session jika ada
+    pairingCodeSessions.delete(sessionId);
+    // Hapus juga dari MongoDB jika authCollection ada
+    if (authCollection) {
+        try {
+            yield authCollection.deleteOne({ sessionId });
+        }
+        catch (error) {
+            console.error(`Error deleting session ${sessionId} from MongoDB:`, error);
+        }
+    }
+    // Hapus cache grup untuk session ini
+    try {
+        yield Utils_1.groupCache.clearSessionCache(sessionId);
+    }
+    catch (error) {
+        console.error(`Error clearing group cache for session ${sessionId}:`, error);
+    }
+    // Legacy: hapus juga dari file system jika ada
+    const dir = path_1.default.resolve(Defaults_1.CREDENTIALS.DIR_NAME, sessionId + Defaults_1.CREDENTIALS.PREFIX);
+    if (fs_1.default.existsSync(dir)) {
+        fs_1.default.rmSync(dir, { force: true, recursive: true });
+    }
+});
+exports.deleteSession = deleteSession;
+/**
+ * Get all active session IDs
+ * @returns Array of session IDs
+ */
+const getAllSession = () => __awaiter(void 0, void 0, void 0, function* () {
+    // Return active sessions from Map (sessions yang sudah running di memori)
+    const runningSessionIds = Array.from(sessions.keys());
+    // Jika authCollection belum diinisialisasi, kembalikan hanya sessions dari memori
+    if (!authCollection) {
+        return runningSessionIds;
+    }
+    try {
+        // Ambil semua sessionId dari MongoDB
+        const sessionDocs = yield authCollection.find({}).toArray();
+        const mongoSessionIds = sessionDocs.map((doc) => doc.sessionId);
+        // Gabungkan dan deduplikasi session IDs
+        const allSessionIds = [...new Set([...runningSessionIds, ...mongoSessionIds])];
+        return allSessionIds;
+    }
+    catch (error) {
+        console.error("Error fetching sessions from MongoDB:", error);
+        // Fallback ke sessions yang ada di memori jika MongoDB error
+        return runningSessionIds;
+    }
+});
+exports.getAllSession = getAllSession;
+// Untuk backward compatibility
+const getAllSessionSync = () => Array.from(sessions.keys());
+exports.getAllSessionSync = getAllSessionSync;
+const getSession = (key) => sessions.get(key);
+exports.getSession = getSession;
+const isSessionExistAndRunning = (sessionId) => {
+    // Cek jika session sudah berjalan di memory
+    if ((0, exports.getSession)(sessionId)) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Check if session should be loaded
+ * @param sessionId Session ID to check
+ * @returns Boolean indicating if session should be loaded
+ */
+const shouldLoadSession = (sessionId) => __awaiter(void 0, void 0, void 0, function* () {
+    // Jika session sudah berjalan di memory, tidak perlu load lagi
+    if ((0, exports.getSession)(sessionId)) {
+        return false;
+    }
+    // Jika authCollection belum diinisialisasi, tidak bisa load
+    if (!authCollection) {
+        return false;
+    }
+    try {
+        // Periksa apakah session ada di MongoDB
+        const sessionDoc = yield authCollection.findOne({ sessionId });
+        return !!sessionDoc; // Return true jika session ditemukan di MongoDB
+    }
+    catch (error) {
+        console.error(`Error checking session ${sessionId} in MongoDB:`, error);
+        return false;
+    }
+});
+/**
+ * @deprecated Use loadSessionsFromMongo instead
+ */
+const loadSessionsFromStorage = () => {
+    console.warn("loadSessionsFromStorage is deprecated, use loadSessionsFromMongo instead");
+    // Redirect ke fungsi loadSessionsFromMongo untuk backward compatibility
+    (0, exports.loadSessionsFromMongo)().catch(err => {
+        console.error("Error loading sessions from MongoDB:", err);
+    });
+};
+exports.loadSessionsFromStorage = loadSessionsFromStorage;
+const onMessageReceived = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_MESSAGE_RECEIVED, listener);
+};
+exports.onMessageReceived = onMessageReceived;
+const onQRUpdated = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_QR, listener);
+};
+exports.onQRUpdated = onQRUpdated;
+const onConnected = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_CONNECTED, listener);
+};
+exports.onConnected = onConnected;
+const onDisconnected = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_DISCONNECTED, listener);
+};
+exports.onDisconnected = onDisconnected;
+const onConnecting = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_CONNECTING, listener);
+};
+exports.onConnecting = onConnecting;
+const onMessageUpdate = (listener) => {
+    callback.set(Defaults_1.CALLBACK_KEY.ON_MESSAGE_UPDATED, listener);
+};
+exports.onMessageUpdate = onMessageUpdate;
+const onPairingCode = (listener) => {
+    // Set callback ke registry dengan key yang benar
+    callback.set(Defaults_1.CALLBACK_KEY.ON_PAIRING_CODE, listener);
+};
+exports.onPairingCode = onPairingCode;
+/**
+ * Load all sessions from MongoDB and start them automatically
+ */
+const loadSessionsFromMongo = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield initMongo();
+    const sessionDocs = yield authCollection.find({}).toArray();
+    for (const doc of sessionDocs) {
+        const sessionId = doc.sessionId;
+        if (sessionId && !(0, exports.getSession)(sessionId)) {
+            try {
+                yield (0, exports.startSession)(sessionId, { printQR: false });
+            }
+            catch (e) {
+                // Optional: log error jika gagal load session tertentu
+                console.error(`Failed to load session ${sessionId}:`, e);
+            }
+        }
+    }
+});
+exports.loadSessionsFromMongo = loadSessionsFromMongo;
+/**
+ * Configure MongoDB database and collection names
+ *
+ * @param dbName MongoDB database name (default: "wa_session")
+ * @param collectionName MongoDB collection name for auth storage (default: "auth")
+ */
+const setMongoDBNames = (dbName = "wa_session", collectionName = "auth") => {
+    Defaults_1.CREDENTIALS.MONGO_DB_NAME = dbName;
+    Defaults_1.CREDENTIALS.MONGO_COLLECTION_NAME = collectionName;
+};
+exports.setMongoDBNames = setMongoDBNames;
+/**
+ * Sets the directory name for storing credentials (File-based storage)
+ *
+ * @deprecated When using MongoDB, this setting has no effect. Only used for legacy file-based storage.
+ * @param dirname Directory name for storing credentials (default: "wa_credentials")
+ */
+const setCredentialsDir = (dirname = "wa_credentials") => {
+    console.warn("setCredentialsDir() is deprecated when using MongoDB storage. This setting only affects legacy file-based storage.");
+    Defaults_1.CREDENTIALS.DIR_NAME = dirname;
+};
+exports.setCredentialsDir = setCredentialsDir;
+/**
+ * Attempt to reconnect a disconnected session
+ *
+ * @param sessionId Session ID to reconnect
+ * @returns Promise<boolean> indicating success
+ */
+const reconnect = (sessionId) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Cek jika session masih ada di memory
+        const existingSession = sessions.get(sessionId);
+        // Hapus session terlebih dahulu untuk menghindari konflik
+        if (existingSession) {
+            try {
+                // Coba lakukan logout jika memungkinkan (tapi jangan crash jika gagal)
+                yield existingSession.logout().catch((e) => { });
+            }
+            catch (logoutError) {
+                // Abaikan error saat logout
+            }
+            // Akhiri session dan hapus dari map secara paksa
+            try {
+                existingSession.end(undefined);
+            }
+            catch (endError) {
+                // Abaikan error saat mengakhiri
+            }
+            sessions.delete(sessionId);
+        }
+        // Tunggu sedikit waktu untuk memastikan cleanup selesai
+        yield (0, create_delay_1.createDelay)(1000);
+        // Cek jika ini session pairing code dari tracking terlebih dahulu
+        const pairingInfo = pairingCodeSessions.get(sessionId);
+        if (pairingInfo) {
+            // Ini adalah session pairing code, gunakan metode pairing code untuk reconnect
+            try {
+                // Reset retry count untuk session ini
+                retryCount.delete(sessionId);
+                yield (0, exports.startSessionWithPairingCode)(sessionId, pairingInfo.phoneNumber, Object.assign(Object.assign({}, pairingInfo.options), { printQR: false, 
+                    // Tambahkan callback khusus untuk reconnect
+                    onConnected: () => {
+                        // Pairing code session reconnected successfully
+                    }, onDisconnected: () => {
+                        // Pairing code session disconnected after reconnect
+                    } }));
+                // Periksa jika session berhasil dimulai
+                return !!(0, exports.getSession)(sessionId);
+            }
+            catch (startError) {
+                console.error(`Failed to reconnect pairing code session ${sessionId}:`, startError.message);
+                return false;
+            }
+        }
+        else {
+            // Cek jika data session tersedia di MongoDB untuk session biasa
+            yield initMongo();
+            const sessionExists = yield shouldLoadSession(sessionId);
+            if (sessionExists) {
+                // Session biasa, gunakan metode startSession normal
+                try {
+                    yield (0, exports.startSession)(sessionId, {
+                        printQR: false,
+                        // Tambahkan callback khusus untuk reconnect
+                        onConnected: () => {
+                            // Session reconnected successfully
+                        },
+                        onDisconnected: () => {
+                            // Session disconnected after reconnect
+                        },
+                        onQRUpdated: (qr) => {
+                            // QR code updated for reconnecting session
+                        }
+                    });
+                    // Periksa jika session berhasil dimulai
+                    return !!(0, exports.getSession)(sessionId);
+                }
+                catch (startError) {
+                    console.error(`Failed to reconnect session ${sessionId}:`, startError.message);
+                    return false;
+                }
+            }
+            else {
+                // No session data found in MongoDB
+                return false;
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error during reconnect for session ${sessionId}:`, error.message);
+        return false;
+    }
+});
+exports.reconnect = reconnect;
+/**
+ * Reconnect all pairing code sessions that are tracked
+ * Useful for bulk reconnection after system restart
+ */
+const reconnectAllPairingCodeSessions = () => __awaiter(void 0, void 0, void 0, function* () {
+    const results = {};
+    for (const [sessionId, sessionInfo] of pairingCodeSessions.entries()) {
+        try {
+            const success = yield (0, exports.reconnect)(sessionId);
+            results[sessionId] = success;
+            // Add delay between reconnection attempts
+            yield (0, create_delay_1.createDelay)(2000);
+        }
+        catch (error) {
+            console.error(`Error reconnecting pairing code session ${sessionId}:`, error.message);
+            results[sessionId] = false;
+        }
+    }
+    return results;
+});
+exports.reconnectAllPairingCodeSessions = reconnectAllPairingCodeSessions;
+/**
+ * Get all tracked pairing code sessions
+ * @returns Array of session IDs that were created with pairing code
+ */
+const getPairingCodeSessions = () => {
+    return Array.from(pairingCodeSessions.keys());
+};
+exports.getPairingCodeSessions = getPairingCodeSessions;
+/**
+ * Get session status information
+ * @param sessionId Session ID to check
+ * @returns Object with session status information
+ */
+const getSessionStatus = (sessionId) => {
+    const isRunning = !!(0, exports.getSession)(sessionId);
+    const isPairingCodeSession = pairingCodeSessions.has(sessionId);
+    const retryAttempts = retryCount.get(sessionId) || 0;
+    return {
+        sessionId,
+        isRunning,
+        isPairingCodeSession,
+        retryAttempts,
+        hasCredentials: isRunning ? true : null // null means unknown when not running
+    };
+};
+exports.getSessionStatus = getSessionStatus;
+// Fungsi baru untuk mendapatkan konfigurasi TTL cache grup
+const setGroupCacheConfig = (options) => {
+    Utils_1.groupCache.setConfig(options);
+};
+exports.setGroupCacheConfig = setGroupCacheConfig;
+// Fungsi baru untuk mendapatkan atau memuat data grup dengan multi-session support
+const getGroupMetadata = (sessionId_1, jid_1, ...args_1) => __awaiter(void 0, [sessionId_1, jid_1, ...args_1], void 0, function* (sessionId, jid, forceFetch = false) {
+    // Get the session socket
+    const sock = (0, exports.getSession)(sessionId);
+    if (!sock) {
+        throw new Error_1.WhatsappError(Defaults_1.Messages.sessionNotFound(sessionId));
+    }
+    try {
+        // Jika forceFetch true, langsung ambil dari server dan update cache
+        if (forceFetch) {
+            const metadata = yield sock.groupMetadata(jid);
+            yield Utils_1.groupCache.set(sessionId, jid, metadata);
+            return metadata;
+        }
+        // Coba ambil dari cache dulu
+        const cachedData = yield Utils_1.groupCache.get(sessionId, jid);
+        if (cachedData) {
+            return cachedData;
+        }
+        // Jika tidak ada di cache, ambil dari server dan simpan ke cache
+        const metadata = yield sock.groupMetadata(jid);
+        yield Utils_1.groupCache.set(sessionId, jid, metadata);
+        return metadata;
+    }
+    catch (error) {
+        throw new Error_1.WhatsappError(`Failed to fetch group metadata: ${error.message || String(error)}`);
+    }
+});
+exports.getGroupMetadata = getGroupMetadata;
+// Fungsi baru untuk menghapus cache grup tertentu
+const clearGroupMetadataCache = (sessionId, jid) => __awaiter(void 0, void 0, void 0, function* () {
+    yield Utils_1.groupCache.delete(sessionId, jid);
+});
+exports.clearGroupMetadataCache = clearGroupMetadataCache;
+// Fungsi untuk membersihkan seluruh cache grup untuk session tertentu
+const clearSessionGroupMetadataCache = (sessionId) => __awaiter(void 0, void 0, void 0, function* () {
+    yield Utils_1.groupCache.clearSessionCache(sessionId);
+});
+exports.clearSessionGroupMetadataCache = clearSessionGroupMetadataCache;
+// Fungsi untuk membersihkan seluruh cache grup untuk semua session
+const clearAllGroupMetadataCache = () => {
+    Utils_1.groupCache.flush();
+};
+exports.clearAllGroupMetadataCache = clearAllGroupMetadataCache;