nodejs-quickstart-structure 1.13.0 → 1.14.0

package/templates/common/database/js/models/User.spec.js.ejs

@@ -0,0 +1,84 @@
+<% if (database === 'MongoDB') { _%>
+const mongoose = require('mongoose');
+
+jest.mock('mongoose', () => {
+    const mSchema = jest.fn();
+    const mModel = {
+        find: jest.fn(),
+        create: jest.fn(),
+    };
+    return {
+        Schema: mSchema,
+        model: jest.fn().mockReturnValue(mModel),
+    };
+});
+<% } else if (database === 'None') { _%>
+// No external dependencies to mock for None DB
+<% } else { _%>
+const { Model } = require('sequelize');
+
+jest.mock('sequelize', () => {
+    const mDataTypes = {
+        INTEGER: 'INTEGER',
+        STRING: 'STRING',
+    };
+    const mModel = class {
+        static init = jest.fn();
+        static findAll = jest.fn();
+        static create = jest.fn();
+    };
+    return { DataTypes: mDataTypes, Model: mModel };
+});
+
+<% if (architecture === 'MVC') { _%>
+jest.mock('@/config/database', () => ({}));
+<% } else { _%>
+jest.mock('@/infrastructure/database/database', () => ({}));
+<% } _%>
+<% } _%>
+
+describe('User Model', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should be defined and initialized', () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>');
+        expect(User).toBeDefined();
+        <% if (database === 'MongoDB') { %>
+        expect(mongoose.model).toHaveBeenCalled();
+        <% } else if (database === 'None') { %>
+        // Test mockData is initialized
+        expect(User.mockData).toEqual([]);
+        <% } else { %>
+        // Sequelize init is called on the class
+        expect(Model.init).toHaveBeenCalled();
+        <% } %>
+    });
+
+    it('should handle model operations', async () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>');
+        const data = { name: 'Test', email: 'test@example.com' };
+
+        <% if (database === 'MongoDB') { %>
+        User.create.mockResolvedValue({ id: '1', ...data });
+        User.find.mockResolvedValue([{ id: '1', ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        <% } else if (database === 'None') { %>
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        expect(await User.findAll()).toBeDefined();
+        <% } else { %>
+        User.create.mockResolvedValue({ id: 1, ...data });
+        User.findAll.mockResolvedValue([{ id: 1, ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.findAll()).toBeDefined();
+        <% } %>
+    });
+});

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

@@ -0,0 +1,43 @@
+jest.mock('mongoose', () => ({
+    connect: jest.fn().mockResolvedValue(true),
+}));
+
+const mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => mockLogger);
+
+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<% } %>');
+        const mongoose = require('mongoose');
+        await connectDB();
+        expect(mongoose.connect).toHaveBeenCalledWith(
+            expect.stringContaining('mongodb://'),
+            expect.any(Object)
+        );
+    });
+
+    it('should handle connection failure and retry', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        const mongoose = require('mongoose');
+        mongoose.connect
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(true);
+
+        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb());
+        
+        await connectDB();
+        
+        expect(mockLogger.error).toHaveBeenCalled();
+        expect(mongoose.connect).toHaveBeenCalledTimes(2);
+        timeoutSpy.mockRestore();
+    });
+});

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

