nodejs-quickstart-structure 1.18.1 → 1.19.0

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

@@ -1,39 +1,69 @@
-const UserModel = require('../database/models/User');
-
-class UserRepository {
-  async save(user) {
-<%_ if (database === 'None') { -%>
-    const newUser = await UserModel.create(user);
-    return newUser;
-<%_ } else { -%>
-    const newUser = await UserModel.create({ name: user.name, email: user.email });
-<%_ if (database === 'MongoDB') { -%>
-    return { ...user, id: newUser._id.toString() };
-<%_ } else { -%>
-    return { ...user, id: newUser.id };
-<%_ } -%>
-<%_ } -%>
-  }
-
-  async getUsers() {
-<%_ if (database === 'None') { -%>
-    return await UserModel.find();
-<%_ } else if (database === 'MongoDB') { -%>
-    const users = await UserModel.find();
-    return users.map(user => ({
-        id: user._id.toString(),
-        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
-    }));
-<%_ } -%>
-  }
-}
-
-module.exports = UserRepository;
+const UserModel = require('../database/models/User');
+
+class UserRepository {
+  async save(user) {
+<%_ if (database === 'None') { -%>
+    const newUser = await UserModel.create(user);
+    return newUser;
+<%_ } else { -%>
+    const newUser = await UserModel.create({ name: user.name, email: user.email });
+<%_ if (database === 'MongoDB') { -%>
+    return { ...user, id: newUser._id.toString() };
+<%_ } else { -%>
+    return { ...user, id: newUser.id };
+<%_ } -%>
+<%_ } -%>
+  }
+
+  async getUsers() {
+<%_ if (database === 'None') { -%>
+    return await UserModel.find();
+<%_ } else if (database === 'MongoDB') { -%>
+    const users = await UserModel.find();
+    return users.map(user => ({
+        id: user._id.toString(),
+        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, data) {
+<%_ 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 user = await UserModel.update(id, data);
+    return user;
+<%_ } 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) {
+<%_ 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;
+<%_ } -%>
+  }
+}
+
+module.exports = UserRepository;

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

@@ -1,81 +1,142 @@
-const UserRepository = require('@/infrastructure/repositories/UserRepository');
-const UserModel = require('@/infrastructure/database/models/User');
-
-jest.mock('@/infrastructure/database/models/User');
-
-describe('UserRepository', () => {
-    let userRepository;
-
-    beforeEach(() => {
-        userRepository = new UserRepository();
-        jest.clearAllMocks();
-    });
-
-    describe('save', () => {
-        it('should save and return a newly created user (Happy Path)', async () => {
-            const userData = { name: 'New User', email: 'new@example.com' };
-<%_ if (database === 'MongoDB') { -%>
-            const savedData = { _id: 'mock-id', ...userData };
-            UserModel.create.mockResolvedValue(savedData);
-<%_ } else if (database === 'None') { -%>
-            UserModel.create.mockResolvedValue(userData);
-<%_ } else { -%>
-            const savedData = { <%= database === "MongoDB" ? "_id" : "id" %>: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData };
-            UserModel.create.mockResolvedValue(savedData);
-<%_ } -%>
-
-            const result = await userRepository.save(userData);
-
-<%_ if (database === 'None') { -%>
-            expect(result.name).toEqual(userData.name);
-<%_ } else { -%>
-            expect(UserModel.create).toHaveBeenCalledWith(userData);
-            expect(result).toEqual({ id: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData });
-<%_ } -%>
-        });
-
-        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
-<%_ if (database === 'None') { -%>
-            // mock data logic doesn't throw naturally
-<%_ } else { -%>
-            const error = new Error('DB Error');
-            UserModel.create.mockRejectedValue(error);
-
-            await expect(userRepository.save({})).rejects.toThrow('DB Error');
-<%_ } -%>
-        });
-    });
-
-    describe('getUsers', () => {
-        it('should return a list of mapped UserEntities (Happy Path)', async () => {
-<%_ if (database === 'MongoDB') { -%>
-            const mockUsers = [
-                { _id: '1', name: 'User 1', email: 'u1@test.com' },
-                { _id: '2', name: 'User 2', email: 'u2@test.com' }
-            ];
-            UserModel.find.mockResolvedValue(mockUsers);
-<%_ } else if (database === 'None') { -%>
-            const mockUsers = [{ id: '1', name: 'User 1', email: 'u1@test.com' }];
-            UserModel.find.mockResolvedValue(mockUsers);
-<%_ } else { -%>
-            const mockUsers = [
-                { <%= database === "MongoDB" ? "_id" : "id" %>: '1', name: 'User 1', email: 'u1@test.com' },
-                { <%= database === "MongoDB" ? "_id" : "id" %>: '2', name: 'User 2', email: 'u2@test.com' }
-            ];
-            UserModel.<%= database === "MongoDB" ? "find" : "findAll" %>.mockResolvedValue(mockUsers);
-<%_ } -%>
-            
-            const result = await userRepository.getUsers();
-
-<%_ if (database !== 'None') { -%>
-            expect(UserModel.<%= database === 'MongoDB' ? 'find' : 'findAll' %>).toHaveBeenCalled();
-<%_ } -%>
-            expect(result).toEqual([
-                { id: '1', name: 'User 1', email: 'u1@test.com' }
-<%_ if (database !== 'None') { -%>
-                , { id: '2', name: 'User 2', email: 'u2@test.com' }
-<%_ } -%>
-            ]);
-        });
-    });
-});
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+const UserModel = require('@/infrastructure/database/models/User');
+
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            const userData = { name: 'New User', email: 'new@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const savedData = { _id: 'mock-id', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } else if (database === 'None') { -%>
+            UserModel.create.mockResolvedValue(userData);
+<%_ } else { -%>
+            const savedData = { <%= database === "MongoDB" ? "_id" : "id" %>: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } -%>
+
+            const result = await userRepository.save(userData);
+
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(userData.name);
+<%_ } else { -%>
+            expect(UserModel.create).toHaveBeenCalledWith(userData);
+            expect(result).toEqual({ id: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // mock data logic doesn't throw naturally
+<%_ } else { -%>
+            const error = new Error('DB Error');
+            UserModel.create.mockRejectedValue(error);
+
+            await expect(userRepository.save({})).rejects.toThrow('DB Error');
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            const mockUsers = [
+                { _id: '1', name: 'User 1', email: 'u1@test.com' },
+                { _id: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else if (database === 'None') { -%>
+            const mockUsers = [{ id: '1', name: 'User 1', email: 'u1@test.com' }];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else { -%>
+            const mockUsers = [
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '1', name: 'User 1', email: 'u1@test.com' },
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.<%= database === "MongoDB" ? "find" : "findAll" %>.mockResolvedValue(mockUsers);
+<%_ } -%>
+            
+            const result = await userRepository.getUsers();
+
+<%_ if (database !== 'None') { -%>
+            expect(UserModel.<%= database === 'MongoDB' ? 'find' : 'findAll' %>).toHaveBeenCalled();
+<%_ } -%>
+            expect(result).toEqual([
+                { id: '1', name: 'User 1', email: 'u1@test.com' }
+<%_ if (database !== 'None') { -%>
+                , { id: '2', name: 'User 2', email: 'u2@test.com' }
+<%_ } -%>
+            ]);
+        });
+    });
+
+    describe('update', () => {
+        it('should successfully update a user (Happy Path)', async () => {
+            const id = '1';
+            const updateData = { name: 'Updated name' };
+<%_ if (database === 'MongoDB') { -%>
+            const updatedUser = { _id: id, ...updateData, email: 'test@test.com' };
+            UserModel.findByIdAndUpdate.mockResolvedValue(updatedUser);
+<%_ } else if (database === 'None') { -%>
+            const updatedUser = { id, ...updateData, email: 'test@test.com' };
+            UserModel.update.mockResolvedValue(updatedUser);
+<%_ } else { -%>
+            const updatedUser = { id: '1', ...updateData, email: 'test@test.com', update: jest.fn().mockResolvedValue(true) };
+            UserModel.findByPk.mockResolvedValue(updatedUser);
+<%_ } -%>
+
+            const result = await userRepository.update(id, updateData);
+            expect(result.name).toEqual(updateData.name);
+        });
+
+        it('should handle user not found during update (Error Handling)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndUpdate.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            UserModel.update.mockResolvedValue(null);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            const result = await userRepository.update('999', { name: 'fail' });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            const id = '1';
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndDelete.mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            UserModel.destroy.mockResolvedValue(true);
+<%_ } else { -%>
+            const userMock = { id, destroy: jest.fn().mockResolvedValue(true) };
+            UserModel.findByPk.mockResolvedValue(userMock);
+<%_ } -%>
+
+            const result = await userRepository.delete(id);
+            expect(result).toBe(true);
+        });
+
+        it('should handle user not found during deletion (Error Handling)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndDelete.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            UserModel.destroy.mockResolvedValue(false);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            const result = await userRepository.delete('999');
+            expect(result).toBe(false);
+        });
+    });
+});

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

