jcc-express-mvc 1.0.0

package/index.js

@@ -0,0 +1 @@
+module.exports = require("./src");

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "jcc-express-mvc",
+  "version": "1.0.0",
+  "description": "express mvc structure",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jammehabdou64/express-mvc.git"
+  },
+  "keywords": [
+    "library"
+  ],
+  "author": "Abdou Jammeh",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/jammehabdou64/express-mvc.git/issues"
+  },
+  "homepage": "https://github.com/jammehabdou64/express-mvc.git#readme"
+}

package/src/Auth/index.js

@@ -0,0 +1,74 @@
+const passport = require("passport");
+const { getModel, verifyHash } = require("../helpers");
+const User = getModel("User");
+
+class Auth {
+  async login(data = {}, password = "") {
+    try {
+      const user = await User.findOne(data).select("+password");
+      if (!user) {
+        return false;
+      }
+
+      return (await verifyHash(password, user.password)) ? user : false;
+    } catch (error) {
+      return new Error(error.message);
+    }
+  }
+
+  async isAdmin(req, res, next) {
+    try {
+      const user = await User.findById(req.id);
+      if (!user) {
+        return res.json({ message: "Not authorize" }).status(403);
+      }
+
+      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
+      ) {
+        return res.json({ message: "Not authorize" }).status(403);
+      }
+
+      next();
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async verifyEmail(req, res, next) {
+    try {
+      const user = await User.findById(req.id);
+      if (!user) {
+        return res.json({ message: "Not authorize" }).status(403);
+      }
+      if (!user.verify_email || !user.verifyEmail) {
+        return res.json({ message: "please verify your email" }).status(403);
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  attempt(req, res, next) {
+    try {
+      let redirectBack = req.previsiousUrls[1];
+      return passport.authenticate("local", {
+        successRedirect: "/home",
+        failureRedirect: `${redirectBack ? redirectBack : "/login"}`,
+        failureFlash: true,
+      })(req, res, next);
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+module.exports = new Auth();

package/src/Auth/protectedRoute.js

@@ -0,0 +1,30 @@
+exports.authenticated = (req, res, next) =>
+  req.isAuthenticated() ? next() : res.redirect("/login");
+
+// exports.isLogIn = (req, res, next) =>
+//   req.isAuthenticated() ? res.redirect("/home") : next();
+
+// exports.isLogIn
+
+exports.protectedApi = (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(403);
+  }
+  try {
+    request.id = jwt.verify(token, process.env.JWT_SECRET);
+    next();
+  } catch (err) {
+    return response.json({ message: "Not authorize" }).status(403);
+  }
+};

package/src/Router/Router.js

@@ -0,0 +1,42 @@
+const Util = require("../utils");
+
+class Router {
+  constructor(app, prefix, middlewares, classController) {
+    this.app = app;
+    this.prefixUrl = prefix;
+    this.middlewares = middlewares;
+    this.classController = classController;
+
+    this.util = new Util(app, prefix, middlewares, classController);
+  }
+
+  middleware(middlewares) {
+    this.middlewares = middlewares;
+    this.util.setGroupMiddleware(middlewares);
+    return this;
+  }
+
+  get(path, callback) {
+    this.util.routeHelper("get", path, callback);
+    return this;
+  }
+  post(path, callback) {
+    this.util.routeHelper("post", path, callback);
+    return this;
+  }
+  patch(path, callback) {
+    this.util.routeHelper("patch", path, callback);
+    return this;
+  }
+  put(path, callback) {
+    this.util.routeHelper("put", path, callback);
+    return this;
+  }
+  delete(path, callback) {
+    this.util.routeHelper("delete", path, callback);
+    return this;
+  }
+  all() {}
+}
+
+module.exports = Router;

package/src/Router/Routes.js

@@ -0,0 +1,28 @@
+const Router = require("./Router");
+class Routes extends Router {
+  constructor(app) {
+    super(app);
+  }
+  prefix(url) {
+    this.prefixUrl = url;
+    return this;
+  }
+  controller(controller) {
+    this.classController = controller;
+    this.util.setGroupController(controller);
+    return this;
+  }
+  group(callback) {
+    callback(
+      new Router(
+        this.app,
+        this.prefixUrl,
+        this.middlewares,
+        this.classController
+      )
+    );
+    return this;
+  }
+}
+
+module.exports = Routes;

package/src/app/index.js

@@ -0,0 +1,62 @@
+const http = require("http");
+const express = require("express");
+const dotenv = require("dotenv");
+const Middleware = require("../middlware");
+const Routes = require("../Router/Routes");
+const { rootPath } = require("../helpers");
+const dbConnection = require("../dbConnection");
+const ErrorHandler = require("../error/ErrorHandler");
+const SocketIo = require("../socket");
+const getCommands = require("../command-line-interface/getCommands");
+
+class App {
+  constructor() {
+    dotenv.config();
+    this.express = express;
+    this.app = express();
+    new Middleware(express, this.app);
+  }
+
+  commandLineArgv(argv) {
+    return getCommands(argv.slice(2));
+  }
+
+  webRoute() {
+    return new Routes(this.app);
+  }
+  apiRoute() {
+    return new Routes(this.app);
+  }
+  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);
+    return {
+      run() {
+        dbConnection();
+        rootPath("routes/index");
+        // rootPath("routes/api");
+
+        appError.errorRoutesHandler();
+        app.use(appError.handler);
+
+        app.listen(PORT, () => {
+          console.log(`Server running on port ${PORT}`);
+          if (process.send) {
+            process.send("online");
+          }
+        });
+
+        process.on("unhandledRejection", (err) => {
+          console.log({ unhandledRejection: err.message });
+          process.exit(1);
+        });
+      },
+      server,
+    };
+  }
+}
+
+module.exports = App;

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

@@ -0,0 +1,119 @@
+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");
+class Command {
+  addWeb(controllerName, modelName = false) {
+    try {
+      let webControllerPath = path.resolve(`${rootPath}/app/Controllers`);
+      if (fs.existsSync(`${webControllerPath}/${controllerName}.js`)) {
+        return console.log(`${controllerName} already exist`.yellow);
+      }
+      if (modelName) {
+        fs.writeFileSync(
+          `${webControllerPath}/${controllerName}.js`,
+          resourceController(controllerName, modelName)
+        );
+        return console.log(`${controllerName} added successfully`.green);
+      }
+      fs.writeFileSync(
+        `${webControllerPath}/${controllerName}.js`,
+        createController(controllerName)
+      );
+
+      return console.log(`${controllerName} added successfully`.green);
+    } catch (err) {
+      console.log(`${controllerName} admin controller not added`.red);
+    }
+  }
+
+  // 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);
+  //   }
+  // }
+
+  addApi(controllerName, modelName = false) {
+    try {
+      let apiPath = path.resolve(`${rootPath}/app/Controllers/Api`);
+      if (fs.existsSync(`${apiPath}/${controllerName}.js`)) {
+        return console.log(
+          `${controllerName} api controller already exist`.yellow
+        );
+      }
+      if (modelName) {
+        fs.writeFileSync(
+          `${apiPath}/${controllerName}.js`,
+          resourceController(controllerName, modelName)
+        );
+        return console.log(`${controllerName} added successfully`.green);
+      }
+      fs.writeFileSync(
+        `${apiPath}/${controllerName}.js`,
+        createController(controllerName)
+      );
+      return console.log(`${controllerName} added successfully`.green);
+    } catch (err) {
+      console.log(err.message);
+      console.log(`${controllerName} api controller not added`.red);
+    }
+  }
+
+  addModel(modelName) {
+    try {
+      let modelPath = path.resolve(`${rootPath}/app/Model`);
+      if (fs.existsSync(`${modelPath}/${modelName}.js`)) {
+        return console.log(`${modelName} model already exist`.yellow);
+      }
+      fs.writeFileSync(`${modelPath}/${modelName}.js`, createModel(modelName));
+      return console.log(`${modelName} model added successfully`.green);
+    } catch (err) {
+      return console.log(`${modelName} model not added`.red);
+    }
+  }
+
+  addRequest(requestName) {
+    try {
+      let requestPath = path.resolve(`${rootPath}/app/Request`);
+      if (fs.existsSync(`${requestPath}/${requestName}.js`)) {
+        return console.log(`${requestName} already exist`.yellow);
+      }
+
+      fs.writeFileSync(
+        `${requestPath}/${requestName}.js`,
+        createRequest(requestName)
+      );
+      return console.log(`${requestName} added successfully`.green);
+    } catch (err) {
+      return console.log(`${requestName} request not added`.red, { err });
+    }
+  }
+
+  notFound() {
+    return console.log(`Command not found`.bgRed);
+  }
+}
+
+module.exports = new Command();

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

@@ -0,0 +1,59 @@
+const mongose = require("mongoose");
+const dotenv = require("dotenv");
+const { getModel, bcrypt } = require("../helpers");
+class DbCli {
+  constructor(model) {
+    dotenv.config();
+    this.model = getModel(model);
+    this.connection();
+  }
+  async connection() {
+    try {
+      const connect = await mongose.connect(process.env.DB_HOST);
+      return connect
+        ? console.log("Database connected Successfuly")
+        : console.log("Database not connected ");
+    } catch (error) {
+      console.log("Database not connected ");
+    }
+  }
+
+  closeConnection() {
+    return mongose.connection.close();
+  }
+  async all() {
+    const data = await this.model.find({});
+    console.log(data);
+    return this.closeConnection();
+  }
+  async create(data) {
+    const obj = {};
+    const items = data.split(",");
+
+    for (let i = 0; i < items.length; i++) {
+      const objName = items[i].split(":")[0];
+      const objValue = items[i].split(":")[1];
+      if (objName === "password") {
+        obj[objName] = await bcrypt(objValue);
+        continue;
+      }
+      obj[objName] = objValue;
+    }
+    const result = await this.model.create(obj);
+    console.log(result);
+    return this.closeConnection();
+  }
+  async findById(id) {
+    const result = await this.model.findById(id);
+    console.log(result);
+    return this.closeConnection();
+  }
+  async delete(id) {
+    const result = await this.model.findByIdAndRemove(id);
+    console.log(result);
+    return this.closeConnection();
+  }
+  // update() {}
+}
+
+module.exports = DbCli;

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

@@ -0,0 +1,86 @@
+const runCommand = require("./commands");
+
+const getCommandLineArgv = (commandArg) => {
+  let command = commandArg[0].split(":")[1];
+
+  if (
+    commandArg.length === 4 &&
+    (command === "apiController" || command === "ApiController") &&
+    (commandArg[3] === "--resources" || commandArg[3] === "-r")
+  ) {
+    runCommand.addModel(commandArg[2]);
+    return runCommand.addApi(commandArg[1], commandArg[2]);
+  }
+  if (
+    commandArg.length === 4 &&
+    (command === "controller" || command === "Controller") &&
+    (commandArg[3] === "--resources" || commandArg[3] === "-r")
+  ) {
+    runCommand.addModel(commandArg[2]);
+    return runCommand.addWeb(commandArg[1], commandArg[2]);
+  }
+
+  if (
+    commandArg.length === 4 &&
+    (command === "adminController" || command === "AdminController") &&
+    (commandArg[3] === "--resources" || commandArg[3] === "-r")
+  ) {
+    runCommand.addModel(commandArg[2]);
+    return runCommand.addAdmin(commandArg[1], commandArg[2]);
+  }
+
+  if (
+    commandArg.length === 3 &&
+    (command === "controller" || command === "Controller")
+  ) {
+    return runCommand.addWeb(commandArg[1], commandArg[2]);
+  }
+  if (
+    commandArg.length === 3 &&
+    (command === "apiController" || command === "ApiController")
+  ) {
+    return runCommand.addApi(commandArg[1], commandArg[2]);
+  }
+
+  if (
+    commandArg.length === 3 &&
+    (command === "adminController" || command === "AdminController")
+  ) {
+    return runCommand.addAdmin(commandArg[1], commandArg[2]);
+  }
+
+  if (commandArg.length === 2 && (command === "model" || command === "Model")) {
+    return runCommand.addModel(commandArg[1]);
+  }
+
+  if (
+    commandArg.length === 2 &&
+    (command === "controller" || command === "Controller")
+  ) {
+    return runCommand.addWeb(commandArg[1], false);
+  }
+
+  if (
+    commandArg.length === 2 &&
+    (command === "apiController" || command === "ApiController")
+  ) {
+    return runCommand.addApi(commandArg[1], false);
+  }
+
+  // if (
+  //   commandArg.length === 2 &&
+  //   (command === "adminController" || command === "AdminController")
+  // ) {
+  //   return runCommand.addAdmin(commandArg[1], false);
+  // }
+
+  if (
+    commandArg.length === 2 &&
+    (command === "Request" || command === "request")
+  ) {
+    return runCommand.addRequest(commandArg[1]);
+    // return console.log(commandArg[1]);
+  }
+  return runCommand.notFound();
+};
+module.exports = getCommandLineArgv;

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

@@ -0,0 +1,18 @@
+const DbCli = require("./dbCli");
+
+const getCommand = (command, index = 0) => {
+  let cmd = command.slice(2);
+  return `${cmd[0].split(".")[index]}`;
+};
+
+const getArg = (command) => command.slice(3)[0];
+
+const getDbCLineArgv = (commandArg) => {
+  let model = getCommand(commandArg);
+  let method = getCommand(commandArg, 1);
+  let arg = getArg(commandArg);
+  const db = new DbCli(model);
+  return arg ? db[method](arg) : db[method]();
+};
+
+module.exports = getDbCLineArgv;

package/src/dbConnection/index.js

@@ -0,0 +1,14 @@
+const mongose = require("mongoose");
+
+const dbConnection = async () => {
+  try {
+    const connect = await mongose.connect(process.env.DB_HOST);
+    return connect
+      ? console.log("Database connected Successfuly")
+      : console.log("Database not connected ");
+  } catch (error) {
+    console.log("Database not connected ");
+  }
+};
+
+module.exports = dbConnection;

package/src/error/AppError.js

@@ -0,0 +1,8 @@
+class AppError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+
+module.exports = AppError;

package/src/error/ErrorHandler.js

@@ -0,0 +1,71 @@
+class ErrorHandler {
+  constructor(app) {
+    this.app = app;
+  }
+  errorRoutesHandler() {
+    return this.app.all("*", (req, res, next) => {
+      return res.sendFile(__dirname + "/public/pageNotFound.html");
+    });
+  }
+  handler(err, req, res, next) {
+    let error = { ...err };
+    error.message = err.message;
+    //monogoose id not found
+    if (err.name === "CastError") {
+      const message = { [err.path]: ` ${err.kind} not found` };
+      error.message = message;
+      error.statusCode = 400;
+    }
+
+    //duplicate key
+    if (err.code === 11000) {
+      let field = Object.keys(err.keyValue)[0];
+      error.message = { [field]: `${field} already exist` };
+      error.statusCode = 400;
+    }
+
+    //validations error
+
+    if (err.name === "ValidationError") {
+      let message = {};
+
+      const errorMessages = Object.values(err.errors);
+      for (let i = 0; i < errorMessages.length; i++) {
+        let val = errorMessages[i];
+        message[val.path] = val.message
+          .replace(/[^\w ]/g, "")
+          .split(" ")
+          .slice(1)
+          .join(" ");
+      }
+
+      error.message = message;
+      error.statusCode = 400;
+    }
+
+    if (err.apiValidationErrors) {
+      error.message = err.apiValidationErrors;
+      error.statusCode = 400;
+    }
+
+    if (err.validationErrors) {
+      error.message = err.validationErrors;
+      error.statusCode = 400;
+      return res.redirectBack();
+    }
+
+    if (err.validationMethod) {
+      error.message = err.validationMethod;
+      error.statusCode = 400;
+    }
+
+    res.status(error.statusCode || 500).json({
+      status: err.status,
+      error: error.message,
+      message: "error",
+      stack: err.stack,
+    });
+  }
+}
+
+module.exports = ErrorHandler;

package/src/error/public/pageNotFound.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Not Found</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      body {
+        background: #eee;
+        height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+      }
+      h1 {
+        color: rgba(0, 0, 0, 0.893);
+      }
+    </style>
+  </head>
+  <body>
+    <h1>404 Page Not Found</h1>
+  </body>
+</html>