nodejs-quickstart-structure 1.15.1 → 1.16.0

package/templates/common/kafka/ts/messaging/welcomeEmailConsumer.spec.ts.ejs

@@ -0,0 +1,49 @@
+import { WelcomeEmailConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+
+jest.mock('<%= loggerPath %>');
+
+describe('WelcomeEmailConsumer', () => {
+    let consumer: WelcomeEmailConsumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new WelcomeEmailConsumer();
+    });
+
+    it('should log welcome email simulation for USER_CREATED action', async () => {
+        const data = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'test@example.com'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_CREATED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('📧 Sending welcome email to \'test@example.com\'... Done!')
+        );
+    });
+
+    it('should log error for invalid data', async () => {
+        const data = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'invalid-email'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.error).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Invalid user event data:'),
+            expect.anything()
+        );
+    });
+});

package/templates/common/kafka/ts/messaging/welcomeEmailConsumer.ts.ejs

@@ -0,0 +1,25 @@
+import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+import { UserEventSchema } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>';
+
+export class WelcomeEmailConsumer extends BaseConsumer {
+  topic = 'user-topic';
+  groupId = 'welcome-email-group';
+
+  async handle(data: unknown) {
+    const result = UserEventSchema.safeParse(data);
+    
+    if (!result.success) {
+      logger.error('[Kafka] Invalid user event data:', result.error.format());
+      return;
+    }
+
+    const { action, payload } = result.data;
+
+    if (action === 'USER_CREATED') {
+      logger.info(`[Kafka] Consumer: Received USER_CREATED.`);
+      logger.info(`[Kafka] Consumer: 📧 Sending welcome email to '${payload.email}'... Done!`);
+      // In a real app, you would call an EmailService here
+    }
+  }
+}

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

@@ -34,13 +34,14 @@ describe('KafkaService', () => {
 
         expect(producer.connect).toHaveBeenCalled();
         expect(consumer.connect).toHaveBeenCalled();
-        expect(consumer.subscribe).toHaveBeenCalledWith({ topic: 'test-topic', fromBeginning: true });
+        expect(consumer.subscribe).toHaveBeenCalledWith(expect.objectContaining({ topic: 'user-topic', fromBeginning: true }));
         expect(consumer.run).toHaveBeenCalled();
     });
 
     it('should send a message', async () => {
+        await kafkaService.connect();
         const topic = 'test-topic';
-        const message = 'test-message';
+        const message = JSON.stringify({ action: 'TEST', payload: { email: 'test@example.com' } });
         await kafkaService.sendMessage(topic, message);
         const producer = (kafka.producer as jest.Mock).mock.results[0].value;
 
@@ -50,6 +51,25 @@ describe('KafkaService', () => {
         });
     });
 
