nodejs-quickstart-structure 1.12.0 → 1.14.0

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

@@ -0,0 +1,42 @@
+jest.mock('mongoose', () => ({
+    connect: jest.fn().mockResolvedValue(true),
+}));
+
+const logger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => logger);
+
+describe('Mongoose Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+    });
+
+    it('should call mongoose.connect with correct parameters', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
+        const mongoose = require('mongoose');
+        await connectDB();
+        expect(mongoose.connect).toHaveBeenCalledWith(
+            expect.stringContaining('mongodb://')
+        );
+    });
+
+    it('should handle connection failure and retry', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
+        const mongoose = require('mongoose');
+        (mongoose.connect as jest.Mock)
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(true);
+
+        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => { (cb as any)(); return {} as any; });
+        
+        await connectDB();
+        
+        expect(logger.error).toHaveBeenCalled();
+        expect(mongoose.connect).toHaveBeenCalledTimes(2);
+        timeoutSpy.mockRestore();
+    });
+});

package/templates/common/eslint.config.mjs.ejs

@@ -17,8 +17,17 @@ export default tseslint.config(
     rules: {
       "no-console": "warn",
       "no-unused-vars": "off",
-      "@typescript-eslint/no-unused-vars": "warn"
-    }
+      "@typescript-eslint/no-unused-vars": "warn",
+      "@typescript-eslint/no-require-imports": "error",
+    },
+  },
+  {
+    files: ["**/*.test.ts", "**/*.spec.ts", "tests/**/*.ts"],
+    rules: {
+      "@typescript-eslint/no-require-imports": "off",
+      "@typescript-eslint/no-unused-vars": "warn",
+      "@typescript-eslint/no-explicit-any": "off",
+    },
   }
 );<% } else { %>
 export default [

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/js/healthRoute.spec.js.ejs

@@ -0,0 +1,70 @@
+const request = require('supertest');
+const express = require('express');
+<% if (architecture === 'MVC') { -%>
+const healthRoute = require('@/routes/healthRoute');
+<% } else { -%>
+const healthRoute = require('@/interfaces/routes/healthRoute');
+<% } -%>
+const HTTP_STATUS = require('@/utils/httpCodes');
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        connection: {
+            readyState: 1,
+            db: {
+                admin: jest.fn().mockReturnValue({
+                    ping: jest.fn().mockResolvedValue(true)
+                })
+            }
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>', () => {
+    return {
+        authenticate: jest.fn()
+    };
+});
+<%_ } -%>
+
+describe('Health Route', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use('/health', healthRoute);
+        jest.clearAllMocks();
+    });
+
+    it('should return 200 OK with UP status', async () => {
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.OK);
+        expect(res.body.status).toBe('UP');
+        expect(res.body.database).toBe('<% if (database === "None") { %>None<% } else { %>connected<% } %>');
+    });
+
+<%_ if (database === 'MongoDB') { -%>
+    it('should handle database ping failure and return 500', async () => {
+        const mongoose = require('mongoose');
+        mongoose.connection.db.admin.mockReturnValueOnce({
+            ping: jest.fn().mockRejectedValueOnce(new Error('DB Error'))
+        });
+
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(res.body.status).toBe('DOWN');
+        expect(res.body.database).toBe('error');
+    });
+<%_ } else if (database !== 'None') { -%>
+    it('should handle database authentication failure and return 500', async () => {
+        const sequelize = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        sequelize.authenticate.mockRejectedValueOnce(new Error('DB Error'));
+
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(res.body.status).toBe('DOWN');
+        expect(res.body.database).toBe('error');
+    });
+<%_ } -%>
+});

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

