whatsapp-store-db 1.3.43

package/dist/handlers/message.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baileys_1 = require("baileys");
+const shared_1 = require("../shared");
+const utils_1 = require("../utils");
+const getKeyAuthor = (key) => ((key === null || key === void 0 ? void 0 : key.fromMe) ? 'me' : (key === null || key === void 0 ? void 0 : key.participant) || (key === null || key === void 0 ? void 0 : key.remoteJid)) || '';
+function messageHandler(sessionId, event, getJid = undefined) {
+    const prisma = (0, shared_1.usePrisma)();
+    const logger = (0, shared_1.useLogger)();
+    let listening = false;
+    const resolveRemoteJid = (key) => {
+        let jid = undefined;
+        if (key.remoteJid && key.remoteJidAlt) {
+            if (!key.remoteJid.includes('s.whatsapp.net') && key.remoteJidAlt.includes('s.whatsapp.net')) {
+                jid = key.remoteJidAlt;
+            }
+            else if (key.remoteJid.includes('s.whatsapp.net')) {
+                jid = key.remoteJid;
+            }
+        }
+        return (0, baileys_1.jidNormalizedUser)(jid !== null && jid !== void 0 ? jid : key.remoteJid);
+    };
+    const stringifySafe = (value) => {
+        try {
+            return JSON.stringify(value, (_k, v) => (typeof v === 'bigint' ? v.toString() : v));
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to stringify value for logging');
+            return '';
+        }
+    };
+    // Configurable batch sizes based on environment or dataset size
+    const getBatchConfig = (messageCount) => {
+        if (messageCount > 10000) {
+            // Emergency mode for very large datasets
+            return {
+                BATCH_SIZE: 10,
+                MAX_CONCURRENT_BATCHES: 2,
+                TIMEOUT: 45000, // 45 seconds
+            };
+        }
+        else if (messageCount > 5000) {
+            // Large dataset mode
+            return {
+                BATCH_SIZE: 15,
+                MAX_CONCURRENT_BATCHES: 2,
+                TIMEOUT: 30000, // 30 seconds
+            };
+        }
+        else if (messageCount > 1000) {
+            // Medium dataset mode
+            return {
+                BATCH_SIZE: 25,
+                MAX_CONCURRENT_BATCHES: 3,
+                TIMEOUT: 25000, // 25 seconds
+            };
+        }
+        else {
+            // Small dataset mode
+            return {
+                BATCH_SIZE: 50,
+                MAX_CONCURRENT_BATCHES: 4,
+                TIMEOUT: 20000, // 20 seconds
+            };
+        }
+    };
+    const set = async ({ messages, isLatest }) => {
+        try {
+            logger.info({ messageCount: messages.length }, 'Starting message sync');
+            const { BATCH_SIZE, MAX_CONCURRENT_BATCHES, TIMEOUT } = getBatchConfig(messages.length);
+            const batches = [];
+            for (let i = 0; i < messages.length; i += BATCH_SIZE) {
+                batches.push(messages.slice(i, i + BATCH_SIZE));
+            }
+            logger.info({ totalBatches: batches.length, batchSize: BATCH_SIZE }, 'Processing in batches');
+            // Process batches with limited concurrency
+            for (let i = 0; i < batches.length; i += MAX_CONCURRENT_BATCHES) {
+                const currentBatches = batches.slice(i, i + MAX_CONCURRENT_BATCHES);
+                await Promise.all(currentBatches.map(async (batch, batchIndex) => {
+                    const actualBatchIndex = i + batchIndex;
+                    try {
+                        await prisma.$transaction(async (tx) => {
+                            // Use createMany where possible for better performance
+                            const messagesToCreate = [];
+                            const messagesToUpdate = [];
+                            for (const message of batch) {
+                                const jid = resolveRemoteJid(message.key);
+                                const transformedMessage = Object.assign(Object.assign({}, (0, utils_1.transformPrisma)(message)), { remoteJid: jid, id: message.key.id, sessionId });
+                                // Check if message exists
+                                const existing = await tx.message.findUnique({
+                                    where: {
+                                        sessionId_remoteJid_id: {
+                                            sessionId,
+                                            remoteJid: jid,
+                                            id: message.key.id,
+                                        },
+                                    },
+                                    select: { pkId: true },
+                                });
+                                if (existing) {
+                                    messagesToUpdate.push({
+                                        where: {
+                                            sessionId_remoteJid_id: {
+                                                sessionId,
+                                                remoteJid: jid,
+                                                id: message.key.id,
+                                            },
+                                        },
+                                        data: (0, utils_1.validateMessageData)((0, utils_1.transformPrisma)(message)),
+                                    });
+                                }
+                                else {
+                                    messagesToCreate.push(transformedMessage);
+                                }
+                            }
+                            // Bulk create new messages
+                            if (messagesToCreate.length > 0) {
+                                // Validate and transform messages before bulk insertion
+                                const validatedMessages = messagesToCreate.map((msg) => (0, utils_1.validateMessageData)(msg));
+                                // Log validation summary for bulk operations
+                                const totalOriginalFields = messagesToCreate.reduce((sum, msg) => sum + Object.keys(msg).length, 0);
+                                const totalValidatedFields = validatedMessages.reduce((sum, msg) => sum + Object.keys(msg).length, 0);
+                                if (totalOriginalFields !== totalValidatedFields) {
+                                    logger.info({
+                                        batchSize: messagesToCreate.length,
+                                        totalOriginalFields,
+                                        totalValidatedFields,
+                                        fieldsFiltered: totalOriginalFields - totalValidatedFields
+                                    }, 'Bulk message validation filtered out unknown fields');
+                                }
+                                await tx.message.createMany({
+                                    data: validatedMessages,
+                                    skipDuplicates: true,
+                                });
+                            }
+                            // Update existing messages individually (unfortunately updateMany doesn't support unique constraints)
+                            for (const updateOp of messagesToUpdate) {
+                                await tx.message.update(updateOp);
+                            }
+                        }, {
+                            timeout: TIMEOUT,
+                            maxWait: 10000, // 10 seconds max wait
+                        });
+                        if (actualBatchIndex % 10 === 0) {
+                            logger.info({
+                                completedBatches: actualBatchIndex + 1,
+                                totalBatches: batches.length,
+                                progress: `${Math.round(((actualBatchIndex + 1) / batches.length) * 100)}%`
+                            }, 'Batch progress');
+                        }
+                    }
+                    catch (e) {
+                        logger.error({ batchIndex: actualBatchIndex, error: e }, 'Error processing message batch');
+                        throw e; // Re-throw to stop processing
+                    }
+                }));
+            }
+            logger.info({
+                messages: messages.length,
+                batches: batches.length,
+                batchSize: BATCH_SIZE
+            }, 'Successfully synced all messages');
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during messages set');
+            throw e; // Re-throw for upstream handling
+        }
+    };
+    const upsert = async ({ messages, type }) => {
+        switch (type) {
+            case 'append':
+            case 'notify':
+                for (const message of messages) {
+                    try {
+                        const jid = resolveRemoteJid(message.key);
+                        const data = (0, utils_1.transformPrisma)(message);
+                        // Validate data before upsert
+                        const validatedData = (0, utils_1.validateMessageData)(data);
+                        // Log if any fields were filtered out during validation
+                        if (Object.keys(validatedData).length !== Object.keys(data).length) {
+                            logger.info({
+                                messageId: message.key.id,
+                                originalFieldCount: Object.keys(data).length,
+                                validatedFieldCount: Object.keys(validatedData).length
+                            }, 'Message data was filtered during validation');
+                        }
+                        await (0, utils_1.retryDatabaseOperation)(() => prisma.message.upsert({
+                            select: { pkId: true },
+                            create: Object.assign(Object.assign({}, validatedData), { remoteJid: jid, id: message.key.id, sessionId }),
+                            update: Object.assign({}, validatedData),
+                            where: { sessionId_remoteJid_id: { remoteJid: jid, id: message.key.id, sessionId } },
+                        }), 'message.upsert', logger);
+                        const chatExists = (await prisma.chat.count({ where: { id: jid, sessionId } })) > 0;
+                        if (type === 'notify' && !chatExists) {
+                            event.emit('chats.upsert', [
+                                {
+                                    id: jid,
+                                    conversationTimestamp: (0, baileys_1.toNumber)(message.messageTimestamp),
+                                    unreadCount: 1,
+                                },
+                            ]);
+                        }
+                    }
+                    catch (e) {
+                        logger.error(e, 'An error occured during message upsert');
+                    }
+                }
+                break;
+        }
+    };
+    const update = async (updates) => {
+        for (const { update, key } of updates) {
+            try {
+                const jid = resolveRemoteJid(key);
+                await (0, utils_1.retryDatabaseOperation)(() => prisma.$transaction(async (tx) => {
+                    const prevData = await tx.message.findFirst({
+                        where: { id: key.id, remoteJid: jid, sessionId },
+                    });
+                    if (!prevData) {
+                        return logger.info({ update }, 'Got update for non existent message');
+                    }
+                    const data = Object.assign(Object.assign({}, prevData), update);
+                    const transformedData = (0, utils_1.transformPrisma)(data);
+                    // Validate and filter data before upsert
+                    const validatedData = (0, utils_1.validateMessageData)(transformedData);
+                    // Additional debug logging for Buffer issues
+                    if (stringifySafe(validatedData).includes('"type":"Buffer"')) {
+                        logger.error({
+                            messageId: key.id,
+                            issue: 'Buffer objects still present after validation',
+                            data: validatedData
+                        }, 'Buffer serialization issue detected');
+                    }
+                    // Log if any fields were filtered out during validation
+                    if (Object.keys(validatedData).length !== Object.keys(transformedData).length) {
+                        logger.info({
+                            messageId: key.id,
+                            originalFieldCount: Object.keys(transformedData).length,
+                            validatedFieldCount: Object.keys(validatedData).length
+                        }, 'Message data was filtered during validation in update');
+                    }
+                    await tx.message.upsert({
+                        select: { pkId: true },
+                        where: {
+                            sessionId_remoteJid_id: {
+                                id: key.id,
+                                remoteJid: jid,
+                                sessionId,
+                            },
+                        },
+                        create: Object.assign(Object.assign({}, validatedData), { id: key.id, remoteJid: jid, sessionId }),
+                        update: Object.assign({}, validatedData),
+                    });
+                }, {
+                    timeout: 10000, // 10 seconds
+                }), 'message.update.transaction', logger);
+            }
+            catch (e) {
+                logger.error(e, 'An error occured during message update');
+            }
+        }
+    };
+    const del = async (item) => {
+        // try {
+        //   if ('all' in item) {
+        //     await prisma.message.deleteMany({ where: { remoteJid: item.jid, sessionId } });
+        //     return;
+        //   }
+        //   const jid = item.keys[0].remoteJid!;
+        //   await prisma.message.deleteMany({
+        //     where: { id: { in: item.keys.map((k) => k.id!) }, remoteJid: jid, sessionId },
+        //   });
+        // } catch (e) {
+        //   logger.error(e, 'An error occured during message delete');
+        // }
+    };
+    const updateReceipt = async (updates) => {
+        for (const { key, receipt } of updates) {
+            try {
+                const jid = resolveRemoteJid(key);
+                await (0, utils_1.retryDatabaseOperation)(() => prisma.$transaction(async (tx) => {
+                    const message = await tx.message.findFirst({
+                        select: { userReceipt: true },
+                        where: { id: key.id, remoteJid: jid, sessionId },
+                    });
+                    if (!message) {
+                        return logger.debug({ update }, 'Got receipt update for non existent message');
+                    }
+                    let userReceipt = (message.userReceipt || []);
+                    const recepient = userReceipt.find((m) => m.userJid === receipt.userJid);
+                    if (recepient) {
+                        userReceipt = [...userReceipt.filter((m) => m.userJid !== receipt.userJid), receipt];
+                    }
+                    else {
+                        userReceipt.push(receipt);
+                    }
+                    await tx.message.update({
+                        select: { pkId: true },
+                        data: (0, utils_1.validateMessageData)((0, utils_1.transformPrisma)({ userReceipt: userReceipt })),
+                        where: {
+                            sessionId_remoteJid_id: { id: key.id, remoteJid: jid, sessionId },
+                        },
+                    });
+                }, {
+                    timeout: 10000, // 10 seconds
+                }), 'message.receipt.update.transaction', logger);
+            }
+            catch (e) {
+                logger.error(e, 'An error occured during message receipt update');
+            }
+        }
+    };
+    const updateReaction = async (reactions) => {
+        for (const { key, reaction } of reactions) {
+            try {
+                const jid = resolveRemoteJid(key);
+                await (0, utils_1.retryDatabaseOperation)(() => prisma.$transaction(async (tx) => {
+                    const message = await tx.message.findFirst({
+                        select: { reactions: true },
+                        where: { id: key.id, remoteJid: jid, sessionId },
+                    });
+                    if (!message) {
+                        return logger.debug({ update }, 'Got reaction update for non existent message');
+                    }
+                    const authorID = getKeyAuthor(reaction.key);
+                    const existingReactions = (message.reactions || []);
+                    const filteredReactions = existingReactions.filter((r) => r.key && getKeyAuthor(r.key) !== authorID);
+                    const updatedReactions = reaction.text ? [...filteredReactions, reaction] : filteredReactions;
+                    await tx.message.update({
+                        select: { pkId: true },
+                        data: (0, utils_1.validateMessageData)((0, utils_1.transformPrisma)({ reactions: updatedReactions })),
+                        where: {
+                            sessionId_remoteJid_id: { id: key.id, remoteJid: jid, sessionId },
+                        },
+                    });
+                }, {
+                    timeout: 10000, // 10 seconds
+                }), 'message.reaction.update.transaction', logger);
+            }
+            catch (e) {
+                logger.error(e, 'An error occured during message reaction update');
+            }
+        }
+    };
+    const listen = () => {
+        if (listening)
+            return;
+        event.on('messaging-history.set', set);
+        event.on('messages.upsert', upsert);
+        event.on('messages.update', update);
+        event.on('messages.delete', del);
+        event.on('message-receipt.update', updateReceipt);
+        event.on('messages.reaction', updateReaction);
+        listening = true;
+    };
+    const unlisten = () => {
+        if (!listening)
+            return;
+        event.off('messaging-history.set', set);
+        event.off('messages.upsert', upsert);
+        event.off('messages.update', update);
+        event.off('messages.delete', del);
+        event.off('message-receipt.update', updateReceipt);
+        event.off('messages.reaction', updateReaction);
+        listening = false;
+    };
+    return { listen, unlisten };
+}
+exports.default = messageHandler;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './store';
+export * from './session';
+export * from './utils';
+export * from './types';

