nodejs-structure-cli 1.0.0

package/lib/prompts.js

@@ -0,0 +1,128 @@
+import inquirer from 'inquirer';
+
+const validateName = (name) => {
+    return /^[a-zA-Z0-9-_]+$/.test(name) ? true : 'Project name may only include letters, numbers, underscores and dashes.';
+};
+
+export const getProjectDetails = async (options = {}) => {
+    const questions = [
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: 'nodejs-service',
+            validate: validateName,
+            when: !options.projectName
+        },
+        {
+            type: 'select',
+            name: 'language',
+            message: 'Select Language:',
+            choices: ['JavaScript', 'TypeScript'],
+            default: 'TypeScript',
+            when: !options.language
+        },
+        {
+            type: 'select',
+            name: 'architecture',
+            message: 'Select Architecture:',
+            choices: ['MVC', 'Clean Architecture'],
+            default: 'MVC',
+            when: !options.architecture
+        },
+        {
+            type: 'select',
+            name: 'viewEngine',
+            message: 'Select View Engine:',
+            choices: ['None', 'EJS', 'Pug'],
+            when: (answers) => (options.architecture || answers.architecture) === 'MVC' && !options.viewEngine,
+            default: 'None'
+        },
+        {
+            type: 'select',
+            name: 'database',
+            message: 'Select Database:',
+            choices: ['None', 'MySQL', 'PostgreSQL', 'MongoDB'],
+            default: 'None',
+            when: !options.database
+        },
+        {
+            type: 'input',
+            name: 'dbName',
+            message: 'Database Name:',
+            default: 'demo',
+            validate: validateName,
+            when: (answers) => !options.dbName && (options.database || answers.database) !== 'None'
+        },
+        {
+            type: 'select',
+            name: 'communication',
+            message: 'Microservices Communication:',
+            choices: ['REST APIs', 'GraphQL', 'Kafka'],
+            default: 'REST APIs',
+            when: !options.communication
+        },
+        {
+            type: 'select',
+            name: 'caching',
+            message: 'Caching Layer:',
+            choices: ['None', 'Redis', 'Memory Cache'],
+            default: 'None',
+            when: (answers) => !options.caching && (options.database || answers.database) !== 'None'
+        },
+        {
+            type: 'select',
+            name: 'ciProvider',
+            message: 'Select CI/CD Provider:',
+            choices: ['None', 'GitHub Actions', 'Jenkins', 'GitLab CI'],
+            default: 'None',
+            when: !options.ciProvider
+        },
+        {
+            type: 'select',
+            name: 'includeSecurity',
+            message: 'Include Enterprise Security Hardening (Big Tech Standard: Snyk, SonarQube)?',
+            choices: ['No', 'Yes'],
+            default: "No",
+            when: (answers) => options.includeSecurity === undefined && (options.ciProvider || answers.ciProvider) !== 'None'
+        },
+        {
+            type: 'select',
+            name: 'auth',
+            message: 'Select Authentication:',
+            choices: ['None', 'Better-Auth', 'JWT', 'OAuth'],
+            default: 'None',
+            when: !options.auth
+        },
+        {
+            type: 'select',
+            name: 'googleLogin',
+            message: 'Include Social Login?',
+            choices: ['None', 'Google Login'],
+            default: 'None',
+            when: (answers) => (options.auth || answers.auth) === 'OAuth' && !options.googleLogin
+        },
+        {
+            type: 'select',
+            name: 'includeMulter',
+            message: 'Add image upload capability (Multer)?',
+            choices: ['No', 'Yes'],
+            default: 'No',
+            when: options.includeMulter === undefined
+        }
+    ];
+
+    const answers = await inquirer.prompt(questions);
+    const result = { ...options, ...answers };
+
+    // Normalize includeSecurity to boolean if it's a string from the select prompt
+    if (typeof result.includeSecurity === 'string') {
+        result.includeSecurity = result.includeSecurity === 'Yes';
+    }
+
+    if (typeof result.includeMulter === 'string') {
+        result.includeMulter = result.includeMulter === 'Yes';
+    }
+
+    return result;
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "nodejs-structure-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "The ultimate nodejs quickstart structure CLI to scaffold Node.js microservices with MVC or Clean Architecture",
+  "main": "bin/index.js",
+  "bin": {
+    "nodejs-structure-cli": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test:e2e": "npm run test:e2e:windows",
+    "test:e2e:windows": "node scripts/validate-windows.js",
+    "test:e2e:linux": "node scripts/validate-linux.js",
+    "test:validate-command": "node scripts/validate-command.js",
+    "test:verify:mongo": "node scripts/verify-migration.js",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "security:check": "npm audit && npm run snyk:test",
+    "snyk:test": "snyk test"
+  },
+  "keywords": [
+    "nodejs",
+    "node",
+    "quickstart",
+    "structure",
+    "cli",
+    "scaffold",
+    "mvc",
+    "clean-architecture",
+    "microservices",
+    "backend",
+    "generator",
+    "boilerplate"
+  ],
+  "author": "jaysoni <sonijay2709@gmail.com>",
+  "contributors": [
+    {
+      "name": "jaysoni",
+      "url": "https://github.com/Jaysoni2709"
+    }
+  ],
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^14.0.3",
+    "ejs": "^5.0.1",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^13.3.2"
+  },
+  "overrides": {
+    "esbuild": "^0.25.0"
+  },
+  "devDependencies": {
+    "snyk": "^1.1303.2",
+    "vitepress": "^1.0.0-rc.45"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "templates",
+    "README.md",
+    "CHANGELOG.md"
+  ]
+}

