nodejs-quickstart-structure 1.18.0 → 1.19.0

package/templates/common/health/js/healthRoute.js.ejs

@@ -1,47 +1,50 @@
-const express = require('express');
-const router = express.Router();
-const logger = require('<% if (architecture === "MVC") { %>../utils/logger<% } else { %>../../infrastructure/log/logger<% } %>');
-const HTTP_STATUS = require('<% if (architecture === "MVC") { %>../utils/httpCodes<% } else { %>../../utils/httpCodes<% } %>');
-<%_ if (database === 'MongoDB') { -%>
-const mongoose = require('mongoose');
-<%_ } else if (database !== 'None') { -%>
-const sequelize = require('<% if (architecture === "MVC") { %>../config/database<% } else { %>../../infrastructure/database/database<% } %>');
-<%_ } -%>
-
-router.get('/', async (req, res) => {
-  const healthData = {
-    status: 'UP',
-    uptime: process.uptime(),
-    memory: process.memoryUsage(),
-    database: 'disconnected',
-    timestamp: Date.now()
-  };
-  logger.info('Health Check');
-
-<%_ if (database !== 'None') { -%>
-  try {
-<%_ if (database === 'MongoDB') { -%>
-    if (mongoose.connection.readyState === 1) {
-      if (mongoose.connection.db && mongoose.connection.db.admin) {
-         await mongoose.connection.db.admin().ping();
-      }
-      healthData.database = 'connected';
-    }
-<%_ } else { -%>
-    await sequelize.authenticate();
-    healthData.database = 'connected';
-<%_ } -%>
-  } catch (err) {
-    healthData.database = 'error';
-    healthData.status = 'DOWN';
-    logger.error('Health Check Database Ping Failed:', err);
-    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
-  }
-<%_ } else { -%>
-  healthData.database = 'None';
-<%_ } -%>
-
-  res.status(HTTP_STATUS.OK).json(healthData);
-});
-
-module.exports = router;
+const express = require('express');
+const router = express.Router();
+const logger = require('<% if (architecture === "MVC") { %>../utils/logger<% } else { %>../../infrastructure/log/logger<% } %>');
+const HTTP_STATUS = require('<% if (architecture === "MVC") { %>../utils/httpCodes<% } else { %>../../utils/httpCodes<% } %>');
+<%_ if (database !== 'None') { -%>
+const ERROR_MESSAGES = require('<% if (architecture === "MVC") { %>../utils/errorMessages<% } else { %>../../utils/errorMessages<% } %>');
+<%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+const mongoose = require('mongoose');
+<%_ } else if (database !== 'None') { -%>
+const sequelize = require('<% if (architecture === "MVC") { %>../config/database<% } else { %>../../infrastructure/database/database<% } %>');
+<%_ } -%>
+
+router.get('/', async (req, res) => {
+  const healthData = {
+    status: 'UP',
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    database: 'disconnected',
+    timestamp: Date.now()
+  };
+  logger.info('Health Check');
+
+<%_ if (database !== 'None') { -%>
+  try {
+<%_ if (database === 'MongoDB') { -%>
+    if (mongoose.connection.readyState === 1) {
+      if (mongoose.connection.db && mongoose.connection.db.admin) {
+         await mongoose.connection.db.admin().ping();
+      }
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error(`${ERROR_MESSAGES.DATABASE_PING_FAILED}:`, err);
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
+  }
+<%_ } else { -%>
+  healthData.database = 'None';
+<%_ } -%>
+
+  res.status(HTTP_STATUS.OK).json(healthData);
+});
+
+module.exports = router;

package/templates/common/health/ts/healthRoute.ts.ejs

@@ -1,46 +1,49 @@
-import { Router, Request, Response } from 'express';
-import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
-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<% } %>';
-<%_ } -%>
-
-const router = Router();
-
-router.get('/', async (req: Request, res: Response) => {
-  const healthData: Record<string, unknown> = {
-    status: 'UP',
-    uptime: process.uptime(),
-    memory: process.memoryUsage(),
-    database: 'disconnected',
-    timestamp: Date.now()
-  };
-  logger.info('Health Check');
-
-<%_ if (database !== 'None') { -%>
-  try {
-<%_ if (database === 'MongoDB') { -%>
-    if (mongoose.connection.readyState === 1) {
-      await mongoose.connection.db?.admin().ping();
-      healthData.database = 'connected';
-    }
-<%_ } else { -%>
-    await sequelize.authenticate();
-    healthData.database = 'connected';
-<%_ } -%>
-  } catch (err) {
-    healthData.database = 'error';
-    healthData.status = 'DOWN';
-    logger.error('Health Check Database Ping Failed:', err);
-    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
-  }
-<%_ } else { -%>
-  healthData.database = 'None';
-<%_ } -%>
-
-  res.status(HTTP_STATUS.OK).json(healthData);
-});
-
-export default router;
+import { Router, Request, Response } from 'express';
+import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<%_ if (database !== 'None') { -%>
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+
+const router = Router();
+
+router.get('/', async (req: Request, res: Response) => {
+  const healthData: Record<string, unknown> = {
+    status: 'UP',
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    database: 'disconnected',
+    timestamp: Date.now()
+  };
+  logger.info('Health Check');
+
+<%_ if (database !== 'None') { -%>
+  try {
+<%_ if (database === 'MongoDB') { -%>
+    if (mongoose.connection.readyState === 1) {
+      await mongoose.connection.db?.admin().ping();
+      healthData.database = 'connected';
+    }
+<%_ } else { -%>
+    await sequelize.authenticate();
+    healthData.database = 'connected';
+<%_ } -%>
+  } catch (err) {
+    healthData.database = 'error';
+    healthData.status = 'DOWN';
+    logger.error(`${ERROR_MESSAGES.DATABASE_PING_FAILED}:`, err);
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json(healthData);
+  }
+<%_ } else { -%>
+  healthData.database = 'None';
+<%_ } -%>
+
+  res.status(HTTP_STATUS.OK).json(healthData);
+});
+
+export default router;

package/templates/common/jest.e2e.config.js.ejs

@@ -1,8 +1,8 @@
-<%_ if (language === 'TypeScript') { _%>/* eslint-disable @typescript-eslint/no-require-imports */<%_ } _%>
-module.exports = {
-  ...require('./jest.config'),
-  testMatch: ['<rootDir>/tests/e2e/**/*.test.ts', '<rootDir>/tests/e2e/**/*.test.js'],
-  testPathIgnorePatterns: ['/node_modules/'],
-  testTimeout: 30000,
-  clearMocks: true
-};
+<%_ if (language === 'TypeScript') { -%>/* eslint-disable @typescript-eslint/no-require-imports */<%_ } -%>
+module.exports = {
+  ...require('./jest.config'),
+  testMatch: ['<rootDir>/tests/e2e/**/*.test.ts', '<rootDir>/tests/e2e/**/*.test.js'],
+  testPathIgnorePatterns: ['/node_modules/'],
+  testTimeout: 30000,
+  clearMocks: true
+};

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

@@ -1,30 +1,30 @@
-const logger = require('<% if (architecture === "Clean Architecture") { %>../../infrastructure/log/logger<% } else { %>../utils/logger<% } %>');
-
-class BaseConsumer {
-  constructor() {
-    if (this.constructor === BaseConsumer) {
-      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
-    }
-  }
-
-  get topic() { throw new Error("Property 'topic' must be implemented"); }
-  get groupId() { throw new Error("Property 'groupId' must be implemented"); }
-
-  async onMessage({ message }) {
-    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);
-    }
-  }
-
-  async handle(data) {
-    throw new Error("Method 'handle()' must be implemented");
-  }
-}
-
-module.exports = BaseConsumer;
+const logger = require('<%- loggerPath %>');
+
+class BaseConsumer {
+  constructor() {
+    if (this.constructor === BaseConsumer) {
+      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
+    }
+  }
+
+  get topic() { throw new Error("Property 'topic' must be implemented"); }
+  get groupId() { throw new Error("Property 'groupId' must be implemented"); }
+
+  async onMessage({ message }) {
+    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);
+    }
+  }
+
+  async handle(data) {
+    throw new Error("Method 'handle()' must be implemented");
+  }
+}
+
+module.exports = BaseConsumer;

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