@@ -0,0 +1,56 @@
+jest.mock('sequelize', () => {
+    const mSequelize = jest.fn(() => ({
+        authenticate: jest.fn().mockResolvedValue(true),
+        define: jest.fn(),
+    }));
+    return { Sequelize: mSequelize };
+});
+
+jest.mock('dotenv', () => ({
+    config: jest.fn()
+}));
+
+describe('Database Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        
+        // Clean environment
+        const envVars = ['DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT'];
+        envVars.forEach(v => delete process.env[v]);
+    });
+
+    it('should initialize Sequelize with environment variables', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        process.env.DB_NAME = 'testdb';
+        process.env.DB_USER = 'testuser';
+        process.env.DB_PASSWORD = 'testpassword';
+        process.env.DB_HOST = 'localhost';
+        process.env.DB_PORT = '5432';
+
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenLastCalledWith(
+            'testdb',
+            'testuser',
+            'testpassword',
+            expect.objectContaining({
+                host: 'localhost',
+                port: 5432
+            })
+        );
+    });
+
+    it('should initialize Sequelize with default values when env vars are missing', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        delete process.env.DB_NAME;
+        delete process.env.DB_USER;
+        delete process.env.DB_PASSWORD;
+        delete process.env.DB_HOST;
+        delete process.env.DB_PORT;
+
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/common/database/ts/models/User.spec.ts.ejs

@@ -0,0 +1,84 @@
+<% if (database === 'MongoDB') { _%>
+import mongoose from 'mongoose';
+
+jest.mock('mongoose', () => {
+    const mSchema = jest.fn();
+    const mModel = {
+        find: jest.fn(),
+        create: jest.fn(),
+    };
+    return {
+        Schema: mSchema,
+        model: jest.fn().mockReturnValue(mModel),
+    };
+});
+<% } else if (database === 'None') { _%>
+// No external dependencies to mock for None DB
+<% } else { _%>
+import { Model } from 'sequelize';
+
+jest.mock('sequelize', () => {
+    const mDataTypes = {
+        INTEGER: 'INTEGER',
+        STRING: 'STRING',
+    };
+    const mModel = class {
+        static init = jest.fn();
+        static findAll = jest.fn();
+        static create = jest.fn();
+    };
+    return { DataTypes: mDataTypes, Model: mModel };
+});
+
+<% if (architecture === 'MVC') { _%>
+jest.mock('@/config/database', () => ({}));
+<% } else { _%>
+jest.mock('@/infrastructure/database/database', () => ({}));
+<% } _%>
+<% } _%>
+
+describe('User Model', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should be defined and initialized', () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>').default;
+        expect(User).toBeDefined();
+        <% if (database === 'MongoDB') { %>
+        expect(mongoose.model).toHaveBeenCalled();
+        <% } else if (database === 'None') { %>
+        // Test mockData is initialized
+        expect(User.mockData).toEqual([]);
+        <% } else { %>
+        // Sequelize init is called on the class
+        expect(Model.init).toHaveBeenCalled();
+        <% } %>
+    });
+
+    it('should handle model operations', async () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>').default;
+        const data = { name: 'Test', email: 'test@example.com' };
+
+        <% if (database === 'MongoDB') { %>
+        (User.create as jest.Mock).mockResolvedValue({ id: '1', ...data });
+        (User.find as jest.Mock).mockResolvedValue([{ id: '1', ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        <% } else if (database === 'None') { %>
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        expect(await User.findAll()).toBeDefined();
+        <% } else { %>
+        (User.create as jest.Mock).mockResolvedValue({ id: 1, ...data });
+        (User.findAll as jest.Mock).mockResolvedValue([{ id: 1, ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.findAll()).toBeDefined();
+        <% } %>
+    });
+});

package/templates/common/database/ts/models/User.ts.ejs

@@ -1,3 +1,28 @@
+<% if (database === 'None') { -%>
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+export default class UserModel {
+  static mockData: User[] = [];
+
+  static async find() {
+    return this.mockData;
+  }
+
+  static async findAll() {
+    return this.mockData;
+  }
+
+  static async create(data: Omit<User, 'id'>) {
+    const newUser = { id: String(this.mockData.length + 1), ...data };
+    this.mockData.push(newUser);
+    return newUser as User;
+  }
+}
+<% } else { -%>
 import { DataTypes, Model } from 'sequelize';
 <% if (architecture === 'MVC') { %>import sequelize from '@/config/database';<% } else { %>import sequelize from '@/infrastructure/database/database';<% } %>
 
@@ -32,3 +57,4 @@ User.init(
 );
 
 export default User;
+<% } -%>

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.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/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: [
@@ -28,8 +32,8 @@ const sendMessage = async (topic, message) => {
 };
 
 const disconnectKafka = async () => {
-    await producer.disconnect();
-    await consumer.disconnect();
+    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();
+    });
+});