jcc-express-mvc 1.0.0

package/src/files/controller.js

@@ -0,0 +1,67 @@
+const getControllerName = (name) => {
+  return `class ${name}{
+    
+    /**
+     *
+     * @return  Express Request Response
+     */
+     create(req,res,next)
+    {
+        //
+    }
+     /**
+     *
+     * @return  Express Request Response
+     */
+     index(req,res,next)
+    {
+        //
+    }
+   
+    /**
+     *
+     * 
+     * @return Express Request Response
+     */
+     store(req,res,next)
+    {
+        //
+    }
+   
+    /**
+     *
+     * @param    id
+     * @return Express Request Response
+     */
+     show(req,res,next)
+    {
+        //
+    }
+   
+    /**
+     *
+     * 
+     * @param    id
+     * @return Express Request Response
+     */
+     update(req,res,next)
+    {
+        //
+    }
+   
+    /**
+     *
+     * @param  id
+     * @return Express Response
+     */
+     destroy(req,res,next)
+    {
+       //
+    }
+   
+   
+}
+module.exports = new ${name}()
+   `;
+};
+module.exports = getControllerName;

package/src/files/model.js

@@ -0,0 +1,14 @@
+const getModelName = (name) => {
+  return `const mongoose = require("mongoose")
+  
+const ${name}Schema = new mongoose.Schema({
+
+},
+{
+  timestamps:true
+})
+
+module.exports = mongoose.model('${name}',${name}Schema)
+   `;
+};
+module.exports = getModelName;

package/src/files/request.js

@@ -0,0 +1,28 @@
+const request = (fileName) => {
+  return `
+const { getModel, FormRequest } = require("gambtech-lib");
+
+class ${fileName} extends FormRequest {
+  constructor(req) {
+    super(req);
+  }
+
+
+  async rules ()
+  {
+      await this.apiValidate({
+        //
+      })
+  }
+
+  async save()
+  {
+    await this.rules()
+  }
+}
+
+module.exports = ${fileName}
+`;
+};
+
+module.exports = request;

package/src/files/resoucesController.js

@@ -0,0 +1,72 @@
+const resourceController = (controller, model) => {
+  return `const {getModel }= require("express-mvc")
+  const ${model} = getModel('${model}')
+  class ${controller} {
+  
+    /**
+     *
+     * @return  Express Request Response
+     */
+     async create(req,res,next)
+     {
+       return res.render();    
+     }
+
+    /**
+    *
+    * @return  Express Request Response
+    */
+    async index(req,res,next)
+    {
+      return res.json({message: await ${model}.find({}),success:true})    
+    }
+     
+    /**
+    *
+    * 
+    * @return Express Request Response
+    */
+    async store(req,res,next)
+    {       
+      const data = {...req.body}
+      return res.json({message: await ${model}.create(data)})        
+    }
+     
+    /**
+    *
+    * @param    id
+    * @return Express Request Response
+    */
+    async show(req,res,next)
+    {      
+     return res.json({message: await ${model}.findById(req.params.id)})
+     
+    }
+     
+    /**
+    *
+    * 
+    * @param    id
+    * @return Express Request Response
+    */
+    async update(req,res,next)
+    {    
+      const data = {...req.body}
+      return res.json({message: await ${model}.findByIdAndUpdate(req.params.id,data)});
+    }
+     
+    /**
+    *
+    * @param  id
+    * @return Express Response
+    */
+    async destroy(req,res,next)
+    {    
+      return res.json({message:await ${model}.findByIdAndRemove(req.params.id)})     
+    }
+         
+}
+module.exports = new ${controller}()
+     `;
+};
+module.exports = resourceController;

package/src/helpers.js