package/templates/clean-architecture/js/src/domain/models/User.js.ejs

@@ -0,0 +1,11 @@
+class User {
+    constructor(id, name, email<% if (auth && auth !== 'None') { %>, password<% } %><% if (includeMulter) { %>, imageUrl<% } %>) {
+        this.id = id;
+        this.name = name;
+        this.email = email;
+        <% if (auth && auth !== 'None') { %>this.password = password;<% } %>
+        <% if (includeMulter) { %>this.imageUrl = imageUrl;<% } %>
+    }
+}
+
+module.exports = User;

package/templates/clean-architecture/js/src/errors/ApiError.js

@@ -0,0 +1,14 @@
+class ApiError extends Error {
+  constructor(statusCode, message, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+module.exports = { ApiError };

package/templates/clean-architecture/js/src/errors/BadRequestError.js

@@ -0,0 +1,11 @@
+const { ApiError } = require('./ApiError');
+const HTTP_STATUS = require('../utils/httpCodes');
+const ERROR_MESSAGES = require('../utils/errorMessages');
+
+class BadRequestError extends ApiError {
+  constructor(message = ERROR_MESSAGES.BAD_REQUEST) {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}
+
+module.exports = { BadRequestError };

package/templates/clean-architecture/js/src/errors/BadRequestError.spec.js.ejs

@@ -0,0 +1,22 @@
+const { BadRequestError } = require('@/errors/BadRequestError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad Request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe(ERROR_MESSAGES.BAD_REQUEST);
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/clean-architecture/js/src/errors/NotFoundError.js

@@ -0,0 +1,11 @@
+const { ApiError } = require('./ApiError');
+const HTTP_STATUS = require('../utils/httpCodes');
+const ERROR_MESSAGES = require('../utils/errorMessages');
+
+class NotFoundError extends ApiError {
+  constructor(message = ERROR_MESSAGES.RESOURCE_NOT_FOUND) {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}
+
+module.exports = { NotFoundError };

package/templates/clean-architecture/js/src/errors/NotFoundError.spec.js.ejs

@@ -0,0 +1,22 @@
+const { NotFoundError } = require('@/errors/NotFoundError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe(ERROR_MESSAGES.RESOURCE_NOT_FOUND);
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError(ERROR_MESSAGES.USER_NOT_FOUND);
+        expect(error.message).toBe(ERROR_MESSAGES.USER_NOT_FOUND);
+    });
+});

package/templates/clean-architecture/js/src/index.js.ejs

@@ -0,0 +1,56 @@
+const startServer = require('./infrastructure/webserver/server');
+const logger = require('./infrastructure/log/logger');
+<% if (communication === 'Kafka') { -%>
+const { connectKafka } = require('./infrastructure/messaging/kafkaClient');
+<% } -%>
+<%_ if (database !== 'None') { -%>
+// Database Sync
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+const connectDB = require('./infrastructure/database/database');
+<%_ } else { -%>
+const sequelize = require('./infrastructure/database/database');
+<%_ } -%>
+<%_ } -%>
+
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            <%_ if (database === 'MongoDB') { -%>
+            await connectDB();
+            <%_ } else { -%>
+            await sequelize.sync();
+            <%_ } -%>
+            logger.info('Database synced');
+            // Start the web server after DB sync
+            startServer();
+            <%_ if (communication === 'Kafka') { -%>
+            // Connect Kafka
+            connectKafka().then(async () => {
+              logger.info('Kafka connected');
+            }).catch(err => {
+              logger.error('Failed to connect to Kafka:', err);
+            });
+            <%_ } -%>
+            break;
+        } catch (error) {
+            logger.error('Error syncing database:', error);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+syncDatabase();
+<%_ } else { -%>
+startServer();
+<%_ if (communication === 'Kafka') { -%>
+// Connect Kafka
+connectKafka().then(async () => {
+  logger.info('Kafka connected');
+}).catch(err => {
+  logger.error('Failed to connect to Kafka:', err);
+});
+<%_ } -%>
+<%_ } -%>

