nodejs-quickstart-structure 1.10.1 → 1.11.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.11.0] - 2026-03-02
+### Added
+- **Centralized Error Handling Mechanism:** All generated projects now include a standardized, predictable error response structure for both REST APIs and GraphQL communication types.
+  - New `src/errors/` directory with custom error classes: `ApiError`, `NotFoundError`, `BadRequestError`.
+  - New `error.middleware.{ts|js}` global error handler placed at the end of the Express middleware chain in `src/utils/` (MVC) and `src/utils/` + `src/infrastructure/webserver/middlewares/` (Clean Architecture).
+  - Integrates `winston` logger to automatically log 500-level errors to persistent log files.
+  - All controllers updated to pass errors via `next(error)` instead of manually sending responses.
+  - **GraphQL:** Apollo Server `formatError` hook configured with `unwrapResolverError` to intercept resolver errors and map `ApiError` instances to structured GraphQL extension codes.
+  - **REST APIs:** Express error middleware returns a consistent `{ statusCode, message, stack? }` JSON body.
+- **Error Response Standardization:** All error responses follow the same schema regardless of database, caching, or communication type selected.
+
+### Fixed
+- Fixed `swagger.js` / `swagger.yml` being incorrectly generated for non-REST API configurations (GraphQL, Kafka). Converted static `swagger.js` to `swagger.js.ejs` in MVC JS and Clean Architecture JS templates so `renderSwaggerConfig` can conditionally control its generation.
+- Fixed `userRoutes.ts` in Clean Architecture TypeScript template not passing `NextFunction` to controller methods, causing `TypeScript TS2554: Expected 3 arguments` compile errors during Docker builds.
+- Fixed incorrect relative import paths (`../../../../`) in Clean Architecture JS `error.middleware.js` — changed to correct 3-level relative paths (`../../../`).
+- Fixed `HTTP_STATUS` being imported without destructuring from `httpCodes.js` (which uses a plain `module.exports = HTTP_STATUS` default export), causing `Cannot read properties of undefined` runtime errors.
+- Fixed `renderErrorMiddleware` in `app-setup.js` deleting from the **template source directory** instead of the generated project's target directory. This caused error middleware templates to disappear from disk after the first test run, breaking all subsequent generations.
+
 ## [1.10.1] - 2026-03-02
 ### Added
 -  Roadmap & Upcoming Features. **[View our Public Roadmap on Trello](https://trello.com/b/TPTo8ylF/nodejs-quickstart-structure-product)**

package/README.md

@@ -19,6 +19,7 @@ A powerful CLI tool to scaffold production-ready Node.js microservices with buil
 - **Database Integration**: Pre-configured setup for **MySQL**, **PostgreSQL**, or **MongoDB**.
 - **Communication Flow**: Scaffold APIs using **REST**, **GraphQL** (with Apollo Server), or **Kafka** (event-driven).
 - **Caching Layer**: Choose between **Redis** or built-in **Memory Cache** for data caching.
+- **Centralized Error Handling**: Every project ships with a global error handler, custom error classes (`ApiError`, `NotFoundError`, `BadRequestError`), and structured JSON error responses — consistent across REST & GraphQL.
 - **Dockerized**: Automatically generates `docker-compose.yml` for DB, Kafka, Redis, and Zookeeper.
 - **Database Migrations/Schemas**: Integrated **Flyway** for SQL migrations or **Mongoose** schemas for MongoDB.
 - **Professional Standards**: Generated projects come with highly professional, industry-standard tooling.
@@ -29,6 +30,7 @@ We don't just generate boilerplate; we generate **production-ready** foundations
 
 -   **🔍 Code Quality**: Pre-configured `Eslint` and `Prettier` for consistent coding standards.
 -   **🛡️ Security**: Built-in `Helmet`, `HPP`, `CORS`, and Rate-Limiting middleware.
+-   **🚨 Error Handling**: Centralized global error middleware with custom error classes and structured `{ statusCode, message }` JSON responses. GraphQL uses Apollo's `formatError` hook; REST uses Express error middleware. Both integrate with Winston for automatic 500-level logging.
 -   **🧪 Testing Strategy**: Integrated `Jest` and `Supertest` setup for Unit and Integration testing.
 -   **🔄 CI/CD Integration**: Pre-configured workflows for **GitHub Actions**, **Jenkins**, and **GitLab CI**.
 -   **⚓ Git Hooks**: `Husky` and `Lint-Staged` to ensure no bad code is ever committed.
@@ -89,6 +91,8 @@ The CLI will guide you through the following steps:
 The generated project will include:
 
 -   `src/`: Source code (controllers, routes, services/use-cases).
+-   `src/errors/`: Custom error classes — `ApiError`, `NotFoundError`, `BadRequestError`.
+-   `src/utils/error.middleware.{ts|js}`: Global Express error handler (logs 500s, returns `{ statusCode, message }`).
 -   `flyway/sql/`: SQL migration scripts (if SQL database selected).
 -   `docker-compose.yml`: Services configuration for DB, Flyway, and Kafka.
 -   `package.json`: Dependencies and scripts (`start`, `dev`, `build`).

package/docs/generatorFlow.md

@@ -25,7 +25,7 @@ The generator prompts the user for the following configurations. These determine
 | **View Engine** | `None`, `EJS`, `Pug` | `None` | (MVC Only) Template engine for server-side rendering. |
 | **Database** | `None`, `MySQL`, `PostgreSQL`, `MongoDB` | `None` | The primary database. |
 | **Database Name** | Input String | `demo` | The name of the database to use/create. |
-| **Communication**| `REST APIs`, `Kafka` | `REST APIs` | The primary communication method. |
+| **Communication**| `REST APIs`, `GraphQL`, `Kafka` | `REST APIs` | The primary communication method. |
 | **Caching Layer**| `None`, `Redis`, `Memory Cache` | `None` | (If DB selected) Caching solution. |
 | **CI/CD Provider**| `None`, `GitHub Actions`, `Jenkins`| `None` | Setup for Continuous Integration/Deployment. |
 
@@ -47,13 +47,23 @@ The `generateProject` function in `lib/generator.js` executes the following step
 5.  **Render `README.md`**:
     *   Generates custom documentation specific to the selected stack.
 6.  **Render `src/index.{js|ts}`**:
-    *   Processes the entry point file to wire up the selected DB and Architecture.
-7.  **Dynamic Component Generation**:
-    *   **MVC**: Generates `userController` (imports specific DB service).
+    *   Processes the entry point file to wire up the selected DB, Architecture, and Communication type.
+    *   **GraphQL**: Wires up Apollo Server middleware with `formatError` hook for centralized error handling.
+    *   **REST APIs / Kafka**: Registers `app.use(errorMiddleware)` at the end of the Express chain.
+7.  **Render Error Middleware** (`renderErrorMiddleware`):
+    *   Processes `error.middleware.{ts|js}.ejs` template from the target directory's `src/utils/` path.
+    *   Renders to `src/utils/error.middleware.{ts|js}` in the generated project.
+    *   **Clean Architecture**: Also handles `src/infrastructure/webserver/middlewares/error.middleware.{js}` path.
+8.  **Dynamic Component Generation**:
+    *   **MVC**: Generates `userController` (imports specific DB service, uses `next(error)`).
     *   **Clean Architecture**: Generates `UserRepository` (infrastructure layer implementation).
     *   **Clean Architecture (JS only)**: Generates `server.js` (webserver setup).
-8.  **Communication Setup (Kafka)**:
-    *   If **Kafka** is selected:
+9.  **Communication Setup**:
+    *   **GraphQL**:
+        *   Generates Apollo Server v4 schema (`typeDefs`) and resolvers.
+        *   Configures `formatError` hook with `unwrapResolverError` for structured error mapping.
+        *   Automatically embeds Apollo Sandbox with local CSP headers (no CDN dependency).
+    *   **Kafka**:
         *   Copies Kafka client/service templates.
         *   **Clean Architecture Restructuring**:
             *   Moves service to `src/infrastructure/messaging`.
@@ -61,14 +71,14 @@ The `generateProject` function in `lib/generator.js` executes the following step
             *   Removes REST-specific folders (`interfaces/routes`, `interfaces/controllers`).
         *   **MVC Cleanup**:
             *   If no View Engine is selected, removes `src/controllers` and `src/routes` (assumes pure worker).
-9.  **Common Configuration**:
+10. **Common Configuration**:
     *   Copies `.gitignore`, `.dockerignore`, `Dockerfile`.
     *   Copies `tsconfig.json` (if TypeScript).
-10. **Database Setup**:
+11. **Database Setup**:
     *   **MongoDB**: Sets up `migrate-mongo-config.js` and initial migration script.
     *   **SQL (MySQL/Postgres)**: Sets up `flyway/sql` directory and copies initial SQL migration files.
     *   **None**: Skips migration setup.
-11. **Caching Setup**:
+12. **Caching Setup**:
     *   **Redis**:
         *   Injects `ioredis` dependency into `package.json`.
         *   Generates `redisClient.{js|ts}` config.
@@ -78,22 +88,23 @@ The `generateProject` function in `lib/generator.js` executes the following step
         *   Injects `node-cache` dependency.
         *   Generates `memoryCache.{js|ts}` config.
         *   **MVC/Clean**: Consumes the generic abstraction injected above.
-12. **Database Connection Config**:
+13. **Database Connection Config**:
     *   Renders `database.{js|ts}` or `mongoose.{js|ts}` based on DB selection.
     *   Places it in `src/config` (MVC) or `src/infrastructure/database` (Clean Arch).
     *   **None**: Skips this step.
-12. **Model Generation**:
+14. **Model Generation**:
     *   Renders `User` model (Mongoose schema or Sequelize/TypeORM model) in the appropriate directory.
     *   **None**: Generates a simple Mock Entity/Model class with in-memory data for testing.
-13. **View Engine Setup (MVC)**:
+15. **View Engine Setup (MVC)**:
     *   If selected, copies views (`views/ejs` or `views/pug`) and `public` assets.
-14. **Swagger Config**:
-    *   If **REST APIs** is selected, generates Swagger configuration.
-15. **Code Quality Setup**:
+16. **Swagger Config** (`renderSwaggerConfig`):
+    *   If **REST APIs** is selected, generates `swagger.yml` and `swagger.{ts|js}` config.
+    *   Cleans up `.ejs` template copies for non-REST configs (GraphQL, Kafka).
+17. **Code Quality Setup**:
     *   Generates `.eslintrc.json`, `.prettierrc`, `.lintstagedrc`.
-16. **Test Setup**:
+18. **Test Setup**:
     *   Generates `jest.config.js` and a sample `health.test.{js|ts}`.
-17. **CI/CD Setup**:
+19. **CI/CD Setup**:
     *   Helper: `setupCiCd`
     *   Checks `config.ciProvider`:
         *   **GitHub Actions**: Copies `.github/workflows/ci.yml`.
@@ -125,16 +136,41 @@ Standard architecture for web APIs.
 project-name/
 ├── src/
 │   ├── config/         # Database, Redis, Swagger, etc.
-│   ├── controllers/    # Request handlers
+│   ├── controllers/    # Request handlers (use next(error))
+│   ├── errors/         # ApiError, NotFoundError, BadRequestError
 │   ├── models/         # Database models
 │   ├── routes/         # Express routes
-│   └── index.js|ts     # Entry point
+│   ├── utils/
+│   │   ├── error.middleware.{ts|js}  # Global error handler
+│   │   ├── logger.{ts|js}
+│   │   └── httpCodes.{ts|js}
+│   └── index.js|ts     # Entry point (registers errorMiddleware last)
 ├── tests/              # Jest tests
 ├── package.json
 ├── Dockerfile
 └── docker-compose.yml
 ```
 
+### Case A2: MVC (GraphQL)
+Apollo Server v4 mounted as Express middleware.
+
+```text
+project-name/
+├── src/
+│   ├── config/         # Database, Redis config
+│   ├── controllers/    # GraphQL resolver backing logic (throws errors)
+│   ├── errors/         # ApiError, NotFoundError, BadRequestError
+│   ├── graphql/
+│   │   ├── schema/     # typeDefs
+│   │   └── resolvers/  # user.resolvers (calls controllers, throws errors)
+│   ├── models/
+│   ├── utils/
+│   │   ├── error.middleware.{ts|js}  # Express-level fallback error handler
+│   │   └── logger.{ts|js}
+│   └── index.js|ts     # Apollo Server + formatError hook
+└── ...
+```
+
 ### Case B: MVC (Web App with Views)
 Includes frontend views rendered on the server.
 
@@ -158,17 +194,23 @@ Separation of concerns with Domain, Use Cases, and Infrastructure.
 project-name/
 ├── src/
 │   ├── domain/                 # Entities (Enterprise rules)
+│   ├── errors/                 # ApiError, NotFoundError, BadRequestError
 │   ├── use_cases/              # Application business rules
 │   ├── interfaces/             # Adapters
-│   │   ├── controllers/
-│   │   └── routes/
+│   │   ├── controllers/        # Use next(error) for error propagation
+│   │   └── routes/             # Pass NextFunction through handlers
 │   ├── infrastructure/         # Frameworks & Drivers
 │   │   ├── config/             # Environment config
 │   │   ├── caching/            # Redis Client
 │   │   ├── database/           # DB connection & models
 │   │   ├── repositories/       # Data access implementation
-│   │   └── webserver/          # Express server setup
-│   └── index.js|ts
+│   │   └── webserver/
+│   │       ├── middlewares/
+│   │       │   └── error.middleware.js  # JS only — Express error handler
+│   │       └── server.js       # Express app setup
+│   ├── utils/
+│   │   └── error.middleware.ts  # TS — global error handler
+│   └── index.js|ts              # Registers errorMiddleware after Apollo/Express
 └── ...
 ```
 

package/lib/generator.js

@@ -2,7 +2,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { setupProjectDirectory, copyBaseStructure, copyCommonFiles } from './modules/project-setup.js';
 import { renderPackageJson, renderDockerCompose, renderReadme, renderDockerfile, renderProfessionalConfig, setupCiCd, renderTestSample, renderEnvExample } from './modules/config-files.js';
-import { renderIndexFile, renderDynamicComponents, renderSwaggerConfig, setupViews as setupSrcViews } from './modules/app-setup.js';
+import { renderIndexFile, renderErrorMiddleware, renderDynamicComponents, renderSwaggerConfig, setupViews as setupSrcViews } from './modules/app-setup.js';
 import { setupDatabase } from './modules/database-setup.js';
 import { setupKafka, setupViews } from './modules/kafka-setup.js';
 import { setupCaching } from './modules/caching-setup.js';
@@ -33,6 +33,9 @@ export const generateProject = async (config) => {
     // 6. Render index file (ts/js)
     await renderIndexFile(templatePath, targetDir, config);
 
+    // 6a. Render error middleware
+    await renderErrorMiddleware(templatePath, targetDir, config);
+
     // 7. Render Dynamic Components (Controllers/Repos/Server)
     await renderDynamicComponents(templatePath, targetDir, config);
 

package/lib/modules/app-setup.js

@@ -22,6 +22,40 @@ export const renderIndexFile = async (templatePath, targetDir, config) => {
     }
 };
 
+export const renderErrorMiddleware = async (templatePath, targetDir, config) => {
+    const { language, architecture } = config;
+    const errName = language === 'TypeScript' ? 'error.middleware.ts' : 'error.middleware.js';
+    const errTemplateName = `${errName}.ejs`;
+
+    if (architecture === 'MVC') {
+        // MVC: render from target's src/utils/ (the .ejs copy put there by copyBaseStructure)
+        const ejsCopy = path.join(targetDir, 'src/utils', errTemplateName);
+        const dest = path.join(targetDir, 'src/utils', errName);
+        if (await fs.pathExists(ejsCopy)) {
+            await fs.writeFile(dest, await fs.readFile(ejsCopy, 'utf-8'));
+            await fs.remove(ejsCopy);
+        }
+    } else {
+        // Clean Architecture: render from target's src/utils/ (the .ejs copy put there by copyBaseStructure)
+        const utilsEjsCopy = path.join(targetDir, 'src/utils', errTemplateName);
+        const utilsDest = path.join(targetDir, 'src/utils', errName);
+        await fs.ensureDir(path.join(targetDir, 'src/utils'));
+        if (await fs.pathExists(utilsEjsCopy)) {
+            await fs.writeFile(utilsDest, await fs.readFile(utilsEjsCopy, 'utf-8'));
+            await fs.remove(utilsEjsCopy);
+        }
+        // Also render the middlewares version if present (NOT removing from template)
+        const mwDir = path.join(targetDir, 'src/infrastructure/webserver/middlewares');
+        const mwEjsCopy = path.join(mwDir, errTemplateName);
+        const mwDest = path.join(mwDir, errName);
+        if (await fs.pathExists(mwEjsCopy)) {
+            await fs.ensureDir(mwDir);
+            await fs.writeFile(mwDest, await fs.readFile(mwEjsCopy, 'utf-8'));
+            await fs.remove(mwEjsCopy);
+        }
+    }
+};
+
 export const renderDynamicComponents = async (templatePath, targetDir, config) => {
     const { architecture, language, database, caching } = config;
 
@@ -127,6 +161,10 @@ export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
     
     // Check for Swagger config template (typically in src/config/swagger.ts.ejs)
     const swaggerTsTemplate = path.join(targetDir, 'src', 'config', 'swagger.ts.ejs');
+    // MVC JS uses swagger.js.ejs in src/config/
+    const swaggerJsTemplate = path.join(targetDir, 'src', 'config', 'swagger.js.ejs');
+    // Clean Arch JS uses swagger.js.ejs in src/infrastructure/webserver/
+    const swaggerJsCleanTemplate = path.join(targetDir, 'src', 'infrastructure', 'webserver', 'swagger.js.ejs');
     
     // Ensure config directory exists
     let configDir = path.join(targetDir, 'src', 'config');
@@ -146,13 +184,26 @@ export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
             const content = ejs.render(await fs.readFile(swaggerTsTemplate, 'utf-8'), { communication });
             await fs.writeFile(path.join(targetDir, 'src', 'config', 'swagger.ts'), content);
         }
+
+        // MVC JS: render swagger.js.ejs → swagger.js
+        if (await fs.pathExists(swaggerJsTemplate)) {
+            const content = await fs.readFile(swaggerJsTemplate, 'utf-8');
+            await fs.writeFile(path.join(targetDir, 'src', 'config', 'swagger.js'), content);
+        }
+
+        // Clean Arch JS: render swagger.js.ejs → swagger.js in webserver/
+        if (await fs.pathExists(swaggerJsCleanTemplate)) {
+            const content = await fs.readFile(swaggerJsCleanTemplate, 'utf-8');
+            await fs.writeFile(path.join(targetDir, 'src', 'infrastructure', 'webserver', 'swagger.js'), content);
+        }
     }
     
