jcc-express-mvc 1.2.5 → 1.2.7

package/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artisanCommand = exports.Schema = exports.Model = exports.verifyHash = exports.jwtVerify = exports.jwtSign = exports.bcrypt = exports.FormRequest = exports.apiAuth = exports.auth = exports.Auth = exports.config = exports.HttpKernel = exports.server = exports.ApiRoute = exports.Route = void 0;
+const Config_1 = __importDefault(require("./lib/Config/Config"));
+const App_1 = require("./lib/App");
+const HttpKernel_1 = __importDefault(require("./lib/HttpKernel/HttpKernel"));
+const Auth_1 = __importDefault(require("./lib/Auth"));
+const AuthMiddleware_1 = require("./lib/Auth/AuthMiddleware");
+const FormRequest_1 = require("./lib/Request/FormRequest");
+const util_1 = require("./lib/util");
+const Schema_1 = require("./lib/Database/src/Schema");
+const Model_1 = require("./lib/Database/src/Model");
+const NodeArtisanCommand_1 = require("./lib/Command-Line/NodeArtisanCommand");
+exports.Route = App_1.app.webRoutes();
+exports.ApiRoute = App_1.app.apiRoutes();
+exports.server = App_1.app.httpServer();
+exports.HttpKernel = HttpKernel_1.default;
+exports.config = Config_1.default;
+exports.Auth = Auth_1.default;
+exports.auth = AuthMiddleware_1.authMiddleware.auth;
+exports.apiAuth = AuthMiddleware_1.authMiddleware.apiAuth;
+exports.FormRequest = FormRequest_1.FormRequest;
+exports.bcrypt = util_1.bcrypt;
+exports.jwtSign = util_1.jwtSign;
+exports.jwtVerify = util_1.jwtVerify;
+exports.verifyHash = util_1.verifyHash;
+exports.Model = Model_1.Model;
+exports.Schema = Schema_1.Schema;
+exports.artisanCommand = NodeArtisanCommand_1.NodeArtisanCommand;

package/lib/App.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const Router_1 = require("./Routes/Router");
+const Config_1 = __importDefault(require("./Config/Config"));
+const Middlewares_1 = require("./Middlewares");
+const Server_1 = require("./Server");
+const util_1 = require("./util");
+const Constants_1 = require("./Error/Constants");
+class App extends Server_1.HttpSever {
+    // private app = express();
+    constructor() {
+        super();
+        new Middlewares_1.Middleware(this.express, this.app);
+    }
+    webRoutes() {
+        return new Router_1.Router(this.app, { prefixUrl: "", basePath: "" });
+    }
+    /**
+     * Method to define API routes.
+     * @returns {object} - Instance of Routes class for API routes.
+     */
+    apiRoutes() {
+        return new Router_1.Router(this.app, { basePath: "/api", prefixUrl: "" });
+    }
+    /**
+     * Method to configure and start the server.
+     * @returns {object} - Object containing server run method and server instance.
+     */
+    httpServer() {
+        const server = this.server(Number(Config_1.default.get(Constants_1.PORT, "3000")));
+        const httpErrors = this.httpErrors;
+        const app = this.app;
+        return {
+            listen() {
+                (0, util_1.loadRoutes)();
+                httpErrors(app);
+                return server;
+            },
+        };
+    }
+}
+exports.app = new App();

package/lib/Auth/AuthMiddleware.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authMiddleware = void 0;
+const util_1 = require("../util");
+class AuthMiddleware {
+    apiAuth(request, response, next) {
+        let token;
+        if (request.headers.authorization &&
+            request.headers.authorization.startsWith("Bearer")) {
+            token = request.headers.authorization.split(" ")[1];
+        }
+        else if (request.cookies.token) {
+            token = request.cookies.token;
+        }
+        else if (request.header("x-auth-token")) {
+            token = request.header("x-auth-token");
+        }
+        if (!token) {
+            return response.json({ message: "Not authorize" }).status(401);
+        }
+        try {
+            request.id = (0, util_1.jwtVerify)(token);
+            //   request.id = jwtVerify(token, process.env.JWT_SECRET);
+            //
+            next();
+        }
+        catch (err) {
+            next(err);
+            return response.json({ message: "Not authorize" }).status(401);
+        }
+    }
+    auth(request, response, next) {
+        let url = "";
+        if (request.url) {
+            url = request.url;
+            request.session["appRedirect"] = url;
+        }
+        return request.isAuthenticated()
+            ? next()
+            : response.redirect(url ? `/login?redirect=${url}` : "/login");
+    }
+}
+exports.authMiddleware = new AuthMiddleware();

