feat: retornar 404 quando não encontrar o usuario

Author: gabrnunes

src/controllers/user.ts

@@ -1,12 +1,18 @@
 import { Body, Controller, Get, Post, Response, Route, Security } from 'tsoa'
 import { getRankService } from '../services/rank'
-import { checkForSuspiciousActivity, getDatabaseUserById, getDatabaseUsers, softDeleteUserById } from '../services/user'
+import {
+  checkForSuspiciousActivity,
+  getDatabaseUserById,
+  getDatabaseUsers,
+  softDeleteUserById
+} from '../services/user'
 import {
   ErrorResponseModel,
   RankRequestResult,
   RequestResult,
   SoftDeleteResult,
-  User
+  User,
+  UserResponse
 } from '../types'
 
 @Route('/user')
@@ -36,12 +42,34 @@ export class UserController extends Controller {
   })
   @Security('api_key')
   @Get('{userId}')
-  public async getUser(userId: string): Promise<User> {
+  public async getUser(userId: string): Promise<UserResponse> {
     try {
       const user = await getDatabaseUserById(userId)
-      return user
+
+      if (!user) {
+        this.setStatus(404)
+        return {
+          success: false,
+          message: 'User not found',
+          statusCode: 404
+        }
+      }
+
+      return {
+        success: true,
+        message: 'User found',
+        statusCode: 200,
+        user
+      }
     } catch (error) {
+      this.setStatus(500)
       console.log(error)
+
+      return {
+        success: false,
+        statusCode: 500,
+        message: 'An error occurred while searching the user'
+      }
     }
   }
 
@@ -68,14 +96,19 @@ export class UserController extends Controller {
   })
   @Security('api_key')
   @Post('/susp/softdelete')
-  public async softDeleteUser(@Body() body: { userId: string }): Promise<SoftDeleteResult> {
+  public async softDeleteUser(
+    @Body() body: { userId: string }
+  ): Promise<SoftDeleteResult> {
     try {
       const { userId } = body
       const result = await softDeleteUserById(userId)
       return result
     } catch (error) {
       console.log(error)
-      return { success: false, message: 'An error occurred while soft deleting the user' }
+      return {
+        success: false,
+        message: 'An error occurred while soft deleting the user'
+      }
     }
   }
 }

src/routes/user.ts

@@ -27,7 +27,7 @@ router.get(
       const { userId } = request?.params
       const controller = new UserController()
       const user = await controller.getUser(userId)
-      return response.send(user)
+      return response.status(user.statusCode || 200).send(user)
     } catch (error) {
       next(error)
     }

src/services/user.ts

@@ -48,45 +48,54 @@ export async function getDatabaseUsers(): Promise<User[]> {
 export async function checkForSuspiciousActivity(): Promise<any[]> {
   try {
     const users = await getUsersFromMongo({ softDeleted: { $ne: true } })
-    const suspiciousUsers = users.filter(user => {
-      if (user.tokens.length < 10) return false
+    const suspiciousUsers = users
+      .filter((user) => {
+        if (user.tokens.length < 10) return false
 
-      const sortedTokens = user.tokens.sort((a, b) =>
-        DateTime.fromISO(b.claimedAt).toMillis() - DateTime.fromISO(a.claimedAt).toMillis()
-      )
+        const sortedTokens = user.tokens.sort(
+          (a, b) =>
+            DateTime.fromISO(b.claimedAt).toMillis() -
+            DateTime.fromISO(a.claimedAt).toMillis()
+        )
 
-      let consecutiveQuickClaims = 0
-      let suspiciousTokens = []
-      for (let i = 1; i < sortedTokens.length; i++) {
-        const timeDiff = DateTime.fromISO(sortedTokens[i - 1].claimedAt).diff(
-          DateTime.fromISO(sortedTokens[i].claimedAt), 'seconds'
-        ).seconds
+        let consecutiveQuickClaims = 0
+        let suspiciousTokens = []
+        for (let i = 1; i < sortedTokens.length; i++) {
+          const timeDiff = DateTime.fromISO(sortedTokens[i - 1].claimedAt).diff(
+            DateTime.fromISO(sortedTokens[i].claimedAt),
+            'seconds'
+          ).seconds
 
-        if (timeDiff < 5) {
-          consecutiveQuickClaims++
-          suspiciousTokens.push(sortedTokens[i])
-          if (consecutiveQuickClaims >= 9) {
-            suspiciousTokens.push(sortedTokens[i - 1]) // Add the 10th token
-            return true
+          if (timeDiff < 5) {
+            consecutiveQuickClaims++
+            suspiciousTokens.push(sortedTokens[i])
+            if (consecutiveQuickClaims >= 9) {
+              suspiciousTokens.push(sortedTokens[i - 1]) // Add the 10th token
+              return true
+            }
+          } else {
+            consecutiveQuickClaims = 0
+            suspiciousTokens = []
           }
-        } else {
-          consecutiveQuickClaims = 0
-          suspiciousTokens = []
         }
-      }
 
-      return false
-    }).map(user => ({
-      userId: user.userId,
-      score: user.score,
-      suspiciousTokens: user.tokens
-        .sort((a, b) => DateTime.fromISO(b.claimedAt).toMillis() - DateTime.fromISO(a.claimedAt).toMillis())
-        .slice(0, 10)
-        .map(token => ({
-          code: token.code,
-          claimedAt: token.claimedAt
-        }))
-    }))
+        return false
+      })
+      .map((user) => ({
+        userId: user.userId,
+        score: user.score,
+        suspiciousTokens: user.tokens
+          .sort(
+            (a, b) =>
+              DateTime.fromISO(b.claimedAt).toMillis() -
+              DateTime.fromISO(a.claimedAt).toMillis()
+          )
+          .slice(0, 10)
+          .map((token) => ({
+            code: token.code,
+            claimedAt: token.claimedAt
+          }))
+      }))
 
     return suspiciousUsers
   } catch (error) {
@@ -95,15 +104,24 @@ export async function checkForSuspiciousActivity(): Promise<any[]> {
   }
 }
 
-export async function softDeleteUserById(userId: string): Promise<SoftDeleteResult> {
+export async function softDeleteUserById(
+  userId: string
+): Promise<SoftDeleteResult> {
   try {
     const user = await softDeleteUser(userId)
     if (!user) {
       return { success: false, message: `User ${userId} not found` }
     }
-    return { success: true, message: `User ${userId} has been soft deleted`, user }
+    return {
+      success: true,
+      message: `User ${userId} has been soft deleted`,
+      user
+    }
   } catch (error) {
     console.log(`Error soft deleting user ${userId}:`, error)
-    return { success: false, message: 'An error occurred while soft deleting the user' }
+    return {
+      success: false,
+      message: 'An error occurred while soft deleting the user'
+    }
   }
 }

src/types.ts

@@ -122,3 +122,10 @@ export interface SoftDeleteResult {
   message: string
   user?: User
 }
+
+export interface UserResponse {
+  success: boolean
+  message: string
+  statusCode?: number
+  user?: User
+}