package/templates/clean-architecture/js/src/infrastructure/config/env.js.ejs

@@ -0,0 +1,47 @@
+const { z } = require('zod');
+const logger = require('../log/logger');
+
+if (process.env.NODE_ENV !== 'production') {
+  require('dotenv').config();
+}
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+<%_ if (database !== 'None') { -%>
+  DB_HOST: z.string(),
+<%_ if (database === 'MySQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'PostgreSQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'MongoDB') { -%>
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+  REDIS_HOST: z.string(),
+  REDIS_PORT: z.string().transform(Number),
+  REDIS_PASSWORD: z.string().optional(),
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+  KAFKA_BROKER: z.string(),
+<%_ } -%>
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  logger.error('❌ Invalid environment variables:', _env.error.format());
+  process.exit(1);
+}
+
+const env = _env.data;
+
+module.exports = { env };

package/templates/clean-architecture/js/src/infrastructure/log/logger.js

@@ -0,0 +1,36 @@
+const winston = require('winston');
+require('winston-daily-rotate-file');
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/error-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+      level: 'error',
+    }),
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/combined-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+    }),
+  ],
+});
+
+logger.add(new winston.transports.Console({
+  format: process.env.NODE_ENV !== 'production'
+    ? winston.format.simple()
+    : winston.format.json(),
+}));
+
+module.exports = logger;

package/templates/clean-architecture/js/src/infrastructure/log/logger.spec.js.ejs

