fix: queue bug

Author: vikyw89

server/src/index.ts

@@ -13,8 +13,8 @@ const app = express();
 app.use(express.json());
 
 initRoutes()
-// telegramBot.start()
-app.use(`/api/bot/${TELEGRAM_BOT_TOKEN}`, webhookCallback(telegramBot, "express"));
+telegramBot.start()
+// app.use(`/api/bot/${TELEGRAM_BOT_TOKEN}`, webhookCallback(telegramBot, "express"));
 app.use("/api", (req:Request, res:Response) => {
     res.json('Welcome to Fingu!')
 });

server/src/telegramRoutes/index.ts

@@ -4,8 +4,8 @@ import { telegramBot } from "../utils/telegram"
 import { telegramFileHandler } from "./telegramFileHandler"
 import { telegramMessageHandler } from "./telegramMessageHandler"
 import { telegramCommandHandler } from "./telegramCommandHandler"
-import { chatAction } from "../telegramMiddlewares/chatAction"
 import { limit } from "@grammyjs/ratelimiter"
+import { telegramQueueEndHandler, telegramQueueStartHandler } from "./telegramQueueHandler"
 
 telegramBot.use(limit({
     limit: 100,
@@ -15,13 +15,17 @@ telegramBot.use(limit({
     }
 }))
 
+telegramBot.use(telegramQueueStartHandler)
+
 telegramBot.use(logger)
 
 telegramBot.on("msg::bot_command", telegramCommandHandler)
 
 telegramBot.on("message:file", telegramFileHandler)
 
-telegramBot.on("message", telegramMessageHandler)
+telegramBot.on("message:text", telegramMessageHandler)
+
+telegramBot.use(telegramQueueEndHandler)
 
 telegramBot.use((ctx: Context, next: NextFunction) => {
 

server/src/telegramRoutes/telegramCommandHandler/index.ts

@@ -29,5 +29,10 @@ export const telegramCommandHandler = async (ctx: Context, next: NextFunction) =
         console.log(err)
 
     }
+    finally {
+
+        next()
+
+    }
 
 }

server/src/telegramRoutes/telegramMessageHandler/index.ts

@@ -16,21 +16,6 @@ export const telegramMessageHandler = async (ctx: Context, next: NextFunction) =
 
     const fromName = ctx.message.from.first_name ?? "anonymous"
 
-    // block new message
-    const setIsWaiting = await prisma.telegram.upsert({
-        where: {
-            id: fromTelegramId,
-        },
-        update: {
-            id: fromTelegramId,
-            isWaiting: true
-        },
-        create: {
-            id: fromTelegramId,
-            isWaiting: true
-        }
-    })
-
     const newMessage = {
         isUser: true,
         text: ctx.message.text ?? "..."
@@ -122,22 +107,17 @@ export const telegramMessageHandler = async (ctx: Context, next: NextFunction) =
             ]
         })
 
-        // update isWaiting
-        const setIsWaiting = await prisma.telegram.update({
-            where: {
-                id: fromTelegramId
-            },
-            data: {
-                isWaiting: false
-            }
-        })
-
         console.timeEnd('telegramMessageHandler');
 
     } catch (err) {
 
         console.log(err)
 
     }
+    finally{
+
+        next()
+
+    }
 
 }

server/src/telegramRoutes/telegramQueueHandler/index.ts

@@ -1,39 +1,89 @@
 import { Context, NextFunction } from "grammy";
 import { prisma } from "../../utils/prisma";
 
-export const telegramQueueHandler = async (ctx:Context,next:NextFunction) => {
+export const telegramQueueStartHandler = async (ctx: Context, next: NextFunction) => {
     if (!ctx.message) return
 
     const fromTelegramId = ctx.message?.from.id.toString()
-
+    ctx.replyWithChatAction('typing')
     // check for isWaiting
-    let checkIsWaiting = await prisma.telegram.findFirst({
-        where:{
-            id:fromTelegramId
-        },
-        select:{
-            isWaiting:true,
+    try {
+        let checkIsWaiting = await prisma.telegram.findFirst({
+            where: {
+                id: fromTelegramId
+            },
+            select: {
+                isWaiting: true,
+            }
+        })
+
+        // if it's first time user, id would be false
+        if (!checkIsWaiting) {
+            next()
+        }
+
+        // short polling the db
+        // inneficient, will be updated to long polling or pubsub when scaling is needed
+        while (checkIsWaiting?.isWaiting) {
+            console.log("🚀 ~ file: index.ts:28 ~ telegramQueueHandler ~ checkIsWaiting:", checkIsWaiting)
+            await new Promise(r => setTimeout(r, 10000))
+            checkIsWaiting = await prisma.telegram.findFirst({
+                where: {
+                    id: fromTelegramId
+                },
+                select: {
+                    isWaiting: true,
+                }
+            })
         }
-    })
 
-    // if it's first time user, id would be false
-    if (!checkIsWaiting) {
+        await prisma.telegram.upsert({
+            where: {
+                id: fromTelegramId
+            },
+            update: {
+                isWaiting: true
+            },
+            create: {
+                isWaiting: true,
+                id: fromTelegramId
+            }
+        })
+
+
+    }
+    catch (err) {
+
+        console.log(err)
+
+    }
+    finally{
+
         next()
+
     }
+}
+
 
-    // short polling the db
-    // inneficient, will be updated to long polling or pubsub when scaling is needed
-    while (checkIsWaiting?.isWaiting) {
-        await new Promise(r => setTimeout(r, 10000))
-        checkIsWaiting = await prisma.telegram.findFirst({
-            where:{
-                id:fromTelegramId
+export const telegramQueueEndHandler = async (ctx: Context, next: NextFunction) => {
+    if (!ctx.message) return
+
+    const fromTelegramId = ctx.message?.from.id.toString()
+
+    try {
+
+        await prisma.telegram.update({
+            where: {
+                id: fromTelegramId
             },
-            select:{
-                isWaiting:true,
+            data: {
+                isWaiting: false
             }
         })
+
     }
+    catch (err) {
 
-    next()
+        console.log(err)
+    }
 }