package/dist/index.js

@@ -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("./store"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./types"), exports);

package/dist/session.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import type { AuthenticationCreds, SignalDataTypeMap } from 'baileys';
+import { proto } from 'baileys';
+export declare function useSession(sessionId: string): Promise<{
+    state: {
+        creds: AuthenticationCreds;
+        keys: {
+            get: (type: keyof SignalDataTypeMap, ids: string[]) => Promise<{
+                [key: string]: string | Uint8Array | string[] | import("baileys").KeyPair | {
+                    [jid: string]: boolean;
+                } | proto.Message.IAppStateSyncKeyData | import("baileys").LTHashState | {
+                    token: Buffer;
+                    timestamp?: string | undefined;
+                };
+            }>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+}>;

package/dist/session.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSession = void 0;
+const baileys_1 = require("baileys");
+const baileys_2 = require("baileys");
+const shared_1 = require("./shared");
+const fixId = (id) => id.replace(/\//g, '__').replace(/:/g, '-');
+async function useSession(sessionId) {
+    const model = (0, shared_1.usePrisma)().session;
+    const logger = (0, shared_1.useLogger)();
+    const persistSessionRecord = async (jsonData, id) => {
+        const where = { sessionId, id };
+        const createPayload = { data: jsonData, id, sessionId };
+        const updatePayload = { data: jsonData };
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                const updateResult = await model.updateMany({
+                    data: updatePayload,
+                    where,
+                });
+                if (updateResult.count > 0) {
+                    return;
+                }
+                await model.create({
+                    select: { pkId: true },
+                    data: createPayload,
+                });
+                return;
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.code) === 'P2002') {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        logger.error({ id, sessionId }, 'Failed to persist session record after repeated retries');
+    };
+    const write = async (data, id) => {
+        try {
+            const jsonData = JSON.stringify(data, baileys_2.BufferJSON.replacer);
+            try {
+                JSON.parse(jsonData, baileys_2.BufferJSON.reviver);
+            }
+            catch (parseError) {
+                logger.error({ id, parseError, dataLength: jsonData === null || jsonData === void 0 ? void 0 : jsonData.length }, 'Cannot serialize session data properly. Skipping write.');
+                return;
+            }
+            id = fixId(id);
+            await persistSessionRecord(jsonData, id);
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during session write');
+        }
+    };
+    const read = async (id) => {
+        var _a;
+        try {
+            const result = await model.findUnique({
+                select: { data: true },
+                where: { sessionId_id: { id: fixId(id), sessionId } },
+            });
+            if (!result || typeof result.data === 'undefined') {
+                logger.info({ id }, 'Session data not found or value is undefined');
+                return null;
+            }
+            try {
+                return JSON.parse(result.data, baileys_2.BufferJSON.reviver);
+            }
+            catch (parseError) {
+                logger.error({ id, error: parseError, dataLength: (_a = result.data) === null || _a === void 0 ? void 0 : _a.length }, 'Failed to parse session data JSON. The data might be corrupted.');
+                if (id === 'creds') {
+                    logger.info('Returning fresh credentials due to parsing error');
+                    return (0, baileys_2.initAuthCreds)();
+                }
+                return null;
+            }
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during session read');
+            return null;
+        }
+    };
+    const del = async (id) => {
+        try {
+            await model.delete({
+                select: { pkId: true },
+                where: { sessionId_id: { id: fixId(id), sessionId } },
+            });
+        }
+        catch (e) {
+            const code = e === null || e === void 0 ? void 0 : e.code;
+            // P2025: Record to delete does not exist - this is expected behavior
+            if (code === 'P2025') {
+                logger.debug({ id, sessionId }, 'Session record already deleted or does not exist');
+                return;
+            }
+            logger.error(e, 'An error occured during session delete');
+        }
+    };
+    const creds = (await read('creds')) || (0, baileys_2.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await read(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = baileys_1.proto.Message.AppStateSyncKeyData.create(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 sId = `${category}-${id}`;
+                            tasks.push(value ? write(value, sId) : del(sId));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            },
+        },
+        saveCreds: () => write(creds, 'creds'),
+    };
+}
+exports.useSession = useSession;

package/dist/shared.d.ts

@@ -0,0 +1,6 @@
+import type { PrismaClient } from '@prisma/client';
+import type { SocketConfig } from 'baileys';
+export declare function setPrisma(prismaClient: PrismaClient): void;
+export declare function setLogger(pinoLogger?: SocketConfig['logger']): void;
+export declare function usePrisma(): PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+export declare function useLogger(): import("baileys/lib/Utils/logger").ILogger;

package/dist/shared.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogger = exports.usePrisma = exports.setLogger = exports.setPrisma = void 0;
+const baileys_1 = require("baileys");
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+let prisma = null;
+let logger = null;
+function setPrisma(prismaClient) {
+    prisma = prismaClient;
+}
+exports.setPrisma = setPrisma;
+function setLogger(pinoLogger) {
+    logger = pinoLogger || baileys_1.DEFAULT_CONNECTION_CONFIG.logger;
+}
+exports.setLogger = setLogger;
+function usePrisma() {
+    (0, tiny_invariant_1.default)(prisma, 'Prisma client cannot be used before initialization');
+    return prisma;
+}
+exports.usePrisma = usePrisma;
+function useLogger() {
+    return logger || baileys_1.DEFAULT_CONNECTION_CONFIG.logger;
+}
+exports.useLogger = useLogger;

package/dist/store.d.ts

@@ -0,0 +1,22 @@
+import type { BaileysEventEmitter, SocketConfig } from 'baileys';
+import type { PrismaClient } from '@prisma/client';
+type initStoreOptions = {
+    /** Prisma client instance */
+    prisma: PrismaClient;
+    /** Baileys pino logger */
+    logger?: SocketConfig['logger'];
+};
+/** Initialize shared instances that will be consumed by the Store instance */
+export declare function initStore({ prisma, logger }: initStoreOptions): void;
+export declare class Store {
+    private getJid;
+    private readonly chatHandler;
+    private readonly messageHandler;
+    private readonly contactHandler;
+    constructor(sessionId: string, event: BaileysEventEmitter, getJid?: Function | undefined);
+    /** Start listening to the events */
+    listen(): void;
+    /** Stop listening to the events */
+    unlisten(): void;
+}
+export {};

package/dist/store.js

@@ -0,0 +1,56 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = exports.initStore = void 0;
+const shared_1 = require("./shared");
+const handlers = __importStar(require("./handlers"));
+/** Initialize shared instances that will be consumed by the Store instance */
+function initStore({ prisma, logger }) {
+    (0, shared_1.setPrisma)(prisma);
+    (0, shared_1.setLogger)(logger);
+}
+exports.initStore = initStore;
+class Store {
+    constructor(sessionId, event, getJid = undefined) {
+        this.getJid = getJid;
+        this.chatHandler = handlers.chatHandler(sessionId, event, this.getJid);
+        this.messageHandler = handlers.messageHandler(sessionId, event, this.getJid);
+        this.contactHandler = handlers.contactHandler(sessionId, event, this.getJid);
+        this.listen();
+    }
+    /** Start listening to the events */
+    listen() {
+        this.chatHandler.listen();
+        this.messageHandler.listen();
+        this.contactHandler.listen();
+    }
+    /** Stop listening to the events */
+    unlisten() {
+        this.chatHandler.unlisten();
+        this.messageHandler.unlisten();
+        this.contactHandler.unlisten();
+    }
+}
+exports.Store = Store;