package/lib/Auth/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const passport_1 = __importDefault(require("passport")); // Import Passport for authentication
+const util_1 = require("../util"); // Import helper functions for database operations and password hashing
+const User = (0, util_1.getModel)("User"); // Get the User model from database
+class Authentication {
+    // Method to authenticate user login
+    static async login(data = {}, password = "") {
+        try {
+            const user = await User.findOne(data); //.select("+password"); // Find user by provided data and include password field
+            if (!user) {
+                return false; // If user not found, return false
+            }
+            //return (await verifyHash(password, user.password))
+            true ? user : false; // Verify password hash and return user if successful, otherwise false
+        }
+        catch (error) {
+            return new Error(error.message); // Return error if any exception occurs during login
+        }
+    }
+    // Middleware to check if user is an admin
+    static async isAdmin(req, res, next) {
+        try {
+            const user = await User.findById(req.id); // Find user by ID extracted from request
+            if (!user) {
+                return res.json({ message: "Not authorized" }).status(403); // If user not found, return 403 Forbidden
+            }
+            // Check if user has admin privileges
+            if (!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 authorized" }).status(403); // If user doesn't have admin privileges, return 403 Forbidden
+            }
+            next(); // If user is admin, proceed to next middleware
+        }
+        catch (error) {
+            next(error); // Pass any errors to the error handling middleware
+        }
+    }
+    // Middleware to verify user email
+    static async verifyEmail(req, res, next) {
+        try {
+            const user = await User.findById(req?.id); // Find user by ID extracted from request
+            if (!user) {
+                return res.json({ message: "Not authorized" }).status(403); // If user not found, return 403 Forbidden
+            }
+            // 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(); // If email is verified, proceed to next middleware
+        }
+        catch (error) {
+            next(error); // Pass any errors to the error handling middleware
+        }
+    }
+    // Method to handle authentication attempt
+    static attempt(req, res, next) {
+        try {
+            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_1.default.authenticate("local", {
+                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); // Pass any errors to the error handling middleware
+        }
+    }
+    static logout(req, res, next) {
+        return req.logout((err) => {
+            if (err) {
+                next(err);
+            }
+            return res.redirect("/login");
+        });
+    }
+}
+exports.default = Authentication;

package/lib/Command-Line/NodeArtisanCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeArtisanCommand = void 0;
+const command_1 = __importDefault(require("./command"));
+/**
+ Function to parse command line arguments and execute corresponding commands
+ @param {commandArg}  commandArg -string
+ @returns {any} -any
+ *  */
+const NodeArtisanCommand = (commandArg = []) => {
+    let index = commandArg.findIndex((arg, index) => arg.includes(":")); //commandArg[0].split(":")[1] || commandArg[1].split(":")[1]; // Extract the command type from the first argument
+    let command = commandArg[index].split(":")[1];
+    // If the command is for creating an API controller with resources
+    if (commandArg.length === index + 4 &&
+        (command === "apiController" || command === "ApiController") &&
+        (commandArg[index + 3] === "--resources" || commandArg[index + 3] === "-r")) {
+        command_1.default.addModel(commandArg[2]); // Add a model with the provided name
+        return command_1.default.addApi(commandArg[index + 1], commandArg[index + 2]); // Add an API controller with resources
+    }
+    // If the command is for creating a web controller with resources
+    if (commandArg.length === 4 &&
+        (command === "controller" || command === "Controller") &&
+        (commandArg[3] === "--resources" || commandArg[3] === "-r")) {
+        command_1.default.addModel(commandArg[2]); // Add a model with the provided name
+        return command_1.default.addWeb(commandArg[1], commandArg[2]); // Add a web controller with resources
+    }
+    // If the command is for creating an admin controller with resources
+    // If the command is for creating a web controller
+    if (commandArg.length === index + 3 &&
+        (command === "controller" || command === "Controller")) {
+        return command_1.default.addWeb(commandArg[index + 1], commandArg[index + 2]); // Add a web controller
+    }
+    // If the command is for creating an API controller
+    if (commandArg.length === index + 3 &&
+        (command === "apiController" || command === "ApiController")) {
+        return command_1.default.addApi(commandArg[index + 1], commandArg[index + 2]); // Add an API controller
+    }
+    // If the command is for creating a model
+    if (commandArg.length === index + 2 &&
+        (command === "model" || command === "Model")) {
+        return command_1.default.addModel(commandArg[index + 1]); // Add a model
+    }
+    // If the command is for creating a web controller without specifying a model
+    if (commandArg.length === index + 2 &&
+        (command === "controller" || command === "Controller")) {
+        return command_1.default.addWeb(commandArg[index + 1], false); // Add a web controller without a model
+    }
+    // If the command is for creating an API controller without specifying a model
+    if (commandArg.length === index + 2 &&
+        (command === "apiController" || command === "ApiController")) {
+        return command_1.default.addApi(commandArg[index + 1], false); // Add an API controller without a model
+    }
+    // If the command is for creating a request file
+    if (commandArg.length === index + 2 &&
+        (command === "Request" || command === "request")) {
+        return command_1.default.addRequest(commandArg[index + 1]); // Add a request file
+    }
+    // If the command is for creating a request file
+    if (commandArg.length === index + 2 &&
+        (command === "Migration" || command === "migration")) {
+        return command_1.default.addMigration(commandArg[index + 1]); // Add a request file
+    }
+    // If the command is not recognized, display "Command not found"
+    return command_1.default.notFound();
+};
+exports.NodeArtisanCommand = NodeArtisanCommand;

package/lib/Command-Line/command.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const app_root_path_1 = __importDefault(require("app-root-path"));
+const Controller_1 = __importDefault(require("./files/Controller"));
+const Models_1 = __importDefault(require("./files/Models"));
+const ResourcesController_1 = __importDefault(require("./files/ResourcesController"));
+const Request_1 = __importDefault(require("./files/Request"));
+const Migration_1 = __importDefault(require("./files/Migration"));
+const utils_1 = require("./utils");
+const rootPath = app_root_path_1.default.path;
+class Command {
+    // Method to add a web controller
+    addWeb(controllerName, modelName = false) {
+        try {
+            let webControllerPath = path_1.default.resolve(`${rootPath}/app/Http/Controllers`); // Resolve path to web controllers directory
+            if (fs_1.default.existsSync(`${webControllerPath}/${controllerName}.ts`)) {
+                // Check if controller file already exists
+                return console.log(`${controllerName} already exist`.yellow); // Log a warning if controller already exists
+            }
+            if (modelName && typeof modelName === "string") {
+                // If model name is provided, create a resource controller
+                fs_1.default.writeFileSync(`${webControllerPath}/${controllerName}.ts`, (0, ResourcesController_1.default)(controllerName, modelName));
+                return console.log(`${controllerName} added successfully`.green); // Log success message
+            }
+            fs_1.default.writeFileSync(`${webControllerPath}/${controllerName}.ts`, (0, Controller_1.default)(controllerName));
+            return console.log(`${controllerName} added successfully`.green); // Log success message
+        }
+        catch (err) {
+            console.log(`${controllerName} admin controller not added`.red); // Log error if controller addition fails
+        }
+    }
+    // Method to add an API controller
+    addApi(controllerName, modelName = false) {
+        try {
+            let apiPath = path_1.default.resolve(`${rootPath}/app/Http/ApiControllers`); // Resolve path to API controllers directory
+            if (fs_1.default.existsSync(`${apiPath}/${controllerName}.ts`)) {
+                // 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 && typeof modelName === "string") {
+                // If model name is provided, create a resource controller
+                fs_1.default.writeFileSync(`${apiPath}/${controllerName}.ts`, (0, ResourcesController_1.default)(controllerName, modelName));
+                return console.log(`${controllerName} added successfully`.green); // Log success message
+            }
+            fs_1.default.writeFileSync(`${apiPath}/${controllerName}.ts`, (0, Controller_1.default)(controllerName));
+            return console.log(`${controllerName} added successfully`.green); // Log success message
+        }
+        catch (err) {
+            console.log(err.message);
+            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_1.default.resolve(`${rootPath}/app/Models`); // Resolve path to models directory
+            if (fs_1.default.existsSync(`${modelPath}/${modelName}.ts`)) {
+                // Check if model file already exists
+                return console.log(`${modelName} model already exist`.yellow); // Log a warning if model already exists
+            }
+            fs_1.default.writeFileSync(`${modelPath}/${modelName}.ts`, (0, Models_1.default)(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); // Log error if model addition fails
+        }
+    }
+    // Method to add a request file
+    addRequest(requestName) {
+        try {
+            let requestPath = path_1.default.resolve(`${rootPath}/app/Http/Requests`); // Resolve path to request files directory
+            if (fs_1.default.existsSync(`${requestPath}/${requestName}.ts`)) {
+                // Check if request file already exists
+                return console.log(`${requestName} already exist`.yellow); // Log a warning if request file already exists
+            }
+            fs_1.default.writeFileSync(`${requestPath}/${requestName}.ts`, (0, Request_1.default)(requestName));
+            return console.log(`${requestName} added successfully`.green); // Log success message
+        }
+        catch (err) {
+            return console.log(`${requestName} request not added`.red, { err }); // Log error if request addition fails
+        }
+    }
+    // Method to add a request file
+    addMigration(migrationName) {
+        try {
+            const tableName = migrationName.replace(/(create_|_table)/g, "");
+            let migrationPath = path_1.default.resolve(`${rootPath}/database/migrations`);
+            // Resolve path to request files directory
+            const fullName = `${(0, utils_1.formatDate)()}_${migrationName}`;
+            if (fs_1.default.existsSync(`${migrationPath}/${fullName}.ts`)) {
+                // Check if request file already exists
+                return console.log(`${tableName} already exist`.yellow); // Log a warning if request file already exists
+            }
+            fs_1.default.writeFileSync(`${migrationPath}/${fullName}.ts`, (0, Migration_1.default)(tableName));
+            return console.log(`${fullName} added successfully`.green); // Log success message
+        }
+        catch (err) {
+            return console.log(`${migrationName} migration 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); // Log a message indicating the command was not found
+    }
+}
+exports.default = new Command(); // Export an instance of the Command class

package/{Command-Line → lib/Command-Line}/files/Controller.js

@@ -1,10 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  *  Function to create a controller file
  * @param name string
  * @returns string
  */
 const createController = (name) => {
-  return `
+    return `
     import {Request, Response,Next} from "jcc-express-mvc"
 
 
@@ -72,5 +74,4 @@ const createController = (name) => {
   }
      `;
 };
-
-module.exports = createController;
+exports.default = createController;

package/{Command-Line → lib/Command-Line}/files/Migration.js

@@ -1,6 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const inflection = require("inflection");
 const createMigration = (table) => {
-  return `
+    return `
 import {Schema} from "";
 class Migration {
   up() {
@@ -13,5 +15,4 @@ class Migration {
 }
 `;
 };
-
-module.exports = createMigration;
+exports.default = createMigration;

package/{Command-Line → lib/Command-Line}/files/Models.js

@@ -1,10 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Function to create a model file
  * @param name - string
  * @returns string
  */
 const createModel = (name) => {
-  return `
+    return `
     import {Model} from "jcc-express-mvc"
 
     export class ${name} extends Model{
@@ -16,5 +18,4 @@ const createModel = (name) => {
 
      `;
 };
-
-module.exports = createModel;
+exports.default = createModel;

package/{Command-Line → lib/Command-Line}/files/Request.js

@@ -1,10 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Function to create a request file
  * @param name - string
  * @returns string
  */
 const createRequest = (fileName) => {
-  return `
+    return `
   import { getModel, FormRequest,Request } = from "jcc-express-mvc";
   
  export class ${fileName} extends FormRequest {
@@ -28,5 +30,4 @@ const createRequest = (fileName) => {
   
   `;
 };
-
-module.exports = createRequest;
+exports.default = createRequest;

package/{Command-Line → lib/Command-Line}/files/ResourcesController.js

@@ -1,10 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Function to create a resources file
  * @param name - string
  * @returns string
  */
 const resourceController = (controller, model) => {
-  return `const {getModel }= require("jcc-express-mvc")
+    return `const {getModel }= require("jcc-express-mvc")
     const ${model} = getModel('${model}')
    export class ${controller} {
     
@@ -73,5 +75,4 @@ const resourceController = (controller, model) => {
   }
        `;
 };
-
-module.exports = resourceController;
+exports.default = resourceController;

package/lib/Command-Line/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = void 0;
+const formatDate = () => {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    return `${year}_${month}_${day}_${hours}_${minutes}_${seconds}`;
+};
+exports.formatDate = formatDate;

package/lib/Config/Config.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const app_root_path_1 = __importDefault(require("app-root-path"));
+class Config {
+    constructor() {
+        dotenv_1.default.config({ path: `${app_root_path_1.default.path}/.env` });
+        this.config = process.env;
+    }
+    get(key, defaultValue = "") {
+        return this.config[key] || defaultValue;
+    }
+}
+exports.default = new Config();