nodejs-structure-cli 1.0.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/database/ts/mongoose.ts.ejs

@@ -0,0 +1,28 @@
+import mongoose from 'mongoose';
+<% if (architecture === 'MVC') { %>
+import logger from '@/utils/logger';
+<% } else { %>
+import logger from '@/infrastructure/log/logger';
+<% } %>
+const connectDB = async (): Promise<void> => {
+    const dbHost = process.env.DB_HOST || 'localhost';
+    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) {
+        try {
+            await mongoose.connect(mongoURI);
+            logger.info('MongoDB Connected...');
+            break;
+        } catch (err) {
+            logger.error('MongoDB connection failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+export default connectDB;

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

@@ -0,0 +1,159 @@
+services:
+  app:
+    build: .
+    ports:
+      - "${PORT:-3000}:3000"
+<%_ if (database !== 'None' || communication === 'Kafka') { -%>
+    depends_on:
+<%_ if (database !== 'None') { -%>
+      - db
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+      - kafka
+<%_ } -%>
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+    environment:
+      - KAFKA_BROKER=kafka:9092
+      - KAFKAJS_NO_PARTITIONER_WARNING=1
+      - PORT=3000
+<%_ if (caching === 'Redis') { -%>
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+      - REDIS_PASSWORD=
+<%_ } -%>
+<%_ if (database !== 'None') { -%>
+      - DB_HOST=db
+<%_ if (database === 'MySQL') { -%>
+      - 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 { -%>
+    environment:
+      - PORT=3000
+<%_ if (caching === 'Redis') { -%>
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+      - REDIS_PASSWORD=
+<%_ } -%>
+<%_ if (database !== 'None') { -%>
+      - DB_HOST=db
+<%_ if (database === 'MySQL') { -%>
+      - 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
+<%_ } -%>
+<%_ } -%>
+<%_ } -%>
+<%_ if (database !== 'None') { -%>
+  db:
+<%_ if (database === 'MySQL') { -%>
+    image: mysql:8.0
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: <%= dbName %>
+    ports:
+      - "${DB_PORT:-3306}:3306"
+    volumes:
+      - ./flyway/sql:/docker-entrypoint-initdb.d
+<%_ } else if (database === 'PostgreSQL') { -%>
+    image: postgres:15
+    restart: always
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: root
+      POSTGRES_DB: <%= dbName %>
+    ports:
+      - "${DB_PORT:-5432}:5432"
+    volumes:
+      - ./flyway/sql:/docker-entrypoint-initdb.d
+<%_ } else if (database === 'MongoDB') { -%>
+    image: mongo:latest
+    restart: always
+    environment:
+      MONGO_INITDB_DATABASE: <%= dbName %>
+    ports:
+      - "${DB_PORT:-27017}:27017"
+    volumes:
+      - mongodb_data:/data/db
+
+  mongo-migrate:
+    image: node:22-slim
+    working_dir: /app
+    volumes:
+      - .:/app
+    command: sh -c "npm install migrate-mongo && npm run migrate"
+    environment:
+      - DB_HOST=db
+      - DB_NAME=<%= dbName %>
+    depends_on:
+      - db
+<%_ } -%>
+<%_ } -%>
+<%_ if (database !== 'MongoDB' && database !== 'None') { -%>
+  flyway:
+    image: flyway/flyway
+    command: -connectRetries=60 migrate
+    volumes:
+      - ./flyway/sql:/flyway/sql
+    environment:
+<%_ if (database === 'MySQL') { -%>
+      FLYWAY_URL: jdbc:mysql://db:3306/<%= dbName %>
+      FLYWAY_USER: root
+      FLYWAY_PASSWORD: root
+<%_ } -%><%_ if (database === 'PostgreSQL') { -%>
+      FLYWAY_URL: jdbc:postgresql://db:5432/<%= dbName %>
+      FLYWAY_USER: postgres
+      FLYWAY_PASSWORD: root
+<%_ } -%>
+    depends_on:
+      - db
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+  kafka:
+    image: bitnamilegacy/kafka:3.4.1-debian-12-r39
+    ports:
+      - "${KAFKA_EXTERNAL_PORT:-9093}:9093"
+    environment:
+      - KAFKA_ENABLE_KRAFT=yes
+      - KAFKA_CFG_PROCESS_ROLES=broker,controller
+      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=1@localhost:9094
+      - KAFKA_CFG_NODE_ID=1
+      - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:${KAFKA_PORT:-9093}
+      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092,PLAINTEXT_HOST://:9093,CONTROLLER://:9094
+      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
+      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
+      - KAFKA_CFG_INTER_BROKER_LISTENER_NAME=PLAINTEXT
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+  redis:
+    image: redis:alpine
+    restart: always
+    ports:
+      - "${REDIS_PORT:-6379}:6379"
+<%_ } -%>
+<%_ if (database !== 'None') { -%>
+volumes:
+  <%= database.toLowerCase() %>_data:
+<%_ } -%>

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:9093",
+      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/eslint.config.mjs.ejs

@@ -0,0 +1,77 @@
+import eslint from '@eslint/js';
+import eslintConfigPrettier from 'eslint-config-prettier';
+import globals from 'globals';
+import importPlugin from 'eslint-plugin-import-x';
+<% if (language === 'TypeScript') { %>import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintConfigPrettier,
+  {
+    plugins: {
+      import: importPlugin,
+    },
+    settings: {
+      'import-x/resolver': {
+        typescript: true,
+        node: true,
+      },
+    },
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.jest,
+      },
+    },
+    rules: {
+      "no-console": "warn",
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": ["warn", { 
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_"
+      }],
+      "@typescript-eslint/no-require-imports": "error",
+      "import/no-unresolved": [2, { "caseSensitive": false }]
+    },
+  },
+  {
+    files: ["**/*.test.ts", "**/*.spec.ts", "tests/**/*.ts"],
+    rules: {
+      "@typescript-eslint/no-require-imports": "off",
+      "@typescript-eslint/no-unused-vars": ["warn", { 
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_"
+      }],
+      "@typescript-eslint/no-explicit-any": "off",
+      "import/no-unresolved": [2, { "caseSensitive": false }]
+    },
+  }
+);<% } else { %>
+export default [
+  eslint.configs.recommended,
+  eslintConfigPrettier,
+  {
+    plugins: {
+      import: importPlugin,
+    },
+    settings: {
+      'import-x/resolver': {
+        node: true,
+      },
+    },
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+        ...globals.jest,
+      },
+    },
+    rules: {
+      "no-console": "warn",
+      "no-unused-vars": "warn",
+      "import/no-unresolved": [2, { "caseSensitive": false }]
+    }
+  }
+];<% } %>

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

