feat: fixing the pagination, token and token refresh and tests

Author: JoanVasquez

package-lock.json

@@ -26,6 +26,7 @@
     "@aws-sdk/client-ssm": "^3.759.0",
     "compression": "^1.8.0",
     "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
     "dotenv": "^16.4.7",
     "express": "^4.21.2",
     "express-rate-limit": "^7.5.0",
@@ -48,6 +49,7 @@
     "@eslint/js": "^9.22.0",
     "@types/compression": "^1.7.5",
     "@types/cookie-parser": "^1.4.8",
+    "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.14",
     "@types/jsonwebtoken": "^9.0.9",

package.json

@@ -358,15 +358,24 @@ describe('GenericRepository', () => {
       const entities = [testEntity, { ...testEntity, id: 2 }];
       mockRepository.findAndCount.mockResolvedValue([entities, 2]);
 
-      const skip = 0;
-      const take = 2;
-      const result = await testRepository.getEntitiesWithPagination(skip, take);
+      const page = 1;
+      const perPage = 2;
+      const expectedSkip = 0;
+      const expectedTake = 2;
+
+      const result = await testRepository.getEntitiesWithPagination(
+        page,
+        perPage,
+      );
 
       expect(result).toEqual({ data: entities, count: 2 });
-      expect(mockRepository.findAndCount).toHaveBeenCalledWith({ skip, take });
+      expect(mockRepository.findAndCount).toHaveBeenCalledWith({
+        skip: expectedSkip,
+        take: expectedTake,
+      });
       expect(logger.info).toHaveBeenCalledWith(
         expect.stringContaining(
-          `Retrieved ${entities.length} records (Page size: ${take})`,
+          `Retrieved ${entities.length} records (Page: ${page}, PerPage: ${perPage})`,
         ),
       );
     });

src/__tests__/repositories/GenericRepository.test.ts