-    // Always remove the template after processing or if not needed
-    if (await fs.pathExists(swaggerTsTemplate)) {
-        await fs.remove(swaggerTsTemplate);
-    }
-    // Also cleanup yml template if not REST APIs since copyBaseSturcture copies it earlier
+    // Always remove the .ejs template after processing (or if non-REST, just delete it)
+    if (await fs.pathExists(swaggerTsTemplate)) await fs.remove(swaggerTsTemplate);
+    if (await fs.pathExists(swaggerJsTemplate)) await fs.remove(swaggerJsTemplate);
+    if (await fs.pathExists(swaggerJsCleanTemplate)) await fs.remove(swaggerJsCleanTemplate);
+
+    // Also cleanup yml template if not REST APIs since copyBaseStructure copies it earlier
     const swaggerYmlDestPath = path.join(targetDir, 'src', 'config', 'swagger.yml.ejs');
     if (await fs.pathExists(swaggerYmlDestPath)) {
         await fs.remove(swaggerYmlDestPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "type": "module",
   "description": "A CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",

package/templates/clean-architecture/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/clean-architecture/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/clean-architecture/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/clean-architecture/js/src/infrastructure/webserver/middlewares/error.middleware.js

@@ -0,0 +1,29 @@
+const logger = require('../../log/logger');
+const { ApiError } = require('../../../errors/ApiError');
+const HTTP_STATUS = require('../../../utils/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/clean-architecture/js/src/infrastructure/webserver/server.js.ejs

@@ -3,6 +3,7 @@ const cors = require('cors');
 require('dotenv').config();
 const logger = require('../log/logger');
 const morgan = require('morgan');
+const { errorMiddleware } = require('./middlewares/error.middleware');
 <%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('../../interfaces/routes/api');<%_ } -%>
 <%_ if (communication === 'REST APIs') { -%>
 const swaggerUi = require('swagger-ui-express');
@@ -12,6 +13,8 @@ const swaggerSpecs = require('./swagger');
 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('../../interfaces/graphql');
 const { gqlContext } = require('../../interfaces/graphql/context');
 <%_ } -%>
@@ -34,6 +37,25 @@ const startServer = async (port) => {
         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 }));
