feat: implement user sync (#54)

* feat: user sync

* refactor: rename middleware

update backend package

* refactor: extract type alias on DBUsers

* fix: match new APIs

Author: lorenzocorallo

package.json

@@ -37,7 +37,7 @@
     "@grammyjs/menu": "^1.3.1",
     "@grammyjs/parse-mode": "^1.11.1",
     "@grammyjs/runner": "^2.0.3",
-    "@polinetwork/backend": "^0.10.0",
+    "@polinetwork/backend": "^0.12.0",
     "@t3-oss/env-core": "^0.13.4",
     "@trpc/client": "^11.5.1",
     "@types/ssdeep.js": "^0.0.2",

pnpm-lock.yaml

@@ -14,7 +14,7 @@ import { AutoModerationStack } from "./middlewares/auto-moderation-stack"
 import { BotMembershipHandler } from "./middlewares/bot-membership-handler"
 import { checkUsername } from "./middlewares/check-username"
 import { messageLink } from "./middlewares/message-link"
-import { MessageStorage } from "./middlewares/message-storage"
+import { MessageUserStorage } from "./middlewares/message-user-storage"
 import { UIActionsLogger } from "./middlewares/ui-actions-logger"
 import { redis } from "./redis"
 import { once } from "./utils/once"
@@ -87,7 +87,7 @@ bot.on("message", async (ctx, next) => {
 })
 
 bot.on("message", messageLink({ channelIds: [TEST_CHAT_ID] })) // now is configured a test group
-bot.on("message", MessageStorage.getInstance())
+bot.on("message", MessageUserStorage.getInstance())
 bot.on("message", checkUsername)
 // bot.on("message", async (ctx, next) => { console.log(ctx.message); return await next() })
 
@@ -120,7 +120,7 @@ const runner = run(bot, {
 
 const terminate = once(async (signal: NodeJS.Signals) => {
   logger.warn(`Received ${signal}, shutting down...`)
-  const p1 = MessageStorage.getInstance().sync()
+  const p1 = MessageUserStorage.getInstance().sync()
   const p2 = redis.quit()
   const p3 = runner.isRunning() && runner.stop()
   await Promise.all([p1, p2, p3])

src/bot.ts

@@ -35,12 +35,12 @@ export const _commandsBase = new ManagedCommands<Role>({
       }
     }
 
-    const { role } = await api.tg.permissions.getRole.query({ userId: ctx.from.id })
-    if (role === "user") return false // TODO: maybe we should do this differently
+    const { roles } = await api.tg.permissions.getRoles.query({ userId: ctx.from.id })
+    if (!roles) return false
 
-    const userRole = role as Role
-    if (allowedRoles && !allowedRoles.includes(userRole)) return false
-    if (excludedRoles?.includes(userRole)) return false
+    // blacklist is stronger than whitelist
+    if (allowedRoles?.every((r) => !roles.includes(r))) return false
+    if (excludedRoles?.some((r) => roles.includes(r))) return false
 
     return true
   },

src/commands/_base.ts

@@ -13,9 +13,9 @@ const numberOrString = z.string().transform((s) => {
 
 _commandsBase
   .createCommand({
-    trigger: "getrole",
+    trigger: "getroles",
     scope: "private",
-    description: "Get role of userid",
+    description: "Get roles of an user",
     args: [
       {
         key: "username",
@@ -33,24 +33,26 @@ _commandsBase
       }
 
       try {
-        const { role } = await api.tg.permissions.getRole.query({ userId })
-        await context.reply(fmt(({ b }) => [`Role:`, b`${role}`]))
+        const { roles } = await api.tg.permissions.getRoles.query({ userId })
+        await context.reply(
+          fmt(({ b }) => (roles?.length ? [`Roles:`, b`${roles.join(" ")}`] : "This user has no roles"))
+        )
       } catch (err) {
         await context.reply(`There was an error: \n${String(err)}`)
       }
     },
   })
   .createCommand({
-    trigger: "setrole",
+    trigger: "addrole",
     scope: "private",
-    description: "Set role of username",
+    description: "Add role to user",
     args: [
       {
         key: "username",
         type: numberOrString,
         description: "The username or the user id of the user you want to update the role",
       },
-      { key: "role", type: z.enum<Role[]>(["direttivo", "hr", "admin"]) },
+      { key: "role", type: z.enum<Role[]>(["owner", "president", "direttivo", "hr", "admin"]) },
     ],
     permissions: {
       allowedRoles: ["owner", "direttivo"],
@@ -65,16 +67,73 @@ _commandsBase
       }
 
       try {
-        const { role: prev } = await api.tg.permissions.getRole.query({ userId })
-        await api.tg.permissions.setRole.query({ userId, adderId: context.from.id, role: args.role })
+        const { roles, error } = await api.tg.permissions.addRole.mutate({
+          userId,
+          adderId: context.from.id,
+          role: args.role,
+        })
+
+        if (error) {
+          await context.reply(fmt(({ n }) => n`There was an error: ${error}`))
+          return
+        }
+
+        await context.reply(
+          fmt(
+            ({ b, n }) => [b`✅ Role added!`, n`${b`Username:`} ${args.username}`, n`${b`Updated roles:`} ${roles}`],
+            {
+              sep: "\n",
+            }
+          )
+        )
+        await context.deleteMessage()
+      } catch (err) {
+        await context.reply(`There was an error: \n${String(err)}`)
+      }
+    },
+  })
+  .createCommand({
+    trigger: "delrole",
+    scope: "private",
+    description: "Remove role from an user",
+    args: [
+      {
+        key: "username",
+        type: numberOrString,
+        description: "The username or the user id of the user you want to remove the role from",
+      },
+      { key: "role", type: z.enum<Role[]>(["owner", "president", "direttivo", "hr", "admin"]) },
+    ],
+    permissions: {
+      allowedRoles: ["owner", "direttivo"],
+    },
+    handler: async ({ context, args }) => {
+      const userId: number | null =
+        typeof args.username === "string" ? await getTelegramId(args.username.replaceAll("@", "")) : args.username
+
+      if (userId === null) {
+        await context.reply("Not a valid userId or username not in our cache")
+        return
+      }
+
+      try {
+        const { roles, error } = await api.tg.permissions.removeRole.mutate({
+          userId,
+          removerId: context.from.id,
+          role: args.role,
+        })
+
+        if (error) {
+          await context.reply(fmt(({ n }) => n`There was an error: ${error}`))
+          return
+        }
+
         await context.reply(
           fmt(
-            ({ b, n }) => [
-              b`✅ Role set!`,
-              n`${b`Username:`} ${args.username}`,
-              n`${b`Role:`} ${prev} -> ${args.role}`,
-            ],
-            { sep: "\n" }
+            ({ b, n }) => [b`✅ Role removed!`, n`${b`Username:`} ${args.username}`, n`${b`Updated roles:`} ${roles}`],
+            {
+              sep: "\n",
+            }
           )
         )
         await context.deleteMessage()

src/commands/role.ts

@@ -12,7 +12,7 @@ import { fmt, fmtUser } from "@/utils/format"
 import { createFakeMessage, getText } from "@/utils/messages"
 import type { Context } from "@/utils/types"
 import { wait } from "@/utils/wait"
-import { MessageStorage } from "../message-storage"
+import { MessageUserStorage } from "../message-user-storage"
 import { AIModeration } from "./ai-moderation"
 import { MULTI_CHAT_SPAM, NON_LATIN } from "./constants"
 import { checkForAllowedLinks } from "./functions"
@@ -206,7 +206,7 @@ export class AutoModerationStack<C extends Context> implements MiddlewareObj<C>
           .map(([hash, chatId, messageId]) => ({ hash, chatId: Number(chatId), messageId: Number(messageId) }))
           .filter((v) => ssdeep.similarity(v.hash, hash) > MULTI_CHAT_SPAM.SIMILARITY_THR)
           .map(async (v) => {
-            const msg = await MessageStorage.getInstance().get(v.chatId, v.messageId)
+            const msg = await MessageUserStorage.getInstance().get(v.chatId, v.messageId)
             const message = createFakeMessage(v.chatId, v.messageId, ctx.from, msg?.timestamp)
             return message
           })

src/middlewares/auto-moderation-stack/index.ts

@@ -5,7 +5,7 @@ import { logger } from "@/logger"
 import { padChatId } from "@/utils/chat"
 import { fmt, fmtChat } from "@/utils/format"
 import type { Context } from "@/utils/types"
-import { MessageStorage } from "./message-storage"
+import { MessageUserStorage } from "./message-user-storage"
 
 // --- Configuration ---
 const LINK_REGEX = /https?:\/\/t\.me\/c\/(-?\d+)\/(\d+)(?:\/(\d+))?/gi // Regex with global and case-insensitive flags
@@ -102,7 +102,7 @@ async function makeResponse(
   const inviteLink =
     chat.invite_link ?? (await api.tg.groups.getById.query({ telegramId: chat.id }))[0].link ?? undefined
 
-  const message = await MessageStorage.getInstance().get(chatId, messageId)
+  const message = await MessageUserStorage.getInstance().get(chatId, messageId)
   if (message === null) {
     return {
       message: fmt(

src/middlewares/message-link.ts

@@ -1,24 +1,26 @@
 import { Cron } from "croner"
 import { Composer, type Context, type MiddlewareObj } from "grammy"
-import { api } from "@/backend"
+import type { User } from "grammy/types"
+import { type ApiInput, api } from "@/backend"
 import { logger } from "@/logger"
 import { padChatId } from "@/utils/chat"
 
 export type Message = Parameters<typeof api.tg.messages.add.mutate>[0]["messages"][0]
+type DBUsers = ApiInput["tg"]["users"]["add"]["users"]
 
-export class MessageStorage<C extends Context> implements MiddlewareObj<C> {
-  private static instance: MessageStorage<Context> | null = null
-  static getInstance<C extends Context>(): MessageStorage<C> {
-    if (!MessageStorage.instance) {
-      MessageStorage.instance = new MessageStorage<Context>()
+export class MessageUserStorage<C extends Context> implements MiddlewareObj<C> {
+  private static instance: MessageUserStorage<Context> | null = null
+  static getInstance<C extends Context>(): MessageUserStorage<C> {
+    if (!MessageUserStorage.instance) {
+      MessageUserStorage.instance = new MessageUserStorage<Context>()
     }
-    return MessageStorage.instance as unknown as MessageStorage<C>
+    return MessageUserStorage.instance as unknown as MessageUserStorage<C>
   }
 
   private composer: Composer<C> = new Composer<C>()
-  private memoryStorage: Message[]
+  private memoryStorage: Message[] = []
+  private userStorage: Map<number, User> = new Map()
   private constructor() {
-    this.memoryStorage = []
     new Cron("0 */1 * * * *", () => this.sync())
 
     this.composer.on(["message:text", "message:caption"], (ctx, next) => {
@@ -36,6 +38,7 @@ export class MessageStorage<C extends Context> implements MiddlewareObj<C> {
         timestamp: new Date(ctx.message.date * 1000),
       })
 
+      this.userStorage.set(ctx.from.id, ctx.from)
       return next()
     })
   }
@@ -60,6 +63,10 @@ export class MessageStorage<C extends Context> implements MiddlewareObj<C> {
   }
 
   async sync(): Promise<void> {
+    await Promise.all([this.syncMessages(), this.syncUsers()])
+  }
+
+  private async syncMessages(): Promise<void> {
     if (this.memoryStorage.length === 0) return
     const { error } = await api.tg.messages.add.mutate({ messages: this.memoryStorage })
     if (error) {
@@ -73,6 +80,34 @@ export class MessageStorage<C extends Context> implements MiddlewareObj<C> {
     this.memoryStorage = []
   }
 
+  private async syncUsers(): Promise<void> {
+    if (this.userStorage.size === 0) return
+    const users: DBUsers = this.userStorage
+      .values()
+      .toArray()
+      .map((u) => ({
+        id: u.id,
+        firstName: u.first_name,
+        lastName: u.last_name,
+        username: u.username,
+        isBot: u.is_bot,
+        langCode: u.language_code,
+      }))
+
+    this.userStorage.clear()
+
+    const { error } = await api.tg.users.add.mutate({ users })
+    if (error === "ENCRYPT_ERROR") {
+      logger.error("userStorage: There was an error while encrypting users in the backend, users voided")
+      return
+    } else if (error === "INTERNAL_SERVER_ERROR") {
+      logger.error("userStorage: There was an UNEXPECTED error while saving users in backend, users voided")
+      return
+    }
+
+    logger.debug(`userStorage: ${users.length} users upserted in the database`)
+  }
+
   middleware() {
     return this.composer.middleware()
   }

src/middlewares/message-storage.ts src/middlewares/message-user-storage.tssrc/middlewares/message-storage.ts renamed to src/middlewares/message-user-storage.ts

@@ -15,4 +15,4 @@ export type ContextWith<P extends OptionalPropertyOf<TContext>> = Exclude<TConte
 export type MaybePromise<T> = T | Promise<T>
 
 export type Context = ManagedCommandsFlavor<TContext>
-export type Role = ApiInput["tg"]["permissions"]["setRole"]["role"]
+export type Role = ApiInput["tg"]["permissions"]["addRole"]["role"]