nodejs-quickstart-structure 1.12.0 → 1.13.0

package/CHANGELOG.md

@@ -5,6 +5,16 @@ 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.13.0] - 2026-03-05
+### Added
+- **Enhanced Health Check System:**
+  - Standardized health logic for both MVC and Clean Architecture.
+  - Deep verification: Automatically pings the selected database (MySQL, PostgreSQL, MongoDB) during health checks and returns a `DOWN` status with 500 code if the connection is lost.
+  - Structured response including `uptime`, `memoryUsage`, `database` connectivity status, and `timestamp`.
+- **Improved Graceful Shutdown:**
+  - Standardized signal handling (`SIGINT`, `SIGTERM`) across all architecture types to ensure clean disposal of database and caching resources.
+  - Integrated proper shutdown sequences for Redis, MySQL, PostgreSQL, and MongoDB.
+
 ## [1.12.0] - 2026-03-04
 ### Added
 - **Zod Environment Validation:** Replaced manual `dotenv` process calls in server entry points with a centralized schema parser.
@@ -16,13 +26,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [1.11.1] - 2026-03-03
 ### Fixed
-- Fixed relative import paths in Clean Architecture JS `error.middleware.js` — changed to correct 3-level relative paths (`../../../`).
+- Fixed relative import paths in Clean Architecture JS `errorMiddleware.js` — changed to correct 3-level relative paths (`../../../`).
 
 ## [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).
+  - 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/middleware/` (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.
@@ -32,7 +42,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### 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 incorrect relative import paths (`../../../../`) in Clean Architecture JS `errorMiddleware.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.
 

package/README.md

@@ -34,6 +34,7 @@ We don't just generate boilerplate; we generate **production-ready** foundations
 -   **🧪 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.
+-   **🤝 Reliability**: Advanced Health Checks (`/health`) with deep database pings and Graceful Shutdown workflows for zero-downtime rollouts.
 -   **🐳 DevOps**: Highly optimized **Multi-Stage Dockerfile** for small, secure production images.
 -   **🚀 Deployment**: Ship confidently with an integrated **PM2 Ecosystem Configuration** for zero-downtime reloads and robust process management.
 

package/docs/generatorFlow.md

@@ -50,10 +50,10 @@ The `generateProject` function in `lib/generator.js` executes the following step
     *   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.
+7.  **Error Middleware setup** (`renderErrorMiddleware`):
+    *   Processes `errorMiddleware.{ts|js}.ejs` template from the target directory's `src/utils/` path.
+    *   Renders to `src/utils/errorMiddleware.{ts|js}` in the generated project.
+    *   **Clean Architecture**: Also handles `src/infrastructure/webserver/middleware/errorMiddleware.{js}` path.
 8.  **Dynamic Component Generation**:
     *   **MVC**: Generates `userController` (imports specific DB service, uses `next(error)`).
     *   **Clean Architecture**: Generates `UserRepository` (infrastructure layer implementation).
@@ -141,7 +141,7 @@ project-name/
 │   ├── models/         # Database models
 │   ├── routes/         # Express routes
 │   ├── utils/
-│   │   ├── error.middleware.{ts|js}  # Global error handler
+│   │   ├── errorMiddleware.{ts|js}  # Global error handler
 │   │   ├── logger.{ts|js}
 │   │   └── httpCodes.{ts|js}
 │   └── index.js|ts     # Entry point (registers errorMiddleware last)
@@ -165,7 +165,7 @@ project-name/
 │   │   └── resolvers/  # user.resolvers (calls controllers, throws errors)
 │   ├── models/
 │   ├── utils/
-│   │   ├── error.middleware.{ts|js}  # Express-level fallback error handler
+│   │   ├── errorMiddleware.{ts|js}  # Express-level fallback error handler
 │   │   └── logger.{ts|js}
 │   └── index.js|ts     # Apollo Server + formatError hook
 └── ...
@@ -205,11 +205,11 @@ project-name/
 │   │   ├── database/           # DB connection & models
 │   │   ├── repositories/       # Data access implementation
 │   │   └── webserver/
