nodejs-quickstart-structure 1.10.1 → 1.11.1

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.1",
   "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;
     }
   }
 };