nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.spec.ts.ejs

@@ -1,40 +1,40 @@
-import request from 'supertest';
-import express, { Express } from 'express';
-import router from '@/interfaces/routes/userRoutes';
-
-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 {
-    UserController: jest.fn().mockImplementation(() => ({
-      getUsers: (...args: unknown[]) => mockGetUsers(...args),
-      createUser: (...args: unknown[]) => mockCreateUser(...args)
-    }))
-  };
-});
-
-describe('UserRoutes', () => {
-    let app: Express;
-
-    beforeEach(() => {
-        app = express();
-        app.use(express.json());
-        app.use('/users', router);
-    });
-
-    it('POST /users should call controller.createUser', async () => {
-        await request(app)
-            .post('/users')
-            .send({ name: 'Test', email: 'test@example.com' });
-
-        expect(mockCreateUser).toHaveBeenCalledTimes(1);
-    });
-
-    it('GET /users should call controller.getUsers', async () => {
-        await request(app)
-            .get('/users');
-
-        expect(mockGetUsers).toHaveBeenCalledTimes(1);
-    });
-});
+import request from 'supertest';
+import express, { Express } from 'express';
+import router from '@/interfaces/routes/userRoutes';
+
+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 {
+    UserController: jest.fn().mockImplementation(() => ({
+      getUsers: (...args: unknown[]) => mockGetUsers(...args),
+      createUser: (...args: unknown[]) => mockCreateUser(...args)
+    }))
+  };
+});
+
+describe('UserRoutes', () => {
+    let app: Express;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/users', router);
+    });
+
+    it('POST /users should call controller.createUser', async () => {
+        await request(app)
+            .post('/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.ts

@@ -1,11 +1,13 @@
-import { Router, Request, Response, NextFunction } from 'express';
-import { UserController } from '@/interfaces/controllers/userController';
-
-const router = Router();
-const userController = new UserController();
-
-router.post('/', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
-router.get('/', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
-
-export default router;
-
+import { Router, Request, Response, NextFunction } from 'express';
+import { UserController } from '@/interfaces/controllers/userController';
+
+const router = Router();
+const userController = new UserController();
+
+router.post('/', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
+router.get('/', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
+router.patch('/:id', (req: Request, res: Response, next: NextFunction) => userController.updateUser(req, res, next));
+router.delete('/:id', (req: Request, res: Response, next: NextFunction) => userController.deleteUser(req, res, next));
+
+export default router;
+

package/templates/clean-architecture/ts/src/usecases/createUser.spec.ts.ejs

@@ -1,51 +1,51 @@
-import CreateUser from '@/usecases/createUser';
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-<%_ if (caching !== 'None') { -%>
-import cacheService from '<% 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: CreateUser;
-    let mockUserRepository: jest.Mocked<UserRepository>;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
-
-        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);
-    });
-});
+import CreateUser from '@/usecases/createUser';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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: CreateUser;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
+
+        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/ts/src/usecases/createUser.ts

@@ -1,13 +1,13 @@
-import { User } from '@/domain/user';
-
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-
-export default class CreateUser {
-    constructor(private userRepository: UserRepository) {}
-
-    async execute(name: string, email: string) {
-        const user = new User(null, name, email);
-        return this.userRepository.save(user);
-    }
-}
-
+import { User } from '@/domain/user';
+
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class CreateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(name: string, email: string) {
+        const user = new User(null, name, email);
+        return this.userRepository.save(user);
+    }
+}
+

package/templates/clean-architecture/ts/src/usecases/deleteUser.spec.ts.ejs

@@ -0,0 +1,47 @@
+import DeleteUser from '@/usecases/deleteUser';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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: DeleteUser;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
+
+        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/ts/src/usecases/deleteUser.ts

@@ -0,0 +1,9 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class DeleteUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string) {
+        return this.userRepository.delete(id);
+    }
+}

package/templates/clean-architecture/ts/src/usecases/getAllUsers.spec.ts.ejs

@@ -1,63 +1,63 @@
-import GetAllUsers from '@/usecases/getAllUsers';
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-<%_ if (caching !== 'None') { -%>
-import cacheService from '<% 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: GetAllUsers;
-    let mockUserRepository: jest.Mocked<UserRepository>;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
-<%_ if (caching !== 'None') { -%>
-        (cacheService.get as jest.Mock).mockResolvedValue(null);
-<%_ } %>
-
-        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 as jest.Mock).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 as jest.Mock).mockResolvedValue(null);
-<%_ } -%>
-
-        await expect(getAllUsers.execute()).rejects.toThrow(error);
-    });
-});
+import GetAllUsers from '@/usecases/getAllUsers';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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: GetAllUsers;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
+<%_ if (caching !== 'None') { -%>
+        (cacheService.get as jest.Mock).mockResolvedValue(null);
+<%_ } %>
+
+        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 as jest.Mock).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 as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+        await expect(getAllUsers.execute()).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/ts/src/usecases/getAllUsers.ts

@@ -1,10 +1,10 @@
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-
-export default class GetAllUsers {
-    constructor(private userRepository: UserRepository) {}
-
-    async execute() {
-        return this.userRepository.getUsers();
-    }
-}
-
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class GetAllUsers {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute() {
+        return this.userRepository.getUsers();
+    }
+}
+

package/templates/clean-architecture/ts/src/usecases/updateUser.spec.ts.ejs

@@ -0,0 +1,48 @@
+import UpdateUser from '@/usecases/updateUser';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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: UpdateUser;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
+
+        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/ts/src/usecases/updateUser.ts

@@ -0,0 +1,9 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class UpdateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string, data: { name?: string, email?: string }) {
+        return this.userRepository.update(id, data);
+    }
+}

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

@@ -0,0 +1,12 @@
+export 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',
+} as const;

package/templates/clean-architecture/ts/src/utils/errorMiddleware.ts.ejs

@@ -1,27 +1,27 @@
-import { Request, Response } from 'express';
-import logger from '@/infrastructure/log/logger';
-import { ApiError } from '@/errors/ApiError';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-
-export const errorMiddleware = (err: Error, req: Request, res: Response, _next: unknown) => {
-  let error = err;
-
-  if (!(error instanceof ApiError)) {
-    const statusCode = HTTP_STATUS.INTERNAL_SERVER_ERROR;
-    const message = error.message || 'Internal Server Error';
-    error = new ApiError(statusCode, message, false, err.stack);
-  }
-
-  const { statusCode, message } = error as ApiError;
-
-  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
-    logger.error(error.stack || 'No stack trace');
-  }
-
-  res.status(statusCode).json({
-    statusCode,
-    message,
-    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
-  });
-};
+import { Request, Response } from 'express';
+import logger from '@/infrastructure/log/logger';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+export const errorMiddleware = (err: Error, req: Request, res: Response, _next: unknown) => {
+  let error = err;
+
+  if (!(error instanceof ApiError)) {
+    const statusCode = HTTP_STATUS.INTERNAL_SERVER_ERROR;
+    const message = error.message || 'Internal Server Error';
+    error = new ApiError(statusCode, message, false, err.stack);
+  }
+
+  const { statusCode, message } = error as ApiError;
+
+  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
+    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
+    logger.error(error.stack || 'No stack trace');
+  }
+
+  res.status(statusCode).json({
+    statusCode,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+};

package/templates/clean-architecture/ts/src/utils/httpCodes.ts

@@ -1,7 +1,7 @@
-export const HTTP_STATUS = {
-    OK: 200,
-    CREATED: 201,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500
-} as const;
+export const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+} as const;