@@ -0,0 +1,76 @@
+import request from 'supertest';
+import express from 'express';
+<% if (architecture === 'MVC') { -%>
+import healthRoute from '@/routes/healthRoute';
+<% } else { -%>
+import healthRoute from '@/interfaces/routes/healthRoute';
+<% } -%>
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        connection: {
+            readyState: 1,
+            db: {
+                admin: jest.fn().mockReturnValue({
+                    ping: jest.fn().mockResolvedValue(true)
+                })
+            }
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>', () => {
+    return {
+        __esModule: true,
+        default: {
+            authenticate: jest.fn()
+        }
+    };
+});
+<%_ } -%>
+
+describe('Health Route', () => {
+    let app: express.Express;
+
+    beforeEach(() => {
+        app = express();
+        app.use('/health', healthRoute);
+        jest.clearAllMocks();
+    });
+
+    it('should return 200 OK with UP status', async () => {
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.OK);
+        expect(res.body.status).toBe('UP');
+        expect(res.body.database).toBe('<% if (database === "None") { %>None<% } else { %>connected<% } %>');
+    });
+
+<%_ if (database === 'MongoDB') { -%>
+    it('should handle database ping failure and return 500', async () => {
+        ((mongoose.connection.db as any).admin as jest.Mock).mockReturnValueOnce({
+            ping: jest.fn().mockRejectedValueOnce(new Error('DB Error'))
+        });
+
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(res.body.status).toBe('DOWN');
+        expect(res.body.database).toBe('error');
+    });
+<%_ } else if (database !== 'None') { -%>
+    it('should handle database authentication failure and return 500', async () => {
+        (sequelize.authenticate as jest.Mock).mockRejectedValueOnce(new Error('DB Error'));
+
+        const res = await request(app).get('/health');
+        expect(res.status).toBe(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(res.body.status).toBe('DOWN');
+        expect(res.body.database).toBe('error');
+    });
+<%_ } -%>
+});

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/jest.config.js.ejs

@@ -2,13 +2,27 @@ module.exports = {
   testEnvironment: 'node',
   coverageDirectory: 'coverage',
   collectCoverageFrom: ['src/**/*.{js,ts}'],
-  testMatch: ['**/*.test.ts', '**/*.test.js'],
-  <% if (language === 'TypeScript') { %>preset: 'ts-jest',
+  testMatch: ['**/*.test.ts', '**/*.test.js', '**/*.spec.ts', '**/*.spec.js'],
+  <% if (language === 'TypeScript') { %>preset: 'ts-jest',<% } %>
   moduleNameMapper: {
     '^@/(.*)$': '<rootDir>/src/$1',
-  },<% } %>
+  },
   coveragePathIgnorePatterns: [
     "/node_modules/",
-    "/dist/"
-  ]
+    "/dist/",
+    "src/index",
+    "src/app",
+    "src/config/env",
+    "src/config/swagger",
+    "src/infrastructure/webserver/swagger",
+    "src/infrastructure/webserver/server"
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 65,
+      functions: 70,
+      lines: 70,
+      statements: 70
+    }
+  }
 };

package/templates/common/kafka/js/config/kafka.spec.js.ejs

@@ -0,0 +1,21 @@
+const { Kafka } = require('kafkajs');
+
+jest.mock('kafkajs', () => {
+    return {
+        Kafka: jest.fn().mockImplementation(() => ({
+            producer: jest.fn(),
+            consumer: jest.fn(),
+        })),
+    };
+});
+
+describe('Kafka Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should initialize Kafka', () => {
+        require('<% if (architecture === "MVC") { %>@/config/kafka<% } else { %>@/infrastructure/config/kafka<% } %>');
+        expect(Kafka).toHaveBeenCalled();
+    });
+});

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

@@ -1,16 +1,19 @@
 const { kafka } = require('../config/kafka');
 const logger = require('<%= loggerPath %>');
 
