feat: add message logging middleware and model to record user and bot interactions, and update user context handling

Author: parthsali

src/middlewares/messageLoggerMiddleware.js

@@ -0,0 +1,114 @@
+import Msg from "../models/msg-model.js";
+import logger from "../helpers/logger.js";
+
+export const messageLoggerMiddleware = async (ctx, next) => {
+  // We need the Mongo User ID. It should be in ctx.state.user from previous middleware.
+  // If not, we might be in a context where user auth didn't run or failed (e.g. some public commands?), but usually it runs.
+  const mongoUserId = ctx.state.user?._id;
+  const chatId = ctx.chat?.id ? String(ctx.chat.id) : null;
+
+  // 1. Log Incoming User Action (Only real messages)
+  try {
+    if (mongoUserId && chatId) {
+      if (ctx.message) {
+        // Standard User Message
+        const content =
+          ctx.message.text || ctx.message.caption || "[Non-text message]";
+        const type = ctx.message.text
+          ? ctx.message.text.startsWith("/")
+            ? "command"
+            : "text"
+          : "other";
+
+        await Msg.create({
+          userId: mongoUserId,
+          messageId: ctx.message.message_id,
+          chatId,
+          content,
+          isBot: false,
+          type,
+          originalMessage: ctx.message,
+        });
+      }
+      // Note: We are explicitly skipping ctx.callbackQuery logging here as requested
+      // "handle callbacks clearly and like no need to lock them"
+    }
+  } catch (err) {
+    logger.error("Error logging incoming message:", err);
+  }
+
+  // 2. Wrap Bot Response Methods to Log Outgoing
+  const originalReply = ctx.reply.bind(ctx);
+  const originalEditMessageText = ctx.editMessageText.bind(ctx);
+
+  ctx.reply = async (...args) => {
+    try {
+      const message = await originalReply(...args);
+      // content is arg[0] usually
+      const content =
+        typeof args[0] === "string" ? args[0] : "[Non-text reply]";
+
+      // Log Bot Message
+      if (message && mongoUserId) {
+        try {
+          await Msg.create({
+            userId: mongoUserId,
+            messageId: message.message_id,
+            chatId: String(message.chat.id),
+            content,
+            isBot: true,
+            type: "text",
+            originalMessage: message,
+          });
+        } catch (logErr) {
+          logger.error("Failed to log outgoing message:", logErr);
+        }
+      }
+      return message;
+    } catch (err) {
+      logger.error("Error in wrapped ctx.reply:", err);
+      throw err;
+    }
+  };
+
+  ctx.editMessageText = async (...args) => {
+    try {
+      const message = await originalEditMessageText(...args);
+
+      // Update the existing message if we tracked it
+      if (message && mongoUserId) {
+        try {
+          await Msg.findOneAndUpdate(
+            { messageId: message.message_id, chatId: String(message.chat.id) },
+            {
+              // For a bot edit, the 'userId' field on the Msg still refers to the *User* owner of the chat context
+              // which we have as mongoUserId.
+              userId: mongoUserId,
+              content:
+                typeof args[0] === "string"
+                  ? args[0]
+                  : message.text || "[Edited Content]",
+              isBot: true,
+              originalMessage: message,
+            },
+            { upsert: true, new: true }
+          );
+        } catch (logErr) {
+          logger.error("Failed to log edited message:", logErr);
+        }
+      }
+      return message;
+    } catch (err) {
+      if (
+        err.description &&
+        err.description.includes("message is not modified")
+      ) {
+        return; // Ignore
+      }
+      logger.error("Error in wrapped ctx.editMessageText:", err);
+      throw err;
+    }
+  };
+
+  await next();
+};

src/middlewares/userAuthAndSetupMiddleware.js

@@ -23,7 +23,8 @@ export const userAuthAndSetupMiddleware = async (ctx, next) => {
   }
 
   // create user if not exists
-  await createUserIfNotExists(ctx);
+  const user = await createUserIfNotExists(ctx);
+  ctx.state.user = user;
   next();
 };
 

src/models/msg-model.js

@@ -0,0 +1,42 @@
+import mongoose from "mongoose";
+
+const msgSchema = new mongoose.Schema(
+  {
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "TelegramUser",
+      required: true,
+      index: true,
+    },
+    messageId: {
+      type: Number,
+      required: true,
+    },
+    chatId: {
+      type: String,
+      required: true,
+    },
+    content: {
+      type: String,
+      default: "",
+    },
+    isBot: {
+      type: Boolean,
+      default: false,
+    },
+    type: {
+      type: String,
+      enum: ["text", "callback_query", "command", "photo", "other"],
+      default: "text",
+    },
+    // Meta info
+    originalMessage: {
+      type: mongoose.Schema.Types.Mixed, // Store some raw data if needed
+    },
+  },
+  { timestamps: true }
+);
+
+const Msg = mongoose.model("TelegramMsg", msgSchema);
+
+export default Msg;

src/services/telegraf.js

@@ -16,12 +16,14 @@ import {
   checkGroupChatMiddleware,
   userAuthAndSetupMiddleware,
 } from "../middlewares/userAuthAndSetupMiddleware.js";
+import { messageLoggerMiddleware } from "../middlewares/messageLoggerMiddleware.js";
 import logger from "../helpers/logger.js";
 
 export const bot = new Telegraf(TELEGRAM_BOT_TOKEN);
 
 bot.use(checkGroupChatMiddleware);
 bot.use(userAuthAndSetupMiddleware);
+bot.use(messageLoggerMiddleware);
 
 bot.telegram.setMyCommands(commands);