@@ -0,0 +1,70 @@
+const bcryptjs = require("bcryptjs");
+const getRootPath = require("app-root-path").path;
+const jwt = require("jsonwebtoken");
+const path = require("path");
+const AppError = require("./error/AppError");
+
+exports.rootPath = (file) =>
+  require(`${path.resolve(`${getRootPath}/${file}`)}`);
+
+exports.getController = (file) =>
+  require(`${getRootPath}/app/Controllers/${file}`);
+
+exports.getApiController = (file) =>
+  require(`${getRootPath}/app/Controllers/Api/${file}`);
+
+exports.getModel = (file) => require(`${getRootPath}/app/Models/${file}`);
+
+exports.getMiddleware = (file) =>
+  require(`${getRootPath}/app/Middlewares/${file}`);
+
+exports.getRequest = (file) => require(`${getRootPath}/app/Request/${file}`);
+
+exports.bcrypt = async (string) => {
+  const salt = await bcryptjs.genSalt(10);
+  return bcryptjs.hash(`${string}`, salt);
+};
+
+exports.verifyHash = async (string, hash) => {
+  return bcryptjs.compare(`${string}`, hash);
+};
+
+exports.jwtSign = (data) => {
+  try {
+    return jwt.sign(data, process.env.JWT_SECRET);
+  } catch (error) {
+    console.log(error.message);
+  }
+};
+
+exports.jwtVerify = (token) => {
+  try {
+    return jwt.verify(token, process.env.JWT_SECRET);
+  } catch (error) {
+    new AppError(error, 500);
+  }
+};
+
+exports.saveImage = (req, fieldName, folder = "image") => {
+  let file = req.files[fieldName];
+  const name = file.name.split(".")[0];
+  const randomNum = Math.floor(Math.random() * 1000);
+  const extension = path.extname(req.files[fieldName].name).toLocaleLowerCase();
+  const fileName = `${name}-${randomNum + extension}`;
+  file.mv(
+    `${require("app-root-path").path}/public/${folder}/${fileName}`,
+    (err) => {
+      if (err) {
+        return false;
+      }
+    }
+  );
+  return fileName;
+};
+
+exports.capitalize = (str) => {
+  return `${str[0].toUpperCase() + str.slice(1)}`;
+};
+
+exports.asyncHandler = (func) => (req, res, next) =>
+  Promise.resolve(func(req, res, next)).catch(next);

package/src/index.js

@@ -0,0 +1,42 @@
+const App = require("./app");
+const { authenticated, protectedApi } = require("./Auth/protectedRoute");
+const Auth = require("./Auth");
+
+const {
+  bcrypt,
+  getApiController,
+  getModel,
+  jwtSign,
+  jwtVerify,
+  getMiddleware,
+  getRequest,
+  verifyHash,
+  saveImage,
+  getController,
+  rootPath,
+} = require("./helpers");
+
+const getDbCli = require("./command-line-interface/getDbCliCommand");
+
+const app = new App();
+
+module.exports = {
+  server: app.server(),
+  Route: app.webRoute(),
+  jccCommadLine: app.commandLineArgv,
+  bcrypt,
+  getModel,
+  getController,
+  getApiController,
+  jwtSign,
+  jwtVerify,
+  getMiddleware,
+  getRequest,
+  verifyHash,
+  saveImage,
+  rootPath,
+  authenticated,
+  apiAuthenticated: protectedApi,
+  Auth,
+  getDbCli,
+};

package/src/middlware/index.js

@@ -0,0 +1,60 @@
+const passport = require("passport");
+const { getMiddleware, rootPath } = require("../helpers");
+const Response = require("../response");
+const Request = require("../request");
+const middlewares = getMiddleware("app");
+const templateEngine = rootPath("/app/Config/engine");
+const isLogIn = require("./isLogin");
+
+// console.log(middlewares);
+class Middleware {
+  constructor(express, app) {
+    this.express = express;
+    this.app = app;
+    this.handler();
+  }
+
+  expressBodyParser() {
+    this.app.use(this.express.json());
+    return this.app.use(this.express.urlencoded({ extended: false }));
+  }
+
+  staticFiles() {
+    this.app.use(
+      this.express.static(`${require("app-root-path").path}/resources`)
+    );
+    return this.app.use(
+      this.express.static(`${require("app-root-path").path}/public`)
+    );
+  }
+
+  registeredMiddleware() {
+    return middlewares.map((middleware) => this.app.use(middleware));
+  }
+
+  passport() {
+    require("../passport/config")(passport);
+    this.app.use(passport.initialize());
+    return this.app.use(passport.session());
+  }
+
+  handler() {
+    try {
+      templateEngine(this.app);
+      this.expressBodyParser();
+      this.staticFiles();
+      this.registeredMiddleware();
+      this.passport();
+      this.app.use((req, res, next) => {
+        new Response(req, res);
+        new Request(req, res);
+        next();
+      });
+      new isLogIn(this.app);
+    } catch (error) {
+      console.log({ middleware: error?.message });
+    }
+  }
+}
+
+module.exports = Middleware;