-│   │       ├── middlewares/
-│   │       │   └── error.middleware.js  # JS only — Express error handler
+│   │       ├── middleware/
+│   │       │   └── errorMiddleware.js  # JS only — Express error handler
 │   │       └── server.js       # Express app setup
 │   ├── utils/
-│   │   └── error.middleware.ts  # TS — global error handler
+│   │   └── errorMiddleware.ts  # TS — global error handler
 │   └── index.js|ts              # Registers errorMiddleware after Apollo/Express
 └── ...
 ```

package/lib/modules/app-setup.js

@@ -3,19 +3,20 @@ import path from 'path';
 import ejs from 'ejs';
 
 export const renderIndexFile = async (templatePath, targetDir, config) => {
-    const { communication, viewEngine, database, architecture, projectName, language } = config;
+    const { communication, viewEngine, database, architecture, projectName, language, caching } = config;
     const indexFileName = language === 'TypeScript' ? 'index.ts' : 'index.js';
     const indexPath = path.join(targetDir, 'src', indexFileName);
     const indexTemplateSource = path.join(templatePath, 'src', `${indexFileName}.ejs`);
-    
+
     if (await fs.pathExists(indexTemplateSource)) {
         const indexTemplate = await fs.readFile(indexTemplateSource, 'utf-8');
-        const indexContent = ejs.render(indexTemplate, { 
-            communication, 
+        const indexContent = ejs.render(indexTemplate, {
+            communication,
             viewEngine,
             database,
             architecture,
-            projectName
+            projectName,
+            caching
         });
         await fs.writeFile(indexPath, indexContent);
         await fs.remove(path.join(targetDir, 'src', `${indexFileName}.ejs`));
@@ -25,7 +26,7 @@ export const renderIndexFile = async (templatePath, targetDir, config) => {
 export const renderEnvConfig = async (templatePath, targetDir, config) => {
     const { language, architecture, database, caching, communication } = config;
     const envExt = language === 'TypeScript' ? 'ts' : 'js';
-    
+
     let configDir = path.join(targetDir, 'src', 'config');
     if (architecture === 'Clean Architecture' && language === 'JavaScript') {
         configDir = path.join(targetDir, 'src', 'infrastructure', 'config');
@@ -33,7 +34,7 @@ export const renderEnvConfig = async (templatePath, targetDir, config) => {
 
     const envTemplatePath = path.join(configDir, `env.${envExt}.ejs`);
     const envDestPath = path.join(configDir, `env.${envExt}`);
-    
+
     if (await fs.pathExists(envTemplatePath)) {
         const envTemplate = await fs.readFile(envTemplatePath, 'utf-8');
         const envContent = ejs.render(envTemplate, {
@@ -48,7 +49,7 @@ export const renderEnvConfig = 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 errName = language === 'TypeScript' ? 'errorMiddleware.ts' : 'errorMiddleware.js';
     const errTemplateName = `${errName}.ejs`;
 
     if (architecture === 'MVC') {
@@ -68,8 +69,8 @@ export const renderErrorMiddleware = async (templatePath, targetDir, config) =>
             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');
+        // Also render the middleware version if present (NOT removing from template)
+        const mwDir = path.join(targetDir, 'src/infrastructure/webserver/middleware');
         const mwEjsCopy = path.join(mwDir, errTemplateName);
         const mwDest = path.join(mwDir, errName);
         if (await fs.pathExists(mwEjsCopy)) {
@@ -94,11 +95,11 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
             await fs.writeFile(userControllerPath, content);
             await fs.remove(path.join(targetDir, 'src/controllers', `${userControllerName}.ejs`));
         }
-    } 
+    }
     // Clean Architecture Repo
     else if (architecture === 'Clean Architecture') {
         const repoName = language === 'TypeScript' ? 'UserRepository.ts' : 'UserRepository.js';
-        const repoPath = path.join(targetDir, 'src/infrastructure/repositories', repoName); 
+        const repoPath = path.join(targetDir, 'src/infrastructure/repositories', repoName);
         const repoTemplate = path.join(templatePath, 'src/infrastructure/repositories', `${repoName}.ejs`);
 
         if (await fs.pathExists(repoTemplate)) {
@@ -119,22 +120,58 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
     }
     // Render Server (Clean Arch JS only)
     if (architecture === 'Clean Architecture' && language === 'JavaScript') {
-         const serverName = 'server.js';
-         const serverPath = path.join(targetDir, 'src/infrastructure/webserver', serverName);
-         const serverTemplate = path.join(templatePath, 'src/infrastructure/webserver', `${serverName}.ejs`);
-         
-         if (await fs.pathExists(serverTemplate)) {
-             const content = ejs.render(await fs.readFile(serverTemplate, 'utf-8'), { communication: config.communication });
-             await fs.writeFile(serverPath, content);
-             await fs.remove(path.join(targetDir, 'src/infrastructure/webserver', `${serverName}.ejs`));
-         }
+        const serverName = 'server.js';
+        const serverPath = path.join(targetDir, 'src/infrastructure/webserver', serverName);
+        const serverTemplate = path.join(templatePath, 'src/infrastructure/webserver', `${serverName}.ejs`);
+
+        if (await fs.pathExists(serverTemplate)) {
+            const content = ejs.render(await fs.readFile(serverTemplate, 'utf-8'), { communication: config.communication, database, caching });
+            await fs.writeFile(serverPath, content);
+            await fs.remove(path.join(targetDir, 'src/infrastructure/webserver', `${serverName}.ejs`));
+        }
+    }
+
+    // Cleanup REST routes if GraphQL or Kafka is selected
+    if (config.communication !== 'REST APIs') {
+        if (architecture === 'MVC') {
+            await fs.remove(path.join(targetDir, 'src/routes'));
+        } else if (architecture === 'Clean Architecture') {
+            await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
+        }
+    }
+
+    // Advanced Health Check Route Modularization
+    const healthExt = language === 'TypeScript' ? 'ts' : 'js';
+    const healthTemplatePath = path.join(templatePath, '../../common/health', healthExt, `healthRoute.${healthExt}.ejs`);
+
+    if (await fs.pathExists(healthTemplatePath)) {
+        let routeDestDir = path.join(targetDir, 'src', 'routes');
+        if (architecture === 'Clean Architecture') {
+            routeDestDir = path.join(targetDir, 'src', 'interfaces', 'routes');
+        }
+        await fs.ensureDir(routeDestDir);
+
+        const healthRouteContent = ejs.render(await fs.readFile(healthTemplatePath, 'utf-8'), { database, architecture });
+        await fs.writeFile(path.join(routeDestDir, `healthRoute.${healthExt}`), healthRouteContent);
+    }
+
+    // Advanced Graceful Shutdown Modularization
+    const shutdownExt = language === 'TypeScript' ? 'ts' : 'js';
+    const shutdownTemplatePath = path.join(templatePath, '../../common/shutdown', shutdownExt, `gracefulShutdown.${shutdownExt}.ejs`);
+
+    if (await fs.pathExists(shutdownTemplatePath)) {
+        let utilsDestDir = path.join(targetDir, 'src', 'utils');
+        await fs.ensureDir(utilsDestDir);
+
+        const shutdownContent = ejs.render(await fs.readFile(shutdownTemplatePath, 'utf-8'), { database, architecture, caching, communication: config.communication });
+        await fs.writeFile(path.join(utilsDestDir, `gracefulShutdown.${shutdownExt}`), shutdownContent);
     }
 
     // GraphQL Setup
     if (config.communication === 'GraphQL') {
         const ext = language === 'TypeScript' ? 'ts' : 'js';
         let graphqlInternalPath = architecture === 'MVC' ? 'src/graphql' : 'src/interfaces/graphql';
-        
+
         const sourceGraphqDir = path.join(templatePath, graphqlInternalPath);
         const targetGraphqlDir = path.join(targetDir, graphqlInternalPath);
 
@@ -169,27 +206,18 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
         let graphqlInternalPath = architecture === 'MVC' ? 'src/graphql' : 'src/interfaces/graphql';
         await fs.remove(path.join(targetDir, graphqlInternalPath));
     }
-
-    // Cleanup REST routes if GraphQL or Kafka is selected
-    if (config.communication !== 'REST APIs') {
-        if (architecture === 'MVC') {
-            await fs.remove(path.join(targetDir, 'src/routes'));
-        } else if (architecture === 'Clean Architecture') {
-            await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
-        }
-    }
 };
 
 export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
     const { communication, projectName, architecture, language } = 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');
     if (architecture === 'Clean Architecture' && language === 'JavaScript') {
@@ -221,7 +249,7 @@ export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
             await fs.writeFile(path.join(targetDir, 'src', 'infrastructure', 'webserver', 'swagger.js'), content);
         }
     }
-    
+
     // 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);
@@ -239,7 +267,7 @@ export const setupViews = async (templatesDir, targetDir, config) => {
     if (architecture === 'MVC' && viewEngine && viewEngine !== 'None') {
         const viewsSource = path.join(templatesDir, 'common', 'views', viewEngine.toLowerCase());
         if (await fs.pathExists(viewsSource)) {
-             await fs.copy(viewsSource, path.join(targetDir, 'src/views'));
+            await fs.copy(viewsSource, path.join(targetDir, 'src/views'));
         }
     }
 };

package/lib/modules/kafka-setup.js

@@ -55,16 +55,14 @@ export const setupKafka = async (templatesDir, targetDir, config) => {
         // Cleanup old services folder
         await fs.remove(path.join(targetDir, 'src/services'));
         
-        // Remove REST-specific folders (Interfaces)
-        await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
+        // Remove REST-specific folders (Interfaces) - Note: routes is kept for health endpoint
         await fs.remove(path.join(targetDir, 'src/interfaces/controllers'));
         
         // Original logic removed src/config entirely, but now we use it for Zod env validation in TS.
         // We will no longer delete it.
     } else if (architecture === 'MVC' && (!config.viewEngine || config.viewEngine === 'None')) {
-        // MVC Cleanup for Kafka Worker (No views)
+        // MVC Cleanup for Kafka Worker (No views) - Note: routes is kept for health endpoint
         await fs.remove(path.join(targetDir, 'src/controllers'));
-        await fs.remove(path.join(targetDir, 'src/routes'));
     }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "1.12.0",
+  "version": "1.13.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/infrastructure/webserver/server.js.ejs

@@ -2,9 +2,10 @@ const express = require('express');
 const cors = require('cors');
 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');<%_ } -%>
+const { errorMiddleware } = require('./middleware/errorMiddleware');
+const healthRoutes = require('../../interfaces/routes/healthRoute');
 <%_ if (communication === 'REST APIs') { -%>
+const apiRoutes = require('../../interfaces/routes/api');
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./swagger');
 <%_ } -%>
@@ -36,7 +37,7 @@ const startServer = async () => {
     <%_ } -%>
     <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer({
+    const apolloServer = new ApolloServer({
         typeDefs,
         resolvers,
         plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -60,18 +61,28 @@ const startServer = async () => {
             return formattedError;
         },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
     <%_ } -%>
-    app.get('/health', (req, res) => {
-        res.json({ status: 'UP' });
-    });
+    app.use('/health', healthRoutes);
 
     app.use(errorMiddleware);
 
-    app.listen(port, () => {
+    const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'Kafka') { -%>
+        const { connectKafka, sendMessage } = require('../../infrastructure/messaging/kafkaClient');
+        connectKafka().then(() => {
+          logger.info('Kafka connected');
+          sendMessage('test-topic', 'Hello Kafka from Clean Arch JS!');
+        }).catch(err => {
+          logger.error('Failed to connect to Kafka:', err);
+        });
+<%_ } -%>
     });
+
+    const setupGracefulShutdown = require('../../utils/gracefulShutdown');
+    setupGracefulShutdown(server);
 };
 
 module.exports = startServer;

package/templates/clean-architecture/ts/src/index.ts.ejs

@@ -1,13 +1,15 @@
-import express, { Request, Response } from 'express';
+import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
 import hpp from 'hpp';
 import rateLimit from 'express-rate-limit';
 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';<%_ } -%>
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/interfaces/routes/healthRoute';
 <% if (communication === 'REST APIs') { -%>
+import userRoutes from '@/interfaces/routes/userRoutes';
 import swaggerUi from 'swagger-ui-express';
 import swaggerSpecs from '@/config/swagger';<% } -%>
 <%_ if (communication === 'Kafka') { -%>import { KafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
@@ -56,15 +58,13 @@ app.use('/api/users', userRoutes);
 <%_ if (communication === 'REST APIs') { -%>
 app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
 <%_ } -%>
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer<MyContext>({
+    const apolloServer = new ApolloServer<MyContext>({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -88,14 +88,16 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(port, () => {
+<%_ if (communication === 'Kafka') { -%>
+    const kafkaService = new KafkaService();
+<%_ } -%>
+    const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>
-        const kafkaService = new KafkaService();
         kafkaService.connect().then(() => {
           logger.info('Kafka connected');
           kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
@@ -104,6 +106,8 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
 };
 
 <%_ if (database !== 'None') { -%>

package/templates/common/caching/js/redisClient.js.ejs

@@ -66,6 +66,10 @@ class RedisService {
         if (data) await this.set(key, data, ttl);
         return data;
     }
+
+    async quit() {
+        return await this.client.quit();
+    }
 }
 
 module.exports = RedisService.getInstance();

package/templates/common/caching/ts/redisClient.ts.ejs

@@ -71,6 +71,10 @@ class RedisService {
         if (data) await this.set(key, data, ttl);
         return data;
     }
+
+    public async quit(): Promise<'OK'> {
+        return await this.client.quit();
+    }
 }
 
 export default RedisService.getInstance();

package/templates/common/health/js/healthRoute.js.ejs

@@ -0,0 +1,44 @@
+const express = require('express');
+const router = express.Router();
+const logger = require('<% if (architecture === "MVC") { %>../utils/logger<% } else { %>../../infrastructure/log/logger<% } %>');
+const HTTP_STATUS = require('<% if (architecture === "MVC") { %>../utils/httpCodes<% } else { %>../../utils/httpCodes<% } %>');
+
+router.get('/', async (req, res) => {
+  const healthData = {
+    status: 'UP',
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    database: 'disconnected',
+    timestamp: Date.now()
+  };
+  logger.info('Health Check');
+
+<%_ if (database !== 'None') { -%>
+  try {
+<%_ if (database === 'MongoDB') { -%>
+    const mongoose = require('mongoose');
+    if (mongoose.connection.readyState === 1) {
+      if (mongoose.connection.db && mongoose.connection.db.admin) {
+         await mongoose.connection.db.admin().ping();
+      }
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    const sequelize = require('<% if (architecture === "MVC") { %>../config/database<% } else { %>../../infrastructure/database/database<% } %>');
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error('Health Check Database Ping Failed:', err);
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
+  }
+<%_ } else { -%>
+  healthData.database = 'None';
+<%_ } -%>
+
+  res.status(HTTP_STATUS.OK).json(healthData);
+});
+
+module.exports = router;

package/templates/common/health/ts/healthRoute.ts.ejs

@@ -0,0 +1,43 @@
+import { Router, Request, Response } from 'express';
+import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+const router = Router();
+
+router.get('/', async (req: Request, res: Response) => {
+  const healthData: Record<string, unknown> = {
+    status: 'UP',
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    database: 'disconnected',
+    timestamp: Date.now()
+  };
+  logger.info('Health Check');
+
+<%_ if (database !== 'None') { -%>
+  try {
+<%_ if (database === 'MongoDB') { -%>
+    const mongoose = (await import('mongoose')).default;
+    if (mongoose.connection.readyState === 1) {
+      await mongoose.connection.db?.admin().ping();
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    const sequelize = (await import('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>')).default;
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error('Health Check Database Ping Failed:', err);
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
+  }
+<%_ } else { -%>
+  healthData.database = 'None';
+<%_ } -%>
+
+  res.status(HTTP_STATUS.OK).json(healthData);
+});
+
+export default router;

package/templates/common/kafka/js/services/kafkaService.js.ejs

@@ -27,4 +27,9 @@ const sendMessage = async (topic, message) => {
     });
 };
 
-module.exports = { connectKafka, sendMessage };
+const disconnectKafka = async () => {
+    await producer.disconnect();
+    await consumer.disconnect();
+};
+
+module.exports = { connectKafka, sendMessage, disconnectKafka };

package/templates/common/kafka/ts/services/kafkaService.ts.ejs

@@ -33,5 +33,10 @@ export class KafkaService {
             ],
         });
     }
+
+    async disconnect() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
+    }
 }
 

package/templates/common/shutdown/js/gracefulShutdown.js.ejs

@@ -0,0 +1,61 @@
+<%_ 
+let loggerPath = './logger';
+let dbPath = '../config/database';
+let redisPath = '../config/redisClient';
+let kafkaPath = '../services/kafkaService';
+
+if (architecture === 'Clean Architecture') {
+    loggerPath = '../infrastructure/log/logger';
+    dbPath = '../infrastructure/database/database';
+    redisPath = '../infrastructure/caching/redisClient';
+    kafkaPath = '../infrastructure/messaging/kafkaClient';
+}
+_%>
+const logger = require('<%- loggerPath %>');
+
+const setupGracefulShutdown = (server) => {
+    const gracefulShutdown = async (signal) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async () => {
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                const mongoose = require('mongoose');
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                const sequelize = require('<%- dbPath %>');
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                const redisService = require('<%- redisPath %>');
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                const { disconnectKafka } = require('<%- kafkaPath %>');
+                await disconnectKafka();
+                logger.info('Kafka connection closed.');
+<%_ } -%>
+                logger.info('Graceful shutdown fully completed.');
+                process.exit(0);
+            } catch (err) {
+                logger.error('Error during shutdown:', err);
+                process.exit(1);
+            }
+        });
+
+        setTimeout(() => {
+            logger.error('Could not close connections in time, forcefully shutting down');
+            process.exit(1);
+        }, 15000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+};
+
+module.exports = setupGracefulShutdown;

package/templates/common/shutdown/ts/gracefulShutdown.ts.ejs

@@ -0,0 +1,58 @@
+import { Server } from 'http';
+<%_ if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<%_ } else { -%>
+import logger from '@/infrastructure/log/logger';
+<%_ } -%>
+
+export const setupGracefulShutdown = (server: Server<% if (communication === 'Kafka') { %>, kafkaService: { disconnect: () => Promise<void> }<% } %>) => {
+    const gracefulShutdown = async (signal: string) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async () => {
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                const mongoose = (await import('mongoose')).default;
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                <%_ if (architecture === 'MVC') { -%>
+                const sequelize = (await import('@/config/database')).default;
+                <%_ } else { -%>
+                const sequelize = (await import('@/infrastructure/database/database')).default;
+                <%_ } -%>
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                <%_ if (architecture === 'MVC') { -%>
+                const redisService = (await import('@/config/redisClient')).default;
+                <%_ } else { -%>
+                const redisService = (await import('@/infrastructure/caching/redisClient')).default;
+                <%_ } -%>
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                await kafkaService.disconnect();
+                logger.info('Kafka connection closed.');
+<%_ } -%>
+                logger.info('Graceful shutdown fully completed.');
+                process.exit(0);
+            } catch (err) {
+                logger.error('Error during shutdown:', err);
+                process.exit(1);
+            }
+        });
+
+        setTimeout(() => {
+            logger.error('Could not close connections in time, forcefully shutting down');
+            process.exit(1);
+        }, 15000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+};

package/templates/common/tests/health.test.ts.ejs

@@ -1,14 +1,24 @@
 <% if (language === 'TypeScript') { %>import request from 'supertest';
-import express from 'express';<% } else { %>const request = require('supertest');
-const express = require('express');<% } %>
+import express from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';<% } else { %>const request = require('supertest');
+const express = require('express');
+const HTTP_STATUS = require('../src/utils/httpCodes');<% } %>
 
 const app = express();
-app.get('/health', (req, res) => res.json({ status: 'UP' }));
+app.get('/health', (req, res) => res.status(HTTP_STATUS.OK).json({ 
+  status: 'UP', 
+  uptime: 120, 
+  memory: { rss: 1024, heapTotal: 512, heapUsed: 256, external: 128 }, 
+  database: 'connected' 
+}));
 
 describe('Health Check', () => {
-  it('should return 200 OK', async () => {
+  it('should return 200 OK with detailed metrics', async () => {
     const res = await request(app).get('/health');
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual({ status: 'UP' });
+    expect(res.status).toBe(HTTP_STATUS.OK);
+    expect(res.body).toHaveProperty('status', 'UP');
+    expect(res.body).toHaveProperty('uptime');
+    expect(res.body).toHaveProperty('memory');
+    expect(res.body).toHaveProperty('database');
   });
 });

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

@@ -1,6 +1,7 @@
 const express = require('express');
 const cors = require('cors');
 <%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } -%>
+const healthRoutes = require('./routes/healthRoute');
 <%_ if (communication === 'Kafka') { -%>const { connectKafka, sendMessage } = require('./services/kafkaService');<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 const { ApolloServer } = require('@apollo/server');
@@ -21,7 +22,7 @@ const app = express();
 const PORT = env.PORT;
 const logger = require('./utils/logger');
 const morgan = require('morgan');
-const { errorMiddleware } = require('./utils/error.middleware');
+const { errorMiddleware } = require('./utils/errorMiddleware');
 
 app.use(cors());
 app.use(express.json());
@@ -48,15 +49,13 @@ app.get('/', (req, res) => {
   });
 });
 <% } -%>
-app.get('/health', (req, res) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer({
+    const apolloServer = new ApolloServer({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -80,11 +79,11 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(PORT, () => {
+    const server = app.listen(PORT, () => {
         logger.info(`Server running on port ${PORT}`);
 <%_ if (communication === 'Kafka') { -%>
         connectKafka().then(() => {
@@ -95,6 +94,9 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    const setupGracefulShutdown = require('./utils/gracefulShutdown');
+    setupGracefulShutdown(server);
 };
 
 <%_ if (database !== 'None') { -%>

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

@@ -6,7 +6,9 @@ import hpp from 'hpp';
 import rateLimit from 'express-rate-limit';
 import logger from '@/utils/logger';
 import morgan from 'morgan';
-import { errorMiddleware } from '@/utils/error.middleware';
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/routes/healthRoute';
 <%_ if (communication === 'REST APIs') { -%>
 import apiRoutes from '@/routes/api';<%_ } -%>
 <% if (communication === 'REST APIs') { %>
@@ -70,15 +72,13 @@ app.get('/', (req: Request, res: Response) => {
   });
 });
 <% } -%>
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer<MyContext>({
+    const apolloServer = new ApolloServer<MyContext>({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -102,14 +102,16 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(port, () => {
+<%_ if (communication === 'Kafka') { -%>
+    const kafkaService = new KafkaService();
+<%_ } -%>
+    const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>
-        const kafkaService = new KafkaService();
         kafkaService.connect().then(() => {
           logger.info('Kafka connected');
           kafkaService.sendMessage('test-topic', 'Hello Kafka from MVC TS!');
@@ -118,6 +120,8 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
 };
 
 <%_ if (database !== 'None') { -%>