@@ -1,11 +1,12 @@
-const { z } = require('zod');
-
-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(),
-  }),
-});
-
-module.exports = { UserEventSchema };
+const { z } = require('zod');
+const { KAFKA_ACTIONS } = require('<%- kafkaEventsPath %>');
+
+const UserEventSchema = z.object({
+  action: z.enum(Object.values(KAFKA_ACTIONS)),
+  payload: z.object({
+    id: z.union([z.string(), z.number()]),
+    email: z.string().email().optional(),
+  }),
+});
+
+module.exports = { UserEventSchema };

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

@@ -1,31 +1,44 @@
-const BaseConsumer = require('../../baseConsumer');
-const logger = require('<% if (architecture === "Clean Architecture") { %>../../../../infrastructure/log/logger<% } else { %>../../../utils/logger<% } %>');
-const { UserEventSchema } = require('../../schemas/userEventSchema');
-
-class WelcomeEmailConsumer extends BaseConsumer {
-  constructor() {
-    super();
-  }
-
-  get topic() { return 'user-topic'; }
-  get groupId() { return 'welcome-email-group'; }
-
-  async handle(data) {
-    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
-    }
-  }
-}
-
-module.exports = WelcomeEmailConsumer;
+const BaseConsumer = require('<%- baseConsumerPath %>');
+const logger = require('<%- loggerPath %>');
+const { UserEventSchema } = require('<%- userEventSchemaPath %>');
+const ERROR_MESSAGES = require('<%- errorMessagesPath %>');
+const { KAFKA_ACTIONS } = require('<%- kafkaEventsPath %>');
+
+class WelcomeEmailConsumer extends BaseConsumer {
+  constructor() {
+    super();
+  }
+
+  get topic() { return 'user-topic'; }
+  get groupId() { return 'welcome-email-group'; }
+
+  async handle(data) {
+    const result = UserEventSchema.safeParse(data);
+    
+    if (!result.success) {
+      logger.error(`[Kafka] ${ERROR_MESSAGES.INVALID_USER_DATA}:`, result.error.format());
+      return;
+    }
+
+    const { action, payload } = result.data;
+
+    switch (action) {
+      case KAFKA_ACTIONS.USER_CREATED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_CREATED}.`);
+        logger.info(`[Kafka] Consumer: 📧 Sending welcome email to '${payload.email}'... Done!`);
+        break;
+      case KAFKA_ACTIONS.USER_UPDATED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_UPDATED}.`);
+        logger.info(`[Kafka] Consumer: 🔄 Updating user records for '${payload.id}' (Email: ${payload.email})... Done!`);
+        break;
+      case KAFKA_ACTIONS.USER_DELETED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_DELETED}.`);
+        logger.info(`[Kafka] Consumer: 🗑️ Cleaning up data for user '${payload.id}'... Done!`);
+        break;
+      default:
+        logger.warn(`[Kafka] Unknown action: ${action}`);
+    }
+  }
+}
+
+module.exports = WelcomeEmailConsumer;

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

@@ -1,49 +1,86 @@
-const WelcomeEmailConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
-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<% } %>');
-
-describe('WelcomeEmailConsumer', () => {
-    let consumer;
-
-    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()
-        );
-    });
-});
+const WelcomeEmailConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+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<% } %>');
+
+describe('WelcomeEmailConsumer', () => {
+    let consumer;
+
+    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 update simulation for USER_UPDATED action', async () => {
+        const data = {
+            action: 'USER_UPDATED',
+            payload: {
+                id: 1,
+                email: 'updated@example.com'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_UPDATED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('🔄 Updating user records for \'1\' (Email: updated@example.com)... Done!')
+        );
+    });
+
+    it('should log deletion simulation for USER_DELETED action', async () => {
+        const data = {
+            action: 'USER_DELETED',
+            payload: {
+                id: 1
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_DELETED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('🗑️ Cleaning up data for user \'1\'... 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()
+        );
+    });
+});