nodejs-quickstart-structure 1.18.1 → 1.19.1

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/index.js.ejs

@@ -1,6 +1,6 @@
-const { mergeTypeDefs } = require('@graphql-tools/merge');
-const { userTypes } = require('./user.types');
-
-const typeDefs = mergeTypeDefs([userTypes]);
-
-module.exports = { typeDefs };
+const { mergeTypeDefs } = require('@graphql-tools/merge');
+const { userTypes } = require('./user.types');
+
+const typeDefs = mergeTypeDefs([userTypes]);
+
+module.exports = { typeDefs };

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/interfaces/routes/api.spec.js.ejs

@@ -1,38 +1,38 @@
-const request = require('supertest');
-const express = require('express');
-const router = require('@/interfaces/routes/api');
-
-const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
-const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
-
-jest.mock('@/interfaces/controllers/userController', () => {
-  return jest.fn().mockImplementation(() => ({
-    getUsers: (...args) => mockGetUsers(...args),
-    createUser: (...args) => mockCreateUser(...args)
-  }));
-});
-
-describe('ApiRoutes', () => {
-    let app;
-
-    beforeEach(() => {
-        app = express();
-        app.use(express.json());
-        app.use('/api', router);
-    });
-
-    it('POST /api/users should call controller.createUser', async () => {
-        await request(app)
-            .post('/api/users')
-            .send({ name: 'Test', email: 'test@example.com' });
-
-        expect(mockCreateUser).toHaveBeenCalledTimes(1);
-    });
-
-    it('GET /api/users should call controller.getUsers', async () => {
-        await request(app)
-            .get('/api/users');
-
-        expect(mockGetUsers).toHaveBeenCalledTimes(1);
-    });
-});
+const request = require('supertest');
+const express = require('express');
+const router = require('@/interfaces/routes/api');
+
+const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
+const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('ApiRoutes', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('POST /api/users should call controller.createUser', async () => {
+        await request(app)
+            .post('/api/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,14 +1,14 @@
-const User = require('../domain/models/User');
-
-class CreateUser {
-    constructor(userRepository) {
-        this.userRepository = userRepository;
-    }
-
-    async execute(name, email) {
-        const user = new User(null, name, email);
-        return await this.userRepository.save(user);
-    }
-}
-
-module.exports = CreateUser;
+const User = require('../domain/models/User');
+
+class CreateUser {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute(name, email) {
+        const user = new User(null, name, email);
+        return await this.userRepository.save(user);
+    }
+}
+
+module.exports = CreateUser;

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

@@ -1,51 +1,51 @@
-const CreateUser = require('@/usecases/CreateUser');
-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('CreateUser UseCase', () => {
-    let createUser;
-    let mockUserRepository;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository();
-        createUser = new CreateUser(mockUserRepository);
-        jest.clearAllMocks();
-    });
-
-    it('should create and save a new user', async () => {
-        const name = 'Test User';
-        const email = 'test@example.com';
-        const expectedResult = { id: 1, name, email };
-
-        mockUserRepository.save.mockResolvedValue(expectedResult);
-
-        const result = await createUser.execute(name, email);
-
-        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
-        const savedUser = mockUserRepository.save.mock.calls[0][0];
-        expect(savedUser.name).toBe(name);
-        expect(savedUser.email).toBe(email);
-        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.save.mockRejectedValue(error);
-
-        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
-    });
-});
+const CreateUser = require('@/usecases/CreateUser');
+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('CreateUser UseCase', () => {
+    let createUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        createUser = new CreateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should create and save a new user', async () => {
+        const name = 'Test User';
+        const email = 'test@example.com';
+        const expectedResult = { id: 1, name, email };
+
+        mockUserRepository.save.mockResolvedValue(expectedResult);
+
+        const result = await createUser.execute(name, email);
+
+        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
+        const savedUser = mockUserRepository.save.mock.calls[0][0];
+        expect(savedUser.name).toBe(name);
+        expect(savedUser.email).toBe(email);
+        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.save.mockRejectedValue(error);
+
+        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+    });
+});

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;

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/GetAllUsers.js

@@ -1,12 +1,12 @@
-
-class GetAllUsers {
-    constructor(userRepository) {
-        this.userRepository = userRepository;
-    }
-
-    async execute() {
-        return await this.userRepository.getUsers();
-    }
-}
-
-module.exports = GetAllUsers;
+
+class GetAllUsers {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute() {
+        return await this.userRepository.getUsers();
+    }
+}
+
+module.exports = GetAllUsers;

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

@@ -1,61 +1,61 @@
-const GetAllUsers = require('@/usecases/GetAllUsers');
-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('GetAllUsers UseCase', () => {
-    let getAllUsers;
-    let mockUserRepository;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository();
-        getAllUsers = new GetAllUsers(mockUserRepository);
-        jest.clearAllMocks();
-    });
-
-    it('should retrieve all users', async () => {
-        const expectedUsers = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];
-        mockUserRepository.getUsers.mockResolvedValue(expectedUsers);
-<%_ if (caching !== 'None') { -%>
-        cacheService.get.mockResolvedValue(null); // Cache miss
-<%_ } -%>
-        const result = await getAllUsers.execute();
-
-        expect(mockUserRepository.getUsers).toHaveBeenCalledTimes(1);
-        expect(result).toEqual(expectedUsers);
-<%_ if (caching !== 'None') { -%>
-        expect(cacheService.set).toHaveBeenCalled();
-<%_ } -%>
-    });
-
-<%_ if (caching !== 'None') { -%>
-    it('should return from cache if available', async () => {
-        const cachedUsers = [{ id: 1, name: 'Cached', email: 'cached@example.com' }];
-        cacheService.get.mockResolvedValue(cachedUsers);
-
-        const result = await getAllUsers.execute();
-
-        expect(mockUserRepository.getUsers).not.toHaveBeenCalled();
-        expect(result).toEqual(cachedUsers);
-    });
-<%_ } -%>
-
-    it('should throw an error if repository fails', async () => {
-        const error = new Error('Database error');
-        mockUserRepository.getUsers.mockRejectedValue(error);
-<%_ if (caching !== 'None') { -%>
-        cacheService.get.mockResolvedValue(null); // Cache miss
-<%_ } -%>
-        await expect(getAllUsers.execute()).rejects.toThrow(error);
-    });
-});
+const GetAllUsers = require('@/usecases/GetAllUsers');
+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('GetAllUsers UseCase', () => {
+    let getAllUsers;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        getAllUsers = new GetAllUsers(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should retrieve all users', async () => {
+        const expectedUsers = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];
+        mockUserRepository.getUsers.mockResolvedValue(expectedUsers);
+<%_ if (caching !== 'None') { -%>
+        cacheService.get.mockResolvedValue(null); // Cache miss
+<%_ } -%>
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(expectedUsers);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.set).toHaveBeenCalled();
+<%_ } -%>
+    });
+
+<%_ if (caching !== 'None') { -%>
+    it('should return from cache if available', async () => {
+        const cachedUsers = [{ id: 1, name: 'Cached', email: 'cached@example.com' }];
+        cacheService.get.mockResolvedValue(cachedUsers);
+
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).not.toHaveBeenCalled();
+        expect(result).toEqual(cachedUsers);
+    });
+<%_ } -%>
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.getUsers.mockRejectedValue(error);
+<%_ if (caching !== 'None') { -%>
+        cacheService.get.mockResolvedValue(null); // Cache miss
+<%_ } -%>
+        await expect(getAllUsers.execute()).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;