fix: Handle error messages in fastify onError and handleError hooks

Author: winverse

apps/server/src/common/plugins/global/errorHandlerPlugin.mts

@@ -1,66 +1,74 @@
 import { ENV } from '@env'
-import { isHttpError } from '@errors/HttpError.js'
-import { DiscordService } from '@lib/discord/DiscordService.js'
-import { FastifyPluginCallback } from 'fastify'
+import type { FastifyPluginCallback, FastifyRequest } from 'fastify'
 import { container } from 'tsyringe'
 import fp from 'fastify-plugin'
+import { isHttpError } from '@errors/HttpError.js'
+import {
+  DiscordService,
+  type MessagePayload,
+  type MessageType,
+} from '@lib/discord/DiscordService.js'
+import { DynamicConfigService } from '@services/DynamicConfigService/index.js'
+
+const errorHandlerPlugin: FastifyPluginCallback = fp(async (fastify) => {
+  const discord = container.resolve(DiscordService)
+  const dynamicConfig = container.resolve(DynamicConfigService)
 
-// TODO: apply fastify-plugin
-const errorHandlerPlugin: FastifyPluginCallback = (fastify, _, done) => {
-  fastify.addHook('preHandler', function (request, reply, done) {
+  fastify.addHook('preHandler', (request, _, done) => {
     if (request.body) {
       request.log.info({ body: request.body }, 'parsed body')
     }
     done()
   })
-  fastify.addHook('onError', (request, reply, error, done) => {
-    request.log.error(error, 'fastify onError')
-    const discord = container.resolve(DiscordService)
-    discord
-      .sendMessage('error', {
-        type: 'fastify OnError',
-        body: request?.body,
-        query: request?.query,
-        error,
-        user: request?.user,
-        ip: request?.ip,
+
+  const sendErrorToDiscord = async (
+    type: MessageType,
+    payload: MessagePayload,
+    request: FastifyRequest,
+  ) => {
+    const isBlocked = await dynamicConfig.isBlockedUser(request.user?.username)
+    if (isBlocked) {
+      fastify.log.info('Blocked user, skipping error message')
+      return
+    }
+
+    try {
+      await discord.sendMessage(type, {
+        ...payload,
+        body: payload.body ?? request.body ?? 'none',
+        query: payload.query ?? request.query ?? 'none',
+        user: request.user,
+        ip: request.ip,
       })
-      .catch(console.error)
-    done()
+    } catch (discordError) {
+      fastify.log.error(discordError, 'Failed to send error message to Discord')
+    }
+  }
+
+  fastify.addHook('onError', async (request, _, error) => {
+    request.log.error(error, 'fastify onError')
+    await sendErrorToDiscord('error', { type: 'fastify OnError', error }, request)
   })
-  fastify.setErrorHandler((error, request, reply) => {
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    const errorResponse = {
+      message: error.message || 'Internal Server Error',
+      name: error.name || 'Error',
+      stack: ENV.appEnv === 'development' ? error.stack : undefined,
+    }
+
     if (isHttpError(error)) {
-      reply.status(error.statusCode).send({
-        message: error.message,
-        name: error.name,
-        stack: ENV.appEnv === 'development' ? error.stack : undefined,
-      })
+      reply.status(error.statusCode).send(errorResponse)
     } else {
-      reply.status(500).send({
-        message: error.message || 'Internal Server Error',
-        name: error.name || 'Error',
-        stack: ENV.appEnv === 'development' ? error.stack : undefined,
-      })
+      reply.status(500).send(errorResponse)
     }
 
     if (ENV.appEnv === 'development') {
       request.log.error(error, 'fastify handleError')
     } else {
-      const discord = container.resolve(DiscordService)
-      discord
-        .sendMessage('error', {
-          type: 'fastify handleError',
-          body: request?.body,
-          query: request?.query,
-          error,
-          user: request?.user,
-          ip: request?.ip,
-        })
-        .catch(console.error)
+      await sendErrorToDiscord('error', { type: 'fastify handleError', error }, request)
     }
   })
+})
 
-  done()
-}
-
-export default fp(errorHandlerPlugin)
+export default errorHandlerPlugin

apps/server/src/lib/discord/DiscordService.ts

@@ -20,7 +20,6 @@ export class DiscordService {
         console.log('Discord Client ready')
         resolve(this.client)
       })
-
       this.client.login(ENV.discordBotToken)
     })
   }
@@ -101,8 +100,8 @@ export class DiscordService {
   }
 }
 
-type MessageType = 'error' | 'spam'
-type MessagePayload = {
+export type MessageType = 'error' | 'spam'
+export type MessagePayload = {
   type: string
   body?: any
   query?: any

apps/server/src/services/DynamicConfigService/index.ts

@@ -13,6 +13,17 @@ export class DynamicConfigService implements Service {
     const list = await this.readBlockUserList()
     return list.includes(username)
   }
+  public async isBlockedUserById(userId: string): Promise<boolean> {
+    const user = await this.db.user.findUnique({
+      where: {
+        id: userId,
+      },
+    })
+    if (!user) {
+      return false
+    }
+    return this.isBlockedUser(user.username)
+  }
   private async readBlockUserList(): Promise<string[]> {
     const list = await this.db.dynamicConfigItem.findMany({
       where: {