nodejs-quickstart-structure 1.18.0 → 1.19.0

package/templates/clean-architecture/js/src/usecases/DeleteUser.spec.js.ejs

@@ -0,0 +1,47 @@
+const DeleteUser = require('@/usecases/DeleteUser');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('DeleteUser UseCase', () => {
+    let deleteUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        deleteUser = new DeleteUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should delete and return the user', async () => {
+        const id = 1;
+        const expectedResult = { id, name: 'Deleted User', email: 'test@test.com' };
+
+        mockUserRepository.delete.mockResolvedValue(expectedResult);
+
+        const result = await deleteUser.execute(id);
+
+        expect(mockUserRepository.delete).toHaveBeenCalledWith(id);
+        expect(result).toEqual(expectedResult);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } %>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.delete.mockRejectedValue(error);
+
+        await expect(deleteUser.execute(1)).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/js/src/usecases/UpdateUser.js

@@ -0,0 +1,11 @@
+class UpdateUser {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(id, data) {
+    return this.userRepository.update(id, data);
+  }
+}
+
+module.exports = UpdateUser;

package/templates/clean-architecture/js/src/usecases/UpdateUser.spec.js.ejs

@@ -0,0 +1,48 @@
+const UpdateUser = require('@/usecases/UpdateUser');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('UpdateUser UseCase', () => {
+    let updateUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        updateUser = new UpdateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should update and return the user', async () => {
+        const id = 1;
+        const data = { name: 'Updated Name' };
+        const expectedUser = { id, name: 'Updated Name', email: 'test@test.com' };
+
+        mockUserRepository.update.mockResolvedValue(expectedUser);
+
+        const result = await updateUser.execute(id, data);
+
+        expect(mockUserRepository.update).toHaveBeenCalledWith(id, data);
+        expect(result).toEqual(expectedUser);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } %>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.update.mockRejectedValue(error);
+
+        await expect(updateUser.execute(1, { name: 'Test' })).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/js/src/utils/errorMessages.js

@@ -0,0 +1,14 @@
+const ERROR_MESSAGES = {
+    USER_NOT_FOUND: 'User not found',
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    INVALID_USER_DATA: 'Invalid user event data',
+    INTERNAL_SERVER_ERROR: 'Internal Server Error',
+    BAD_REQUEST: 'Bad Request',
+    FETCH_USERS_ERROR: 'Error fetching users',
+    CREATE_USER_ERROR: 'Error creating user',
+    UPDATE_USER_ERROR: 'Error updating user',
+    DELETE_USER_ERROR: 'Error deleting user',
+    DATABASE_PING_FAILED: 'Health Check Database Ping Failed',
+};
+
+module.exports = ERROR_MESSAGES;

package/templates/clean-architecture/ts/src/errors/BadRequestError.spec.ts.ejs

@@ -1,21 +1,22 @@
-import { BadRequestError } from '@/errors/BadRequestError';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-describe('BadRequestError', () => {
-    it('should extend ApiError', () => {
-        const error = new BadRequestError();
-        expect(error).toBeInstanceOf(ApiError);
-    });
-
-    it('should have default message "Bad request"', () => {
-        const error = new BadRequestError();
-        expect(error.message).toBe('Bad request');
-        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
-    });
-
-    it('should accept a custom message', () => {
-        const error = new BadRequestError('Custom bad request');
-        expect(error.message).toBe('Custom bad request');
-    });
-});
+import { BadRequestError } from '@/errors/BadRequestError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad Request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe(ERROR_MESSAGES.BAD_REQUEST);
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/clean-architecture/ts/src/errors/BadRequestError.ts

@@ -1,8 +1,9 @@
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export class BadRequestError extends ApiError {
-  constructor(message = 'Bad request') {
-    super(HTTP_STATUS.BAD_REQUEST, message);
-  }
-}
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+export class BadRequestError extends ApiError {
+  constructor(message: string = ERROR_MESSAGES.BAD_REQUEST) {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}

package/templates/clean-architecture/ts/src/errors/NotFoundError.spec.ts.ejs

@@ -1,21 +1,22 @@
-import { NotFoundError } from '@/errors/NotFoundError';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-describe('NotFoundError', () => {
-    it('should extend ApiError', () => {
-        const error = new NotFoundError();
-        expect(error).toBeInstanceOf(ApiError);
-    });
-
-    it('should have default message "Resource not found"', () => {
-        const error = new NotFoundError();
-        expect(error.message).toBe('Resource not found');
-        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
-    });
-
-    it('should accept a custom message', () => {
-        const error = new NotFoundError('User not found');
-        expect(error.message).toBe('User not found');
-    });
-});
+import { NotFoundError } from '@/errors/NotFoundError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe(ERROR_MESSAGES.RESOURCE_NOT_FOUND);
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError(ERROR_MESSAGES.USER_NOT_FOUND);
+        expect(error.message).toBe(ERROR_MESSAGES.USER_NOT_FOUND);
+    });
+});

package/templates/clean-architecture/ts/src/errors/NotFoundError.ts

@@ -1,8 +1,9 @@
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export class NotFoundError extends ApiError {
-  constructor(message = 'Resource not found') {
-    super(HTTP_STATUS.NOT_FOUND, message);
-  }
-}
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+
+export class NotFoundError extends ApiError {
+  constructor(message: string = ERROR_MESSAGES.RESOURCE_NOT_FOUND) {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}

package/templates/clean-architecture/ts/src/index.ts.ejs

@@ -16,7 +16,7 @@ import swaggerSpecs from '@/config/swagger';<% } %>
 <%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 import { ApolloServer } from '@apollo/server';
-import { expressMiddleware } from '@apollo/server/express4';
+import { expressMiddleware } from '@as-integrations/express4';
 import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
 import { unwrapResolverError } from '@apollo/server/errors';
 import { ApiError } from '@/errors/ApiError';

