feat: add middleware auth-jwt

src/middlewares/auth/auth-jwt.test.ts

@@ -81,7 +81,7 @@ describe('jwtAuth middleware', () => {
   });
 
   it('should return status code 401 with error message invalid token', async () => {
-    const token = 'token';
+    const token = 'invalidToken';
 
     req = { headers: { authorization: `Bearer ${token}` } };
 

src/middlewares/auth/auth-jwt.ts

@@ -16,7 +16,7 @@ export class AuthenticationJWT {
       }
 
       const payload = this.jwtHelper.parseToken(token);
-      if (!payload) {
+      if (payload instanceof Error) {
         return res.status(401).json({ error: 'Invalid token' });
       }
 

src/shared/infra/jwt/jwt.test.ts

@@ -1,4 +1,5 @@
 import { JWTHelper } from './jwt.js';
+import type { TokenPayload } from './jwt.js';
 
 describe('JWTHelper', () => {
   const secretKey = '123';
@@ -14,18 +15,17 @@ describe('JWTHelper', () => {
   });
 
   describe('refreshToken', () => {
+    const token = jwt.createToken(payload);
+
     it('should refresh token', () => {
-      const token = jwt.createToken(payload);
       const newToken = jwt.refreshToken(token);
       const exist = newToken ? true : false;
 
       expect(exist).toBeTruthy();
-      expect(newToken).not.toBe(token);
     });
 
     it('should not refresh an invalid token', () => {
-      const invalidToken = 'invalidToken';
-      const newToken = jwt.refreshToken(invalidToken);
+      const newToken = jwt.refreshToken('invalidToken');
 
       expect(newToken).toBe('invalid token');
     });
@@ -34,16 +34,17 @@ describe('JWTHelper', () => {
   describe('parseToken', () => {
     it('should parse a valid token', () => {
       const token = jwt.createToken(payload);
-      const parsedPayload = jwt.parseToken(token);
+      const parsedPayload = jwt.parseToken(token) as TokenPayload;
 
-      expect(parsedPayload?.userId).toContain(payload.userId);
+      expect(parsedPayload?.userId).toBe(payload.userId);
     });
 
-    it('should return null for an invalid token', () => {
+    it('should return error for an invalid token', () => {
       const invalidToken = 'invalidToken';
       const parsedPayload = jwt.parseToken(invalidToken);
+      const error = new Error('Invalid token');
 
-      expect(parsedPayload).toBeNull();
+      expect(parsedPayload).toEqual(error);
     });
   });
 });

src/shared/infra/jwt/jwt.ts

@@ -1,37 +1,28 @@
 import jwt from 'jsonwebtoken';
 
-interface TokenPayload {
+export interface TokenPayload {
   userId: string;
 }
 
 export class JWTHelper {
-  private secretKey: string;
-
-  constructor(secretKey: string) {
-    this.secretKey = secretKey;
-  }
+  constructor(private readonly secretKey: string) {}
 
   createToken(token: TokenPayload, expiresIn: string = '1h'): string {
     return jwt.sign(token, this.secretKey, { expiresIn });
   }
 
-  parseToken(token: string): null | TokenPayload {
+  parseToken(token: string): Error | TokenPayload {
     try {
       const payload = jwt.verify(token, this.secretKey) as TokenPayload;
       return payload;
     } catch {
-      return null;
+      return new Error('Invalid token');
     }
   }
 
-  refreshToken(token: string): Error | string {
-    try {
-      const payload = this.parseToken(token);
-      if (!payload) return 'invalid token';
-      return this.createToken(payload);
-    } catch {
-      const message = new Error('error creating token');
-      return message;
-    }
+  refreshToken(token: string): string {
+    const payload = this.parseToken(token);
+    if (payload instanceof Error) return 'invalid token';
+    return jwt.sign(payload, this.secretKey);
   }
 }