nodejs-quickstart-structure 1.1.6

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

@@ -0,0 +1,23 @@
+const User = require('../models/User');
+const HTTP_STATUS = require('../utils/httpCodes');
+
+const getUsers = async (req, res) => {
+  try {
+    const users = await User.findAll();
+    res.json(users);
+  } catch (error) {
+    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+  }
+};
+
+const createUser = async (req, res) => {
+  try {
+    const { name, email } = req.body;
+    const user = await User.create({ name, email });
+    res.status(HTTP_STATUS.CREATED).json(user);
+  } catch (error) {
+    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+  }
+};
+
+module.exports = { getUsers, createUser };

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

@@ -0,0 +1,81 @@
+const express = require('express');
+const cors = require('cors');
+require('dotenv').config();
+<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { %>const apiRoutes = require('./routes/api');<% } %>
+<% if (communication === 'Kafka') { %>const { connectKafka, sendMessage } = require('./services/kafkaService');<% } %>
+<% if (communication === 'REST APIs') { %>
+const swaggerUi = require('swagger-ui-express');
+const swaggerSpecs = require('./config/swagger');
+<% } %>
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+const logger = require('./utils/logger');
+
+app.use(cors());
+app.use(express.json());
+
+<% if (communication === 'REST APIs') { %>
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+<% } %>
+
+<% if (viewEngine === 'EJS' || viewEngine === 'Pug') { %>
+// View Engine Setup
+const path = require('path');
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', '<%= viewEngine.toLowerCase() %>');
+<% } -%>
+
+// Routes
+<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { -%>
+app.use('/api', apiRoutes);
+<% } -%>
+<% if (viewEngine && viewEngine !== 'None') { -%>
+app.get('/', (req, res) => {
+  res.render('index', { 
+    projectName: 'NodeJS Service',
+    architecture: 'MVC',
+    database: '<%= database %>',
+    communication: '<%= communication %>'
+  });
+});
+<% } -%>
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'UP' });
+});
+
+// Database Sync
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            const sequelize = require('./config/database');
+            await sequelize.sync();
+            logger.info('Database synced');
+            
+            // Start Server after DB is ready
+            app.listen(PORT, async () => {
+              logger.info(`Server running on port ${PORT}`);
+              <% if (communication === 'Kafka') { %>
+              try {
+                await connectKafka();
+                logger.info('Kafka connected');
+                // Demo: Send a test message
+                await sendMessage('test-topic', 'Hello Kafka from MVC JS!');
+              } catch (err) {
+                logger.error('Failed to connect to Kafka:', err);
+              }
+              <% } -%>
+            });
+            break;
+        } catch (err) {
+            logger.error('Database sync failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+syncDatabase();

package/templates/mvc/js/src/routes/api.js

@@ -0,0 +1,74 @@
+const express = require('express');
+const router = express.Router();
+const userController = require('../controllers/userController');
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     User:
+ *       type: object
+ *       required:
+ *         - name
+ *         - email
+ *       properties:
+ *         id:
+ *           type: integer
+ *           description: The auto-generated id of the user
+ *         name:
+ *           type: string
+ *           description: The name of the user
+ *         email:
+ *           type: string
+ *           description: The email of the user
+ *       example:
+ *         id: 1
+ *         name: John Doe
+ *         email: john@example.com
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   name: Users
+ *   description: The users managing API
+ */
+
+/**
+ * @swagger
+ * /api/users:
+ *   get:
+ *     summary: Returns the list of all the users
+ *     tags: [Users]
+ *     responses:
+ *       200:
+ *         description: The list of the users
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/User'
+ *   post:
+ *     summary: Create a new user
+ *     tags: [Users]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/User'
+ *     responses:
+ *       201:
+ *         description: The created user.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/User'
+ *       500:
+ *         description: Some server error
+ */
+router.get('/users', userController.getUsers);
+router.post('/users', userController.createUser);
+
+module.exports = router;

package/templates/mvc/js/src/utils/httpCodes.js

@@ -0,0 +1,9 @@
+const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+};
+
+module.exports = HTTP_STATUS;

package/templates/mvc/js/src/utils/logger.js

@@ -0,0 +1,30 @@
+const winston = require('winston');
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    //
+    // - Write all logs with importance level of `error` or less to `error.log`
+    // - Write all logs with importance level of `info` or less to `combined.log`
+    //
+    new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'combined.log' }),
+  ],
+});
+
+//
+// If we're not in production then log to the `console` with the format:
+// `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
+//
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(new winston.transports.Console({
+    format: winston.format.simple(),
+  }));
+}
+
+module.exports = logger;

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