@@ -1,75 +1,156 @@
-const CreateUser = require('../../usecases/CreateUser');
-const GetAllUsers = require('../../usecases/GetAllUsers');
-const UserRepository = require('../../infrastructure/repositories/UserRepository');
-<% if (communication !== 'GraphQL') { -%>
-const HTTP_STATUS = require('../../utils/httpCodes');
-<% } -%>
-const logger = require('../../infrastructure/log/logger');
-<%_ if (communication === 'Kafka') { -%>
-const { sendMessage } = require('../../infrastructure/messaging/kafkaClient');
-<%_ } -%>
-
-class UserController {
-    constructor() {
-        this.userRepository = new UserRepository();
-        this.createUserUseCase = new CreateUser(this.userRepository);
-        this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
-    }
-
-<% if (communication === 'GraphQL') { -%>
-    async getUsers() {
-        try {
-            return await this.getAllUsersUseCase.execute();
-        } catch (error) {
-            logger.error('Error getting users:', error);
-            throw error;
-        }
-    }
-
-    async createUser(data) {
-        const { name, email } = data;
-        try {
-            const user = await this.createUserUseCase.execute(name, email);
-<%_ if (communication === 'Kafka') { -%>
-            await sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                payload: { id: user.id || user._id, email: user.email }
-            }));
-<%_ } -%>
-            return user;
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            throw error;
-        }
-    }
-<% } else { -%>
-    async getUsers(req, res, next) {
-      try {
-        const users = await this.getAllUsersUseCase.execute();
-        res.json(users);
-      } catch (error) {
-        logger.error('Error getting users:', error);
-        next(error);
-      }
-    }
-
-    async createUser(req, res, next) {
-        const { name, email } = req.body;
-        try {
-            const user = await this.createUserUseCase.execute(name, email);
-<%_ if (communication === 'Kafka') { -%>
-            await sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                payload: { id: user.id || user._id, email: user.email }
-            }));
-<%_ } -%>
-            res.status(HTTP_STATUS.CREATED).json(user);
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            next(error);
-        }
-    }
-<% } -%>
-}
-
-module.exports = UserController;
+const CreateUser = require('../../usecases/CreateUser');
+const GetAllUsers = require('../../usecases/GetAllUsers');
+const UpdateUser = require('../../usecases/UpdateUser');
+const DeleteUser = require('../../usecases/DeleteUser');
+const UserRepository = require('../../infrastructure/repositories/UserRepository');
+const ERROR_MESSAGES = require('../../utils/errorMessages');
+<% if (communication !== 'GraphQL') { -%>
+const HTTP_STATUS = require('../../utils/httpCodes');
+<% } -%>
+const logger = require('../../infrastructure/log/logger');
+<%_ if (communication === 'Kafka') { -%>
+const { sendMessage } = require('../../infrastructure/messaging/kafkaClient');
+const { KAFKA_ACTIONS } = require('../../utils/kafkaEvents');
+<%_ } -%>
+
+class UserController {
+    constructor() {
+        this.userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(this.userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
+        this.updateUserUseCase = new UpdateUser(this.userRepository);
+        this.deleteUserUseCase = new DeleteUser(this.userRepository);
+    }
+
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+            return await this.getAllUsersUseCase.execute();
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async createUser(data) {
+        const { name, email } = data;
+        try {
+            const user = await this.createUserUseCase.execute(name, email);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async updateUser(id, data) {
+        try {
+            const user = await this.updateUserUseCase.execute(id, data);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async deleteUser(id) {
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            return true;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+<% } else { -%>
+    async getUsers(req, res, next) {
+      try {
+        const users = await this.getAllUsersUseCase.execute();
+        res.json(users);
+      } catch (error) {
+        logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+        next(error);
+      }
+    }
+
+    async createUser(req, res, next) {
+        const { name, email } = req.body || {};
+        try {
+            const user = await this.createUserUseCase.execute(name, email);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async updateUser(req, res, next) {
+        const { id } = req.params;
+        const { name, email } = req.body || {};
+        try {
+            const user = await this.updateUserUseCase.execute(id, { name, email });
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            res.json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async deleteUser(req, res, next) {
+        const { id } = req.params;
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            res.status(HTTP_STATUS.OK).json({ message: 'User deleted successfully' });
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+<% } -%>
+}
+
+module.exports = UserController;