nodejs-quickstart-structure 1.18.1 → 1.19.0

package/templates/mvc/ts/src/controllers/userController.ts.ejs

@@ -1,107 +1,248 @@
-<% if (communication !== 'GraphQL') { -%>
-import { Request, Response, NextFunction } from 'express';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-<% } -%>
-import User from '@/models/User';
-import logger from '@/utils/logger';
-<%_ if (caching === 'Redis') { -%>
-import cacheService from '@/config/redisClient';
-<%_ } else if (caching === 'Memory Cache') { -%>
-import cacheService from '@/config/memoryCache';
-<%_ } -%><%_ if (communication === 'Kafka') { -%>
-import { kafkaService } from '@/services/kafkaService';
-<%_ } -%>
-
-export class UserController {
-<% if (communication === 'GraphQL') { -%>
-    async getUsers() {
-        try {
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            const users = await cacheService.getOrSet('users:all', async () => {
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-                return await User.find();
-<%_ } else { -%>
-                return await User.findAll();
-<%_ } -%>
-            }, 60);
-<%_ } else { -%>
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-            const users = await User.find();
-<%_ } else { -%>
-            const users = await User.findAll();
-<%_ } -%>
-<%_ } -%>
-            return users;
-        } catch (error) {
-            logger.error('Error fetching users:', error);
-            throw error;
-        }
-    }
-
-    async createUser(data: { name: string, email: string }) {
-        try {
-            const { name, email } = data;
-            const user = await User.create({ name, email });
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            await cacheService.del('users:all');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-            await kafkaService.sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                payload: { id: (user as any).id || (user as any)._id, email: user.email }
-            }));
-<%_ } -%>
-            return user;
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            throw error;
-        }
-    }
-<% } else { -%>
-    async getUsers(req: Request, res: Response, next: NextFunction) {
-        try {
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            const users = await cacheService.getOrSet('users:all', async () => {
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-                return await User.find();
-<%_ } else { -%>
-                return await User.findAll();
-<%_ } -%>
-            }, 60);
-<%_ } else { -%>
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-            const users = await User.find();
-<%_ } else { -%>
-            const users = await User.findAll();
-<%_ } -%>
-<%_ } -%>
-            res.json(users);
-        } catch (error) {
-            logger.error('Error fetching user:', error);
-            next(error);
-        }
-    }
-
-    async createUser(req: Request, res: Response, next: NextFunction) {
-        try {
-            const { name, email } = req.body;
-            const user = await User.create({ name, email });
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            await cacheService.del('users:all');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-            await kafkaService.sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                payload: { id: (user as any).id || (user as any)._id, email: user.email }
-            }));
-<%_ } -%>
-            res.status(HTTP_STATUS.CREATED).json(user);
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            next(error);
-        }
-    }
-<% } -%>
-}
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<% if (communication !== 'GraphQL') { -%>
+import { Request, Response, NextFunction } from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
+import User from '@/models/User';
+import logger from '@/utils/logger';
+<%_ if (caching === 'Redis') { -%>
+import cacheService from '@/config/redisClient';
+<%_ } else if (caching === 'Memory Cache') { -%>
+import cacheService from '@/config/memoryCache';
+<%_ } -%><%_ if (communication === 'Kafka') { -%>
+import { kafkaService } from '@/services/kafkaService';
+import { KAFKA_ACTIONS } from '@/utils/kafkaEvents';
+<%_ } -%>
+
+export class UserController {
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            const users = await cacheService.getOrSet('users:all', async () => {
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+                return await User.find();
+<%_ } else { -%>
+                return await User.findAll();
+<%_ } -%>
+            }, 60);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            const users = await User.find();
+<%_ } else { -%>
+            const users = await User.findAll();
+<%_ } -%>
+<%_ } -%>
+            return users;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async createUser(data: { name: string, email: string }) {
+        try {
+            const { name, email } = data;
+            const user = await User.create({ name, email });
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const userId = (user as any).id || (user as any)._id;
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: userId, email: user.email }
+            }), userId?.toString() || '');
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async updateUser(id: string, data: { name?: string, email?: string }) {
+        try {
+<%_ if (database === 'MongoDB') { -%>
+            const updatedUser = await User.findByIdAndUpdate(id, data, { new: true });
+            if (!updatedUser) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else if (database === 'None') { -%>
+            const user = await User.findByPk(id);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+            await User.update(id, data);
+            const updatedUser = await User.findByPk(id);
+<%_ } else { -%>
+            const user = await User.findByPk(id);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+            await user.update(data);
+            const updatedUser = user;
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: updatedUser?.email }
+            }), id);
+<%_ } -%>
+            return updatedUser;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async deleteUser(id: string) {
+        try {
+<%_ if (database === 'MongoDB') { -%>
+            const deleted = await User.findByIdAndDelete(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else if (database === 'None') { -%>
+            const deleted = await User.destroy(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            const user = await User.findByPk(id);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+            await user.destroy();
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.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: Request, res: Response, next: NextFunction) {
+        try {
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            const users = await cacheService.getOrSet('users:all', async () => {
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+                return await User.find();
+<%_ } else { -%>
+                return await User.findAll();
+<%_ } -%>
+            }, 60);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            const users = await User.find();
+<%_ } else { -%>
+            const users = await User.findAll();
+<%_ } -%>
+<%_ } -%>
+            res.json(users);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async createUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { name, email } = req.body || {};
+            const user = await User.create({ name, email });
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const userId = (user as any).id || (user as any)._id;
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: userId, email: user.email }
+            }), userId?.toString() || '');
+<%_ } -%>
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            logger.error('Error creating user:', error);
+            next(error);
+        }
+    }
+
+    async updateUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { id } = req.params;
+            const { name, email } = req.body || {};
+<%_ if (database === 'MongoDB') { -%>
+            const updatedUser = await User.findByIdAndUpdate(id, { name, email }, { new: true });
+            if (!updatedUser) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ } else if (database === 'None') { -%>
+            const user = await User.findByPk(id);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+            await User.update(id, { name, email });
+            const updatedUser = await User.findByPk(id);
+<%_ } else { -%>
+            const user = await User.findByPk(id);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+            await user.update({ name, email });
+            const updatedUser = user;
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: updatedUser?.email }
+            }), id);
+<%_ } -%>
+            res.status(HTTP_STATUS.OK).json(updatedUser);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async deleteUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { id } = req.params;
+<%_ if (database === 'MongoDB') { -%>
+            const deleted = await User.findByIdAndDelete(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ } else if (database === 'None') { -%>
+            const deleted = await User.destroy(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ } else { -%>
+            const user = await User.findByPk(id);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+            await user.destroy();
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.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);
+        }
+    }
+<% } -%>
+}