@@ -0,0 +1,24 @@
+<% if (communication === 'REST APIs') { %>
+import swaggerJsdoc from 'swagger-jsdoc';
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'NodeJS API Service',
+      version: '1.0.0',
+      description: 'API documentation for the NodeJS Service',
+    },
+    servers: [
+      {
+        url: process.env.SERVER_URL || `http://localhost:${process.env.PORT || 3000}`,
+        description: 'Server',
+      },
+    ],
+  },
+  apis: ['./src/routes/*.ts', './dist/routes/*.js'], // Path to the API docs
+};
+
+const specs = swaggerJsdoc(options);
+
+export default specs;<% } %>

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

@@ -0,0 +1,32 @@
+import { Request, Response } from 'express';
+import User from '../models/User';
+import { HTTP_STATUS } from '../utils/httpCodes';
+
+export class UserController {
+    async getUsers(req: Request, res: Response) {
+        try {
+            const users = await User.findAll();
+            res.json(users);
+        } catch (error) {
+            if (error instanceof Error) {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+            } else {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
+            }
+        }
+    }
+
+    async createUser(req: Request, res: Response) {
+        try {
+            const { name, email } = req.body;
+            const user = await User.create({ name, email });
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            if (error instanceof Error) {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+            } else {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,89 @@
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import rateLimit from 'express-rate-limit';
+import dotenv from 'dotenv';
+import logger from './utils/logger';
+<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { %>import apiRoutes from './routes/api';<% } %>
+<% if (communication === 'REST APIs') { %>
+import swaggerUi from 'swagger-ui-express';
+import swaggerSpecs from './config/swagger';<% } %>
+<% if (communication === 'Kafka') { %>import { KafkaService } from './services/kafkaService';<% } %>
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+// Security Middleware
+app.use(helmet());
+app.use(hpp());
+app.use(cors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] }));
+const limiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 100 });
+app.use(limiter);
+
+app.use(express.json());
+
+<% if (communication === 'REST APIs') { %>
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));<% } %>
+
+<% if (viewEngine === 'EJS' || viewEngine === 'Pug') { %>
+// View Engine Setup
+import path from 'path';
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', '<%= viewEngine.toLowerCase() %>');<% } -%>
+
+// Routes
+<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { -%>
+app.use('/api', apiRoutes);<% } -%>
+<% if (viewEngine && viewEngine !== 'None') { -%>
+app.get('/', (req: Request, res: Response) => {
+  res.render('index', { 
+    projectName: 'NodeJS Service',
+    architecture: 'MVC',
+    database: '<%= database %>',
+    communication: '<%= communication %>'
+  });
+});
+<% } -%>
+
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'UP' });
+});
+
+// Database Sync
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            const sequelize = (await import('./config/database')).default;
+            await sequelize.sync();
+            logger.info('Database synced');
+            
+            // Start Server after DB is ready
+            app.listen(port, async () => {
+              logger.info(`Server running on port ${port}`);
+              <% if (communication === 'Kafka') { %>
+              try {
+                const kafkaService = new KafkaService();
+                await kafkaService.connect();
+                logger.info('Kafka connected');
+                // Demo: Send a test message
+                await kafkaService.sendMessage('test-topic', 'Hello Kafka from MVC TS!');
+              } catch (err) {
+                logger.error('Failed to connect to Kafka:', err);
+              }
+              <% } -%>
+            });
+            break;
+        } catch (err) {
+            logger.error('Database sync failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+syncDatabase();

package/templates/mvc/ts/src/routes/api.ts

@@ -0,0 +1,76 @@
+import { Router, Request, Response } from 'express';
+import { UserController } from '../controllers/userController';
+
+const router = Router();
+const userController = new UserController();
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     User:
+ *       type: object
+ *       required:
+ *         - name
+ *         - email
+ *       properties:
+ *         id:
+ *           type: integer
+ *           description: The auto-generated id of the user
+ *         name:
+ *           type: string
+ *           description: The name of the user
+ *         email:
+ *           type: string
+ *           description: The email of the user
+ *       example:
+ *         id: 1
+ *         name: John Doe
+ *         email: john@example.com
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   name: Users
+ *   description: The users managing API
+ */
+
+/**
+ * @swagger
+ * /api/users:
+ *   get:
+ *     summary: Returns the list of all the users
+ *     tags: [Users]
+ *     responses:
+ *       200:
+ *         description: The list of the users
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/User'
+ *   post:
+ *     summary: Create a new user
+ *     tags: [Users]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/User'
+ *     responses:
+ *       201:
+ *         description: The created user.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/User'
+ *       500:
+ *         description: Some server error
+ */
+router.get('/users', (req: Request, res: Response) => userController.getUsers(req, res));
+router.post('/users', (req: Request, res: Response) => userController.createUser(req, res));
+
+export default router;

package/templates/mvc/ts/src/utils/httpCodes.ts

@@ -0,0 +1,7 @@
+export const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+} as const;

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

@@ -0,0 +1,22 @@
+import winston from 'winston';
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'combined.log' }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(new winston.transports.Console({
+    format: winston.format.simple(),
+  }));
+}
+
+export default logger;