nodejs-quickstart-structure 1.18.1 → 1.19.1

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/ApiError.ts

@@ -1,15 +1,15 @@
-export class ApiError extends Error {
-  statusCode: number;
-  isOperational: boolean;
-
-  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
-    super(message);
-    this.statusCode = statusCode;
-    this.isOperational = isOperational;
-    if (stack) {
-      this.stack = stack;
-    } else {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
+export class ApiError extends Error {
+  statusCode: number;
+  isOperational: boolean;
+
+  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}

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/context.spec.ts.ejs

@@ -1,30 +1,30 @@
-import { gqlContext } from '@/graphql/context';
-import { Request } from 'express';
-import { resolvers } from '@/graphql/resolvers';
-import { typeDefs } from '@/graphql/typeDefs';
-
-describe('GraphQL Context', () => {
-  it('should exercise GraphQL index entry points', () => {
-    expect(resolvers).toBeDefined();
-    expect(typeDefs).toBeDefined();
-  });
-  it('should return context with token when authorization header is present', async () => {
-    const mockRequest = {
-      headers: {
-        authorization: 'Bearer token123',
-      },
-    } as Request;
-
-    const context = await gqlContext({ req: mockRequest });
-    expect(context).toEqual({ token: 'Bearer token123' });
-  });
-
-  it('should return context with empty token when authorization header is missing', async () => {
-    const mockRequest = {
-      headers: {},
-    } as Request;
-
-    const context = await gqlContext({ req: mockRequest });
-    expect(context).toEqual({ token: '' });
-  });
-});
+import { gqlContext } from '@/graphql/context';
+import { Request } from 'express';
+import { resolvers } from '@/graphql/resolvers';
+import { typeDefs } from '@/graphql/typeDefs';
+
+describe('GraphQL Context', () => {
+  it('should exercise GraphQL index entry points', () => {
+    expect(resolvers).toBeDefined();
+    expect(typeDefs).toBeDefined();
+  });
+  it('should return context with token when authorization header is present', async () => {
+    const mockRequest = {
+      headers: {
+        authorization: 'Bearer token123',
+      },
+    } as Request;
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: 'Bearer token123' });
+  });
+
+  it('should return context with empty token when authorization header is missing', async () => {
+    const mockRequest = {
+      headers: {},
+    } as Request;
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: '' });
+  });
+});

package/templates/mvc/ts/src/graphql/context.ts.ejs

@@ -1,12 +1,12 @@
-import { Request } from 'express';
-
-export interface MyContext {
-  token?: string;
-  // user?: User;
-}
-
-export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
-  // Setup authorization or context here
-  const token = req.headers.authorization || '';
-  return { token };
-};
+import { Request } from 'express';
+
+export interface MyContext {
+  token?: string;
+  // user?: User;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  // Setup authorization or context here
+  const token = req.headers.authorization || '';
+  return { token };
+};

package/templates/mvc/ts/src/graphql/index.ts.ejs

@@ -1,3 +1,3 @@
-export { typeDefs } from '@/graphql/typeDefs';
-export { resolvers } from '@/graphql/resolvers';
-export { gqlContext, MyContext } from '@/graphql/context';
+export { typeDefs } from '@/graphql/typeDefs';
+export { resolvers } from '@/graphql/resolvers';
+export { gqlContext, MyContext } from '@/graphql/context';

package/templates/mvc/ts/src/graphql/resolvers/index.ts.ejs

@@ -1,4 +1,4 @@
-import { mergeResolvers } from '@graphql-tools/merge';
-import { userResolvers } from '@/graphql/resolvers/user.resolvers';
-
-export const resolvers = mergeResolvers([userResolvers]);
+import { mergeResolvers } from '@graphql-tools/merge';
+import { userResolvers } from '@/graphql/resolvers/user.resolvers';
+
+export const resolvers = mergeResolvers([userResolvers]);