nodejs-quickstart-structure 1.18.1 → 1.19.0

package/templates/clean-architecture/js/src/interfaces/controllers/userController.spec.js.ejs

@@ -1,138 +1,234 @@
-const UserController = require('@/interfaces/controllers/userController');
-const CreateUser = require('@/usecases/CreateUser');
-const GetAllUsers = require('@/usecases/GetAllUsers');
-
-jest.mock('@/usecases/CreateUser');
-jest.mock('@/usecases/GetAllUsers');
-<%_ if (communication === 'Kafka') { -%>
-jest.mock('@/infrastructure/messaging/kafkaClient', () => ({
-    sendMessage: jest.fn().mockResolvedValue(undefined)
-}));
-<%_ } -%>
-
-
-describe('UserController (Clean Architecture)', () => {
-    let userController;
-    let mockCreateUserUseCase;
-    let mockGetAllUsersUseCase;
-<%_ if (communication !== 'GraphQL') { -%>
-    let mockRequest;
-    let mockResponse;
-    let mockNext;
-<%_ } -%>
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        userController = new UserController();
-
-        // Retrieve the mocked instances created inside UserController constructor
-        mockCreateUserUseCase = CreateUser.mock.instances[0];
-        mockGetAllUsersUseCase = GetAllUsers.mock.instances[0];
-
-<%_ if (communication !== 'GraphQL') { -%>
-        mockRequest = {
-            body: {}
-        };
-        mockResponse = {
-            status: jest.fn().mockReturnThis(),
-            json: jest.fn()
-        };
-        mockNext = jest.fn();
-<%_ } -%>
-    });
-
-    describe('getUsers', () => {
-        it('should return successfully (Happy Path)', async () => {
-            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
-            mockGetAllUsersUseCase.execute.mockResolvedValue(usersMock);
-
-<%_ if (communication === 'GraphQL') { -%>
-            const result = await userController.getUsers();
-            expect(result).toEqual(usersMock);
-<%_ } else { -%>
-            await userController.getUsers(mockRequest, mockResponse, mockNext);
-            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
-<%_ } -%>
-            expect(mockGetAllUsersUseCase.execute).toHaveBeenCalled();
-        });
-
-        it('should handle errors correctly (Error Handling)', async () => {
-            const error = new Error('UseCase Error');
-            mockGetAllUsersUseCase.execute.mockRejectedValue(error);
-
-<%_ if (communication === 'GraphQL') { -%>
-            await expect(userController.getUsers()).rejects.toThrow(error);
-<%_ } else { -%>
-            await userController.getUsers(mockRequest, mockResponse, mockNext);
-            expect(mockNext).toHaveBeenCalledWith(error);
-<%_ } -%>
-        });
-    });
-
-    describe('createUser', () => {
-        it('should successfully create a new user (Happy Path)', async () => {
-            const payload = { name: 'Alice', email: 'alice@example.com' };
-<%_ if (communication === 'GraphQL') { -%>
-            const dataArg = payload;
-<%_ } else { -%>
-            mockRequest.body = payload;
-<%_ } -%>
-            const expectedUser = { id: '1', ...payload };
-            
-            mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
-
-<%_ if (communication === 'GraphQL') { -%>
-            const result = await userController.createUser(dataArg);
-            expect(result).toEqual(expectedUser);
-<%_ } else { -%>
-            await userController.createUser(mockRequest, mockResponse, mockNext);
-<%_ if (communication === 'Kafka') { -%>
-            const { sendMessage } = require('@/infrastructure/messaging/kafkaClient');
-            expect(sendMessage).toHaveBeenCalled();
-<%_ } -%>
-            expect(mockResponse.status).toHaveBeenCalledWith(201);
-
-            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
-<%_ } -%>
-            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
-        });
-
-        it('should handle errors when creation fails (Error Handling)', async () => {
-            const error = new Error('Creation Error');
-            mockCreateUserUseCase.execute.mockRejectedValue(error);
-
-<%_ if (communication === 'GraphQL') { -%>
-            await expect(userController.createUser({ name: 'Bob', email: 'bob@example.com' })).rejects.toThrow(error);
-<%_ } else { -%>
-            await userController.createUser(mockRequest, mockResponse, mockNext);
-            expect(mockNext).toHaveBeenCalledWith(error);
-<%_ } -%>
-        });
-
-<%_ if (communication === 'Kafka') { -%>
-        it('should successfully create a new user with _id for Kafka (Happy Path)', async () => {
-            const payload = { name: 'Bob', email: 'bob@example.com' };
-<% if (communication === 'GraphQL') { -%>
-            const dataArg = payload;
-<% } else { -%>
-            mockRequest.body = payload;
-<% } -%>
-            const expectedUser = { _id: '2', ...payload };
-            
-            mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
-
-<% if (communication === 'GraphQL') { -%>
-            await userController.createUser(dataArg);
-<% } else { -%>
-            await userController.createUser(mockRequest, mockResponse, mockNext);
-<% } -%>
-            const { sendMessage } = require('@/infrastructure/messaging/kafkaClient');
-            expect(sendMessage).toHaveBeenCalledWith(
-                'user-topic',
-                expect.stringContaining('"id":"2"')
-            );
-        });
-<%_ } -%>
-    });
-});
+const UserController = require('@/interfaces/controllers/userController');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+const CreateUser = require('@/usecases/CreateUser');
+const GetAllUsers = require('@/usecases/GetAllUsers');
+const UpdateUser = require('@/usecases/UpdateUser');
+const DeleteUser = require('@/usecases/DeleteUser');
+
+jest.mock('@/usecases/CreateUser');
+jest.mock('@/usecases/GetAllUsers');
+jest.mock('@/usecases/UpdateUser');
+jest.mock('@/usecases/DeleteUser');
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('@/infrastructure/messaging/kafkaClient', () => ({
+    sendMessage: jest.fn().mockResolvedValue(undefined)
+}));
+<%_ } -%>
+
+
+describe('UserController (Clean Architecture)', () => {
+    let userController;
+    let mockCreateUserUseCase;
+    let mockGetAllUsersUseCase;
+    let mockUpdateUserUseCase;
+    let mockDeleteUserUseCase;
+<%_ if (communication !== 'GraphQL') { -%>
+    let mockRequest;
+    let mockResponse;
+    let mockNext;
+<%_ } -%>
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+
+        userController = new UserController();
+
+        // Retrieve the mocked instances created inside UserController constructor
+        mockCreateUserUseCase = CreateUser.mock.instances[0];
+        mockGetAllUsersUseCase = GetAllUsers.mock.instances[0];
+        mockUpdateUserUseCase = UpdateUser.mock.instances[0];
+        mockDeleteUserUseCase = DeleteUser.mock.instances[0];
+
+<%_ if (communication !== 'GraphQL') { -%>
+        mockRequest = {
+            body: {},
+            params: {}
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        mockNext = jest.fn();
+<%_ } -%>
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+            mockGetAllUsersUseCase.execute.mockResolvedValue(usersMock);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.getUsers();
+            expect(result).toEqual(usersMock);
+<%_ } else { -%>
+            await userController.getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<%_ } -%>
+            expect(mockGetAllUsersUseCase.execute).toHaveBeenCalled();
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            const error = new Error('UseCase Error');
+            mockGetAllUsersUseCase.execute.mockRejectedValue(error);
+
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.getUsers()).rejects.toThrow(error);
+<%_ } else { -%>
+            await userController.getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<%_ if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<%_ } else { -%>
+            mockRequest.body = payload;
+<%_ } -%>
+            const expectedUser = { id: '1', ...payload };
+            
+            mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.createUser(dataArg);
+            expect(result).toEqual(expectedUser);
+<%_ } else { -%>
+            await userController.createUser(mockRequest, mockResponse, mockNext);
+<%_ if (communication === 'Kafka') { -%>
+            const { sendMessage } = require('@/infrastructure/messaging/kafkaClient');
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockResponse.status).toHaveBeenCalledWith(201);
+
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+<%_ } -%>
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
+        });
+    });
+
+    describe('updateUser', () => {
+        it('should successfully update a user (Happy Path)', async () => {
+            const id = '1';
+            const payload = { name: 'Alice Updated' };
+<%_ if (communication === 'GraphQL') { -%>
+            const idArg = id;
+            const dataArg = payload;
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = payload;
+<%_ } -%>
+            const expectedUser = { id, ...payload };
+            
+            mockUpdateUserUseCase.execute.mockResolvedValue(expectedUser);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.updateUser(idArg, dataArg);
+            expect(result.name).toBe(payload.name);
+<%_ } else { -%>
+            await userController.updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.json).toHaveBeenCalled();
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            const { sendMessage } = require('@/infrastructure/messaging/kafkaClient');
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockUpdateUserUseCase.execute).toHaveBeenCalledWith(id, payload);
+        });
+
+        it('should handle database errors during update (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+            mockUpdateUserUseCase.execute.mockRejectedValue(error);
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.updateUser(id, { name: 'Fail' })).rejects.toThrow(error);
+<%_ } else { -%>
+            await userController.updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('deleteUser', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            const id = '1';
+<%_ if (communication === 'GraphQL') { -%>
+            const idArg = id;
+<%_ } else { -%>
+            mockRequest.params = { id };
+<%_ } -%>
+            mockDeleteUserUseCase.execute.mockResolvedValue(true);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.deleteUser(idArg);
+            expect(result).toBe(true);
+<%_ } else { -%>
+            await userController.deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(200);
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            const { sendMessage } = require('@/infrastructure/messaging/kafkaClient');
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockDeleteUserUseCase.execute).toHaveBeenCalledWith(id);
+        });
+
+        it('should throw error if user not found during deletion (Error Handling)', async () => {
+            const id = '999';
+<%_ if (communication === 'GraphQL') { -%>
+            mockDeleteUserUseCase.execute.mockResolvedValue(false);
+            await expect(userController.deleteUser(id)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockDeleteUserUseCase.execute.mockResolvedValue(false);
+            await userController.deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(404);
+<%_ } -%>
+        });
+
+        it('should handle database errors during deletion (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+            mockDeleteUserUseCase.execute.mockRejectedValue(error);
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.deleteUser(id)).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await userController.deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('createUser Error Paths', () => {
+        it('should handle database errors during creation (Error Handling)', async () => {
+            const error = new Error('Database Error');
+            mockCreateUserUseCase.execute.mockRejectedValue(error);
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser({ name: 'Alice', email: 'alice@example.com' })).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.body = { name: 'Alice', email: 'alice@example.com' };
+            await userController.createUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('updateUser Error Paths', () => {
+        it('should handle database errors during update (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+            mockUpdateUserUseCase.execute.mockRejectedValue(error);
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.updateUser(id, { name: 'Bob' })).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Bob' };
+            await userController.updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+});

package/templates/clean-architecture/js/src/interfaces/graphql/resolvers/user.resolvers.js.ejs

@@ -1,21 +1,27 @@
-const UserController = require('../../controllers/userController');
-
-const userController = new UserController();
-
-const userResolvers = {
-  Query: {
-    getAllUsers: async () => {
-      return await userController.getUsers();
-    }
-  },
-  Mutation: {
-    createUser: async (_, { name, email }) => {
-      return await userController.createUser({ name, email });
-    }
-  }<%_ if (database === 'MongoDB') { -%>,
-  User: {
-    id: (parent) => parent.id || parent._id
-  }<%_ } %>
-};
-
-module.exports = { userResolvers };
+const UserController = require('../../controllers/userController');
+
+const userController = new UserController();
+
+const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      return await userController.getUsers();
+    }
+  },
+  Mutation: {
+    createUser: async (_, { name, email }) => {
+      return await userController.createUser({ name, email });
+    },
+    updateUser: async (_, { id, name, email }) => {
+      return await userController.updateUser(id, { name, email });
+    },
+    deleteUser: async (_, { id }) => {
+      return await userController.deleteUser(id);
+    }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent) => parent.id || parent._id
+  }<%_ } %>
+};
+
+module.exports = { userResolvers };

