nodejs-structure-cli 1.0.1 → 1.0.2

package/bin/index.js

@@ -42,13 +42,13 @@ program
     "-c, --communication <communication>",
     "Communication (REST APIs, GraphQL, Kafka)",
   )
-  .option(
-    "--ci-provider <provider>",
-    "CI/CD Provider (None, GitHub Actions, Jenkins, GitLab CI)",
-  )
+  .option("--ci-provider <provider>", "CI/CD Provider (None, GitHub Actions, Jenkins, GitLab CI)")
   .option("--include-security", "Include Enterprise Security Hardening")
   .option("--no-include-security", "Exclude Enterprise Security Hardening")
-  .option("--caching <type>", "Caching Layer (None/Redis)")
+  .option("--caching <type>", "Caching Layer (None/Redis/Memory Cache)")
+  .option("--auth <type>", "Authentication (None, Better-Auth, JWT, OAuth)")
+  .option("--google-login <type>", "Google Login (None, Google Login)")
+  .option("--include-multer <choice>", "Add image upload capability (No/Yes)")
   .action(async (options) => {
     // Fix for Commander camelCase conversion
     if (options.ciProvider) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-structure-cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "description": "The ultimate nodejs quickstart structure CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",

package/templates/common/database/js/database.js.ejs

@@ -1,5 +1,7 @@
-const { Sequelize } = require('sequelize');
-require('dotenv').config();
+import { Sequelize } from 'sequelize';
+import dotenv from 'dotenv';
+
+dotenv.config();
 
 <% if (database === 'MySQL') { %>const dialect = 'mysql';<% } -%>
 <% if (database === 'PostgreSQL') { %>const dialect = 'postgres';<% } -%>
@@ -16,4 +18,4 @@ const sequelize = new Sequelize(
   }
 );
 
-module.exports = sequelize;
+export default sequelize;

package/templates/common/database/js/models/User.js.ejs

@@ -39,10 +39,10 @@ class UserModel {
   }
 }
 
-module.exports = UserModel;
+export default UserModel;
 <% } else { -%>
-const { DataTypes, Model } = require('sequelize');
-<% if (architecture === 'MVC') { %>const sequelize = require('../config/database');<% } else { %>const sequelize = require('../database');<% } %>
+import { DataTypes, Model } from 'sequelize';
+<% if (architecture === 'MVC') { %>import sequelize from '../config/database.js';<% } else { %>import sequelize from '../database.js';<% } %>
 
 class User extends Model {}
 
@@ -87,5 +87,5 @@ User.init(
   }
 );
 
-module.exports = User;
+export default User;
 <% } -%>

package/templates/common/database/js/mongoose.js.ejs

@@ -1,10 +1,12 @@
-const mongoose = require('mongoose');
+import mongoose from 'mongoose';
 
 let logger;
 <% if (architecture === 'MVC') { %>
-logger = require('../utils/logger');
+import logger_mvc from '../utils/logger.js';
+logger = logger_mvc;
 <% } else { %>
-logger = require('../log/logger');
+import logger_ca from '../log/logger.js';
+logger = logger_ca;
 <% } %>
 const connectDB = async () => {
     const dbHost = process.env.DB_HOST || 'localhost';
@@ -30,4 +32,4 @@ const connectDB = async () => {
     }
 };
 
-module.exports = connectDB; // Export function to call in index.js
+export default connectDB; // Export function to call in index.js

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

@@ -1,16 +1,19 @@
-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<% } %>');
+import express from 'express';
+import logger from '<% if (architecture === "MVC") { %>../utils/logger.js<% } else { %>../../infrastructure/log/logger.js<% } %>';
+import HTTP_STATUS from '<% if (architecture === "MVC") { %>../utils/httpCodes.js<% } else { %>../../utils/httpCodes.js<% } %>';
+
 <%_ if (database !== 'None') { -%>
-const ERROR_MESSAGES = require('<% if (architecture === "MVC") { %>../utils/errorMessages<% } else { %>../../utils/errorMessages<% } %>');
+import ERROR_MESSAGES from '<% if (architecture === "MVC") { %>../utils/errorMessages.js<% } else { %>../../utils/errorMessages.js<% } %>';
 <%_ } -%>
