Fixed server crash bug when tokens not found in db

src/auth/strategies/at.strategy.ts

@@ -4,6 +4,7 @@ import { Request } from "express";
 import { Injectable, Inject } from "@nestjs/common";
 import { UsersService } from "../../users/users.service";
 import { AuthConfig } from "../../config/auth/auth.interface";
+import { UserReq } from "@/global/types/CustomRequest";
 
 @Injectable()
 export class AtStrategy extends PassportStrategy(Strategy, "jwt-at") {
@@ -33,21 +34,25 @@ export class AtStrategy extends PassportStrategy(Strategy, "jwt-at") {
         return null;
     }
 
-    async validate(payload: any) {
-        const userInDb = await this.usersService.getUserRolesById(payload.sub);
+    async validate(payload: any): Promise<UserReq | undefined> {
+        //Get user roles
+        const userRoles = await this.usersService.getUserRolesById(payload.sub);
 
         // Note: Update global/types/CustomRequest when updating this
-        return {
-            userId: payload.sub,
-            email: payload.email,
-            roles: userInDb.roles,
-            isVerified: userInDb.emailVerified,
-            voyageTeams: userInDb.voyageTeamMembers?.map((t) => {
-                return {
-                    teamId: t.voyageTeamId,
-                    memberId: t.id,
-                };
-            }),
-        };
+        //Check if userRoles actually returns user details before returning
+        if (userRoles) {
+            return {
+                userId: payload.sub,
+                email: payload.email,
+                roles: userRoles.roles,
+                isVerified: userRoles.emailVerified,
+                voyageTeams: userRoles.voyageTeamMembers?.map((t) => {
+                    return {
+                        teamId: t.voyageTeamId,
+                        memberId: t.id,
+                    };
+                }),
+            };
+        }
     }
 }

src/users/users.service.spec.ts

@@ -99,7 +99,7 @@ describe("UsersService", () => {
         it("should be defined", () => {
             expect(usersService.getUserRolesById).toBeDefined();
         });
-        it("should return user roles by id", async () => {
+        it("should return user roles by id when user exists", async () => {
             const userWithRoles = {
                 ...userOne,
                 roles: [{ role: { name: "admin" } }],
@@ -119,6 +119,23 @@ describe("UsersService", () => {
                 },
             });
         });
+        it("should return undefined if userId does not exist", async () => {
+            prismaMock.user.findUnique.mockResolvedValue(null);
+            const result =
+                await usersService.getUserRolesById("inexistentUserId");
+            expect(result).toBeUndefined();
+            expect(formatUserSpy).not.toHaveBeenCalledWith();
+            expect(prismaMock.user.findUnique).toHaveBeenCalledWith({
+                where: { id: "inexistentUserId" },
+                select: {
+                    roles: { select: { role: { select: { name: true } } } },
+                    voyageTeamMembers: {
+                        select: { id: true, voyageTeamId: true },
+                    },
+                    emailVerified: true,
+                },
+            });
+        });
     });
     describe("findAll", () => {
         it("should be defined", () => {

src/users/users.service.ts

@@ -34,31 +34,33 @@ export class UsersService {
     }
 
     async getUserRolesById(userId: string) {
-        return this.formatUser(
-            await this.prisma.user.findUnique({
-                where: {
-                    id: userId,
-                },
-                select: {
-                    roles: {
-                        select: {
-                            role: {
-                                select: {
-                                    name: true,
-                                },
+        //Return user roles only when userDd actually exists
+        const user = await this.prisma.user.findUnique({
+            where: {
+                id: userId,
+            },
+            select: {
+                roles: {
+                    select: {
+                        role: {
+                            select: {
+                                name: true,
                             },
                         },
                     },
-                    voyageTeamMembers: {
-                        select: {
-                            id: true,
-                            voyageTeamId: true,
-                        },
+                },
+                voyageTeamMembers: {
+                    select: {
+                        id: true,
+                        voyageTeamId: true,
                     },
-                    emailVerified: true,
                 },
-            }),
-        );
+                emailVerified: true,
+            },
+        });
+        if (user) {
+            return this.formatUser(user);
+        }
     }
 
     async findAll() {