+    it('should retry connection on failure', async () => {
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        producer.connect
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(undefined);
+        
+        jest.useFakeTimers();
+        const connectPromise = kafkaService.connect(2);
+        
+        await jest.advanceTimersByTimeAsync(10000);
+        await connectPromise;
+        
+        expect(producer.connect).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if producer not connected', async () => {
+        await expect(kafkaService.sendMessage('topic', 'msg')).rejects.toThrow('[Kafka] Producer not connected');
+    });
+
     it('should disconnect producer and consumer', async () => {
         await kafkaService.disconnect();
         const producer = (kafka.producer as jest.Mock).mock.results[0].value;

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

@@ -5,33 +5,92 @@ import logger from '<%= loggerPath %>';
 export class KafkaService {
     private producer: Producer;
     private consumer: Consumer;
+    private isConnected = false;
+    private connectionPromise: Promise<void> | null = null;
 
     constructor() {
         this.producer = kafka.producer();
         this.consumer = kafka.consumer({ groupId: 'test-group' });
     }
 
-    async connect() {
-        await this.producer.connect();
-        await this.consumer.connect();
-        await this.consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
-
-        await this.consumer.run({
-            eachMessage: async ({ message }: EachMessagePayload) => {
-                logger.info({
-                    value: message.value?.toString(),
-                });
-            },
-        });
+    async connect(retries = 10) {
+        if (this.connectionPromise) return this.connectionPromise;
+
+        this.connectionPromise = (async () => {
+            let attempt = 0;
+            while (attempt < retries) {
+                try {
+                    await this.producer.connect();
+                    await this.consumer.connect();
+                    logger.info('[Kafka] Producer connected successfully');
+                    logger.info('[Kafka] Consumer connected successfully');
+                    this.isConnected = true;
+
+                    <%_ if (language === 'TypeScript') { -%>
+                    // Auto-register WelcomeEmailConsumer if it exists
+                    try {
+                        const { WelcomeEmailConsumer } = await import('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+                        const welcomeConsumer = new WelcomeEmailConsumer();
+                        await this.consumer.subscribe({ topic: welcomeConsumer.topic, fromBeginning: true });
+                        logger.info(`[Kafka] Registered consumer for topic: ${welcomeConsumer.topic}`);
+                        
+                        await this.consumer.run({
+                            eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
+                        });
+                    } catch (e) {
+                        // Fallback or no consumers found
+                        logger.warn(`[Kafka] Could not load WelcomeEmailConsumer, using fallback: ${(e as Error).message}`);
+                        await this.consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
+                        await this.consumer.run({
+                            eachMessage: async ({ message }: EachMessagePayload) => {
+                                logger.info(`[Kafka] Consumer: Received message on user-topic: ${message.value?.toString()}`);
+                            },
+                        });
+                    }
+                    <%_ } else { _%>
+                    await this.consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
+                    await this.consumer.run({
+                        eachMessage: async ({ message }: EachMessagePayload) => {
+                            logger.info({ value: message.value?.toString() });
+                        },
+                    });
+                    <%_ } _%>
+                    return;
+                } catch (error) {
+                    attempt++;
+                    logger.error(`[Kafka] Connection attempt ${attempt} failed:`, (error as Error).message);
+                    if (attempt >= retries) {
+                        throw error;
+                    }
+                    await new Promise(res => setTimeout(res, 3000));
+                }
+            }
+        })();
+
+        return this.connectionPromise;
     }
 
     async sendMessage(topic: string, message: string) {
+        if (this.connectionPromise) {
+            await this.connectionPromise;
+        }
+
+        if (!this.isConnected) {
+            throw new Error('[Kafka] Producer not connected. Check logs for connection errors.');
+        }
+
         await this.producer.send({
             topic,
             messages: [
                 { value: message },
             ],
         });
+        try {
+            const parsed = JSON.parse(message);
+            logger.info(`[Kafka] Producer: Sent ${parsed.action} event for '${parsed.payload?.email || 'unknown'}'`);
+        } catch {
+            logger.info(`[Kafka] Producer: Sent message to ${topic}`);
+        }
     }
 
     async disconnect() {
@@ -40,3 +99,4 @@ export class KafkaService {
     }
 }
 
+export const kafkaService = new KafkaService();

package/templates/common/package.json.ejs

@@ -6,7 +6,7 @@
   "scripts": {
     "start": "<% if (language === 'TypeScript') { %>node dist/index.js<% } else { %>node src/index.js<% } %>",
     "dev": "<% if (language === 'TypeScript') { %>nodemon --exec ts-node -r tsconfig-paths/register src/index.ts<% } else { %>nodemon src/index.js<% } %>"<% if (language === 'TypeScript') { %>,
-    "build": "rimraf dist && tsc && tsc-alias<% if (viewEngine && viewEngine !== 'None') { %> && cpx \"src/views/**/*\" dist/views<% } %><% if (communication === 'REST APIs') { %> && cpx \"src/**/*.yml\" dist/<% } %>"<% } %>,
+    "build": "rimraf dist && tsc && tsc-alias<% if (viewEngine && viewEngine !== 'None') { %> && cpx \"src/views/**/*\" dist/views<% } %><% if (communication === 'REST APIs' || communication === 'Kafka') { %> && cpx \"src/**/*.yml\" dist/<% } %>"<% } %>,
     "deploy": "npx pm2 start ecosystem.config.js --env production",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -47,7 +47,7 @@
     "express-rate-limit": "^7.1.5",
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0",
-    "morgan": "^1.10.0"<% if (communication === 'REST APIs') { %>,
+    "morgan": "^1.10.0"<% if (communication === 'REST APIs' || communication === 'Kafka') { %>,
     "swagger-ui-express": "^5.0.0",
     "yamljs": "^0.3.0"<% } %><% if (communication === 'GraphQL') { %>,
     "@apollo/server": "^4.10.0",
@@ -72,16 +72,18 @@
     "@types/sequelize": "^4.28.19",
 <%_ } -%>
     "@types/morgan": "^1.9.9",
-    "rimraf": "^6.0.1"<% if ((viewEngine && viewEngine !== 'None') || communication === 'REST APIs') { %>,
+    "rimraf": "^6.0.1"<% if ((viewEngine && viewEngine !== 'None') || communication === 'REST APIs' || communication === 'Kafka') { %>,
     "cpx2": "^8.0.0"<% } %><% } %>,
     "eslint": "^9.20.1",
     "@eslint/js": "^9.20.0",
     "globals": "^15.14.0",
     "prettier": "^3.5.1",
     "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-import-x": "^4.6.1",
+    "eslint-import-resolver-typescript": "^3.7.0",
     "husky": "^8.0.3",
     "lint-staged": "^15.4.3"<% if (language === 'TypeScript') { %>,
-    "typescript-eslint": "^8.24.1",<%_ if (communication === 'REST APIs') { %>
+    "typescript-eslint": "^8.24.1",<%_ if (communication === 'REST APIs' || communication === 'Kafka') { %>
     "@types/swagger-ui-express": "^4.1.6",
     "@types/yamljs": "^0.2.34",<%_ } %>
     "jest": "^29.7.0",

package/templates/mvc/js/src/controllers/userController.js.ejs

@@ -40,6 +40,13 @@ const createUser = async (data) => {
     const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+    const { sendMessage } = require('../services/kafkaService');
+    await sendMessage('user-topic', JSON.stringify({
+      action: 'USER_CREATED',
+      payload: { id: user.id || user._id, email: user.email }
+    }));
 <%_ } -%>
     return user;
   } catch (error) {
@@ -78,6 +85,13 @@ const createUser = async (req, res, next) => {
     const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+    const { sendMessage } = require('../services/kafkaService');
+    await sendMessage('user-topic', JSON.stringify({
+      action: 'USER_CREATED',
+      payload: { id: user.id || user._id, email: user.email }
+    }));
 <%_ } -%>
     res.status(HTTP_STATUS.CREATED).json(user);
   } catch (error) {

package/templates/mvc/js/src/controllers/userController.spec.js.ejs

@@ -23,6 +23,14 @@ jest.mock('@/config/memoryCache', () => ({
 }));
 <%_ } -%>
 jest.mock('@/utils/logger');
+<%_ if (communication === 'Kafka') { -%>
+const { sendMessage } = require('@/services/kafkaService');
+jest.mock('@/services/kafkaService', () => ({
+    sendMessage: jest.fn().mockResolvedValue(undefined),
+    connectKafka: jest.fn().mockResolvedValue(undefined)
+}));
+<%_ } -%>
+
 
 describe('UserController', () => {
 <% if (communication !== 'GraphQL') { -%>
@@ -143,6 +151,9 @@ describe('UserController', () => {
 <% } -%>
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
             expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(sendMessage).toHaveBeenCalled();
 <%_ } -%>
         });
 
@@ -166,5 +177,33 @@ describe('UserController', () => {
             expect(mockNext).toHaveBeenCalledWith(error);
 <% } -%>
         });
+
+<%_ if (communication === 'Kafka') { -%>
+        it('should successfully create a new user with _id for Kafka (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Bob', email: 'bob@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { _id: '2', ...payload };
+            User.create.mockResolvedValue(expectedUser);
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            await createUser(dataArg);
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+<% } -%>
+
+            // Assert
+            expect(sendMessage).toHaveBeenCalledWith(
+                'user-topic',
+                expect.stringContaining('"id":"2"')
+            );
+        });
+<%_ } -%>
     });
 });

package/templates/mvc/js/src/index.js.ejs

@@ -1,6 +1,6 @@
 const express = require('express');
 const cors = require('cors');
-<%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } %>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>const apiRoutes = require('./routes/api');<%_ } %>
 const healthRoutes = require('./routes/healthRoute');
 <%_ if (communication === 'Kafka') { -%>const { connectKafka, sendMessage } = require('./services/kafkaService');<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
@@ -11,8 +11,8 @@ const { unwrapResolverError } = require('@apollo/server/errors');
 const { ApiError } = require('./errors/ApiError');
 const { typeDefs, resolvers } = require('./graphql');
 const { gqlContext } = require('./graphql/context');
-<% } -%>
-<%_ if (communication === 'REST APIs') { -%>
+<% } %>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./config/swagger');
 <%_ } -%>