+
 <%_ if (database === 'MongoDB') { -%>
-const mongoose = require('mongoose');
+import mongoose from 'mongoose';
 <%_ } else if (database !== 'None') { -%>
-const sequelize = require('<% if (architecture === "MVC") { %>../config/database<% } else { %>../../infrastructure/database/database<% } %>');
+import sequelize from '<% if (architecture === "MVC") { %>../config/database.js<% } else { %>../../infrastructure/database/database.js<% } %>';
 <%_ } -%>
 
+const router = express.Router();
+
 router.get('/', async (req, res) => {
   const healthData = {
     status: 'UP',
@@ -47,4 +50,4 @@ router.get('/', async (req, res) => {
   res.status(HTTP_STATUS.OK).json(healthData);
 });
 
-module.exports = router;
+export default router;

package/templates/common/package.json.ejs

@@ -1,6 +1,7 @@
 {
   "name": "<%= projectName %>",
   "version": "1.0.0",
+  "type": "module",
   "description": "Generated by nodejs-quickstart",
   "main": "<% if (language === 'TypeScript') { %>dist/index.js<% } else { %>src/index.js<% } %>",
   "scripts": {

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

@@ -1,17 +1,30 @@
 <%_ 
-let loggerPath = './logger';
-let dbPath = '../config/database';
-let redisPath = '../config/redisClient';
-let kafkaPath = '../services/kafkaService';
+let loggerPath = './logger.js';
+let dbPath = '../config/database.js';
+let redisPath = '../config/redisClient.js';
+let kafkaPath = '../services/kafkaService.js';
 
 if (architecture === 'Clean Architecture') {
-    loggerPath = '../infrastructure/log/logger';
-    dbPath = '../infrastructure/database/database';
-    redisPath = '../infrastructure/caching/redisClient';
-    kafkaPath = '../infrastructure/messaging/kafkaClient';
+    loggerPath = '../infrastructure/log/logger.js';
+    dbPath = '../infrastructure/database/database.js';
+    redisPath = '../infrastructure/caching/redisClient.js';
+    kafkaPath = '../infrastructure/messaging/kafkaClient.js';
 }
 -%>
-const logger = require('<%- loggerPath %>');
+import logger from '<%- loggerPath %>';
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else { -%>
+import sequelize from '<%- dbPath %>';
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+import redisService from '<%- redisPath %>';
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+import { disconnectKafka } from '<%- kafkaPath %>';
+<%_ } -%>
+<%_ } -%>
 
 const setupGracefulShutdown = (server) => {
     const gracefulShutdown = async (signal) => {
@@ -25,22 +38,18 @@ const setupGracefulShutdown = (server) => {
             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.');
 <%_ } -%>
@@ -62,4 +71,4 @@ const setupGracefulShutdown = (server) => {
     process.on('SIGINT', () => gracefulShutdown('SIGINT'));
 };
 
-module.exports = setupGracefulShutdown;
+export default setupGracefulShutdown;

package/templates/common/src/config/auth.js.ejs

@@ -1,7 +1,7 @@
 import { betterAuth } from "better-auth";
 <% if (database === 'MongoDB') { %>import { mongodbAdapter } from "better-auth/adapters/mongodb";
 import mongoose from "mongoose";<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>import { sequelizeAdapter } from "better-auth/adapters/sequelize";
-import sequelize from "./database";<% } %>
+import sequelize from "./database<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>";<% } %>
 
 export const auth = betterAuth({
     database: <% if (database === 'MongoDB') { %>mongodbAdapter(mongoose.connection.db)<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>sequelizeAdapter(sequelize)<% } else { %>null // Better-Auth requires a database adapter<% } %>,

package/templates/common/src/controllers/authController.js.ejs

@@ -1,5 +1,5 @@
 <% if (auth === 'Better-Auth') { %>
-import { auth } from '../config/auth<% if (language === 'TypeScript') { %>.ts<% } %>';
+import { auth } from '../config/auth<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>';
 
 export const register = async (req, res, next) => {
   try {
@@ -34,7 +34,7 @@ export const login = async (req, res, next) => {
 <% } else if (auth === 'JWT') { %>
 import jwt from 'jsonwebtoken';
 import bcrypt from 'bcryptjs';
-import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>';
 
 // Mock User database (In production, use your database models)
 const users = []; 

package/templates/common/src/middleware/auth.js.ejs

@@ -1,5 +1,5 @@
 import jwt from 'jsonwebtoken';
-import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>';
 
 export const authMiddleware = (req, res, next) => {
   const authHeader = req.headers.authorization;

package/templates/common/src/middleware/upload.js.ejs

@@ -1,6 +1,6 @@
 import multer from 'multer';
 import path from 'path';
-import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>';
 
 // Storage configuration
 const storage = multer.diskStorage({

package/templates/common/src/routes/authRoutes.js.ejs

@@ -1,6 +1,6 @@
 import express from 'express';
 <% if (auth === 'OAuth' || googleLogin === 'Google Login') { %>import passport from 'passport';<% } %>
-import * as authController from '../controllers/authController<% if (language === 'TypeScript') { %>.ts<% } %>';
+import * as authController from '../controllers/authController<% if (language === 'TypeScript') { %>.ts<% } else { %>.js<% } %>';
 
 const router = express.Router();
 

package/templates/mvc/js/src/config/env.js.ejs

@@ -1,8 +1,9 @@
-const { z } = require('zod');
-const logger = require('../utils/logger');
+import { z } from 'zod';
+import logger from '../utils/logger.js';
+import dotenv from 'dotenv';
 
 if (process.env.NODE_ENV !== 'production') {
-  require('dotenv').config();
+  dotenv.config();
 }
 const envSchema = z.object({
   NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
@@ -43,4 +44,4 @@ if (!_env.success) {
 
 const env = _env.data;
 
-module.exports = { env };
+export { env };

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

@@ -1,6 +1,10 @@
-const path = require('path');
-const YAML = require('yamljs');
+import path from 'path';
+import YAML from 'yamljs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
 
-module.exports = swaggerDocument;
+export default swaggerDocument;

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

@@ -1,24 +1,24 @@
-const User = require('../models/User');
-const ERROR_MESSAGES = require('../utils/errorMessages');
+import User from '../models/User.js';
+import ERROR_MESSAGES from '../utils/errorMessages.js';
 <% if (communication !== 'GraphQL') { -%>
-const HTTP_STATUS = require('../utils/httpCodes');
+import HTTP_STATUS from '../utils/httpCodes.js';
 <% } -%>
-const logger = require('../utils/logger');
+import logger from '../utils/logger.js';
 <%_ if (caching === 'Redis') { -%>
-const cacheService = require('../config/redisClient');
+import cacheService from '../config/redisClient.js';
 <%_ } else if (caching === 'Memory Cache') { -%>
-const cacheService = require('../config/memoryCache');
+import cacheService from '../config/memoryCache.js';
 <%_ } -%>
 <%_ if (communication === 'Kafka') { -%>
-const { sendMessage } = require('../services/kafkaService');
-const { KAFKA_ACTIONS } = require('../utils/kafkaEvents');
+import { sendMessage } from '../services/kafkaService.js';
+import { KAFKA_ACTIONS } from '../utils/kafkaEvents.js';
 <%_ } -%>
 <%_ if (auth && auth !== 'None') { _%>
-const bcrypt = require('bcryptjs');
+import bcrypt from 'bcryptjs';
 <%_ } _%>
 
 <% if (communication === 'GraphQL') { -%>
-const getUsers = async () => {
+export const getUsers = async () => {
   try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     const users = await cacheService.getOrSet('users:all', async () => {
@@ -42,7 +42,7 @@ const getUsers = async () => {
   }
 };
 
-const createUser = async (data) => {
+export const createUser = async (data) => {
   try {
     const { name, email, password, imageUrl } = data;
     const userData = { name, email };
@@ -73,7 +73,7 @@ const createUser = async (data) => {
   }
 };
 
-const updateUser = async (id, data) => {
+export const updateUser = async (id, data) => {
   try {
 <%_ if (database === 'MongoDB') { -%>
     const updatedUser = await User.findByIdAndUpdate(id, data, { new: true });
@@ -105,7 +105,7 @@ const updateUser = async (id, data) => {
   }
 };
 
-const deleteUser = async (id) => {
+export const deleteUser = async (id) => {
   try {
 <%_ if (database === 'MongoDB') { -%>
     const deleted = await User.findByIdAndDelete(id);
@@ -133,10 +133,8 @@ const deleteUser = async (id) => {
     throw error;
   }
 };
-
-module.exports = { getUsers, createUser, updateUser, deleteUser };
 <% } else { -%>
-const getUsers = async (req, res, next) => {
+export const getUsers = async (req, res, next) => {
   try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     const users = await cacheService.getOrSet('users:all', async () => {
@@ -160,7 +158,7 @@ const getUsers = async (req, res, next) => {
   }
 };
 
-const createUser = async (req, res, next) => {
+export const createUser = async (req, res, next) => {
   try {
     const { name, email, password } = req.body || {};
     const userData = { name, email };
@@ -194,7 +192,7 @@ const createUser = async (req, res, next) => {
   }
 };
 
-const updateUser = async (req, res, next) => {
+export const updateUser = async (req, res, next) => {
   try {
     const { id } = req.params;
     const { name, email, password } = req.body || {};
@@ -248,7 +246,7 @@ const updateUser = async (req, res, next) => {
   }
 };
 
-const deleteUser = async (req, res, next) => {
+export const deleteUser = async (req, res, next) => {
   try {
     const { id } = req.params;
 <%_ if (database === 'MongoDB') { -%>
@@ -283,6 +281,4 @@ const deleteUser = async (req, res, next) => {
     next(error);
   }
 };
-
-module.exports = { getUsers, createUser, updateUser, deleteUser };
 <% } -%>

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

@@ -1,34 +1,38 @@
-const { env } = require('./config/env');
-const express = require('express');
-const cors = require('cors');
-<%_ 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');<%_ } -%>
+import { env } from './config/env.js';
+import express from 'express';
+import cors from 'cors';
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>import apiRoutes from './routes/api.js';<%_ } %>
+import healthRoutes from './routes/healthRoute.js';
+<%_ if (communication === 'Kafka') { -%>import { connectKafka, sendMessage } from './services/kafkaService.js';<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
-const { ApolloServer } = require('@apollo/server');
-const { expressMiddleware } = require('@as-integrations/express4');
-const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
-const { unwrapResolverError } = require('@apollo/server/errors');
-const { ApiError } = require('./errors/ApiError');
-const { typeDefs, resolvers } = require('./graphql');
-const { gqlContext } = require('./graphql/context');
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express4';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { unwrapResolverError } from '@apollo/server/errors';
+import { ApiError } from './errors/ApiError.js';
+import { typeDefs, resolvers } from './graphql/index.js';
+import { gqlContext } from './graphql/context.js';
 <% } %>
 <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-const swaggerUi = require('swagger-ui-express');
-const swaggerSpecs = require('./config/swagger');
+import swaggerUi from 'swagger-ui-express';
+import swaggerSpecs from './config/swagger.js';
 <%_ } -%>
-const setupGracefulShutdown = require('./utils/gracefulShutdown');
+import setupGracefulShutdown from './utils/gracefulShutdown.js';
+import logger from './utils/logger.js';
+import morgan from 'morgan';
+import { errorMiddleware } from './utils/errorMiddleware.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const app = express();
 const PORT = env.PORT;
-const logger = require('./utils/logger');
-const morgan = require('morgan');
-const { errorMiddleware } = require('./utils/errorMiddleware');
 
 app.use(cors());
 app.use(express.json());
 <% if (includeMulter) { %>
-const path = require('path');
 app.use('/uploads', express.static(path.join(__dirname, '../uploads')));
 <% } %>
 app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));
@@ -38,7 +42,6 @@ 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() %>');
 app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
@@ -106,12 +109,10 @@ const startServer = async () => {
 
 <%_ if (database !== 'None') { -%>
 // Database Sync
-<%_ if (database !== 'None') { -%>
 <%_ if (database === 'MongoDB') { -%>
-const connectDB = require('./config/database');
+import connectDB from './config/database.js';
 <%_ } else { -%>
-const sequelize = require('./config/database');
-<%_ } -%>
+import sequelize from './config/database.js';
 <%_ } -%>
 const syncDatabase = async () => {
     let retries = 30;

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

@@ -1,9 +1,10 @@
-const express = require('express');
+import express from 'express';
+import userController from '../controllers/userController.js';
+<% if (auth && auth !== 'None') { %>import { authMiddleware } from '../middleware/auth.js';<% } %>
+<% if (includeMulter) { %>import { upload } from '../middleware/upload.js';<% } %>
+<% if (auth && auth !== 'None') { %>import authRoutes from './authRoutes.js';<% } %>
+
 const router = express.Router();
-const userController = require('../controllers/userController');
-<% if (auth && auth !== 'None') { %>const { authMiddleware } = require('../middleware/auth');<% } %>
-<% if (includeMulter) { %>const { upload } = require('../middleware/upload');<% } %>
-<% if (auth && auth !== 'None') { %>const authRoutes = require('./authRoutes');<% } %>
 
 <% if (auth && auth !== 'None') { %>router.use('/auth', authRoutes);<% } %>
 
@@ -12,4 +13,4 @@ router.post('/users', <% if (auth && auth !== 'None') { %>authMiddleware, <% } %
 router.patch('/users/:id', <% if (auth && auth !== 'None') { %>authMiddleware, <% } %><% if (includeMulter) { %>upload.single('image'), <% } %>userController.updateUser);
 router.delete('/users/:id', <% if (auth && auth !== 'None') { %>authMiddleware, <% } %>userController.deleteUser);
 
-module.exports = router;
+export default router;

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

@@ -11,4 +11,4 @@ const ERROR_MESSAGES = {
     DATABASE_PING_FAILED: 'Health Check Database Ping Failed',
 };
 
-module.exports = ERROR_MESSAGES;
+export default ERROR_MESSAGES;

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

@@ -1,6 +1,6 @@
-const logger = require('./logger');
-const { ApiError } = require('../errors/ApiError');
-const HTTP_STATUS = require('./httpCodes');
+import logger from './logger.js';
+import { ApiError } from '../errors/ApiError.js';
+import HTTP_STATUS from './httpCodes.js';
 
 // eslint-disable-next-line no-unused-vars
 const errorMiddleware = (err, req, res, next) => {
@@ -26,4 +26,4 @@ const errorMiddleware = (err, req, res, next) => {
   });
 };
 
-module.exports = { errorMiddleware };
+export { errorMiddleware };

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

@@ -6,4 +6,4 @@ const HTTP_STATUS = {
     INTERNAL_SERVER_ERROR: 500
 };
 
-module.exports = HTTP_STATUS;
+export default HTTP_STATUS;

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

@@ -1,5 +1,5 @@
-const winston = require('winston');
-require('winston-daily-rotate-file');
+import winston from 'winston';
+import 'winston-daily-rotate-file';
 
 const logger = winston.createLogger({
   level: 'info',
@@ -37,4 +37,4 @@ logger.add(new winston.transports.Console({
     : winston.format.json(),
 }));
 
-module.exports = logger;
+export default logger;