package/templates/clean-architecture/ts/src/infrastructure/repositories/UserRepository.spec.ts.ejs

@@ -1,85 +1,175 @@
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-import UserModel from '@/infrastructure/database/models/User';
-
-// Mock DB Model Database Layer
-jest.mock('@/infrastructure/database/models/User');
-
-describe('UserRepository', () => {
-    let userRepository: UserRepository;
-
-    beforeEach(() => {
-        userRepository = new UserRepository();
-        jest.clearAllMocks();
-    });
-
-    describe('save', () => {
-        it('should save and return a newly created user (Happy Path)', async () => {
-            // Arrange
-            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
-<%_ if (database === 'MongoDB') { -%>
-            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
-            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } else if (database === 'None') { -%>
-            (UserModel.create as jest.Mock).mockResolvedValue(payload);
-<%_ } else { -%>
-            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
-            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } -%>
-
-            // Act
-            const result = await userRepository.save(payload);
-
-            // Assert
-<%_ if (database === 'None') { -%>
-            expect(result.name).toEqual(payload.name)
-<%_ } else { -%>
-            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
-            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
-<%_ } -%>
-        });
-
-        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
-<%_ if (database === 'None') { -%>
-            // Mocks do not naturally fail 
-<%_ } else { -%>
-            // Arrange
-            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
-            const error = new Error('DB Connection Refused');
-            (UserModel.create as jest.Mock).mockRejectedValue(error);
-
-            // Act & Assert
-            await expect(userRepository.save(payload)).rejects.toThrow(error);
-<%_ } -%>
-        });
-    });
-
-    describe('getUsers', () => {
-        it('should return a list of mapped UserEntities (Happy Path)', async () => {
-            // Arrange
-<%_ if (database === 'MongoDB') { -%>
-            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
-            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
-<%_ } else if (database === 'None') { -%>
-            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
-            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
-<%_ } else { -%>
-            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
-            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
-<%_ } -%>
-
-            // Act
-            const result = await userRepository.getUsers();
-
-            // Assert
-            expect(result).toHaveLength(1);
-            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
-<%_ if (database !== 'None') { -%>
-<%_ if (database === 'MongoDB') { -%>
-            expect(UserModel.find).toHaveBeenCalled();
-<%_ } else { -%>
-            expect(UserModel.findAll).toHaveBeenCalled();
-<%_ } -%>
-<%_ } -%>
-        });
-    });
-});
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import UserModel from '@/infrastructure/database/models/User';
+
+// Mock DB Model Database Layer
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository: UserRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            // Arrange
+            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.create as jest.Mock).mockResolvedValue(payload);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.save(payload);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(payload.name)
+<%_ } else { -%>
+            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
+            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // Mocks do not naturally fail 
+<%_ } else { -%>
+            // Arrange
+            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
+            const error = new Error('DB Connection Refused');
+            (UserModel.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+            await expect(userRepository.save(payload)).rejects.toThrow(error);
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+            // Arrange
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } else if (database === 'None') { -%>
+            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
+<%_ } else { -%>
+            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.getUsers();
+
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.find).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+    });
+
+    describe('update', () => {
+        it('should update and return the user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+            const data = { name: 'Updated' };
+            const expectedUser = { id: '1', name: 'Updated', email: 'test@example.com' };
+
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'Updated', email: 'test@example.com' };
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'Updated', email: 'test@example.com', update: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, data);
+
+            // Assert
+            expect(result?.name).toEqual(data.name);
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.findByIdAndUpdate).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findByPk).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+
+        it('should return null when user not found (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, { name: 'Fail' });
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(true);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', destroy: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(true);
+        });
+
+        it('should return false when user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(false);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+});

package/templates/clean-architecture/ts/src/infrastructure/repositories/userRepository.ts.ejs

@@ -0,0 +1,74 @@
+import { User as UserEntity } from '@/domain/user';
+import UserModel from '@/infrastructure/database/models/User';
+
+export class UserRepository {
+    async save(user: UserEntity): Promise<UserEntity> {
+<%_ if (database === 'MongoDB') { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
+<%_ } else if (database === 'None') { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<%_ } else { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<%_ } -%>
+    }
+
+    async getUsers(): Promise<UserEntity[]> {
+<%_ if (database === 'MongoDB') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user._id.toString(),
+            name: user.name,
+            email: user.email
+        }));
+<%_ } else if (database === 'None') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email
+        }));
+<%_ } else { -%>
+        const users = await UserModel.findAll();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email
+        }));
+<%_ } -%>
+    }
+
+    async update(id: number | string, data: Partial<UserEntity>): Promise<UserEntity | null> {
+<%_ if (database === 'MongoDB') { -%>
+        const user = await UserModel.findByIdAndUpdate(id, data, { new: true });
+        if (!user) return null;
+        return { id: user._id.toString(), name: user.name, email: user.email };
+<%_ } else if (database === 'None') { -%>
+        const { id: _, ...updateData } = data;
+        const user = await UserModel.update(id, updateData as Parameters<typeof UserModel.update>[1]);
+        if (!user) return null;
+        return { id: user.id, name: user.name, email: user.email };
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return null;
+        await user.update(data);
+        return { id: user.id || 0, name: user.name, email: user.email };
+<%_ } -%>
+    }
+
+    async delete(id: number | string): Promise<boolean> {
+<%_ if (database === 'MongoDB') { -%>
+        const result = await UserModel.findByIdAndDelete(id);
+        return !!result;
+<%_ } else if (database === 'None') { -%>
+        return await UserModel.destroy(id);
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return false;
+        await user.destroy();
+        return true;
+<%_ } -%>
+    }
+}