nodejs-quickstart-structure 1.15.1 → 1.16.1

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

@@ -0,0 +1,50 @@
+import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+
+jest.mock('<%= loggerPath %>');
+
+class TestConsumer extends BaseConsumer {
+    constructor() {
+        super();
+    }
+    get topic() { return 'test-topic'; }
+    get groupId() { return 'test-group'; }
+    async handle(data: any) {
+        logger.info('Handled', data);
+    }
+}
+
+describe('BaseConsumer', () => {
+    let consumer: TestConsumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new TestConsumer();
+    });
+
+    it('should throw error if instantiated directly', () => {
+        // @ts-expect-error: Abstract class cannot be instantiated
+        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 } as any);
+        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
+    });
+
+    it('should handle invalid JSON', async () => {
+        const message = { value: Buffer.from('invalid-json') };
+        await consumer.onMessage({ message } as any);
+        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 } as any);
+        expect(logger.info).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,27 @@
+import { EachMessagePayload } from 'kafkajs';
+import logger from '<%= loggerPath %>';
+
+export abstract class BaseConsumer {
+  abstract topic: string;
+  abstract groupId: string;
+
+  public constructor() {
+    if (new.target === BaseConsumer) {
+      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
+    }
+  }
+
+  async onMessage({ message }: EachMessagePayload) {
+    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);
+    }
+  }
+
+  abstract handle(data: unknown): Promise<void>;
+}

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

@@ -0,0 +1,51 @@
+import { UserEventSchema } from '<% 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 validate a correct UPDATE_USER event', () => {
+        const validEvent = {
+            action: 'UPDATE_USER',
+            payload: {
+                id: 'abc-123',
+                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);
+    });
+
+    it('should fail validation for invalid action', () => {
+        const invalidEvent = {
+            action: 'INVALID_ACTION',
+            payload: {
+                id: 1,
+                email: 'test@example.com'
+            }
+        };
+        const result = UserEventSchema.safeParse(invalidEvent);
+        expect(result.success).toBe(false);
+    });
+});

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const UserEventSchema = z.object({
+  action: z.enum(['USER_CREATED', 'UPDATE_USER', 'DELETE_USER']),
+  payload: z.object({
+    id: z.union([z.string(), z.number()]),
+    email: z.string().email(),
+  }),
+});
+
+export type UserEvent = z.infer<typeof UserEventSchema>;

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,85 @@ 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;
+            // Auto-register WelcomeEmailConsumer if it exists
+            // Note: Dynamic import used here for simplicity and to avoid startup crashes.
+            // In enterprise production, consider using Dependency Injection.
+            const { WelcomeEmailConsumer } = await import('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+            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;
+
+                    try {
+                        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()}`);
+                            },
+                        });
+                    }
+                    return; // Success
+                } 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 +92,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/common/shutdown/ts/gracefulShutdown.ts.ejs

@@ -4,6 +4,14 @@ import logger from '@/utils/logger';
 <%_ } else { -%>
 import logger from '@/infrastructure/log/logger';
 <%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+import redisService from '<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>';
+<%_ } -%>
 
 export const setupGracefulShutdown = (server: Server<% if (communication === 'Kafka') { %>, kafkaService: { disconnect: () => Promise<void> }<% } %>) => {
     const gracefulShutdown = async (signal: string) => {
@@ -13,25 +21,14 @@ export const setupGracefulShutdown = (server: Server<% if (communication === 'Ka
             try {
 <%_ if (database !== 'None') { -%>
 <%_ if (database === 'MongoDB') { -%>
-                const mongoose = (await import('mongoose')).default;
                 await mongoose.connection.close(false);
                 logger.info('MongoDB connection closed.');
 <%_ } else { -%>
-                <%_ if (architecture === 'MVC') { -%>
-                const sequelize = (await import('@/config/database')).default;
-                <%_ } else { -%>
-                const sequelize = (await import('@/infrastructure/database/database')).default;
-                <%_ } -%>
                 await sequelize.close();
                 logger.info('Database connection closed.');
 <%_ } -%>
 <%_ } -%>
 <%_ if (caching === 'Redis') { -%>
-                <%_ if (architecture === 'MVC') { -%>
-                const redisService = (await import('@/config/redisClient')).default;
-                <%_ } else { -%>
-                const redisService = (await import('@/infrastructure/caching/redisClient')).default;
-                <%_ } -%>
                 await redisService.quit();
                 logger.info('Redis connection closed.');
 <%_ } -%>

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

@@ -8,6 +8,9 @@ const cacheService = require('../config/redisClient');
 <%_ } else if (caching === 'Memory Cache') { -%>
 const cacheService = require('../config/memoryCache');
 <%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+const { sendMessage } = require('../services/kafkaService');
+<%_ } -%>
 
 <% if (communication === 'GraphQL') { -%>
 const getUsers = async () => {
@@ -40,6 +43,12 @@ 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') { -%>
+    await sendMessage('user-topic', JSON.stringify({
+      action: 'USER_CREATED',
+      payload: { id: user.id || user._id, email: user.email }
+    }));
 <%_ } -%>
     return user;
   } catch (error) {
@@ -78,6 +87,12 @@ 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') { -%>
+    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,12 +11,13 @@ 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');
 <%_ } -%>
 const { env } = require('./config/env');
+const setupGracefulShutdown = require('./utils/gracefulShutdown');
 
 const app = express();
 const PORT = env.PORT;
@@ -28,7 +29,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 +38,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,34 +87,38 @@ 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);
+            });
 <%_ } -%>
     });
 
-    const setupGracefulShutdown = require('./utils/gracefulShutdown');
     setupGracefulShutdown(server);
 };
 
 <%_ if (database !== 'None') { -%>
 // Database Sync
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+const connectDB = require('./config/database');
+<%_ } else { -%>
+const sequelize = require('./config/database');
+<%_ } -%>
+<%_ } -%>
 const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
             <%_ if (database === 'MongoDB') { -%>
-            const connectDB = require('./config/database');
             await connectDB();
             <%_ } else { -%>
-            const sequelize = require('./config/database');
             await sequelize.sync();
             <%_ } -%>
             logger.info('Database synced');
-            
             // Start Server after DB is ready
             await startServer();
             break;

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'));