nodejs-quickstart-structure 1.11.1 → 1.13.0

package/templates/clean-architecture/ts/src/config/env.ts.ejs

@@ -0,0 +1,46 @@
+import dotenv from 'dotenv';
+import { z } from 'zod';
+import logger from '@/infrastructure/log/logger';
+
+if (process.env.NODE_ENV !== 'production') {
+  dotenv.config();
+}
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+<%_ if (database !== 'None') { -%>
+  DB_HOST: z.string(),
+<%_ if (database === 'MySQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'PostgreSQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'MongoDB') { -%>
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+  REDIS_HOST: z.string(),
+  REDIS_PORT: z.string().transform(Number),
+  REDIS_PASSWORD: z.string().optional(),
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+  KAFKA_BROKER: z.string(),
+<%_ } -%>
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  logger.error('❌ Invalid environment variables:', _env.error.format());
+  process.exit(1);
+}
+
+export const env = _env.data;

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

@@ -1,14 +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 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';<%_ } -%>
+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';<%_ } -%>
@@ -20,12 +21,12 @@ import { unwrapResolverError } from '@apollo/server/errors';
 import { ApiError } from '@/errors/ApiError';
 import { typeDefs, resolvers } from '@/interfaces/graphql';
 import { gqlContext, MyContext } from '@/interfaces/graphql/context';
-<% } -%>
+<%_ } -%>
 
-dotenv.config();
+import { env } from '@/config/env';
 
 const app = express();
-const port = process.env.PORT || 3000;
+const port = env.PORT;
 
 // Security Middleware
 <%_ if (communication === 'GraphQL') { -%>
@@ -57,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 })],
@@ -89,24 +88,26 @@ 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') { -%>
-        try {
-          const kafkaService = new KafkaService();
-          kafkaService.connect().then(() => {
-            logger.info('Kafka connected');
-            kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
-          });
-        } catch (err) {
+        kafkaService.connect().then(() => {
+          logger.info('Kafka connected');
+          kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
+        }).catch(err => {
           logger.error('Failed to connect to Kafka:', err);
-        }
+        });
 <%_ } -%>
     });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
 };
 
 <%_ if (database !== 'None') { -%>

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

@@ -14,5 +14,8 @@ export const userResolvers = {
       const user = await userController.createUser({ name, email });
       return user;
     }
-  }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent: { id?: string; _id?: unknown }) => parent.id || parent._id
+  }<%_ } %>
 };

package/templates/clean-architecture/ts/src/utils/{error.middleware.ts.ejs → errorMiddleware.ts.ejs}