@@ -219,12 +219,19 @@ describe('SellRepository', () => {
     it('should return paginated sell entities', async () => {
       mockRepository.findAndCount.mockResolvedValue([[testSell], 1]);
 
-      const result = await sellRepository.getEntitiesWithPagination(0, 10);
+      const page = 1;
+      const perPage = 10;
+      const expectedSkip = (page - 1) * perPage;
+
+      const result = await sellRepository.getEntitiesWithPagination(
+        page,
+        perPage,
+      );
 
       expect(result).toEqual({ data: [testSell], count: 1 });
       expect(mockRepository.findAndCount).toHaveBeenCalledWith({
-        skip: 0,
-        take: 10,
+        skip: expectedSkip,
+        take: perPage,
       });
     });
 

src/__tests__/repositories/SellRepository.test.ts

@@ -5,6 +5,7 @@ import {
   authenticate as cognitoAuthenticate,
   registerUser as cognitoRegisterUser,
   resendConfirmationCode as cognitoResendConfirmation,
+  refreshToken as cognitoRefreshToken,
 } from '../../utils/cognitoUtil';
 
 // Mock dependencies
@@ -21,7 +22,10 @@ describe('AuthenticationService', () => {
   const testUsername = 'testuser';
   const testPassword = 'TestPassword123!';
   const testEmail = 'test@example.com';
-  const testToken = 'mock-id-token';
+  const testToken = {
+    idToken: 'fake-jwt-token',
+    refreshToken: 'fake-refresh-token',
+  };
   const testConfirmationCode = '123456';
 
   beforeEach(() => {
@@ -78,7 +82,7 @@ describe('AuthenticationService', () => {
       );
 
       // Assert
-      expect(result).toBe(testToken);
+      expect(result).toStrictEqual(testToken);
       expect(cognitoAuthenticate).toHaveBeenCalledWith(
         testUsername,
         testPassword,
@@ -241,4 +245,31 @@ describe('AuthenticationService', () => {
       expect(logCalls.join(' ')).not.toContain(testPassword);
     });
   });
+  describe('refreshUserToken', () => {
+    const validRefreshToken = 'valid-refresh-token';
+
+    it('should refresh the token successfully', async () => {
+      (cognitoRefreshToken as jest.Mock).mockResolvedValue('new-id-token');
+
+      const result = await authService.refreshUserToken(validRefreshToken);
+
+      expect(result).toBe('new-id-token');
+      expect(cognitoRefreshToken).toHaveBeenCalledWith(validRefreshToken);
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Refreshing token for user with refresh token'),
+      );
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Token refreshed successfully'),
+      );
+    });
+
+    it('should throw error when refresh fails', async () => {
+      const error = new Error('Refresh failed');
+      (cognitoRefreshToken as jest.Mock).mockRejectedValue(error);
+
+      await expect(
+        authService.refreshUserToken(validRefreshToken),
+      ).rejects.toThrow('Refresh failed');
+    });
+  });
 });

src/__tests__/services/AuthenticationService.test.ts

@@ -257,7 +257,7 @@ describe('GenericService', () => {
         count: 2,
       });
 
-      const result = await testService.findWithPagination(0, 2);
+      const result = await testService.findPaginated(0, 2);
 
       expect(result).toEqual({ data: entities, count: 2 });
       expect(mockRepository.getEntitiesWithPagination).toHaveBeenCalledWith(
@@ -280,7 +280,7 @@ describe('GenericService', () => {
       const cacheKey = 'testentity:pagination:skip=0:take=2';
       mockCache.get.mockResolvedValue(JSON.stringify(paginatedResult));
 
-      const result = await testService.findWithPagination(0, 2);
+      const result = await testService.findPaginated(0, 2);
 
       expect(result).toEqual(paginatedResult);
       expect(mockRepository.getEntitiesWithPagination).not.toHaveBeenCalled();

src/__tests__/services/GenericService.test.ts

@@ -68,6 +68,7 @@ describe('UserService', () => {
       confirmUserRegistration: jest.fn(),
       resendConfirmationCode: jest.fn(),
       authenticateUser: jest.fn(),
+      refreshUserToken: jest.fn(),
     } as unknown as jest.Mocked<AuthenticationService>;
 
     // Mocked PasswordService
@@ -262,7 +263,11 @@ describe('UserService', () => {
   describe('authenticate', () => {
     it('should authenticate a user successfully (cache miss, DB hit)', async () => {
       // Arrange
-      mockAuthService.authenticateUser.mockResolvedValue('fake-jwt-token');
+      mockAuthService.authenticateUser.mockResolvedValue({
+        idToken: 'fake-jwt-token',
+        refreshToken: 'fake-refresh-token',
+      });
+
       // user not in cache
       mockCache.get.mockResolvedValue(null);
       // user found in DB
@@ -275,7 +280,11 @@ describe('UserService', () => {
       );
 
       // Assert
-      expect(result).toEqual({ token: 'fake-jwt-token' });
+      expect(result).toEqual({
+        token: 'fake-jwt-token',
+        refreshToken: 'fake-refresh-token',
+      });
+
       expect(mockAuthService.authenticateUser).toHaveBeenCalledWith(
         testUser.username,
         'some-password',
@@ -295,7 +304,11 @@ describe('UserService', () => {
     });
 
     it('should authenticate a user successfully (cache hit)', async () => {
-      mockAuthService.authenticateUser.mockResolvedValue('fake-jwt-token');
+      mockAuthService.authenticateUser.mockResolvedValue({
+        idToken: 'fake-jwt-token',
+        refreshToken: 'fake-refresh-token',
+      });
+
       // user found in cache
       mockCache.get.mockResolvedValue(JSON.stringify(testUser));
 
@@ -304,7 +317,11 @@ describe('UserService', () => {
         'some-password',
       );
 
-      expect(result).toEqual({ token: 'fake-jwt-token' });
+      expect(result).toEqual({
+        token: 'fake-jwt-token',
+        refreshToken: 'fake-refresh-token',
+      });
+
       expect(mockAuthService.authenticateUser).toHaveBeenCalledWith(
         testUser.username,
         'some-password',
@@ -316,7 +333,11 @@ describe('UserService', () => {
     });
 
     it('should throw NotFoundError if user not found in DB', async () => {
-      mockAuthService.authenticateUser.mockResolvedValue('fake-jwt-token');
+      mockAuthService.authenticateUser.mockResolvedValue({
+        idToken: 'fake-jwt-token',
+        refreshToken: 'fake-refresh-token',
+      });
+
       mockCache.get.mockResolvedValue(null);
       mockUserRepository.findUserByUsername.mockResolvedValue(null);
 
@@ -484,4 +505,28 @@ describe('UserService', () => {
       );
     });
   });
+  describe('refreshUserToken', () => {
+    it('should refresh the token successfully', async () => {
+      mockAuthService.refreshUserToken.mockResolvedValue('new-id-token');
+
+      const result = await userService.refreshUserToken('valid-refresh-token');
+
+      expect(result).toBe('new-id-token');
+      expect(mockAuthService.refreshUserToken).toHaveBeenCalledWith(
+        'valid-refresh-token',
+      );
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Token refreshed successfully'),
+      );
+    });
+
+    it('should propagate errors from authService', async () => {
+      const error = new Error('Refresh failed');
+      mockAuthService.refreshUserToken.mockRejectedValue(error);
+
+      await expect(
+        userService.refreshUserToken('invalid-token'),
+      ).rejects.toThrow(error);
+    });
+  });
 });