package/src/middlware/isLogin.js

@@ -0,0 +1,19 @@
+class isLogIn {
+  constructor(app) {
+    this.handler(app);
+  }
+
+  handler(app) {
+    return app.use((req, res, next) => {
+      if (
+        (req.url === "/login" || req.url == "/register") &&
+        req.isAuthenticated()
+      ) {
+        return res.redirectBack();
+      }
+      return next();
+    });
+  }
+}
+
+module.exports = isLogIn;

package/src/passport/config.js

@@ -0,0 +1,38 @@
+const LocalStrategy = require("passport-local").Strategy;
+
+const { getModel, verifyHash } = require("../helpers");
+const User = getModel("User");
+
+module.exports = (passport) => {
+  passport.use(
+    new LocalStrategy(
+      { usernameField: "email" },
+      async (email, password, done) => {
+        try {
+          const user = await User.findOne({ email }).select("+password");
+          if (!user) {
+            return done(null, false, { message: "Invalid credentials" });
+          }
+          const isMatch = await verifyHash(password, user.password);
+          if (isMatch) {
+            // console.log("Match");
+            return done(null, user);
+          }
+          return done(null, false, { message: "Invalid credentials" });
+        } catch (error) {
+          console.log({ passportError: error.message });
+        }
+      }
+    )
+  );
+
+  passport.serializeUser((user, done) => done(null, user.id));
+  passport.deserializeUser(async (id, done) => {
+    try {
+      const user = await User.findById(id);
+      done(null, user);
+    } catch (error) {
+      console.log({ passportError: error.message });
+    }
+  });
+};

package/src/request/FormRequest.js

@@ -0,0 +1,35 @@
+const { getModel } = require("../helpers");
+
+class FormRequest {
+  constructor(req) {
+    this.req = req;
+    const formdata = req.body;
+    for (let data in formdata) {
+      this[data] = formdata[data] || null;
+    }
+  }
+
+  query(name) {
+    return this.req.query[name];
+  }
+  route(name) {
+    return this.req.params[name];
+  }
+  request() {
+    return this.req.body;
+  }
+
+  async validate(formData) {
+    return this.req.validate(formData);
+  }
+
+  async apiValidate(formData) {
+    return this.req.apiValidate(formData);
+  }
+
+  async findById(model, id) {
+    return getModel(model).findById(id);
+  }
+}
+
+module.exports = FormRequest;

package/src/request/index.js

@@ -0,0 +1,22 @@
+const validate = require("../validation");
+class Request {
+  constructor(request, response) {
+    this.validationErrors(request, response);
+  }
+
+  validationErrors(request, response) {
+    const errors = {};
+    response.locals.error = errors;
+    response.locals.errors = request.flash("validationErrors")[0];
+    response.locals.old = request.flash("old")[0];
+    request.validate = async (formData) =>
+      validate("validationErrors", request, formData);
+
+    request.apiValidate = async (formdata = {}) =>
+      validate("apiValidationErrors", request, formdata);
+
+    return;
+  }
+}
+
+module.exports = Request;

package/src/response/index.js

@@ -0,0 +1,32 @@
+const reqUrls = [];
+class Response {
+  constructor(request, response) {
+    this.request = request;
+    this.response = response;
+    this.visitedUrls();
+    response.redirectBack = () => this.redirectBack();
+  }
+
+  visitedUrls() {
+    if (
+      this.request.originalUrl !== "/favicon.ico" &&
+      this.request.originalUrl !== "/js/app.js"
+    ) {
+      if (reqUrls.length > 1) {
+        reqUrls.pop();
+      }
+      reqUrls.unshift(this.request.originalUrl);
+    }
+    this.request.previsiousUrls = reqUrls;
+    return;
+  }
+
+  redirectBack() {
+    // console.log(this.request.previsiousUrls);
+    return reqUrls.length > 0 && reqUrls[1]
+      ? this.response.redirect(reqUrls[1])
+      : this.response.redirect(reqUrls[0]);
+  }
+}
+
+module.exports = Response;

package/src/socket/index.js