@@ -3,7 +3,8 @@ 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) => {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const errorMiddleware = (err: Error, req: Request, res: Response, next: unknown) => {
   let error = err;
 
   if (!(error instanceof ApiError)) {

package/templates/common/.env.example.ejs

@@ -19,7 +19,9 @@ DB_PASSWORD=root
 DB_NAME=<%= dbName %>
 <%_ } -%>
 <%_ if (database === 'MongoDB') { -%>
-DB_URI=mongodb://localhost:27017/<%= dbName %>
+DB_HOST=localhost
+DB_PORT=27017
+DB_NAME=<%= dbName %>
 <%_ } -%>
 <%_ } -%>
 

package/templates/common/README.md.ejs

@@ -183,6 +183,36 @@ docker run -p 3000:3000 <%= projectName %>
 ```
 <% } -%>
 
+## 🚀 PM2 Deployment (VPS/EC2)
+This project is pre-configured for direct deployment to a VPS/EC2 instance using **PM2** (via `ecosystem.config.js`).
+1. Install dependencies
+```bash
+npm install
+```
+2. **Start Infrastructure (DB, Redis, Kafka, etc.) in the background**
+*(This specifically starts the background services without running the application inside Docker, allowing PM2 to handle it).*
+```bash
+docker-compose up -d<% if (database !== 'None') { %> db<% } %><% if (caching === 'Redis') { %> redis<% } %><% if (communication === 'Kafka') { %> zookeeper kafka<% } %>
+```
+3. **Wait 5-10s** for the database to fully initialize.
+4. **Deploy the App using PM2 in Cluster Mode**
+```bash
+<% if (language === 'TypeScript') { %>npm run build
+<% } %>npm run deploy
+```
+5. **Check logs**
+```bash
+npx pm2 logs
+```
+6. Stop and remove the PM2 application
+```bash
+npx pm2 delete <%= projectName %>
+```
+7. Stop and remove the Docker infrastructure
+```bash
+docker-compose down
+```
+
 ## 🔒 Security Features
 -   **Helmet**: Sets secure HTTP headers.
 -   **CORS**: Configured for cross-origin requests.

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/database/js/mongoose.js.ejs

@@ -8,7 +8,9 @@ logger = require('../log/logger');
 <% } %>
 const connectDB = async () => {
     const dbHost = process.env.DB_HOST || 'localhost';
-    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:27017/<%= dbName %>`;
+    const dbPort = process.env.DB_PORT || '27017';
+    const dbName = process.env.DB_NAME || '<%= dbName %>';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
     
     let retries = 5;
     while (retries) {

package/templates/common/database/ts/mongoose.ts.ejs

@@ -6,7 +6,9 @@ import logger from '@/infrastructure/log/logger';
 <% } %>
 const connectDB = async (): Promise<void> => {
     const dbHost = process.env.DB_HOST || 'localhost';
-    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:27017/<%= dbName %>`;
+    const dbPort = process.env.DB_PORT || '27017';
+    const dbName = process.env.DB_NAME || '<%= dbName %>';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
     
     let retries = 5;
     while (retries) {

package/templates/common/docker-compose.yml.ejs

@@ -28,10 +28,15 @@ services:
       - DB_USER=root
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
+      - DB_PORT=3306
 <%_ } -%><%_ if (database === 'PostgreSQL') { -%>
       - DB_USER=postgres
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
+      - DB_PORT=5432
+<%_ } -%><%_ if (database === 'MongoDB') { -%>
+      - DB_NAME=<%= dbName %>
+      - DB_PORT=27017
 <%_ } -%>
 <%_ } -%>
 <%_ } else { -%>
@@ -48,10 +53,15 @@ services:
       - DB_USER=root
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
+      - DB_PORT=3306
 <%_ } -%><%_ if (database === 'PostgreSQL') { -%>
       - DB_USER=postgres
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
+      - DB_PORT=5432
+<%_ } -%><%_ if (database === 'MongoDB') { -%>
+      - DB_NAME=<%= dbName %>
+      - DB_PORT=27017
 <%_ } -%>
 <%_ } -%>
 <%_ } -%>
@@ -89,7 +99,7 @@ services:
       - mongodb_data:/data/db
 
   mongo-migrate:
-    image: node:18-alpine
+    image: node:22-alpine
     working_dir: /app
     volumes:
       - .:/app

package/templates/common/ecosystem.config.js.ejs

@@ -0,0 +1,40 @@
+module.exports = {
+  apps: [{
+    name: "<%= projectName %>",
+    script: "<% if (language === 'TypeScript') { %>./dist/index.js<% } else { %>./src/index.js<% } %>", // Entry point
+    instances: "max",           // Run in Cluster Mode to utilize all CPUs (Note: On Windows, cluster mode may throw `spawn wmic ENOENT` errors due to missing WMIC in Windows 11. To fix, change instances to 1, or install wmic)
+    exec_mode: "cluster",
+    watch: false,               // Disable watch in production
+    max_memory_restart: "1G",
+    env_production: {
+      NODE_ENV: "production",
+      PORT: 3000,
+<%_ if (caching === 'Redis') { -%>
+      REDIS_HOST: "127.0.0.1",
+      REDIS_PORT: 6379,
+      REDIS_PASSWORD: "",
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+      KAFKA_BROKER: "127.0.0.1:9092",
+      KAFKAJS_NO_PARTITIONER_WARNING: 1,
+<%_ } -%>
+<%_ if (database !== 'None') { -%>
+      DB_HOST: "127.0.0.1",
+<%_ if (database === 'MySQL') { -%>
+      DB_USER: "root",
+      DB_PASSWORD: "root",
+      DB_NAME: "<%= dbName %>",
+      DB_PORT: 3306
+<%_ } else if (database === 'PostgreSQL') { -%>
+      DB_USER: "postgres",
+      DB_PASSWORD: "root",
+      DB_NAME: "<%= dbName %>",
+      DB_PORT: 5432
+<%_ } else if (database === 'MongoDB') { -%>
+      DB_NAME: "<%= dbName %>",
+      DB_PORT: 27017
+<%_ } -%>
+<%_ } -%>
+    }
+  }]
+};

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/package.json.ejs

@@ -7,6 +7,7 @@
     "start": "<% if (language === 'TypeScript') { %>node dist/index.js<% } else { %>node src/index.js<% } %>",
     "dev": "<% if (language === 'TypeScript') { %>nodemon --exec ts-node -r tsconfig-paths/register src/index.ts<% } else { %>nodemon src/index.js<% } %>"<% if (language === 'TypeScript') { %>,
     "build": "rimraf dist && tsc && tsc-alias<% if (viewEngine && viewEngine !== 'None') { %> && cpx \"src/views/**/*\" dist/views<% } %><% if (communication === 'REST APIs') { %> && cpx \"src/**/*.yml\" dist/<% } %>"<% } %>,
+    "deploy": "npx pm2 start ecosystem.config.js --env production",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
@@ -20,6 +21,7 @@
   "dependencies": {
     "express": "^4.18.2",
     "dotenv": "^16.3.1",
+    "zod": "^3.22.4",
 <% if (database === 'MySQL') { %>    "mysql2": "^3.6.5",
     "sequelize": "^6.35.2",
 <% } -%>
@@ -81,7 +83,7 @@
     "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",<%_ } -%>
+    "@types/yamljs": "^0.2.34",<%_ } %>
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "@types/jest": "^29.5.14",

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');
   });
 });