-const producer = kafka.producer();
-const consumer = kafka.consumer({ groupId: 'test-group' });
+let producer = null;
+let consumer = null;
 
 const connectKafka = async () => {
+    if (!producer) producer = kafka.producer();
+    if (!consumer) consumer = kafka.consumer({ groupId: 'test-group' });
+
     await producer.connect();
     await consumer.connect();
     await consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
 
     await consumer.run({
-        eachMessage: async ({ topic, partition, message }) => {
+        eachMessage: async ({ _topic, _partition, message }) => {
             logger.info({
                 value: message.value.toString(),
             });
@@ -19,6 +22,7 @@ const connectKafka = async () => {
 };
 
 const sendMessage = async (topic, message) => {
+    if (!producer) producer = kafka.producer();
     await producer.send({
         topic,
         messages: [
@@ -27,4 +31,9 @@ const sendMessage = async (topic, message) => {
     });
 };
 
-module.exports = { connectKafka, sendMessage };
+const disconnectKafka = async () => {
+    if (producer) await producer.disconnect();
+    if (consumer) await consumer.disconnect();
+};
+
+module.exports = { connectKafka, sendMessage, disconnectKafka };

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

@@ -0,0 +1,60 @@
+let kafka;
+let connectKafka, sendMessage, disconnectKafka;
+
+jest.mock('<%= configPath %>', () => ({
+    kafka: {
+        producer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            send: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+        consumer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            subscribe: jest.fn().mockResolvedValue(undefined),
+            run: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+    },
+}));
+
+jest.mock('<%= loggerPath %>');
+
+describe('Kafka Client', () => {
+    beforeEach(async () => {
+        jest.resetModules();
+        jest.clearAllMocks();
+        kafka = require('<%= configPath %>').kafka;
+        ({ connectKafka, sendMessage, disconnectKafka } = require('<%= servicePath %>'));
+        await connectKafka();
+    });
+
+    it('should connect producer and consumer', async () => {
+        await connectKafka();
+        const producer = kafka.producer.mock.results[0].value;
+        const consumer = kafka.consumer.mock.results[0].value;
+
+        expect(producer.connect).toHaveBeenCalled();
+        expect(consumer.connect).toHaveBeenCalled();
+    });
+
+    it('should send a message', async () => {
+        const topic = 'test-topic';
+        const message = 'test-message';
+        await sendMessage(topic, message);
+        const producer = kafka.producer.mock.results[0].value;
+
+        expect(producer.send).toHaveBeenCalledWith({
+            topic,
+            messages: [{ value: message }],
+        });
+    });
+
+    it('should disconnect Kafka', async () => {
+        await disconnectKafka();
+        const producer = kafka.producer.mock.results[0].value;
+        const consumer = kafka.consumer.mock.results[0].value;
+
+        expect(producer.disconnect).toHaveBeenCalled();
+        expect(consumer.disconnect).toHaveBeenCalled();
+    });
+});

package/templates/common/kafka/ts/config/kafka.spec.ts.ejs

@@ -0,0 +1,21 @@
+import { Kafka } from 'kafkajs';
+
+jest.mock('kafkajs', () => {
+    return {
+        Kafka: jest.fn().mockImplementation(() => ({
+            producer: jest.fn(),
+            consumer: jest.fn(),
+        })),
+    };
+});
+
+describe('Kafka Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should initialize Kafka', () => {
+        require('<% if (architecture === "MVC") { %>@/config/kafka<% } else { %>@/infrastructure/config/kafka<% } %>');
+        expect(Kafka).toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,61 @@
+import { KafkaService } from '<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>';
+import { kafka } from '<%= configPath %>';
+
+jest.mock('<%= configPath %>', () => ({
+    kafka: {
+        producer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            send: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+        consumer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            subscribe: jest.fn().mockResolvedValue(undefined),
+            run: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+    },
+}));
+
+jest.mock('<%= loggerPath %>');
+
+describe('KafkaService', () => {
+    let kafkaService: KafkaService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        kafkaService = new KafkaService();
+    });
+
+    it('should connect producer and consumer', async () => {
+        await kafkaService.connect();
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
+
+        expect(producer.connect).toHaveBeenCalled();
+        expect(consumer.connect).toHaveBeenCalled();
+        expect(consumer.subscribe).toHaveBeenCalledWith({ topic: 'test-topic', fromBeginning: true });
+        expect(consumer.run).toHaveBeenCalled();
+    });
+
+    it('should send a message', async () => {
+        const topic = 'test-topic';
+        const message = 'test-message';
+        await kafkaService.sendMessage(topic, message);
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+
+        expect(producer.send).toHaveBeenCalledWith({
+            topic,
+            messages: [{ value: message }],
+        });
+    });
+
+    it('should disconnect producer and consumer', async () => {
+        await kafkaService.disconnect();
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
+
+        expect(producer.disconnect).toHaveBeenCalled();
+        expect(consumer.disconnect).toHaveBeenCalled();
+    });
+});

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

@@ -17,7 +17,7 @@ export class KafkaService {
         await this.consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
 
         await this.consumer.run({
-            eachMessage: async ({ topic, partition, message }: EachMessagePayload) => {
+            eachMessage: async ({ message }: EachMessagePayload) => {
                 logger.info({
                     value: message.value?.toString(),
                 });
@@ -33,5 +33,10 @@ export class KafkaService {
             ],
         });
     }
+
+    async disconnect() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
+    }
 }
 

package/templates/common/package.json.ejs

@@ -94,9 +94,6 @@
     "jest": "^29.7.0",
     "supertest": "6.3.3"<% } %>
   },
-  "overrides": {
-    "minimatch": "^10.2.1"
-  },
   "lint-staged": {
     "*.{js,ts}": [
       "eslint --fix",

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;