nodejs-quickstart-structure 1.19.0 → 2.0.0

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

@@ -1,58 +1,58 @@
-const BaseConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>');
-const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-class TestConsumer extends BaseConsumer {
-    constructor() {
-        super();
-        this._topic = 'test-topic';
-    }
-    get topic() { return this._topic; }
-    get groupId() { return 'test-group'; }
-    async handle(data) {
-        logger.info('Handled', data);
-    }
-}
-
-describe('BaseConsumer', () => {
-    let consumer;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        consumer = new TestConsumer();
-    });
-
-    it('should throw error if instantiated directly', () => {
-        expect(() => new BaseConsumer()).toThrow("Abstract class 'BaseConsumer' cannot be instantiated.");
-    });
-
-    it('should process a valid message', async () => {
-        const message = { value: Buffer.from(JSON.stringify({ test: 'data' })) };
-        await consumer.onMessage({ message });
-        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
-    });
-
-    it('should handle invalid JSON', async () => {
-        const message = { value: Buffer.from('invalid-json') };
-        await consumer.onMessage({ message });
-        expect(logger.error).toHaveBeenCalledWith(
-            expect.stringContaining('[Kafka] Error processing message on topic test-topic:'),
-            expect.anything()
-        );
-    });
-
-    it('should skip empty messages', async () => {
-        const message = { value: null };
-        await consumer.onMessage({ message });
-        expect(logger.info).not.toHaveBeenCalled();
-    });
-
-    it('should throw if topic, groupId or handle are not implemented', async () => {
-        class IncompleteConsumer extends BaseConsumer {}
-        const incomplete = new IncompleteConsumer();
-        expect(() => incomplete.topic).toThrow("Property 'topic' must be implemented");
-        expect(() => incomplete.groupId).toThrow("Property 'groupId' must be implemented");
-        await expect(incomplete.handle({})).rejects.toThrow("Method 'handle()' must be implemented");
-    });
-});
+const BaseConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>');
+const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+class TestConsumer extends BaseConsumer {
+    constructor() {
+        super();
+        this._topic = 'test-topic';
+    }
+    get topic() { return this._topic; }
+    get groupId() { return 'test-group'; }
+    async handle(data) {
+        logger.info('Handled', data);
+    }
+}
+
+describe('BaseConsumer', () => {
+    let consumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new TestConsumer();
+    });
+
+    it('should throw error if instantiated directly', () => {
+        expect(() => new BaseConsumer()).toThrow("Abstract class 'BaseConsumer' cannot be instantiated.");
+    });
+
+    it('should process a valid message', async () => {
+        const message = { value: Buffer.from(JSON.stringify({ test: 'data' })) };
+        await consumer.onMessage({ message });
+        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
+    });
+
+    it('should handle invalid JSON', async () => {
+        const message = { value: Buffer.from('invalid-json') };
+        await consumer.onMessage({ message });
+        expect(logger.error).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Error processing message on topic test-topic:'),
+            expect.anything()
+        );
+    });
+
+    it('should skip empty messages', async () => {
+        const message = { value: null };
+        await consumer.onMessage({ message });
+        expect(logger.info).not.toHaveBeenCalled();
+    });
+
+    it('should throw if topic, groupId or handle are not implemented', async () => {
+        class IncompleteConsumer extends BaseConsumer {}
+        const incomplete = new IncompleteConsumer();
+        expect(() => incomplete.topic).toThrow("Property 'topic' must be implemented");
+        expect(() => incomplete.groupId).toThrow("Property 'groupId' must be implemented");
+        await expect(incomplete.handle({})).rejects.toThrow("Method 'handle()' must be implemented");
+    });
+});

package/templates/common/kafka/js/messaging/userEventSchema.spec.js.ejs

@@ -1,27 +1,27 @@
-const { UserEventSchema } = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>');
-
-describe('UserEventSchema', () => {
-    it('should validate a correct USER_CREATED event', () => {
-        const validEvent = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'test@example.com'
-            }
-        };
-        const result = UserEventSchema.safeParse(validEvent);
-        expect(result.success).toBe(true);
-    });
-
-    it('should fail validation for invalid email', () => {
-        const invalidEvent = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'invalid-email'
-            }
-        };
-        const result = UserEventSchema.safeParse(invalidEvent);
-        expect(result.success).toBe(false);
-    });
-});
+const { UserEventSchema } = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>');
+
+describe('UserEventSchema', () => {
+    it('should validate a correct USER_CREATED event', () => {
+        const validEvent = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'test@example.com'
+            }
+        };
+        const result = UserEventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+    });
+
+    it('should fail validation for invalid email', () => {
+        const invalidEvent = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'invalid-email'
+            }
+        };
+        const result = UserEventSchema.safeParse(invalidEvent);
+        expect(result.success).toBe(false);
+    });
+});