@@ -28,7 +28,7 @@ app.use(cors());
 app.use(express.json());
 app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));
 
-<%_ if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
 <%_ } -%>
 <%_ if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
@@ -37,7 +37,7 @@ const path = require('path');
 app.set('views', path.join(__dirname, 'views'));
 app.set('view engine', '<%= viewEngine.toLowerCase() %>');
 app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
-<%_ if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 app.use('/api', apiRoutes);
 <%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
 app.get('/', (req, res) => {
@@ -86,12 +86,13 @@ const startServer = async () => {
     const server = app.listen(PORT, () => {
         logger.info(`Server running on port ${PORT}`);
 <%_ if (communication === 'Kafka') { -%>
-        connectKafka().then(() => {
-          logger.info('Kafka connected');
-          sendMessage('test-topic', 'Hello Kafka from MVC JS!');
-        }).catch(err => {
-          logger.error('Failed to connect to Kafka:', err);
-        });
+        connectKafka()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', err.message);
+            });
 <%_ } -%>
     });
 

package/templates/mvc/ts/src/config/swagger.ts.ejs

@@ -1,4 +1,4 @@
-<% if (communication === 'REST APIs') { %>import path from 'path';
+<% if (communication === 'REST APIs' || communication === 'Kafka') { %>import path from 'path';
 import YAML from 'yamljs';
 
 const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));

package/templates/mvc/ts/src/controllers/userController.spec.ts.ejs

@@ -24,6 +24,20 @@ jest.mock('@/config/memoryCache', () => ({
 }));
 <%_ } -%>
 jest.mock('@/utils/logger');
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('@/services/kafkaService', () => {
+    const mockSendMessage = jest.fn().mockResolvedValue(undefined);
+    return {
+        kafkaService: {
+            sendMessage: mockSendMessage
+        },
+        KafkaService: jest.fn().mockImplementation(() => ({
+            sendMessage: mockSendMessage
+        }))
+    };
+});
+<%_ } -%>
+
 
 describe('UserController', () => {
     let userController: UserController;
@@ -158,6 +172,10 @@ describe('UserController', () => {
 <% } -%>
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
             expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            const { kafkaService } = require('@/services/kafkaService');
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
 <%_ } -%>
         });
 

