whatsapp-store-db 1.3.43

package/.env.example

@@ -0,0 +1,2 @@
+# Your Database Connection URL here, please see https://pris.ly/d/connection-strings
+DATABASE_URL="mysql://root:12345@localhost:3306/baileys_store"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Royhan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+> 🚨 **NOTICE**: `baileys` which is this project relied on, has been discontinued. Thus, this project will be archived and stopped receiving updates anymore. Thanks everyone who's been part of this❤️
+
+---
+
+# Baileys Store
+
+Minimal Baileys data storage for your favorite DBMS built with Prisma. This library is a simple handler for Baileys event emitter that will listen and update your data in the database
+
+## Requirements
+
+- **Prisma** version **4.7.x** or higher
+- **Baileys** version **5.x.x** or higher
+
+## Supported Databases
+
+- MySQL and PostgreSQL database should support the default schema out of the box
+- For CockroachDB, you need to do this small change in the schema file
+
+```diff prisma
+model Session {
+  pkId      BigInt    @id @default(autoincrement())
+  sessionId String
+  id        String
+-  data      String @db.Text
++  data      String
+
+  @@unique([sessionId, id], map: "unique_id_per_session_id_session")
+  @@index([sessionId])
+}
+```
+
+- For MongoDB, you need to follow [this convention](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference?query=getdmff&page=1#mongodb-10) and update the `pkId` field. Then follow the previous CockroachDB guide
+- SQLite and SQL Server database are not supported since they didn't support Prisma's `JSON` scalar type
+
+## Installation
+
+```bash
+# Using npm
+npm i @ookamiiixd/baileys-store
+
+# Using yarn
+yarn add @ookamiiixd/baileys-store
+```
+
+## Setup
+
+Before you can actually use this library, you have to setup your database first
+
+1. Copy the `.env.example` file from this repository or from the `node_modules` directory (should be located at `node_modules/@ookamiiixd/baileys-store/.env.example`). Rename it into `.env` and then update your [connection url](https://www.prisma.io/docs/reference/database-reference/connection-urls) in the `DATABASE_URL` field
+1. Copy the `prisma` directory from this repository or from the `node_modules` directory (should be located at `node_modules/@ookamiiixd/baileys-store/prisma/`). Additionaly, you may want to update your `provider` in the `schema.prisma` file if you're not using MySQL database
+1. Run your [migration](https://www.prisma.io/docs/reference/api-reference/command-reference#prisma-migrate)
+
+## Usage
+
+```ts
+import pino from 'pino';
+import makeWASocket from 'baileys';
+import { PrismaClient } from '@prisma/client';
+import { initStore, Store } from '@ookamiiixd/baileys-store';
+
+const logger = pino();
+const socket = makeWASocket();
+
+// Configure Prisma client with increased transaction timeout
+const prisma = new PrismaClient({
+  transactionOptions: {
+    timeout: 60000, // 60 seconds (increase from default 5 seconds)
+    maxWait: 30000, // 30 seconds max wait time
+    isolationLevel: 'ReadCommitted', // Optional: set isolation level
+  },
+});
+
+// You only need to run this once
+initStore({
+  prisma, // Prisma client instance
+  logger, // Pino logger (Optional)
+});
+
+// Create a store and start listening to the events
+const store = new Store('unique-session-id-here', socket.ev);
+
+// That's it, you can now query from the prisma client without having to worry about handling the events
+const messages = prisma.message.findMany();
+```
+
+## Transaction Timeout Issue
+
+If you encounter the `P2028` error (transaction timeout), it's because the default transaction timeout is 5 seconds. When processing large amounts of data (like message history), transactions may take longer. You can:
+
+1. **Increase the timeout** (shown above) - Set `timeout` to 60000ms (60 seconds) or higher
+2. **Optimize database performance** - Ensure proper indexing and database optimization
+3. **Batch operations** - Process data in smaller chunks if dealing with very large datasets
+
+For production environments, consider:
+- Setting `timeout` to at least 30-60 seconds
+- Monitoring database performance
+- Using connection pooling if needed
+
+## Contributing
+
+PRs, issues, suggestions, etc are welcome. Please kindly open a new issue to discuss it

package/dist/handlers/chat.d.ts

@@ -0,0 +1,5 @@
+import type { BaileysEventEmitter } from 'baileys';
+export default function chatHandler(sessionId: string, event: BaileysEventEmitter, getJid?: Function | undefined): {
+    listen: () => void;
+    unlisten: () => void;
+};

package/dist/handlers/chat.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baileys_1 = require("baileys");
+const client_1 = require(".prisma/client");
+const shared_1 = require("../shared");
+const utils_1 = require("../utils");
+function chatHandler(sessionId, event, getJid = undefined) {
+    const prisma = (0, shared_1.usePrisma)();
+    const logger = (0, shared_1.useLogger)();
+    let listening = false;
+    const resolveChatId = (id, chatOrUpdate) => {
+        // console.log("chatHandler:chatOrUpdate:", chatOrUpdate);
+        // Prefer primary number JID when id is a LID
+        if (id === null || id === void 0 ? void 0 : id.endsWith('@lid')) {
+            const candidate = (chatOrUpdate === null || chatOrUpdate === void 0 ? void 0 : chatOrUpdate.pnJid) || (chatOrUpdate === null || chatOrUpdate === void 0 ? void 0 : chatOrUpdate.senderPn) || (chatOrUpdate === null || chatOrUpdate === void 0 ? void 0 : chatOrUpdate.jid);
+            if (candidate) {
+                return (0, baileys_1.jidNormalizedUser)(candidate);
+            }
+        }
+        const jidByLid = typeof getJid === 'function' ? getJid(id || '') : undefined;
+        return (0, baileys_1.jidNormalizedUser)(jidByLid !== null && jidByLid !== void 0 ? jidByLid : id);
+    };
+    const persistChatRecord = async ({ id, createData, updateData, }) => {
+        const where = { sessionId, id };
+        const createPayload = Object.assign(Object.assign({}, createData), { id, sessionId });
+        const updatePayload = Object.assign({}, updateData);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                const updateResult = await prisma.chat.updateMany({
+                    data: updatePayload,
+                    where,
+                });
+                if (updateResult.count > 0) {
+                    return;
+                }
+                await prisma.chat.create({
+                    select: { pkId: true },
+                    data: createPayload,
+                });
+                return;
+            }
+            catch (err) {
+                if (err instanceof client_1.Prisma.PrismaClientKnownRequestError && err.code === 'P2002') {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        logger.error({ id, sessionId }, 'Failed to persist chat record after repeated retries');
+    };
+    const set = async ({ chats, isLatest }) => {
+        try {
+            await prisma.$transaction(async (tx) => {
+                if (isLatest)
+                    await tx.chat.deleteMany({ where: { sessionId } });
+                // Process chats in batches to avoid timeout
+                const BATCH_SIZE = 100;
+                const normalizedChats = chats.map((c) => {
+                    const id = resolveChatId(c.id, c);
+                    const transformedData = (0, utils_1.transformPrisma)(c);
+                    const validatedData = (0, utils_1.validateChatData)(transformedData);
+                    return Object.assign(Object.assign({}, validatedData), { id });
+                });
+                const existingIds = (await tx.chat.findMany({
+                    select: { id: true },
+                    where: { id: { in: normalizedChats.map((c) => c.id) }, sessionId },
+                })).map((i) => i.id);
+                const newChats = normalizedChats.filter((c) => !existingIds.includes(c.id));
+                let totalAdded = 0;
+                for (let i = 0; i < newChats.length; i += BATCH_SIZE) {
+                    const batch = newChats.slice(i, i + BATCH_SIZE);
+                    const result = await tx.chat.createMany({
+                        data: batch.map((c) => (Object.assign(Object.assign({}, c), { sessionId }))),
+                    });
+                    totalAdded += result.count;
+                }
+                logger.info({ chatsAdded: totalAdded }, 'Synced chats');
+            }, {
+                timeout: 30000, // 30 seconds for this specific transaction
+            });
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during chats set');
+        }
+    };
+    const upsert = async (chats) => {
+        try {
+            // Normalize and de-duplicate by resolved id (keep the last occurrence)
+            const dedupedById = new Map();
+            for (const c of chats) {
+                const id = resolveChatId(c.id, c);
+                const transformedData = (0, utils_1.transformPrisma)(c);
+                const validatedData = (0, utils_1.validateChatData)(transformedData);
+                dedupedById.set(id, Object.assign(Object.assign({}, validatedData), { id }));
+            }
+            const normalizedChats = Array.from(dedupedById.values());
+            await Promise.all(normalizedChats.map((data) => persistChatRecord({
+                id: data.id,
+                createData: Object.assign({}, data),
+                updateData: Object.assign(Object.assign({}, data), { id: undefined }),
+            })));
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during chats upsert');
+        }
+    };
+    const update = async (updates) => {
+        for (const update of updates) {
+            if (!update.id) {
+                logger.warn({ update }, 'Skipping chat update with no ID');
+                continue;
+            }
+            try {
+                const chatId = resolveChatId(update.id, update);
+                const transformedData = (0, utils_1.transformPrisma)(update);
+                const validatedData = (0, utils_1.validateChatData)(transformedData);
+                await persistChatRecord({
+                    id: chatId,
+                    createData: Object.assign(Object.assign({}, validatedData), { id: chatId }),
+                    updateData: Object.assign(Object.assign({}, validatedData), { id: undefined, unreadCount: typeof validatedData.unreadCount === 'number'
+                            ? validatedData.unreadCount > 0
+                                ? { increment: validatedData.unreadCount }
+                                : { set: validatedData.unreadCount }
+                            : undefined }),
+                });
+            }
+            catch (e) {
+                logger.error(e, 'An error occured during chat update');
+            }
+        }
+    };
+    const del = async (ids) => {
+        try {
+            const normalizedIds = ids.map((id) => resolveChatId(id));
+            await prisma.chat.deleteMany({
+                where: { id: { in: normalizedIds } },
+            });
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during chats delete');
+        }
+    };
+    const listen = () => {
+        if (listening)
+            return;
+        event.on('messaging-history.set', set);
+        event.on('chats.upsert', upsert);
+        event.on('chats.update', update);
+        event.on('chats.delete', del);
+        listening = true;
+    };
+    const unlisten = () => {
+        if (!listening)
+            return;
+        event.off('messaging-history.set', set);
+        event.off('chats.upsert', upsert);
+        event.off('chats.update', update);
+        event.off('chats.delete', del);
+        listening = false;
+    };
+    return { listen, unlisten };
+}
+exports.default = chatHandler;

package/dist/handlers/contact.d.ts

@@ -0,0 +1,5 @@
+import type { BaileysEventEmitter } from 'baileys';
+export default function contactHandler(sessionId: string, event: BaileysEventEmitter, getJid?: Function | undefined): {
+    listen: () => void;
+    unlisten: () => void;
+};

package/dist/handlers/contact.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baileys_1 = require("baileys");
+const shared_1 = require("../shared");
+const utils_1 = require("../utils");
+function contactHandler(sessionId, event, getJid = undefined) {
+    const prisma = (0, shared_1.usePrisma)();
+    const logger = (0, shared_1.useLogger)();
+    let listening = false;
+    const resolveContactId = (id, contact) => {
+        // console.log("contactHandler:contact:", contact);
+        // Prefer primary number when we get a LID id and contact carries pn/jid
+        if (id === null || id === void 0 ? void 0 : id.endsWith('@lid')) {
+            const candidate = ((contact === null || contact === void 0 ? void 0 : contact.senderPn) || (contact === null || contact === void 0 ? void 0 : contact.pnJid) || (contact === null || contact === void 0 ? void 0 : contact.jid));
+            if (candidate) {
+                return (0, baileys_1.jidNormalizedUser)(candidate);
+            }
+        }
+        const jidByLid = typeof getJid === 'function' ? getJid(id || '') : undefined;
+        return (0, baileys_1.jidNormalizedUser)(jidByLid !== null && jidByLid !== void 0 ? jidByLid : id);
+    };
+    const sanitizeContactData = (raw) => {
+        // Only keep fields that exist in the Contact model
+        const allowed = ['id', 'name', 'notify', 'verifiedName', 'imgUrl', 'status'];
+        const out = {};
+        for (const k of allowed) {
+            if (raw[k] !== undefined)
+                out[k] = raw[k];
+        }
+        return out;
+    };
+    const set = async ({ contacts }) => {
+        try {
+            const normalizedContacts = contacts.map((c) => {
+                const id = resolveContactId(c.id, c);
+                const data = sanitizeContactData((0, utils_1.transformPrisma)(c));
+                return Object.assign(Object.assign({}, data), { id });
+            });
+            const contactIds = normalizedContacts.map((c) => c.id);
+            const deletedOldContactIds = (await prisma.contact.findMany({
+                select: { id: true },
+                where: { id: { notIn: contactIds }, sessionId },
+            })).map((c) => c.id);
+            const upsertPromises = normalizedContacts
+                .map((data) => prisma.contact.upsert({
+                select: { pkId: true },
+                create: Object.assign(Object.assign({}, data), { sessionId }),
+                update: data,
+                where: { sessionId_id: { id: data.id, sessionId } },
+            }));
+            await Promise.any([
+                ...upsertPromises,
+                prisma.contact.deleteMany({ where: { id: { in: deletedOldContactIds }, sessionId } }),
+            ]);
+            logger.info({ deletedContacts: deletedOldContactIds.length, newContacts: contacts.length }, 'Synced contacts');
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during contacts set');
+        }
+    };
+    const upsert = async (contacts) => {
+        try {
+            const normalizedContacts = contacts.map((c) => {
+                const id = resolveContactId(c.id, c);
+                const data = sanitizeContactData((0, utils_1.transformPrisma)(c));
+                return Object.assign(Object.assign({}, data), { id });
+            });
+            await Promise.any(normalizedContacts.map((data) => prisma.contact.upsert({
+                select: { pkId: true },
+                create: Object.assign(Object.assign({}, data), { sessionId }),
+                update: data,
+                where: { sessionId_id: { id: data.id, sessionId } },
+            })));
+        }
+        catch (e) {
+            logger.error(e, 'An error occured during contacts upsert');
+        }
+    };
+    const update = async (updates) => {
+        for (const update of updates) {
+            if (!update.id) {
+                logger.warn({ update }, 'Skipping contact update with no ID');
+                continue;
+            }
+            try {
+                const contactId = resolveContactId(update.id, update);
+                const transformedData = sanitizeContactData((0, utils_1.transformPrisma)(update));
+                await prisma.contact.upsert({
+                    select: { pkId: true },
+                    create: Object.assign(Object.assign({}, transformedData), { id: contactId, sessionId }),
+                    update: transformedData,
+                    where: { sessionId_id: { id: contactId, sessionId } },
+                });
+            }
+            catch (e) {
+                logger.error(e, 'An error occured during contact update');
+            }
+        }
+    };
+    const listen = () => {
+        if (listening)
+            return;
+        event.on('messaging-history.set', set);
+        event.on('contacts.upsert', upsert);
+        event.on('contacts.update', update);
+        listening = true;
+    };
+    const unlisten = () => {
+        if (!listening)
+            return;
+        event.off('messaging-history.set', set);
+        event.off('contacts.upsert', upsert);
+        event.off('contacts.update', update);
+        listening = false;
+    };
+    return { listen, unlisten };
+}
+exports.default = contactHandler;

package/dist/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as chatHandler } from './chat';
+export { default as messageHandler } from './message';
+export { default as contactHandler } from './contact';

package/dist/handlers/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contactHandler = exports.messageHandler = exports.chatHandler = void 0;
+var chat_1 = require("./chat");
+Object.defineProperty(exports, "chatHandler", { enumerable: true, get: function () { return __importDefault(chat_1).default; } });
+var message_1 = require("./message");
+Object.defineProperty(exports, "messageHandler", { enumerable: true, get: function () { return __importDefault(message_1).default; } });
+var contact_1 = require("./contact");
+Object.defineProperty(exports, "contactHandler", { enumerable: true, get: function () { return __importDefault(contact_1).default; } });

package/dist/handlers/message.d.ts

@@ -0,0 +1,5 @@
+import type { BaileysEventEmitter } from 'baileys';
+export default function messageHandler(sessionId: string, event: BaileysEventEmitter, getJid?: Function | undefined): {
+    listen: () => void;
+    unlisten: () => void;
+};