@@ -42,6 +64,8 @@ const startServer = async (port) => {
         res.json({ status: 'UP' });
     });
 
+    app.use(errorMiddleware);
+
     app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
     });

package/templates/clean-architecture/js/src/interfaces/controllers/userController.js.ejs

@@ -33,23 +33,20 @@ class UserController {
         }
     }
 <% } else { -%>
-    getUsers(req, res) {
+    getUsers(req, res, next) {
         this.getAllUsersUseCase.execute()
             .then(users => res.json(users))
-            .catch(err => {
-                logger.error('Error getting users:', err);
-                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: err.message });
-            });
+            .catch(next);
     }
 
-    async createUser(req, res) {
+    async createUser(req, res, next) {
         const { name, email } = req.body;
         try {
             const user = await this.createUserUseCase.execute(name, email);
             res.status(HTTP_STATUS.CREATED).json(user);
         } catch (error) {
             logger.error('Error creating user:', error);
-            res.status(HTTP_STATUS.BAD_REQUEST).json({ error: error.message });
+            next(error);
         }
     }
 <% } -%>

package/templates/clean-architecture/js/src/interfaces/graphql/resolvers/user.resolvers.js.ejs

@@ -1,4 +1,3 @@
-const { GraphQLError } = require('graphql');
 const UserController = require('../../controllers/userController');
 
 const userController = new UserController();
