beech-api 3.2.11 → 3.4.0

package/packages/cli/core/generator/index.js

@@ -78,9 +78,26 @@ class Generator {
               resolve("\n Faltal  commnad it's not available.");
             }
           }
-        } else if (this.option == 'kill') {
-          /* require('./app')
-          console.log(_SERVER) */
+        } else if (this.option == 'passport') {
+          if (this.argument == "init") {
+            this.makePassportInit()
+              .then(make => resolve(make))
+              .catch(err => reject(err));
+          } else {
+            resolve("\n Warning  Using `passport init` for initiate passport-jwt.");
+          }
+        } else if (this.option == "key:generate") {
+          this.generateKeyConfigFile()
+          .then(resGenKey => resolve(resGenKey))
+          .catch(err => reject(err));;
+        } else if (this.option == "add-on") {
+          if (this.argument == "init") {
+            this.makeAddOnInit()
+              .then(make => resolve(make))
+              .catch(err => reject(err));            
+          } else {
+            resolve("\n Warning  Using `add-on init` for initiate add-on.");
+          }          
         } else {
           resolve("\n Faltal  commnad it's not available.");
         }
@@ -201,7 +218,7 @@ class Generator {
     });
   }
 
-  async makeFolder(path) {
+  makeFolder(path) {
     /**
      * @param path path to make
      * 
@@ -224,7 +241,45 @@ class Generator {
     });
   }
 
-  async copy(path, to) {
+  makePassportInit() {
+    return new Promise((resolve, reject) => {
+      try {
+        let passport_config_file = __dirname + '/../configure/passport.config.js';
+        let passport_config_paste_point = "./passport.config.js";
+        if (!this.fs.existsSync(passport_config_paste_point)) {
+          this.copy(passport_config_file, passport_config_paste_point)
+            .then(resolve("\n Passed  The `passport-jwt` is initialized."))
+            .catch(err => console.log(err));
+        } else {
+          resolve("\n Warning  The `passport-jwt` already is initialized.");
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  makeAddOnInit() {
+    return new Promise((resolve, reject) => {
+      try {
+        let tmpEndpointsPath = __dirname + '/add-on';
+        let add_on_paste_point = "Add-on.js";
+        let folder_add_on = "./src/";
+        if (!this.fs.existsSync(folder_add_on + add_on_paste_point)) {
+          this.makeFolder(folder_add_on)
+            .then(this.copy.bind(this, tmpEndpointsPath, folder_add_on + add_on_paste_point))
+            .then(resolve("\n Passed  The `add-on` is initialized."))
+            .catch(err => console.log(err));
+        } else {
+          resolve("\n Warning  The `add-on` already is initialized.");
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  copy(path, to) {
     /**
      * @param path old path file
      * @param to save to new path file
@@ -248,7 +303,7 @@ class Generator {
     });
   }
 
-  async contentReplace(pathFile, textCondition) {
+  contentReplace(pathFile, textCondition) {
     return new Promise((resolve, reject) => {
       try {
         let endpoint = textCondition.endpoint;
@@ -283,7 +338,7 @@ class Generator {
     });
   }
 
-  async modelContentReplace(pathFile, textCondition) {
+  modelContentReplace(pathFile, textCondition) {
     return new Promise((resolve, reject) => {
       try {
         let modelName = textCondition.modelName;
@@ -312,6 +367,58 @@ class Generator {
     });
   }
 
+  appKeyGenerator(length) {
+    return new Promise((resolve, reject) => {
+      try {
+        let md5 = require("md5");
+        let secret = require(__dirname + "/../../../lib/salt").salt;
+        let result = '';
+        let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let charactersLength = characters.length;
+        for ( var i = 0; i < length; i++ ) {
+          result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        resolve(md5(result + secret));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  generateKeyConfigFile() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.fs.readFile("app.config.js", 'utf8', (err, data) => {
+          if (err) {
+            throw err;
+          } else {
+            // edit or add property
+            let buffer = Buffer.from(data);
+            let buf2str = buffer.toString();
+            let buf2json = JSON.parse(JSON.stringify(buf2str));
+            let buf2eval = eval(buf2json);
+            let oldSecret = buf2eval.main_config.app_secret;
+            // generate new key secret
+            this.appKeyGenerator(8).then(newAppSecret => {
+              // content replace
+              let text = data.replace(new RegExp(oldSecret, 'g'), newAppSecret);
+              // writing the file
+              this.fs.writeFile("app.config.js", text, 'utf8', (err) => {
+                if (err) {
+                  throw err;
+                } else {
+                  resolve("\n Passed  App secret it's new generated.");
+                }
+              });              
+            });
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
   help() {
     return new Promise((resolve, reject) => {
       try {

package/packages/cli/core/generator/package

@@ -8,23 +8,9 @@
     "test": "node ./node_modules/jest/bin/jest __tests__ -o --watch --config"
   },
   "dependencies": {
-    "app-root-path": "^3.0.0",
-    "axios": "^0.18.1",
-    "beech-api": "^3.2.11",
-    "cookie-parser": "1.4.3",
-    "cors": "^2.8.1",
-    "express": "4.16.3",
-    "express-validator": "2.21.0",
-    "fs": "0.0.1-security",
-    "module-alias": "^2.2.2",
-    "mysql": "^2.18.1",
-    "mysql2": "^2.1.0",
-    "nodemon": "^2.0.2",
-    "sequelize": "^5.21.6",
-    "walk": "^2.3.14"
+    "beech-api": "^3.2.11"
   },
   "devDependencies": {
-    "jest": "^25.2.7",
-    "sequelize-cli": "^5.5.1"
+    "jest": "^25.2.7"
   }
 }

package/packages/cli/core/index.js

@@ -1,3 +1,4 @@
+const fs = require("fs");
 const appRoot = require("app-root-path");
 const moduleAlias = require("module-alias");
 moduleAlias.addAlias("@", appRoot + "/src");
@@ -8,18 +9,25 @@ global.endpoint = _express_.Router();
 global._mysql_ = require("mysql");
 const cookieParser = require("cookie-parser");
 const bodyParser = require("body-parser");
+const expressSession = require("express-session");
 const expressValidator = require("express-validator");
 const globalVariable = require(appRoot + "/global.config.js");
 globalVariable.init();
 // Local environments
 global._config_ = require(appRoot + "/app.config");
 const dbConnect = require("./databases/mysql.connection");
+dbConnect.mySqlConnection();
 const httpExpress = require("./services/http.express");
 const fileWalk = require("./file-walk/file-walk");
 // View engine
 _app_.use(bodyParser.json());
 _app_.use(bodyParser.urlencoded({ extended: true }));
 _app_.use(cookieParser());
+_app_.use(expressSession({
+  secret: 'keyboard cat',
+  resave: true,
+  saveUninitialized: true
+}));
 _app_.use(expressValidator());
 _app_.use(cors({ origin: true, credentials: true }));
 // Allow Origin
@@ -30,28 +38,41 @@ _app_.all("/", (req, res, next) => {
   res.header("Content-Type", "application/json; charset=utf-8");
   next();
 });
+// passport initialization
+const authPassport = require("./auth/Passport");
+const passport = require("passport");
+_app_.use(passport.initialize());
+_app_.use(passport.session());
+passport.serializeUser((user, done) =>{
+  done(null, user);
+});
+passport.deserializeUser((user, done) => {
+  done(null, user);
+});
 // Read folder in ./src/endpoints/*
 const walk = require("walk");
-let jsfiles = []
+let jsfiles = [];
 let walker = walk.walk(appRoot + "/src/endpoints", { followLinks: false });
 walker.on("file", (root, stat, next) => {
   jsfiles.push(root + "/" + stat.name);
+  // check add-on file exists ?
+  if (fs.existsSync(root + "/../Add-on.js")) {
+    if (_config_.addOn) {
+      jsfiles.push(root + "/../Add-on.js");
+    }
+  }
   next();
 });
+// Walking
 walker.on("end", () => {
   init(jsfiles);
 });
-// define server variable
-global._SERVER;
 // Initialize the application
-init = (jsfiles) => {
+init = async (jsfiles) => {
   try {
-    httpExpress.expressStart()
-      .then(dbConnect.mySqlConnection.bind(this))
-      .then(fileWalk.fileWalk.bind(this, jsfiles))
-      .catch(error => {
-        throw error;
-      });
+    await httpExpress.expressStart();
+    await authPassport.init();
+    await fileWalk.fileWalk(jsfiles);
   } catch (error) {
     throw error;
   }

package/packages/cli/core/services/http.express.js

@@ -1,61 +1,218 @@
 const appRoot = require("app-root-path");
 const package = require(appRoot + '/package.json');
-// Server start using by Express
-exports.expressStart = () => {
-  return new Promise((resolve, reject) => {
-    try {
-      // Create express server
-      const ExpressServer = _app_.listen(_config_.main_config.app_port, () => {
-        console.log('\n Passed  Service is started at:\n - Local:   http://' + _config_.main_config.app_host + ':' + ExpressServer.address().port, '\n - Network: ' + _config_.main_config.client_host + '\n');
-        this.badRequest()
-          .then(this.wrongRequest())
-          .catch(err => {
-            throw err;
+const fs = require("fs");
+const passport_config_file = "/passport.config.js";
+const auth = require("../auth/Credentials");
+
+module.exports = {
+  expressStart() {
+    return new Promise((resolve, reject) => {
+      try {
+        // Create express server
+        const ExpressServer = _app_.listen(_config_.main_config.app_port, async () => {
+          await console.log('\n Passed  Service is started at:\n - Local:   http://' + _config_.main_config.app_host + ':' + ExpressServer.address().port, '\n - Network: ' + _config_.main_config.client_host + '');
+          await this.authentication();
+          await this.badRequest()
+            .then(resolve(ExpressServer))
+            .catch(err => {
+              reject(err);
+            });
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  },
+  // Bad request
+  badRequest() {
+    return new Promise((resolve, reject) => {
+      try {
+        // base get request
+        _app_.get('/', (req, res) => {
+          res.status(200).json({
+            code: 200,
+            status: "SUCCESS",
+            message: `Welcome to ${package.name} (version ${package.version})`
           });
-        resolve(ExpressServer);
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-// Express server get variable
-exports.getExpressServer = (serve) => {
-  return new Promise((resolve, reject) => {
-    try {
-      resolve(serve);
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-// Bad request
-exports.badRequest = () => {
-  return new Promise((resolve, reject) => {
+          resolve(200);
+        });
+        // request 404 not found
+        _app_.use((req, res, next) => {
+          res.status(404).json({
+            code: 404,
+            status: "error",
+            error: "404_NOT_FOUND"
+          });
+          resolve(404);
+          next();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  },
+  // Authentication request
+  authentication() {
     try {
-      _app_.get('/', (req, res) => {
-        let data = {};
-        data.code = 200;
-        data.message = `Welcome to ${package.name} (version ${package.version})`;
-        res.json(data);
-        resolve(data);
+      // require jwt & passport
+      if (fs.existsSync(appRoot + passport_config_file)) {
+        var passport_config = require(appRoot + passport_config_file);
+        var jwt = require('jsonwebtoken');
+        var passport = require('passport');
+        var Beech = require("../../../lib/beech");
+        if (!passport_config.jwt_allow) {
+          // jwt is false
+          console.log(" - JWT:     OFF");
+          return;
+        }
+        // jwt is true
+        console.log(" - JWT:     ON");
+      } else {
+        return;
+      }
+      // declare authentication endpoint name
+      const auth_endpoint = (passport_config.auth_endpoint) ? (passport_config.auth_endpoint[0] === "/" ? passport_config.auth_endpoint : "/" + passport_config.auth_endpoint) : "/authentication";
+      // authentication endpoints
+      _app_.post(auth_endpoint, (req, res, next) => {
+        passport.authenticate('local', { session: false }, (err, user, opt) => {
+          if (err) {
+            res.status(502).json({
+              code: 502,
+              error: 'BAD_GATEWAY',
+              message: err
+            });
+          }
+          if (user) {
+            const accessToken = jwt.sign(user, passport_config.secret, {
+              expiresIn: passport_config.token_expired
+            });
+            if (passport_config.app_secret_allow) {              
+              if (req.body.app_secret) {
+                if (_config_.main_config.app_secret == req.body.app_secret) {
+                  res.status(200).json({
+                    code: 200,
+                    status: "AUTHORIZED",
+                    message: "success.",
+                    user,
+                    accessToken
+                  });
+                } else {
+                  res.status(401).json({ code: 401, message: "Unauthorized." });
+                }
+              } else {
+                res.status(422).json({ code: 422, message: "Unprocessable Entity." });
+              }
+            } else {
+              res.status(200).json({
+                code: 200,
+                status: "AUTHORIZED",
+                message: "success.",
+                user,
+                accessToken
+              });
+            }
+          } else if (opt) {
+            res.status(422).json({ code: 422, message: "Unprocessable Entity." });
+          } else {
+            res.status(401).json({ code: 401, message: "Unauthorized." });
+          }
+        })(req, res, next);
       });
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-// Default route if request went wrong
-exports.wrongRequest = () => {
-  return new Promise((resolve, reject) => {
-    try {
-      _app_.use((req, res, next) => {
-        res.status(404).send({ code: 404, message: '404 Not found, cannot request to ' + req.url });
-        resolve(404);
-        next();
+      // create users endpoints
+      _app_.post(auth_endpoint + '/users', (req, res) => {
+        Beech.store(req.body, (err, result) => {
+          if (err) {
+            res.status(500).json({ code: 500, status: "CREATE_FAILED", error: err });
+          } else {
+            res.status(201).json({ code: 201, status: "CREATE_SUCCESS", result });
+          }
+        });
+      });
+      // patch users endpoints
+      _app_.patch(auth_endpoint + '/users/:id', auth.credentials, (req, res) => {
+        // require some fields with body params
+        Beech.update(req.body, req.params.id, (err, result) => {
+          if (err) {
+            res.status(500).json({ code: 500, status: "UPDATE_FAILED", error: err });
+          } else {
+            res.status(200).json({ code: 200, status: "UPDATE_SUCCESS", result });
+          }
+        });
       });
+      /**
+       * Google Strategy
+       *  
+       */
+      if (passport_config.strategy.google.allow) {
+        _app_.get(auth_endpoint + '/google', passport.authenticate('google', {
+          scope: [
+            'https://www.googleapis.com/auth/userinfo.email',
+            'https://www.googleapis.com/auth/plus.login'
+          ]
+        }));
+        // google auth callback
+        const googleCallback = (passport_config.strategy.google.callback_endpoint) ? (passport_config.strategy.google.callback_endpoint[0] === "/" ? passport_config.strategy.google.callback_endpoint : "/" + passport_config.strategy.google.callback_endpoint) : "/google/callback";
+        _app_.get(auth_endpoint + googleCallback, passport.authenticate('google'), (req, res) => {
+          if (typeof req.user.user !== 'undefined') {
+            // declare user for sign JWT
+            let user = JSON.parse(JSON.stringify(req.user.user));
+            const accessToken = jwt.sign(user, passport_config.secret, {
+              expiresIn: passport_config.token_expired
+            });
+            // response JWT
+            res.status(200).json({
+              code: 200,
+              status: "AUTHORIZED",
+              message: "success.",
+              user: req.user,
+              accessToken
+            });
+          } else {
+            let condUser = {};
+            condUser[(passport_config.strategy.google.google_id_field) ? passport_config.strategy.google.google_id_field : "google_id"] = req.user.google.id;
+            Beech.findOne(passport_config.model.table || "users", condUser, (err, result) => {
+              if (err) {
+                res.status(500).json({
+                  code: 500,
+                  status: "INTERNAL_SERVER_ERR",
+                  message: "Internal server error.",
+                  error: err
+                });
+              } else {
+                let user = JSON.parse(JSON.stringify(result[0]));
+                const accessToken = jwt.sign(user, passport_config.secret, {
+                  expiresIn: passport_config.token_expired
+                });
+                // response JWT
+                res.status(201).json({
+                  code: 201,
+                  status: "AUTHORIZED",
+                  message: "success.",
+                  user: {
+                    google: req.user.google,
+                    user
+                  },
+                  accessToken
+                });
+              }
+            });
+          }
+        });
+      }
+      /**
+       * Facebook strategy
+       * 
+       */
+      if (passport_config.strategy.facebook.allow) {
+        _app_.get(auth_endpoint + '/facebook', passport.authenticate('facebook', { scope: ['email', 'pages_show_list'] }));
+        // facebook callback
+        const facebookCallback = (passport_config.strategy.facebook.callback_endpoint) ? (passport_config.strategy.facebook.callback_endpoint[0] === "/" ? passport_config.strategy.facebook.callback_endpoint : "/" + passport_config.strategy.facebook.callback_endpoint) : "/facebook/callback";
+        _app_.get(auth_endpoint + facebookCallback, passport.authenticate('facebook', (err, res) => {
+           console.log(err, res)
+        }));
+      }
     } catch (error) {
-      reject(error);
+      throw error;
     }
-  });
-}
+  }
+}

