nodejs-quickstart-structure 1.18.0 → 1.19.0

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

@@ -1,95 +1,95 @@
-import { kafka } from '<%= configPath %>';
-import { EachMessagePayload, Producer, Consumer } from 'kafkajs';
-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(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() {
-        await this.producer.disconnect();
-        await this.consumer.disconnect();
-    }
-}
-
-export const kafkaService = new KafkaService();
+import { kafka } from '<%= configPath %>';
+import { EachMessagePayload, Producer, Consumer } from 'kafkajs';
+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(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, key?: 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: [
+                { key, 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() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
+    }
+}
+
+export const kafkaService = new KafkaService();

package/templates/common/kafka/ts/utils/kafkaEvents.ts.ejs

@@ -0,0 +1,5 @@
+export enum KAFKA_ACTIONS {
+    USER_CREATED = 'USER_CREATED',
+    USER_UPDATED = 'USER_UPDATED',
+    USER_DELETED = 'USER_DELETED'
+}

package/templates/common/package.json.ejs

@@ -22,6 +22,13 @@
     "security:check": "npm audit && npm run snyk:test",
     "snyk:test": "snyk test"<% } %>
   },
+  "overrides": {
+    "brace-expansion": "^5.0.5",
+    "jake": "^10.9.4",
+    "micromatch": "^4.0.8",
+    "braces": "^3.0.3",
+    "picomatch": "^4.0.4"
+  },
   "dependencies": {
     "express": "^4.18.2",
     "dotenv": "^16.3.1",
@@ -54,7 +61,8 @@
     "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",
+    "@apollo/server": "^5.5.0",
+    "@as-integrations/express4": "^1.1.2",
     "graphql": "^16.8.1",
     "@graphql-tools/merge": "^9.0.3"<% } %>
   },
@@ -76,7 +84,7 @@
     "@types/morgan": "^1.9.9",
     "rimraf": "^6.0.1"<% if ((viewEngine && viewEngine !== 'None') || communication === 'REST APIs' || communication === 'Kafka') { %>,
     "cpx2": "^8.0.0"<% } %><% } %>,
-    "eslint": "^9.20.1",
+    "eslint": "^10.1.0",
     "@eslint/js": "^9.20.0",
     "globals": "^15.14.0",
     "prettier": "^3.5.1",

package/templates/common/shutdown/js/gracefulShutdown.js.ejs

@@ -1,61 +1,65 @@
-<%_ 
-let loggerPath = './logger';
-let dbPath = '../config/database';
-let redisPath = '../config/redisClient';
-let kafkaPath = '../services/kafkaService';
-
-if (architecture === 'Clean Architecture') {
-    loggerPath = '../infrastructure/log/logger';
-    dbPath = '../infrastructure/database/database';
-    redisPath = '../infrastructure/caching/redisClient';
-    kafkaPath = '../infrastructure/messaging/kafkaClient';
-}
-_%>
-const logger = require('<%- loggerPath %>');
-
-const setupGracefulShutdown = (server) => {
-    const gracefulShutdown = async (signal) => {
-        logger.info(`Received ${signal}. Shutting down gracefully...`);
-        server.close(async () => {
-            logger.info('HTTP server closed.');
-            try {
-<%_ if (database !== 'None') { -%>
-<%_ if (database === 'MongoDB') { -%>
-                const mongoose = require('mongoose');
-                await mongoose.connection.close(false);
-                logger.info('MongoDB connection closed.');
-<%_ } else { -%>
-                const sequelize = require('<%- dbPath %>');
-                await sequelize.close();
-                logger.info('Database connection closed.');
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-                const redisService = require('<%- redisPath %>');
-                await redisService.quit();
-                logger.info('Redis connection closed.');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-                const { disconnectKafka } = require('<%- kafkaPath %>');
-                await disconnectKafka();
-                logger.info('Kafka connection closed.');
-<%_ } -%>
-                logger.info('Graceful shutdown fully completed.');
-                process.exit(0);
-            } catch (err) {
-                logger.error('Error during shutdown:', err);
-                process.exit(1);
-            }
-        });
-
-        setTimeout(() => {
-            logger.error('Could not close connections in time, forcefully shutting down');
-            process.exit(1);
-        }, 15000);
-    };
-
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-};
-
-module.exports = setupGracefulShutdown;
+<%_ 
+let loggerPath = './logger';
+let dbPath = '../config/database';
+let redisPath = '../config/redisClient';
+let kafkaPath = '../services/kafkaService';
+
+if (architecture === 'Clean Architecture') {
+    loggerPath = '../infrastructure/log/logger';
+    dbPath = '../infrastructure/database/database';
+    redisPath = '../infrastructure/caching/redisClient';
+    kafkaPath = '../infrastructure/messaging/kafkaClient';
+}
+-%>
+const logger = require('<%- loggerPath %>');
+
+const setupGracefulShutdown = (server) => {
+    const gracefulShutdown = async (signal) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async (err) => {
+            if (err) {
+                logger.error('Error closing HTTP server:', err);
+                process.exit(1);
+            }
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                const mongoose = require('mongoose');
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                const sequelize = require('<%- dbPath %>');
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                const redisService = require('<%- redisPath %>');
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                const { disconnectKafka } = require('<%- kafkaPath %>');
+                await disconnectKafka();
+                logger.info('Kafka connection closed.');
+<%_ } -%>
+                logger.info('Graceful shutdown fully completed.');
+                process.exit(0);
+            } catch (err) {
+                logger.error('Error during shutdown:', err);
+                process.exit(1);
+            }
+        });
+
+        setTimeout(() => {
+            logger.error('Could not close connections in time, forcefully shutting down');
+            process.exit(1);
+        }, 15000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+};
+
+module.exports = setupGracefulShutdown;