@@ -6,20 +5,12 @@ const userController = new 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/clean-architecture/js/src/interfaces/routes/api.js

@@ -4,7 +4,7 @@ const UserController = require('../controllers/userController');
 
 const userController = new UserController();
 
-router.post('/users', (req, res) => userController.createUser(req, res));
-router.get('/users', (req, res) => userController.getUsers(req, res));
+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;

package/templates/clean-architecture/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/clean-architecture/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/clean-architecture/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/clean-architecture/ts/src/index.ts.ejs

@@ -6,6 +6,7 @@ import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
 import logger from '@/infrastructure/log/logger';
 import morgan from 'morgan';
+import { errorMiddleware } from '@/utils/error.middleware';
 <%_ if (communication === 'REST APIs') { -%>import userRoutes from '@/interfaces/routes/userRoutes';<%_ } -%>
 <% if (communication === 'REST APIs') { -%>
 import swaggerUi from 'swagger-ui-express';
@@ -15,6 +16,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 '@/interfaces/graphql';
 import { gqlContext, MyContext } from '@/interfaces/graphql/context';
 <% } -%>
@@ -66,10 +69,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/clean-architecture/ts/src/interfaces/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 { UserRepository } from '@/infrastructure/repositories/UserRepository';
@@ -25,7 +25,7 @@ export class UserController {
             return user;
         } catch (error: unknown) {
             const message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('UserController Error:', message);
+            logger.error('UserController CreateUser Error:', message);
             throw error;
         }
     }