package/templates/mvc/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/mvc/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/mvc/ts/src/errors/NotFoundError.spec.ts.ejs

@@ -1,21 +1,27 @@
-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);
+    });
+
+    it('should have the correct status code', () => {
+        const error = new NotFoundError();
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+});

package/templates/mvc/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/mvc/ts/src/graphql/resolvers/user.resolvers.spec.ts.ejs

@@ -1,51 +1,68 @@
-import { userResolvers } from '@/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('@/controllers/userController', () => {
-  return {
-    UserController: jest.fn().mockImplementation(() => ({
-      getUsers: (...args: unknown[]) => mockGetUsers(...args),
-      createUser: (...args: unknown[]) => 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 as { id?: string; _id?: unknown });
-      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 as { id?: string; _id?: unknown });
-      expect(result).toBe('456');
-    });
-  });
-<%_ } -%>
-});
+import { userResolvers } from '@/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('@/controllers/userController', () => {
+  return {
+    UserController: jest.fn().mockImplementation(() => ({
+      getUsers: (...args: unknown[]) => mockGetUsers(...args),
+      createUser: (...args: unknown[]) => 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 as { id?: string; _id?: unknown });
+      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 as { id?: string; _id?: unknown });
+      expect(result).toBe('456');
+    });
+  });
+<%_ } -%>
+});