@@ -0,0 +1,18 @@
+const socket = require("socket.io");
+const socketCors = require(`${
+  require("app-root-path").path
+}/app/Config/cors/socket`);
+const SocketFile = require(`${require("app-root-path").path}/socket`);
+class SocketIo {
+  constructor(server) {
+    const io = socket(server, {
+      origin: socketCors.origin,
+      credentials: socketCors.credential,
+      methods: ["GET", "POST"],
+    });
+
+    SocketFile(io);
+  }
+}
+
+module.exports = SocketIo;

package/src/utils/index.js

@@ -0,0 +1,79 @@
+const { asyncHandler } = require("../helpers");
+class Util {
+  //
+  constructor(app, prefix, middlewares, controller) {
+    this.app = app;
+    this.prefix = prefix;
+    this.controller = controller;
+    this.middlewares = middlewares;
+  }
+
+  setGroupMiddleware(middlewares) {
+    this.middlewares = middlewares;
+  }
+
+  /**
+   *
+   * @param {*} path
+   * @returns
+   */
+  resolvePath(path) {
+    return this.prefix ? `${this.prefix}${path}` : path;
+  }
+
+  setGroupController(controller) {
+    this.controller = controller;
+  }
+
+  classController(callback) {
+    return typeof this.controller === "object" && typeof callback === "string";
+  }
+
+  isMiddleware() {
+    return (
+      typeof this.middlewares === "function" ||
+      this.middlewares instanceof Array
+    );
+  }
+
+  async validateMiddleware(middlewares) {
+    if (typeof middlewares === "function") {
+      return asyncHandler(middlewares);
+    }
+    if (middlewares instanceof Array) {
+      return middlewares.map((middleware) => asyncHandler(middleware));
+    }
+    return (req, res, next) => {
+      next();
+    };
+  }
+
+  async routeHelper(httpMethod, path, callback) {
+    // check to see if class controller is added in route
+    try {
+      if (this.classController(callback)) {
+        return this.isMiddleware()
+          ? this.app[httpMethod](this.resolvePath(path), [
+              this.middlewares,
+              asyncHandler(this.controller[callback]),
+            ])
+          : this.app[httpMethod](
+              this.resolvePath(path),
+              asyncHandler(this.controller[callback])
+            );
+      }
+      //
+      // console.log(this.middlewares);
+      return this.isMiddleware()
+        ? this.app[httpMethod](this.resolvePath(path), [
+            this.middlewares,
+            asyncHandler(callback),
+          ])
+        : this.app[httpMethod](this.resolvePath(path), asyncHandler(callback));
+    } catch (error) {
+      console.log({ errMsg: error?.message, stack: error?.stack });
+    }
+  }
+}
+
+module.exports = Util;

package/src/validation/index.js

@@ -0,0 +1,71 @@
+const validationMethod = require("./method");
+const { rules } = require("./rules");
+
+// class Validation {
+const run = async (req, formData) => {
+  const errors = {};
+  const validateData = {};
+  const { extractValue, secondValue } = validationMethod;
+
+  for (let data in formData) {
+    for (let item of formData[data]) {
+      if (item.includes("same:")) {
+        const result = await rules(
+          extractValue(item, 0),
+          [`${data}`, `${extractValue(item, 1)}`],
+          [`${req.body[data]}`, `${req.body[extractValue(item, 1)]}`]
+        );
+
+        if (result) {
+          errors[data] = result;
+        }
+        validateData[data] = req.body[data];
+        break;
+      }
+
+      if (secondValue(item)) {
+        let result = await rules(
+          extractValue(item, 0),
+          data,
+          req.body[data],
+          extractValue(item, 1)
+        );
+        if (result) {
+          errors[data] = result;
+          break;
+        }
+
+        validateData[data] = req.body[data];
+      }
+
+      if (!secondValue(item)) {
+        let result = await rules(item, data, req.body[data]);
+        if (result) {
+          errors[data] = result;
+          break;
+        }
+        validateData[data] = req.body[data];
+      }
+    }
+  }
+
+  req.flash("old", req.body);
+  req.flash("validationErrors", errors);
+  return { errors, validateData };
+};
+
+const validate = async (errorType, req, formData) => {
+  const validation = await run(req, formData);
+
+  const errors = validation.errors;
+
+  if (errors && Object.keys(errors).length > 0) {
+    let err = new Error("validation", errors);
+    err[errorType] = errors;
+    throw err;
+  }
+  return validation.validateData;
+};
+// }
+
+module.exports = validate;