@@ -0,0 +1,50 @@
+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<% } %>');
+<%_ if (database !== 'None') { -%>
+const ERROR_MESSAGES = require('<% if (architecture === "MVC") { %>../utils/errorMessages<% } else { %>../../utils/errorMessages<% } %>');
+<%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+const mongoose = require('mongoose');
+<%_ } else if (database !== 'None') { -%>
+const sequelize = require('<% if (architecture === "MVC") { %>../config/database<% } else { %>../../infrastructure/database/database<% } %>');
+<%_ } -%>
+
+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') { -%>
+    if (mongoose.connection.readyState === 1) {
+      if (mongoose.connection.db && mongoose.connection.db.admin) {
+         await mongoose.connection.db.admin().ping();
+      }
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error(`${ERROR_MESSAGES.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,49 @@
+import { Router, Request, Response } from 'express';
+import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<%_ if (database !== 'None') { -%>
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+
+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') { -%>
+    if (mongoose.connection.readyState === 1) {
+      await mongoose.connection.db?.admin().ping();
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error(`${ERROR_MESSAGES.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

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

package/templates/common/jest.e2e.config.js.ejs

@@ -0,0 +1,8 @@
+<%_ if (language === 'TypeScript') { -%>/* eslint-disable @typescript-eslint/no-require-imports */<%_ } -%>
+module.exports = {
+  ...require('./jest.config'),
+  testMatch: ['<rootDir>/tests/e2e/**/*.test.ts', '<rootDir>/tests/e2e/**/*.test.js'],
+  testPathIgnorePatterns: ['/node_modules/'],
+  testTimeout: 30000,
+  clearMocks: true
+};

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

@@ -0,0 +1,9 @@
+const { Kafka } = require('kafkajs');
+const { env } = require('./env');
+
+const kafka = new Kafka({
+    clientId: 'nodejs-service',
+    brokers: [env.KAFKA_BROKER]
+});
+
+module.exports = { kafka };

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

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