package/templates/clean-architecture/js/src/interfaces/graphql/resolvers/user.resolvers.spec.js.ejs

@@ -1,49 +1,66 @@
-const { userResolvers } = require('@/interfaces/graphql/resolvers/user.resolvers');
-
-const mockGetUsers = jest.fn().mockResolvedValue([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
-const mockCreateUser = jest.fn().mockResolvedValue({ id: '1', name: 'Jane', email: 'jane@example.com' });
-
-jest.mock('@/interfaces/controllers/userController', () => {
-  return jest.fn().mockImplementation(() => ({
-    getUsers: (...args) => mockGetUsers(...args),
-    createUser: (...args) => mockCreateUser(...args)
-  }));
-});
-
-describe('User Resolvers', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('Query.getAllUsers', () => {
-    it('should return all users', async () => {
-      const result = await userResolvers.Query.getAllUsers();
-      expect(result).toEqual([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
-      expect(mockGetUsers).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('Mutation.createUser', () => {
-    it('should create and return a new user', async () => {
-      const result = await userResolvers.Mutation.createUser(null, { name: 'Jane', email: 'jane@example.com' });
-      expect(result).toEqual({ id: '1', name: 'Jane', email: 'jane@example.com' });
-      expect(mockCreateUser).toHaveBeenCalledWith({ name: 'Jane', email: 'jane@example.com' });
-      expect(mockCreateUser).toHaveBeenCalledTimes(1);
-    });
-  });
-<%_ if (database === 'MongoDB') { -%>
-  describe('User.id', () => {
-    it('should return parent.id if available', () => {
-      const parent = { id: '123' };
-      const result = userResolvers.User.id(parent);
-      expect(result).toBe('123');
-    });
-
-    it('should fallback to parent._id if id is not available', () => {
-      const parent = { _id: '456' };
-      const result = userResolvers.User.id(parent);
-      expect(result).toBe('456');
-    });
-  });
-<%_ } -%>
-});
+const { userResolvers } = require('@/interfaces/graphql/resolvers/user.resolvers');
+
+const mockGetUsers = jest.fn().mockResolvedValue([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+const mockCreateUser = jest.fn().mockResolvedValue({ id: '1', name: 'Jane', email: 'jane@example.com' });
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args),
+    updateUser: jest.fn().mockImplementation((id, data) => Promise.resolve({ id, ...data })),
+    deleteUser: jest.fn().mockImplementation(() => Promise.resolve(true))
+  }));
+});
+
+describe('User Resolvers', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Query.getAllUsers', () => {
+    it('should return all users', async () => {
+      const result = await userResolvers.Query.getAllUsers();
+      expect(result).toEqual([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+      expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Mutation.createUser', () => {
+    it('should create and return a new user', async () => {
+      const result = await userResolvers.Mutation.createUser(null, { name: 'Jane', email: 'jane@example.com' });
+      expect(result).toEqual({ id: '1', name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledWith({ name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Mutation.updateUser', () => {
+    it('should update and return the user', async () => {
+      const payload = { name: 'Updated' };
+      const result = await userResolvers.Mutation.updateUser(null, { id: '1', ...payload });
+      expect(result).toMatchObject(payload);
+    });
+  });
+
+  describe('Mutation.deleteUser', () => {
+    it('should delete and return true', async () => {
+      const result = await userResolvers.Mutation.deleteUser(null, { id: '1' });
+      expect(result).toBe(true);
+    });
+  });
+<%_ if (database === 'MongoDB') { -%>
+  describe('User.id', () => {
+    it('should return parent.id if available', () => {
+      const parent = { id: '123' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('123');
+    });
+
+    it('should fallback to parent._id if id is not available', () => {
+      const parent = { _id: '456' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('456');
+    });
+  });
+<%_ } -%>
+});

package/templates/clean-architecture/js/src/interfaces/graphql/typeDefs/user.types.js.ejs

@@ -1,17 +1,19 @@
-const userTypes = `#graphql
-  type User {
-    id: ID!
-    name: String!
-    email: String!
-  }
-
-  type Query {
-    getAllUsers: [User]
-  }
-
-  type Mutation {
-    createUser(name: String!, email: String!): User
-  }
-`;
-
-module.exports = { userTypes };
+const userTypes = `#graphql
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+  }
+
+  type Query {
+    getAllUsers: [User]
+  }
+
+  type Mutation {
+    createUser(name: String!, email: String!): User
+    updateUser(id: ID!, name: String, email: String): User
+    deleteUser(id: ID!): Boolean
+  }
+`;
+
+module.exports = { userTypes };

package/templates/clean-architecture/js/src/interfaces/routes/api.js

@@ -1,10 +1,12 @@
-const express = require('express');
-const router = express.Router();
-const UserController = require('../controllers/userController');
-
-const userController = new UserController();
-
-router.post('/users', (req, res, next) => userController.createUser(req, res, next));
-router.get('/users', (req, res, next) => userController.getUsers(req, res, next));
-
-module.exports = router;
+const express = require('express');
+const router = express.Router();
+const UserController = require('../controllers/userController');
+
+const userController = new UserController();
+
+router.post('/users', (req, res, next) => userController.createUser(req, res, next));
+router.get('/users', (req, res, next) => userController.getUsers(req, res, next));
+router.patch('/users/:id', (req, res, next) => userController.updateUser(req, res, next));
+router.delete('/users/:id', (req, res, next) => userController.deleteUser(req, res, next));
+
+module.exports = router;

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

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