package/templates/mvc/ts/src/controllers/userController.ts.ejs

@@ -42,6 +42,14 @@ export class UserController {
             const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
             await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            const { kafkaService } = await import('@/services/kafkaService');
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: 'USER_CREATED',
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                payload: { id: (user as any).id || (user as any)._id, email: user.email }
+            }));
 <%_ } -%>
             return user;
         } catch (error) {
@@ -80,6 +88,14 @@ export class UserController {
             const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
             await cacheService.del('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            const { kafkaService } = await import('@/services/kafkaService');
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: 'USER_CREATED',
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                payload: { id: (user as any).id || (user as any)._id, email: user.email }
+            }));
 <%_ } -%>
             res.status(HTTP_STATUS.CREATED).json(user);
         } catch (error) {

package/templates/mvc/ts/src/index.ts.ejs

@@ -9,12 +9,11 @@ import morgan from 'morgan';
 import { errorMiddleware } from '@/utils/errorMiddleware';
 import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
 import healthRoutes from '@/routes/healthRoute';
-<%_ if (communication === 'REST APIs') { -%>
-import apiRoutes from '@/routes/api';<%_ } -%>
-<% if (communication === 'REST APIs') { %>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+import apiRoutes from '@/routes/api';
 import swaggerUi from 'swagger-ui-express';
-import swaggerSpecs from '@/config/swagger';<% } -%>
-<%_ if (communication === 'Kafka') { -%>import { KafkaService } from '@/services/kafkaService';<%_ } -%>
+import swaggerSpecs from '@/config/swagger';<%_ } %>
+<%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/services/kafkaService';<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 import { ApolloServer } from '@apollo/server';
 import { expressMiddleware } from '@apollo/server/express4';
@@ -51,7 +50,7 @@ app.use(limiter);
 
 app.use(express.json());
 app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
-<%_ if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
 <%_ } -%>
 <%_ if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
@@ -60,7 +59,7 @@ import path from 'path';
 app.set('views', path.join(__dirname, 'views'));
 app.set('view engine', '<%= viewEngine.toLowerCase() %>');
 app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
-<%_ if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 app.use('/api', apiRoutes);
 <%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
 app.get('/', (req: Request, res: Response) => {
@@ -106,18 +105,16 @@ const startServer = async () => {
     app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-<%_ if (communication === 'Kafka') { -%>
-    const kafkaService = new KafkaService();
-<%_ } -%>
     const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>
-        kafkaService.connect().then(() => {
-          logger.info('Kafka connected');
-          kafkaService.sendMessage('test-topic', 'Hello Kafka from MVC TS!');
-        }).catch(err => {
-          logger.error('Failed to connect to Kafka:', err);
-        });
+        kafkaService.connect()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', (err as Error).message);
+            });
 <%_ } -%>
     });
 

package/templates/mvc/ts/src/utils/logger.spec.ts.ejs

@@ -56,7 +56,6 @@ describe('Logger', () => {
         const winston = require('winston');
         jest.resetModules();
         process.env.NODE_ENV = 'production';
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
         require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
         expect(winston.format.json).toHaveBeenCalled();
         process.env.NODE_ENV = 'test';