nodejs-quickstart-structure 1.18.1 → 1.19.1

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

@@ -1,70 +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');
-    });
-<%_ } -%>
-});
+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

@@ -1,76 +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');
-    });
-<%_ } -%>
-});
+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

@@ -1,46 +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 === '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('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;
+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

@@ -1,32 +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
-    }
-  }
-};
+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

@@ -1,8 +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
-};
+<%_ 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

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

@@ -1,27 +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();
-    });
-});
+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();
+    });
+});

package/templates/common/kafka/js/messaging/baseConsumer.js.ejs

@@ -1,30 +1,30 @@
-const logger = require('<% if (architecture === "Clean Architecture") { %>../../infrastructure/log/logger<% } else { %>../utils/logger<% } %>');
-
-class BaseConsumer {
-  constructor() {
-    if (this.constructor === BaseConsumer) {
-      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
-    }
-  }
-
-  get topic() { throw new Error("Property 'topic' must be implemented"); }
-  get groupId() { throw new Error("Property 'groupId' must be implemented"); }
-
-  async onMessage({ message }) {
-    try {
-      const rawValue = message.value?.toString();
-      if (!rawValue) return;
-      
-      const data = JSON.parse(rawValue);
-      await this.handle(data);
-    } catch (error) {
-      logger.error(`[Kafka] Error processing message on topic ${this.topic}:`, error);
-    }
-  }
-
-  async handle(data) {
-    throw new Error("Method 'handle()' must be implemented");
-  }
-}
-
-module.exports = BaseConsumer;
+const logger = require('<%- loggerPath %>');
+
+class BaseConsumer {
+  constructor() {
+    if (this.constructor === BaseConsumer) {
+      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
+    }
+  }
+
+  get topic() { throw new Error("Property 'topic' must be implemented"); }
+  get groupId() { throw new Error("Property 'groupId' must be implemented"); }
+
+  async onMessage({ message }) {
+    try {
+      const rawValue = message.value?.toString();
+      if (!rawValue) return;
+      
+      const data = JSON.parse(rawValue);
+      await this.handle(data);
+    } catch (error) {
+      logger.error(`[Kafka] Error processing message on topic ${this.topic}:`, error);
+    }
+  }
+
+  async handle(data) {
+    throw new Error("Method 'handle()' must be implemented");
+  }
+}
+
+module.exports = BaseConsumer;