@@ -36,37 +36,31 @@ export class UserController {
             return users;
         } catch (error: unknown) {
             const message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('UserController Error:', message);
+            logger.error('UserController GetUsers Error:', message);
             throw error;
         }
     }
 <% } else { -%>
-    async createUser(req: Request, res: Response) {
+    async createUser(req: Request, res: Response, next: NextFunction) {
         try {
             const { name, email } = req.body;
             const user = await this.createUserUseCase.execute(name, email);
             res.status(HTTP_STATUS.CREATED).json(user);
-        } catch (error) {
-            logger.error('UserController Error:', 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' });
-            }
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('UserController CreateUser Error:', message);
+            next(error);
         }
     }
 
-    async getUsers(req: Request, res: Response) {
+    async getUsers(req: Request, res: Response, next: NextFunction) {
         try {
             const users = await this.getAllUsersUseCase.execute();
             res.json(users);
-        } catch (error) {
-            logger.error('UserController Error:', 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' });
-            }
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('UserController GetUsers Error:', message);
+            next(error);
         }
     }
 <% } -%>

package/templates/clean-architecture/ts/src/interfaces/graphql/resolvers/user.resolvers.ts.ejs

@@ -1,4 +1,3 @@
-import { GraphQLError } from 'graphql';
 import { UserController } from '@/interfaces/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/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 }),
+  });
+};