package/packages/lib/beech.js

@@ -0,0 +1,72 @@
+const appRoot = require("app-root-path");
+const passport_config = require(appRoot + "/passport.config.js");
+const md5 = require("md5");
+const secret = require("./salt").salt;
+
+module.exports = {
+  findOne(table, fieldCondArr, cb) {
+    try {
+      let cond = '1';
+      let passportFields = (passport_config.model.fields.length) ? passport_config.model.fields : ["id", "name", "email"];
+      // Generate condition
+      Object.keys(fieldCondArr).forEach(key => {
+        cond += ' AND ' + key + '=' + fieldCondArr[key]
+      });
+      // raw SQL
+      let sql = 'SELECT ?? FROM ?? WHERE ' + cond;
+      const pool = eval("mysql." + passport_config.model.name);
+      pool.query(sql, [passportFields, table], (err, row) => {
+        cb(err, row);
+      });
+    } catch (error) {
+      cb(error, null);
+    }
+  },
+  store(fields, cb) {
+    try {
+      let keys = [];
+      let values = [passport_config.model.table || "users"];
+      let escaped = [];
+      let passwordField = String(passport_config.model.password_field || "password");
+      // asign password hash
+      fields[passwordField] = md5(fields[passwordField] + secret);
+      // sql generate
+      Object.keys(fields).forEach(key => {
+        keys.push(key);
+        values.push(fields[key]);
+        escaped.push('?');
+      });
+      let sql = 'INSERT INTO ?? (' + keys.join() + ') VALUES (' + escaped.join() + ')';
+      const pool = eval("mysql." + passport_config.model.name);
+      pool.query(sql, values, (err, result) => {
+        cb(err, result);
+      });
+    } catch (error) {
+      cb(error, null);
+    }
+  },
+  update(someFields, id, cb) {
+    try {
+      let keys = [];
+      let values = [passport_config.model.table || "users"];
+      let passwordField = String(passport_config.model.password_field || "password");
+      // check password body for asign hash
+      if (someFields[passwordField]) {
+        someFields[passwordField] = md5(someFields[passwordField] + secret);
+      }
+      // sql generate
+      Object.keys(someFields).forEach(key => {
+        keys.push(`${key}=?`);
+        values.push(someFields[key]);
+      });
+      values.push(id);
+      let sql = 'UPDATE ?? SET ' + keys.join() + ' WHERE id = ?';
+      const pool = eval("mysql." + passport_config.model.name);
+      pool.query(sql, values, (err, result) => {
+        cb(err, result);
+      });
+    } catch (error) {
+      cb(error, null);
+    }
+  },
+}

package/packages/lib/salt.js

@@ -0,0 +1,3 @@
+module.exports = {
+  salt: ["?p9E1oXV8My9akelVzsf3"]
+}

package/packages/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "application",
+  "version": "0.1.0",
+  "description": "The project is powered by Beech API framework",
+  "main": "index.js",
+  "scripts": {
+    "start": "nodemon ./node_modules/beech-api/packages/cli/beech",
+    "test": "node ./node_modules/jest/bin/jest __tests__ -o --watch --config"
+  },
+  "dependencies": {
+    "beech-api": "^3.2.11"
+  },
+  "devDependencies": {
+    "jest": "^25.2.7",
+    "sequelize-cli": "^5.5.1"
+  }
+}