jcc-express-mvc 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jcc-express-mvc",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "express mvc structure",
   "main": "index.js",
   "scripts": {

package/src/Auth/index.js

@@ -1,76 +1,89 @@
-const passport = require("passport");
-const { getModel, verifyHash } = require("../helpers");
-const User = getModel("User");
+const passport = require("passport"); // Import Passport for authentication
+const { getModel, verifyHash } = require("../helpers"); // Import helper functions for database operations and password hashing
+const User = getModel("User"); // Get the User model from database
 
 class Auth {
-  async login(data = {}, password = "") {
+  // Method to authenticate user login
+  static async login(data = {}, password = "") {
     try {
-      const user = await User.findOne(data).select("+password");
+      const user = await User.findOne(data).select("+password"); // Find user by provided data and include password field
       if (!user) {
-        return false;
+        return false; // If user not found, return false
       }
 
-      return (await verifyHash(password, user.password)) ? user : false;
+      return (await verifyHash(password, user.password)) ? user : false; // Verify password hash and return user if successful, otherwise false
     } catch (error) {
-      return new Error(error.message);
+      return new Error(error.message); // Return error if any exception occurs during login
     }
   }
 
-  async isAdmin(req, res, next) {
+  // Middleware to check if user is an admin
+  static async isAdmin(req, res, next) {
     try {
-      const user = await User.findById(req.id);
+      const user = await User.findById(req.id); // Find user by ID extracted from request
       if (!user) {
-        return res.json({ message: "Not authorize" }).status(403);
+        return res.json({ message: "Not authorized" }).status(403); // If user not found, return 403 Forbidden
       }
 
+      // Check if user has admin privileges
       if (
-        user.role != "admin" ||
-        user.role != "Admin" ||
-        user.role != false ||
-        user.roleType != "admin" ||
-        user.roleType != "Admin" ||
-        user.roleType != false ||
-        user.isAdmin != "Admin" ||
-        user.isAdmin != "admin" ||
-        user.isAdmin != false
+        !user.role ||
+        !user.roleType ||
+        !user.isAdmin ||
+        !(
+          user.role === "admin" ||
+          user.role === "Admin" ||
+          user.roleType === "admin" ||
+          user.roleType === "Admin" ||
+          user.isAdmin === true ||
+          user.isAdmin === "admin" ||
+          user.isAdmin === "Admin"
+        )
       ) {
-        return res.json({ message: "Not authorize" }).status(403);
+        return res.json({ message: "Not authorized" }).status(403); // If user doesn't have admin privileges, return 403 Forbidden
       }
 
-      next();
+      next(); // If user is admin, proceed to next middleware
     } catch (error) {
-      next(error);
+      next(error); // Pass any errors to the error handling middleware
     }
   }
 
-  async verifyEmail(req, res, next) {
+  // Middleware to verify user email
+  static async verifyEmail(req, res, next) {
     try {
-      const user = await User.findById(req.id);
+      const user = await User.findById(req.id); // Find user by ID extracted from request
       if (!user) {
-        return res.json({ message: "Not authorize" }).status(403);
+        return res.json({ message: "Not authorized" }).status(403); // If user not found, return 403 Forbidden
       }
-      if (!user.verify_email || !user.verifyEmail) {
-        return res.json({ message: "please verify your email" }).status(403);
+
+      // Check if user's email is verified
+      if (!user.verify_email && !user.verifyEmail) {
+        return res.json({ message: "Please verify your email" }).status(403); // If email is not verified, return 403 Forbidden
       }
-      next();
-    } catch (err) {
-      next(err);
+
+      next(); // If email is verified, proceed to next middleware
+    } catch (error) {
+      next(error); // Pass any errors to the error handling middleware
     }
   }
 
-  attempt(req, res, next) {
+  // Method to handle authentication attempt
+  static attempt(req, res, next) {
     try {
-      let redirectBack = req.previsiousUrls[1];
-      const appRedirect = req.session["appRedirect"];
-      const redirectPath = appRedirect ? appRedirect : "/home";
+      let redirectBack = req.previsiousUrls[1]; // Retrieve the previous URL
+      const appRedirect = req.session["appRedirect"]; // Retrieve redirect URL from session
+      const redirectPath = appRedirect ? appRedirect : "/home"; // Determine the redirect path
+      // Use Passport's local authentication strategy
       return passport.authenticate("local", {
-        successRedirect: redirectPath,
-        failureRedirect: `${redirectBack ? redirectBack : "/login"}`,
-        failureFlash: true,
-      })(req, res, next);
+        successRedirect: redirectPath, // Redirect on successful authentication
+        failureRedirect: `${redirectBack ? redirectBack : "/login"}`, // Redirect on failed authentication
+        failureFlash: true, // Enable flash messages on failed authentication
+      })(req, res, next); // Call Passport's authentication middleware
     } catch (error) {
-      next(error);
+      next(error); // Pass any errors to the error handling middleware
     }
   }
 }
-module.exports = new Auth();
+
+module.exports = Auth; // Export an instance of the Auth class

package/src/Auth/protectedRoute.js

@@ -1,21 +1,20 @@
+// Middleware to check if user is authenticated, redirect to login page if not
 exports.authenticated = (req, res, next) => {
   let url = "";
   if (req.url) {
     url = req.url;
     req.session["appRedirect"] = url;
   }
+  // Check if user is authenticated using Passport's isAuthenticated method
   return req.isAuthenticated()
-    ? next()
-    : res.redirect(url ? `/login?redirect=${url}` : "/login");
+    ? next() // If authenticated, proceed to the next middleware
+    : res.redirect(url ? `/login?redirect=${url}` : "/login"); // If not authenticated, redirect to login page
 };
 
-// exports.isLogIn = (req, res, next) =>
-//   req.isAuthenticated() ? res.redirect("/home") : next();
-
-// exports.isLogIn
-
+// Middleware to protect API routes, ensuring requests have a valid token
 exports.protectedApi = (request, response, next) => {
   let token;
+  // Extract token from different sources: headers, cookies, or custom header
   if (
     request.headers.authorization &&
     request.headers.authorization.startsWith("Bearer")
@@ -26,13 +25,15 @@ exports.protectedApi = (request, response, next) => {
   } else if (request.header("x-auth-token")) {
     token = request.header("x-auth-token");
   }
+  // If token is not present, return unauthorized response
   if (!token) {
-    return response.json({ message: "Not authorize" }).status(403);
+    return response.json({ message: "Not authorized" }).status(403);
   }
   try {
+    // Verify the token using JWT and store the decoded ID in the request object
     request.id = jwt.verify(token, process.env.JWT_SECRET);
-    next();
+    next(); // Proceed to the next middleware if token is valid
   } catch (err) {
-    return response.json({ message: "Not authorize" }).status(403);
+    return response.json({ message: "Not authorized" }).status(403); // Return unauthorized response if token is invalid
   }
 };

package/src/Router/Router.js

@@ -1,37 +1,86 @@
 const Util = require("../utils");
 
+/**
+ * Initializes a Router object.
+ * This class helps in setting up routes for different HTTP methods.
+ * @param {Object} options - Options object containing basePath and app properties.
+ * @param {string} prefix - Prefix for the routes.
+ * @param {Array} middlewares - Array of middleware functions.
+ * @param {Object} classController - Controller class.
+ */
 class Router {
-  constructor(app, prefix, middlewares, classController) {
+  constructor({ basePath, app }, prefix, middlewares, classController) {
     this.app = app;
+    this.basePath = basePath;
     this.prefixUrl = prefix;
     this.middlewares = middlewares;
     this.classController = classController;
 
-    this.util = new Util(app, prefix, middlewares, classController);
+    // Initializes Util instance for route handling
+    this.util = new Util(basePath, app, prefix, middlewares, classController);
   }
 
+  /**
+   * Sets middleware functions for the router.
+   * @param {Array} middlewares - Array of middleware functions.
+   * @returns {Router} - Returns the router instance.
+   */
   middleware(middlewares = [] || func) {
     this.middlewares = middlewares;
     this.util.setGroupMiddleware(middlewares);
     return this;
   }
 
+  /**
+   * Adds a route handler for GET requests.
+   * @param {string} path - Route path.
+   * @param {Function} callback - Callback function to handle the request.
+   * @returns {Router} - Returns the router instance.
+   */
   get(path, callback) {
     this.util.routeHelper("get", path, callback);
     return this;
   }
+
+  /**
+   * Adds a route handler for POST requests.
+   * @param {string} path - Route path.
+   * @param {Function} callback - Callback function to handle the request.
+   * @returns {Router} - Returns the router instance.
+   */
   post(path, callback) {
     this.util.routeHelper("post", path, callback);
     return this;
   }
+
+  /**
+   * Adds a route handler for PATCH requests.
+   * @param {string} path - Route path.
+   * @param {Function} callback - Callback function to handle the request.
+   * @returns {Router} - Returns the router instance.
+   */
   patch(path, callback) {
     this.util.routeHelper("patch", path, callback);
     return this;
   }
+
+  /**
+   * Adds a route handler for PUT requests.
+   * @param {string} path - Route path.
+   * @param {Function} callback - Callback function to handle the request.
+   * @returns {Router} - Returns the router instance.
+   */
   put(path, callback) {
     this.util.routeHelper("put", path, callback);
     return this;
   }
+
+  /**
+   * Adds a route handler for DELETE requests.
+   * @param {string} path - Route path.
+   * @param {Function} callback - Callback function to handle the request.
+   * @returns {Router} - Returns the router instance.
+   */
   delete(path, callback) {
     this.util.routeHelper("delete", path, callback);
     return this;

package/src/Router/Routes.js

@@ -1,21 +1,47 @@
 const Router = require("./Router");
+
+/**
+ * Initializes a Routes object.
+ * This class extends the Router class and provides additional functionalities for route grouping and controller setting.
+ * @param {Object} app - Express application instance.
+ */
 class Routes extends Router {
   constructor(app) {
     super(app);
   }
+
+  /**
+   * Sets a prefix for the routes.
+   * @param {string} url - Prefix URL for the routes.
+   * @returns {Routes} - Returns the Routes instance.
+   */
   prefix(url) {
     this.prefixUrl = url;
     return this;
   }
+
+  /**
+   * Sets the controller for the routes.
+   * @param {Object} controller - Controller class or object.
+   * @returns {Routes} - Returns the Routes instance.
+   */
   controller(controller) {
     this.classController = controller;
+    // Sets group controller using Util instance
     this.util.setGroupController(controller);
     return this;
   }
+
+  /**
+   * Groups routes using a callback function.
+   * @param {Function} callback - Callback function for defining grouped routes.
+   * @returns {Routes} - Returns the Routes instance.
+   */
   group(callback) {
+    // Invokes the callback with a new Router instance and returns the Routes instance
     callback(
       new Router(
-        this.app,
+        { basePath: this.basePath, app: this.app },
         this.prefixUrl,
         this.middlewares,
         this.classController

package/src/app/index.js

@@ -17,44 +17,65 @@ class App {
     new Middleware(express, this.app);
   }
 
+  /**
+   * Method to parse command line arguments.
+   * @param {string[]} argv - Command line arguments.
+   * @returns {object} - Processed command line arguments.
+   */
   commandLineArgv(argv) {
     return getCommands(argv.slice(2));
   }
 
+  /**
+   * Method to define web routes.
+   * @returns {object} - Instance of Routes class for web routes.
+   */
   webRoute() {
-    return new Routes(this.app);
+    return new Routes({ basePath: "", app: this.app });
   }
+
+  /**
+   * Method to define API routes.
+   * @returns {object} - Instance of Routes class for API routes.
+   */
   apiRoute() {
-    return new Routes(this.app);
+    return new Routes({ basePath: "/api", app: this.app });
   }
+
+  /**
+   * Method to configure and start the server.
+   * @returns {object} - Object containing server run method and server instance.
+   */
   server() {
     const app = this.app;
-    const PORT = process.env.PORT || process.env.NODE_ENV;
-    const server = http.Server(app);
-    const appError = new ErrorHandler(app);
-    new SocketIo(server);
+    const PORT = process.env.PORT || process.env.NODE_ENV; // Set the port for the server
+    const server = http.Server(app); // Create HTTP server using Express app
+    const appError = new ErrorHandler(app); // Initialize error handling middleware
+    new SocketIo(server); // Set up Socket.IO for real-time communication
     return {
       run() {
-        dbConnection();
-        rootPath("routes/index");
-        // rootPath("routes/api");
+        dbConnection(); // Establish connection to the database
+        rootPath("routes/api"); // Set root path for API routes
+        rootPath("routes/web"); // Set root path for web routes
 
-        appError.errorRoutesHandler();
-        app.use(appError.handler);
+        appError.errorRoutesHandler(); // Handle error routes
+        app.use(appError.handler); // Use error handling middleware
 
+        // Start listening on the specified port
         app.listen(PORT, () => {
-          console.log(`Server running on port ${PORT}`);
+          console.log(`Server running on port ${PORT}`); // Log server start message
           if (process.send) {
-            process.send("online");
+            process.send("online"); // Notify parent process that server is online
           }
         });
 
+        // Handle unhandled promise rejections
         process.on("unhandledRejection", (err) => {
-          console.log({ unhandledRejection: err.message });
-          process.exit(1);
+          console.log({ unhandledRejection: err.message }); // Log unhandled rejection error message
+          process.exit(1); // Exit process with failure status
         });
       },
-      server,
+      server, // Return the HTTP server instance
     };
   }
 }

package/src/command-line-interface/commands.js

@@ -1,119 +1,107 @@
 const path = require("path");
 const fs = require("fs");
-const createController = require("../files/controller");
-const createModel = require("../files/model");
-const resourceController = require("../files/resoucesController");
-const createRequest = require("../files/request");
-const rootPath = require("app-root-path").path;
-const colors = require("colors");
+const createController = require("../files/controller"); // Function to create a controller file
+const createModel = require("../files/model"); // Function to create a model file
+const resourceController = require("../files/resoucesController"); // Function to create a resource controller file
+const createRequest = require("../files/request"); // Function to create a request file
+const rootPath = require("app-root-path").path; // Module to get the root path of the application
+const colors = require("colors"); // Module for adding color to console output
+
 class Command {
+  // Method to add a web controller
   addWeb(controllerName, modelName = false) {
     try {
-      let webControllerPath = path.resolve(`${rootPath}/app/Controllers`);
+      let webControllerPath = path.resolve(`${rootPath}/app/Controllers`); // Resolve path to web controllers directory
       if (fs.existsSync(`${webControllerPath}/${controllerName}.js`)) {
-        return console.log(`${controllerName} already exist`.yellow);
+        // Check if controller file already exists
+        return console.log(`${controllerName} already exist`.yellow); // Log a warning if controller already exists
       }
       if (modelName) {
+        // If model name is provided, create a resource controller
         fs.writeFileSync(
           `${webControllerPath}/${controllerName}.js`,
           resourceController(controllerName, modelName)
         );
-        return console.log(`${controllerName} added successfully`.green);
+        return console.log(`${controllerName} added successfully`.green); // Log success message
       }
       fs.writeFileSync(
         `${webControllerPath}/${controllerName}.js`,
-        createController(controllerName)
+        createController(controllerName) // Create a basic controller file
       );
 
-      return console.log(`${controllerName} added successfully`.green);
+      return console.log(`${controllerName} added successfully`.green); // Log success message
     } catch (err) {
-      console.log(`${controllerName} admin controller not added`.red);
+      console.log(`${controllerName} admin controller not added`.red); // Log error if controller addition fails
     }
   }
 
-  // addAdmin(controllerName, modelName = false) {
-  //   try {
-  //     let adminPath = path.resolve(`${rootPath}/app/Controllers/Admin`);
-  //     if (fs.existsSync(`${adminPath}/${controllerName}.js`)) {
-  //       return console.log(`${controllerName} already exist`.yellow);
-  //     }
-  //     if (modelName) {
-  //       fs.writeFileSync(
-  //         `${adminPath}/${controllerName}.js`,
-  //         resourceController(controllerName, modelName)
-  //       );
-  //       return console.log(`${controllerName} added successfully`.green);
-  //     }
-  //     fs.writeFileSync(
-  //       `${adminPath}/${controllerName}.js`,
-  //       createController(controllerName)
-  //     );
-
-  //     return console.log(`${controllerName} added successfully`.green);
-  //   } catch (err) {
-  //     console.log(`${controllerName} admin controller not added`.red);
-  //   }
-  // }
-
+  // Method to add an API controller
   addApi(controllerName, modelName = false) {
     try {
-      let apiPath = path.resolve(`${rootPath}/app/Controllers/Api`);
+      let apiPath = path.resolve(`${rootPath}/app/Controllers/Api`); // Resolve path to API controllers directory
       if (fs.existsSync(`${apiPath}/${controllerName}.js`)) {
+        // Check if API controller file already exists
         return console.log(
           `${controllerName} api controller already exist`.yellow
-        );
+        ); // Log a warning if API controller already exists
       }
       if (modelName) {
+        // If model name is provided, create a resource controller
         fs.writeFileSync(
           `${apiPath}/${controllerName}.js`,
           resourceController(controllerName, modelName)
         );
-        return console.log(`${controllerName} added successfully`.green);
+        return console.log(`${controllerName} added successfully`.green); // Log success message
       }
       fs.writeFileSync(
         `${apiPath}/${controllerName}.js`,
-        createController(controllerName)
+        createController(controllerName) // Create a basic controller file
       );
-      return console.log(`${controllerName} added successfully`.green);
+      return console.log(`${controllerName} added successfully`.green); // Log success message
     } catch (err) {
       console.log(err.message);
-      console.log(`${controllerName} api controller not added`.red);
+      console.log(`${controllerName} api controller not added`.red); // Log error if controller addition fails
     }
   }
 
+  // Method to add a model
   addModel(modelName) {
     try {
-      let modelPath = path.resolve(`${rootPath}/app/Models`);
+      let modelPath = path.resolve(`${rootPath}/app/Models`); // Resolve path to models directory
       if (fs.existsSync(`${modelPath}/${modelName}.js`)) {
-        return console.log(`${modelName} model already exist`.yellow);
+        // Check if model file already exists
+        return console.log(`${modelName} model already exist`.yellow); // Log a warning if model already exists
       }
-      fs.writeFileSync(`${modelPath}/${modelName}.js`, createModel(modelName));
-      return console.log(`${modelName} model added successfully`.green);
+      fs.writeFileSync(`${modelPath}/${modelName}.js`, createModel(modelName)); // Create a model file
+      return console.log(`${modelName} model added successfully`.green); // Log success message
     } catch (err) {
-      return console.log(`${modelName} model not added`.red);
+      return console.log(`${modelName} model not added`.red); // Log error if model addition fails
     }
   }
 
+  // Method to add a request file
   addRequest(requestName) {
     try {
-      let requestPath = path.resolve(`${rootPath}/app/Request`);
+      let requestPath = path.resolve(`${rootPath}/app/Request`); // Resolve path to request files directory
       if (fs.existsSync(`${requestPath}/${requestName}.js`)) {
-        return console.log(`${requestName} already exist`.yellow);
+        // Check if request file already exists
+        return console.log(`${requestName} already exist`.yellow); // Log a warning if request file already exists
       }
 
       fs.writeFileSync(
         `${requestPath}/${requestName}.js`,
-        createRequest(requestName)
+        createRequest(requestName) // Create a request file
       );
-      return console.log(`${requestName} added successfully`.green);
+      return console.log(`${requestName} added successfully`.green); // Log success message
     } catch (err) {
-      return console.log(`${requestName} request not added`.red, { err });
+      return console.log(`${requestName} request not added`.red, { err }); // Log error if request addition fails
     }
   }
 
+  // Method to handle a command not found
   notFound() {
-    return console.log(`Command not found`.bgRed);
+    return console.log(`Command not found`.bgRed); // Log a message indicating the command was not found
   }
 }
 
-module.exports = new Command();
+module.exports = new Command(); // Export an instance of the Command class