nodejs-quickstart-structure 1.10.1 → 1.11.1

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

@@ -1,10 +1,11 @@
-import { Router, Request, Response } from 'express';
+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) => userController.createUser(req, res));
-router.get('/', (req: Request, res: Response) => userController.getUsers(req, res));
+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;
+

package/templates/clean-architecture/ts/src/utils/error.middleware.ts.ejs

@@ -0,0 +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, _: 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/common/package.json.ejs

@@ -11,12 +11,11 @@
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
     "prepare": "node -e \"try { require('child_process').execSync('husky install'); } catch (e) { console.log('Not a git repository, skipping husky install'); }\"",
+<% if (database === 'MongoDB') { %>    "migrate": "migrate-mongo up",
+<% } -%>
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"
-    <%_ if (database === 'MongoDB') { -%>,
-    "migrate": "migrate-mongo up"
-<%_ } -%>
   },
   "dependencies": {
     "express": "^4.18.2",
@@ -80,9 +79,9 @@
     "eslint-config-prettier": "^10.0.1",
     "husky": "^8.0.3",
     "lint-staged": "^15.4.3"<% if (language === 'TypeScript') { %>,
-    "typescript-eslint": "^8.24.1",
-<% if (communication === 'REST APIs') { %>    "@types/swagger-ui-express": "^4.1.6",
-    "@types/yamljs": "^0.2.34",<% } %>
+    "typescript-eslint": "^8.24.1",<%_ if (communication === 'REST APIs') { %>
+    "@types/swagger-ui-express": "^4.1.6",
+    "@types/yamljs": "^0.2.34",<%_ } -%>
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "@types/jest": "^29.5.14",

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

@@ -61,7 +61,7 @@ const createUser = async (data) => {
   }
 };
 <% } else { -%>
-const getUsers = async (req, res) => {
+const getUsers = async (req, res, next) => {
   try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     const users = await cacheService.getOrSet('users:all', async () => {
@@ -85,11 +85,11 @@ const getUsers = async (req, res) => {
     res.json(users);
   } catch (error) {
     logger.error('Error fetching users:', error);
-    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Internal Server Error' });
+    next(error);
   }
 };
 
-const createUser = async (req, res) => {
+const createUser = async (req, res, next) => {
   try {
     const { name, email } = req.body;
 <%_ if (database === 'None') { -%>
@@ -107,7 +107,8 @@ const createUser = async (req, res) => {
     res.status(HTTP_STATUS.CREATED).json(user);
 <%_ } -%>
   } catch (error) {
-    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+    logger.error('Error creating user:', error);
+    next(error);
   }
 };
 <% } -%>

package/templates/mvc/js/src/errors/ApiError.js

@@ -0,0 +1,14 @@
+class ApiError extends Error {
+  constructor(statusCode, message, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+module.exports = { ApiError };

package/templates/mvc/js/src/errors/BadRequestError.js

@@ -0,0 +1,10 @@
+const { ApiError } = require('./ApiError');
+const { HTTP_STATUS } = require('../utils/httpCodes');
+
+class BadRequestError extends ApiError {
+  constructor(message = 'Bad request') {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}
+
+module.exports = { BadRequestError };

package/templates/mvc/js/src/errors/NotFoundError.js

@@ -0,0 +1,10 @@
+const { ApiError } = require('./ApiError');
+const { HTTP_STATUS } = require('../utils/httpCodes');
+
+class NotFoundError extends ApiError {
+  constructor(message = 'Resource not found') {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}
+
+module.exports = { NotFoundError };

package/templates/mvc/js/src/graphql/resolvers/user.resolvers.js.ejs

@@ -1,23 +1,14 @@
-const { GraphQLError } = require('graphql');
 const userController = require('../../controllers/userController');
 
 const userResolvers = {
   Query: {
     getAllUsers: async () => {
-      try {
-        return await userController.getUsers();
-      } catch (error) {
-        throw new GraphQLError(error.message || 'Internal server error', { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
-      }
+      return await userController.getUsers();
     }
   },
   Mutation: {
     createUser: async (_, { name, email }) => {
-      try {
-        return await userController.createUser({ name, email });
-      } catch (error) {
-        throw new GraphQLError(error.message || 'Internal server error', { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
-      }
+      return await userController.createUser({ name, email });
     }
   }
 };

package/templates/mvc/js/src/index.js.ejs

@@ -7,6 +7,8 @@ require('dotenv').config();
 const { ApolloServer } = require('@apollo/server');
 const { expressMiddleware } = require('@apollo/server/express4');
 const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
+const { unwrapResolverError } = require('@apollo/server/errors');
+const { ApiError } = require('./errors/ApiError');
 const { typeDefs, resolvers } = require('./graphql');
 const { gqlContext } = require('./graphql/context');
 <% } -%>
@@ -19,6 +21,7 @@ const app = express();
 const PORT = process.env.PORT || 3000;
 const logger = require('./utils/logger');
 const morgan = require('morgan');
+const { errorMiddleware } = require('./utils/error.middleware');
 
 app.use(cors());
 app.use(express.json());
@@ -57,10 +60,30 @@ const startServer = async () => {
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+      formatError: (formattedError, error) => {
+        const originalError = unwrapResolverError(error);
+        if (originalError instanceof ApiError) {
+          return {
+            ...formattedError,
+            message: originalError.message,
+            extensions: {
+              ...formattedError.extensions,
+              code: originalError.statusCode.toString(),
+            }
+          };
+        }
+        
+        logger.error(`GraphQL Error: ${formattedError.message}`);
+        if (originalError && originalError.stack && process.env.NODE_ENV === 'development') {
+           logger.error(originalError.stack);
+        }
+        return formattedError;
+      },
     });
     await server.start();
     app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
 <%_ } -%>
+    app.use(errorMiddleware);
     app.listen(PORT, () => {
         logger.info(`Server running on port ${PORT}`);
 <%_ if (communication === 'Kafka') { -%>

package/templates/mvc/js/src/utils/error.middleware.js

@@ -0,0 +1,28 @@
+const logger = require('./logger');
+const { ApiError } = require('../errors/ApiError');
+const HTTP_STATUS = require('./httpCodes');
+
+const errorMiddleware = (err, req, res, _) => {
+  let error = err;
+
+  if (!(error instanceof ApiError)) {
+    const statusCode = err.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;
+
+  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 }),
+  });
+};
+
+module.exports = { errorMiddleware };

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

@@ -1,5 +1,5 @@
 <% if (communication !== 'GraphQL') { -%>
-import { Request, Response } from 'express';
+import { Request, Response, NextFunction } from 'express';
 import { HTTP_STATUS } from '@/utils/httpCodes';
 <% } -%>
 import User from '@/models/User';
@@ -63,7 +63,7 @@ export class UserController {
         }
     }
 <% } else { -%>
-    async getUsers(req: Request, res: Response) {
+    async getUsers(req: Request, res: Response, next: NextFunction) {
         try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
             const users = await cacheService.getOrSet('users:all', async () => {
@@ -86,16 +86,12 @@ export class UserController {
 <%_ } -%>
             res.json(users);
         } catch (error) {
-            logger.error('Error fetching users:', error);
-            if (error instanceof Error) {
-                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
-            } else {
-                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
-            }
+            logger.error('Error fetching user:', error);
+            next(error);
         }
     }
 
-    async createUser(req: Request, res: Response) {
+    async createUser(req: Request, res: Response, next: NextFunction) {
         try {
             const { name, email } = req.body;
 <%_ if (database === 'None') { -%>
@@ -114,11 +110,7 @@ export class UserController {
 <%_ } -%>
         } catch (error) {
             logger.error('Error creating user:', error);
-            if (error instanceof Error) {
-                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
-            } else {
-                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
-            }
+            next(error);
         }
     }
 <% } -%>

package/templates/mvc/ts/src/errors/ApiError.ts

@@ -0,0 +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);
+    }
+  }
+}

package/templates/mvc/ts/src/errors/BadRequestError.ts

@@ -0,0 +1,8 @@
+import { ApiError } from './ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+export class BadRequestError extends ApiError {
+  constructor(message = 'Bad request') {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}

package/templates/mvc/ts/src/errors/NotFoundError.ts

@@ -0,0 +1,8 @@
+import { ApiError } from './ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+export class NotFoundError extends ApiError {
+  constructor(message = 'Resource not found') {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}

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

@@ -1,4 +1,3 @@
-import { GraphQLError } from 'graphql';
 import { UserController } from '@/controllers/userController';
 
 const userController = new UserController();
@@ -6,22 +5,14 @@ const userController = new UserController();
 export const userResolvers = {
   Query: {
     getAllUsers: async () => {
-      try {
-        return await userController.getUsers();
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : 'Internal server error';
-        throw new GraphQLError(message, { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
-      }
+      const users = await userController.getUsers();
+      return users;
     }
   },
   Mutation: {
     createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
-      try {
-        return await userController.createUser({ name, email });
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : 'Internal server error';
-        throw new GraphQLError(message, { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
-      }
+      const user = await userController.createUser({ name, email });
+      return user;
     }
   }
 };

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

@@ -6,6 +6,7 @@ import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
 import logger from '@/utils/logger';
 import morgan from 'morgan';
+import { errorMiddleware } from '@/utils/error.middleware';
 <%_ if (communication === 'REST APIs') { -%>
 import apiRoutes from '@/routes/api';<%_ } -%>
 <% if (communication === 'REST APIs') { %>
@@ -16,6 +17,8 @@ import swaggerSpecs from '@/config/swagger';<% } -%>
 import { ApolloServer } from '@apollo/server';
 import { expressMiddleware } from '@apollo/server/express4';
 import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { unwrapResolverError } from '@apollo/server/errors';
+import { ApiError } from '@/errors/ApiError';
 import { typeDefs, resolvers } from '@/graphql';
 import { gqlContext, MyContext } from '@/graphql/context';
 <% } -%>
@@ -81,10 +84,30 @@ const startServer = async () => {
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+      formatError: (formattedError, error) => {
+        const originalError = unwrapResolverError(error);
+        if (originalError instanceof ApiError) {
+          return {
+            ...formattedError,
+            message: originalError.message,
+            extensions: {
+              ...formattedError.extensions,
+              code: originalError.statusCode.toString(),
+            }
+          };
+        }
+        
+        logger.error(`GraphQL Error: ${formattedError.message}`);
+        if (originalError instanceof Error && originalError.stack && process.env.NODE_ENV === 'development') {
+           logger.error(originalError.stack);
+        }
+        return formattedError;
+      },
     });
     await server.start();
     app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
 <%_ } -%>
+    app.use(errorMiddleware);
     app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>

package/templates/mvc/ts/src/routes/api.ts

@@ -1,10 +1,10 @@
-import { Router, Request, Response } from 'express';
+import { Router, Request, Response, NextFunction } from 'express';
 import { UserController } from '@/controllers/userController';
 
 const router = Router();
 const userController = new UserController();
 
-router.get('/users', (req: Request, res: Response) => userController.getUsers(req, res));
-router.post('/users', (req: Request, res: Response) => userController.createUser(req, res));
+router.get('/users', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
+router.post('/users', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
 
 export default router;

package/templates/mvc/ts/src/utils/error.middleware.ts.ejs

@@ -0,0 +1,27 @@
+import { Request, Response } from 'express';
+import logger from '@/utils/logger';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+export const errorMiddleware = (err: Error, req: Request, res: Response, _: 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 }),
+  });
+};