@@ -0,0 +1,63 @@
+jest.mock('winston-daily-rotate-file');
+jest.mock('winston', () => {
+    const mockLogger = {
+        add: jest.fn(),
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    const format = {
+        combine: jest.fn(),
+        timestamp: jest.fn(),
+        json: jest.fn(),
+        simple: jest.fn()
+    };
+    const transports = {
+        Console: jest.fn(),
+        DailyRotateFile: jest.fn()
+    };
+    return {
+        format,
+        transports,
+        createLogger: jest.fn().mockReturnValue(mockLogger)
+    };
+});
+
+<% if (architecture === 'MVC') { -%>
+const logger = require('@/utils/logger');
+<% } else { -%>
+const logger = require('@/infrastructure/log/logger');
+<% } -%>
+
+describe('Logger', () => {
+    it('should export a logger instance', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have info method', () => {
+        expect(typeof logger.info).toBe('function');
+    });
+
+    it('should have error method', () => {
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should call info', () => {
+        logger.info('test message');
+        expect(logger.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call error', () => {
+        logger.error('test error');
+        expect(logger.error).toHaveBeenCalledWith('test error');
+    });
+
+    it('should use JSON format in production environment', () => {
+        const winston = require('winston');
+        jest.resetModules();
+        process.env.NODE_ENV = 'production';
+        require('@/infrastructure/log/logger');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

package/templates/clean-architecture/js/src/infrastructure/repositories/UserRepository.js.ejs

@@ -0,0 +1,88 @@
+const UserModel = require('../database/models/User');
+
+class UserRepository {
+  async save(user) {
+<%_ if (database === 'None') { -%>
+    const newUser = await UserModel.create(user);
+    return newUser;
+<%_ } else { -%>
+    const userData = { name: user.name, email: user.email };
+    <% if (auth && auth !== 'None') { %>if (user.password) userData.password = user.password;<% } %>
+    <% if (includeMulter) { %>if (user.imageUrl) userData.imageUrl = user.imageUrl;<% } %>
+    const newUser = await UserModel.create(userData);
+<%_ if (database === 'MongoDB') { -%>
+    return { ...user, id: newUser._id.toString() };
+<%_ } else { -%>
+    return { ...user, id: newUser.id };
+<%_ } -%>
+<%_ } -%>
+  }
+
+  async getUsers() {
+<%_ if (database === 'None') { -%>
+    return await UserModel.find();
+<%_ } else if (database === 'MongoDB') { -%>
+    const users = await UserModel.find();
+    return users.map(user => ({
+        id: user._id.toString(),
+        name: user.name,
+        email: user.email,
+        <% if (auth && auth !== 'None') { %>password: user.password,<% } %>
+        <% if (includeMulter) { %>imageUrl: user.imageUrl,<% } %>
+    }));
+<%_ } else { -%>
+    const users = await UserModel.findAll();
+    return users.map(user => ({
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        <% if (auth && auth !== 'None') { %>password: user.password,<% } %>
+        <% if (includeMulter) { %>imageUrl: user.imageUrl,<% } %>
+    }));
+<%_ } -%>
+  }
+
+  async update(id, data) {
+<%_ if (database === 'MongoDB') { -%>
+    const user = await UserModel.findByIdAndUpdate(id, data, { new: true });
+    if (!user) return null;
+    return { 
+      id: user._id.toString(), 
+      name: user.name, 
+      email: user.email,
+      <% if (auth && auth !== 'None') { %>password: user.password,<% } %>
+      <% if (includeMulter) { %>imageUrl: user.imageUrl,<% } %>
+    };
+<%_ } else if (database === 'None') { -%>
+    const user = await UserModel.update(id, data);
+    return user;
+<%_ } else { -%>
+    const user = await UserModel.findByPk(id);
+    if (!user) return null;
+    await user.update(data);
+    return { 
+      id: user.id || 0, 
+      name: user.name, 
+      email: user.email,
+      <% if (auth && auth !== 'None') { %>password: user.password,<% } %>
+      <% if (includeMulter) { %>imageUrl: user.imageUrl,<% } %>
+    };
+<%_ } -%>
+  }
+
+  async delete(id) {
+<%_ if (database === 'MongoDB') { -%>
+    const result = await UserModel.findByIdAndDelete(id);
+    return !!result;
+<%_ } else if (database === 'None') { -%>
+    return await UserModel.destroy(id);
+<%_ } else { -%>
+    const user = await UserModel.findByPk(id);
+    if (!user) return false;
+    await user.destroy();
+    return true;
+<%_ } -%>
+  }
+}
+
+module.exports = UserRepository;