beech-api 3.3.1 → 3.4.0

package/README.md

@@ -259,6 +259,17 @@ You can easy management `users` data with Beech helper just define below:
   });
 ```
 
+## API with Official strategies
+
+
+
+
+
+
+
+
+
+
 ## Databases managements
 
 ### # Migrations & Seeder
@@ -312,6 +323,8 @@ Before continuing further we will need to tell CLI how to connect to database. T
 }
 ```
 
+:grey_question: **Note:** The database connect default port 3306 if you another port you can add object ``port`` in config.
+
 :grey_question: **Note:** If your database doesn't exists yet, you can just call `npx sequelize-cli db:create` command. With proper access it will create that database for you.
 
 ### # Creating first Migrations
@@ -409,6 +422,71 @@ describe("Test endpoint : " + endpoint, () => {
 });
 ```
 
+## Implementation
+  
+### # Implement with [PM2](https://pm2.keymetrics.io/)
+[PM2](https://pm2.keymetrics.io/) is a daemon process manager that will help you manage and keep your application online. Getting started with PM2 is straightforward, it is offered as a simple and intuitive CLI, installable via [NPM](https://www.npmjs.com/).
+
+```sh
+# Start service as standalone
+$ pm2 start ./node_modules/beech-api/packages/cli/beech --name <serviceName>
+
+# OR
+
+# Start service as cluster mode
+$ pm2 start ./node_modules/beech-api/packages/cli/beech --name <serviceName> -i <instances>
+```
+
+### # Implement with [Docker](https://www.docker.com)
+
+[Docker](https://www.docker.com) is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly.
+
+- **Create Dockerfile**
+
+Docker builds images automatically by reading the instructions from a Dockerfile -- a text file that contains all commands, in order, needed to build a given image. A Dockerfile adheres to a specific format and set of instructions which you can find at [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).
+
+```js
+// Dockerfile
+
+FROM node:12.18-alpine
+ENV NODE_ENV=production
+WORKDIR /usr/src/api
+COPY ["package.json", "package-lock.json*", "npm-shrinkwrap.json*", "./"]
+RUN npm install --production --silent && mv node_modules .
+COPY . .
+EXPOSE 9000
+CMD ["node", "./node_modules/beech-api/packages/cli/beech"]
+```
+
+- **Docker build image**
+
+The docker build command builds an image from a Dockerfile and a context. The build’s context is the set of files at a specified location ```PATH``` or ```URL```. The PATH is a directory on your local filesystem. The URL is a Git repository location.
+
+```sh
+$ docker build -t <imageName> .
+```
+
+:grey_question: Tips: You can specify a repository and tag at which to save the new image : ``` $ docker build -t <imageName>:<tags> . ``` |
+------------ |
+
+- **Run docker**
+
+  After create ``image`` you can run docker engine following :
+
+  - **Docker Container (Standalone)**
+  ```sh
+  $ docker run -d -p 9000:9000 --name <containerName> <imageName>
+  ```
+
+  - **Create Docker Swarm (Cluster)**
+  ```sh
+  # initiate swarm
+  $ docker swarm init  
+  # run docker service
+  $ docker service create --replicas <instances> --name <containerName> --publish 9000:9000 <imageName>
+  ```
+
+
 ## Bonus
 
 Free `helpers` you can make [LINE Notify](https://github.com/Yuhsak/line-api#readme) by using [line-api](https://notify-bot.line.me/en/) package with create the helper function following.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beech-api",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "Command line interface for rapid Beech API development",
   "keywords": [
     "beech-api",
@@ -26,7 +26,7 @@
   "homepage": "https://github.com/bombkiml/beech-api/blob/master/README.md",
   "deprecated": false,
   "engines": {
-    "node": ">=10.13"
+    "node": ">=8.9"
   },
   "dependencies": {
     "fs": "0.0.1-security",
@@ -36,12 +36,26 @@
     "mkdirp": "^0.5.1",
     "node-cmd": "^3.0.0",
     "passport": "^0.4.1",
+    "passport-facebook": "^3.0.0",
+    "passport-google-oauth": "^2.0.0",
     "passport-jwt": "^4.0.0",
     "passport-local": "^1.0.0",
-    "path": "^0.12.7"
+    "passport-oauth": "^1.0.0",
+    "path": "^0.12.7",
+    "cookie-parser": "1.4.3",
+    "cors": "^2.8.1",
+    "express": "4.16.3",
+    "express-session": "^1.17.1",
+    "express-validator": "2.21.0",
+    "module-alias": "^2.2.2",
+    "mysql": "^2.18.1",
+    "sequelize": "^5.21.6",
+    "walk": "^2.3.14",
+    "app-root-path": "^3.0.0"
   },
   "devDependencies": {
-    "jest": "^25.2.7"
+    "jest": "^25.2.7",
+    "sequelize-cli": "^5.5.1"
   },
   "jest": {
     "prdFile": "./node_modules/beech-api/packages/cli/core/test/utils.js",

package/packages/cli/core/auth/Passport.js

@@ -8,8 +8,13 @@ module.exports = {
   init() {
     try {
       if (fs.existsSync(passport_config_file)) {
-        var passport = require("passport"), LocalStrategy = require("passport-local").Strategy;
-        var passportJWT = require("passport-jwt"), JWTStrategy = passportJWT.Strategy, ExtractJWT = passportJWT.ExtractJwt;
+        var passport = require("passport"),
+            LocalStrategy = require("passport-local").Strategy,
+            GoogleStrategy = require("passport-google-oauth").OAuth2Strategy,
+            FacebookStrategy = require('passport-facebook').Strategy;
+        var passportJWT = require("passport-jwt"),
+            JWTStrategy = passportJWT.Strategy,
+            ExtractJWT = passportJWT.ExtractJwt;
         const auth = require("./Credentials");
         var passport_config = require(passport_config_file);
         if (passport_config.jwt_allow) {
@@ -22,14 +27,12 @@ module.exports = {
         global.Credentials = [];
         return;
       }
-      // passport initialization
-      _app_.use(passport.initialize());
       // declare constant
       let passportUsernameField = passport_config.model.username_field || "username";
       let passportPasswordField = passport_config.model.password_field || "password";
       let passportTable = passport_config.model.table || "users";
       let passportFields = (passport_config.model.fields.length) ? passport_config.model.fields : ["id", "name", "email"];
-      // passport initial with token
+      // passport initial with token (encoder)
       passport.use(new LocalStrategy({
         usernameField: passportUsernameField,
         passwordField: passportPasswordField
@@ -44,7 +47,6 @@ module.exports = {
             md5(password + secret)
           ], (err, result) => {
             if (err) {
-              console.log("pass",err)
               return done(err);
             } else {
               return done(null, JSON.parse(JSON.stringify(result[0] || null)));
@@ -54,7 +56,7 @@ module.exports = {
           return done(null, null, true);
         }
       }));
-      // passport jwt payload
+      // passport jwt payload (decoder)
       passport.use(new JWTStrategy({
         jwtFromRequest: ExtractJWT.fromAuthHeaderAsBearerToken(),
         secretOrKey: passport_config.secret
@@ -75,8 +77,128 @@ module.exports = {
           return done(null, null, true);
         }
       }));
+      
+      // declare head authentication enpoint for all strategy
+      let auth_endpoint = (passport_config.auth_endpoint) ? (passport_config.auth_endpoint[0] === "/" ? passport_config.auth_endpoint : "/" + passport_config.auth_endpoint) : "/authentication";      
+      
+      /**
+       * Passport Google Strategy
+       * 
+       */
+      let google_callback_endpoint = (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";
+      passport.use(new GoogleStrategy({
+        clientID: passport_config.strategy.google.client_id,
+        clientSecret: passport_config.strategy.google.client_secret,
+        callbackURL:  auth_endpoint + google_callback_endpoint
+      }, (accessToken, refreshToken, profile, done) => {
+        // find google user
+        let googleIdField = (passport_config.strategy.google.google_id_field) ? passport_config.strategy.google.google_id_field : "google_id";
+        this.findOrCreate(passport_config, "google", passportFields, passportTable, accessToken, refreshToken, profile, googleIdField, (err, res, dbFailed) => {
+          if (err) {
+            return done(err);
+          } else {
+            return done(err, res, dbFailed);
+          }
+        });
+      }));
+      
+      /**
+       * Passport Facebook Strategy
+       * 
+       */
+       let facebook_callback_endpoint = (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";
+       passport.use(new FacebookStrategy({
+        clientID: passport_config.strategy.facebook.app_id,
+        clientSecret: passport_config.strategy.facebook.app_secret,
+        callbackURL: auth_endpoint + facebook_callback_endpoint
+      }, (accessToken, refreshToken, profile, done) => {
+
+        console.log(accessToken, refreshToken, profile);
+
+        // fix somthing went wrong
+
+
+        //return
+        
+        // find facebook user
+        let faecbookIdField = (passport_config.strategy.facebook.google_id_field) ? passport_config.strategy.facebook.facebook_id_field : "facebook_id";
+        this.findOrCreate(passport_config, "facebook", passportFields, passportTable, accessToken, refreshToken, profile, faecbookIdField, (err, res, dbFailed) => {
+          if (err) {
+            return done(err);
+          } else {
+            return done(err, res, dbFailed);
+          }
+        });
+      }
+    ));
     } catch (error) {
-      return done(true);
+      throw error;
+    }
+  },
+  findOrCreate(passport_config, strategy_name, passportFields, passportTable, accessToken, refreshToken, profile, googleIdField, cb) {
+    let pool = eval("mysql." + passport_config.model.name);
+    if (pool) {
+      pool.query("SELECT " + passportFields + " FROM ?? WHERE ?? = ?", [
+        passportTable,
+        googleIdField,
+        profile.id
+      ], (err, result) => {
+        if (err) {
+          cb(err);
+        } else {
+          // declare data response
+          let data = {};
+          // check strategy name for store
+          if (strategy_name == "google") {
+            if (!result[0]) { // find not found and create
+              // filter fields
+              let fields = [].concat.apply([], [
+                (passport_config.strategy.google.profile_fields.name) ? passport_config.strategy.google.profile_fields.name : null,
+                (passport_config.strategy.google.profile_fields.email) ? passport_config.strategy.google.profile_fields.email : null,
+                (passport_config.strategy.google.profile_fields.photos) ? passport_config.strategy.google.profile_fields.photos : null,
+                (passport_config.strategy.google.profile_fields.locate) ? passport_config.strategy.google.profile_fields.locate : null
+              ].filter((el) => el != null));
+              // fileter values
+              let values = [].concat.apply([], [
+                (passport_config.strategy.google.profile_fields.name) ? profile.displayName : null,
+                (passport_config.strategy.google.profile_fields.email) ? profile.emails[0].value : null,
+                (passport_config.strategy.google.profile_fields.photos) ? profile.photos[0].value : null,
+                (passport_config.strategy.google.profile_fields.locate) ? profile._json.locale : null
+              ].filter((el) => el != null));
+              // Store google profile
+              pool.query("INSERT INTO ??(??,??,??,??) VALUES(?,?,?,?)", [
+                passportTable,
+                passport_config.model.username_field || "username",
+                passport_config.model.password_field || "password",
+                googleIdField,
+                fields,
+                profile.emails[0].value.split("@")[0],
+                md5(profile.id + secret),
+                profile.id,
+                values
+              ], (err, result) => {
+                data.result = result;
+                data.google = profile;
+                cb(err, data);
+              });
+            } else { // find found
+              let users = {};
+              users.google = profile;
+              users.google.accessToken = accessToken;
+              users.google.refreshToken = refreshToken;
+              users.user = result[0];
+              cb(err, users);
+            }
+          } else if (strategy_name == "facebook") {
+
+            console.log(result)
+
+          }
+        }
+      });          
+    } else {
+      cb(null, null, true);
     }
   }
+
 }

package/packages/cli/core/configure/app.config.js

@@ -15,6 +15,9 @@ module.exports = {
     app_secret: ["2cc118cd91b52ff99e3c005ddced76fb"]
   },
 
+  // Add-on it's work when enable. You can enable add-on by run CMD `$ beech add-on init`.
+  addOn: true,
+
   /**
    * Database configuration (mutiple connection) currenty support for MySQL
    * 

package/packages/cli/core/configure/passport.config.js

@@ -1,23 +1,84 @@
 module.exports = {
-  // allow using jwt
+  // Allow using jwt
   jwt_allow: true,
-  // custom authenticaiton endpoint, default `/authentication`
+
+  // Custom authenticaiton endpoint, default `/authentication`
   auth_endpoint: "",
-  // your jwt secret key
+
+  // Assign your jwt secret key
   secret: "your_jwt_secret",
-  // token expiry time (second), default expired in 1 day
+
+  // Set token expiry time (seconds), default expired in 24 hr.
   token_expired: 86400,
+
   model: {
-    // mysql connection name inside `app.config.js` file
+    // Main mysql connection same name inside `app.config.js` file
     name: "default_db",
-    // table name store your authenticate, default table `users`
+    // The user table name for store your authenticate, default table `users`
     table: "",
-    // secret field for authenticate, default field `username` and `password`
+    // The fields for authenticate, default fields: `username` and `password`
     username_field: "",
     password_field: "",
-    // show fields, default show fields ["id", "name", "email"]
+    // Show JWT fields, default show fields: ["id", "name", "email"]
     fields: []
   },
-  // allow using with app_secret requset
-  app_secret_allow: false
+
+  // Allow using with app_secret requset
+  app_secret_allow: true,
+
+  // Official strategy
+  strategy: {
+    /**
+     * The Client Id and Client Secret needed to authenticate with Google can be set up from the Google Developers Console (https://console.developers.google.com/)
+     * You may also need to enable Google+ API in the developer console, otherwise user profile data may not be fetched. 
+     * Now Google supports authentication with oAuth 2.0.
+     * 
+     */
+    google: {
+      // Allow using google strategy
+      allow: true,
+      // Google ID fields, default field: `google_id`
+      google_id_field: "",
+      // User profile fields, default fields: `name`, `email`, `photos`, `locate`
+      profile_fields: {
+        name: "name",
+        email: "email",
+        photos: "profile_url",
+        locate: "" // If not storing set to null
+      },
+      // Google development Credentials OAuth 2.0 Client IDs
+      client_id: GOOGLE_CLIENT_ID,
+      client_secret: GOOGLE_CLIENT_SECRET,
+      // Callback endpoint default `/google/callback`
+      callback_endpoint: ""
+    },
+
+    /**
+     * The Facebook strategy allows users to log in to a web application using their Facebook account. Internally, Facebook authentication works using OAuth 2.0.
+     * Support for Facebook is implemented by the passport-facebook (https://github.com/jaredhanson/passport-facebook) module.
+     * 
+     * In order to use Facebook authentication, you must first create an app at Facebook Developers. (https://developers.facebook.com/apps) When created, an app is assigned an App ID and App Secret.
+     * Your application must also implement a redirect URL, to which Facebook will redirect users after they have approved access for your application.
+     * 
+     */
+    facebook: {
+      // Allow using facebook strategy
+      allow: true,
+      // Facebook ID fields, default field: `facebook_id`
+      facebook_id_field: "",
+      // User profile fields, default fields: `name`, `email`, `photos`, `locate`
+      profile_fields: {
+        name: "name",
+        email: "email",
+        photos: "profile_url",
+        locate: "" // If not storing set to null
+      },
+      // Facebook development Credentials OAuth 2.0
+      app_id: FACEBOOK_APP_ID,
+      app_secret: FACEBOOK_APP_SECRET,
+      // Callback endpoint default `/facebook/callback`
+      callback_endpoint: ""
+    },
+
+  }
 }

package/packages/cli/core/databases/mysql.connection.js

@@ -2,9 +2,16 @@ exports.mySqlConnection = () => {
   return new Promise((resolve, reject) => {
     try {
       global.mysql = {};
+      var headDbShow = true;
       // loop database connection
       _config_.mysql_config.map((val, index) => {
         if (val.is_connect) {
+          // show only one text db connnections
+          if (headDbShow) {
+            console.log('\n Passed  Database is connected at:');
+            headDbShow = false;
+          }
+          // db connection config
           let connection = _mysql_.createConnection({
             host: val.host,
             user: val.username,
@@ -13,10 +20,11 @@ exports.mySqlConnection = () => {
             charset: val.charset,
             port: val.port
           })
+          // db connecting
           connection.connect((err) => {
             if (!err) {
               mysql[val.name] = connection;
-              console.log(' Passed  Database is connected at [' + val.name, '->', connection.config.database + ':' + connection.config.port + ']');
+              console.log(' - ' + val.name, '->', connection.config.database + ':' + connection.config.port + '');
               // checking for resolve
               if ((index + 1) == _config_.mysql_config.length) {
                 resolve(true);

package/packages/cli/core/generator/add-on

@@ -0,0 +1,9 @@
+//const Users = require("@/models/Users");
+
+exports.init = () => {
+
+  //Users.findAll().then(console.log)
+
+  console.log("Add-on is work!")
+
+}

package/packages/cli/core/generator/help

@@ -13,4 +13,5 @@ The following commands are available:
                                   for require model file(s) in generate processing
   $ beech make <model> --model    Create a new models file
   $ beech passport init           Initialize authentication with passport-jwt
+  $ beech add-on init             Initialize add-on file
   

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

@@ -79,17 +79,25 @@ class Generator {
             }
           }
         } else if (this.option == 'passport') {
-          if (!this.argument) {
-            resolve("\n Warning  Using `passport init` for initiate passport-jwt.");
-          } else {
+          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.");
         }
@@ -251,6 +259,26 @@ class Generator {
     });
   }
 
+  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

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,16 +38,32 @@ _app_.all("/", (req, res, next) => {
   res.header("Content-Type", "application/json; charset=utf-8");
   next();
 });
-// passport
-const passport = require("./auth/Passport");
+// 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 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);
 });
@@ -47,8 +71,7 @@ walker.on("end", () => {
 init = async (jsfiles) => {
   try {
     await httpExpress.expressStart();
-    await dbConnect.mySqlConnection();
-    await passport.init();
+    await authPassport.init();
     await fileWalk.fileWalk(jsfiles);
   } catch (error) {
     throw error;

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

@@ -61,8 +61,12 @@ module.exports = {
         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;
       }
@@ -76,16 +80,22 @@ module.exports = {
               code: 502,
               error: 'BAD_GATEWAY',
               message: err
-            })
+            });
           }
           if (user) {
-            const token = jwt.sign(user, passport_config.secret, {
+            const accessToken = jwt.sign(user, passport_config.secret, {
               expiresIn: passport_config.token_expired
             });
-            if (passport_config.app_secret_allow) {
+            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({ user, token });
+                  res.status(200).json({
+                    code: 200,
+                    status: "AUTHORIZED",
+                    message: "success.",
+                    user,
+                    accessToken
+                  });
                 } else {
                   res.status(401).json({ code: 401, message: "Unauthorized." });
                 }
@@ -93,7 +103,13 @@ module.exports = {
                 res.status(422).json({ code: 422, message: "Unprocessable Entity." });
               }
             } else {
-              res.status(200).json({ user, token });
+              res.status(200).json({
+                code: 200,
+                status: "AUTHORIZED",
+                message: "success.",
+                user,
+                accessToken
+              });
             }
           } else if (opt) {
             res.status(422).json({ code: 422, message: "Unprocessable Entity." });
@@ -104,13 +120,97 @@ module.exports = {
       });
       // create users endpoints
       _app_.post(auth_endpoint + '/users', (req, res) => {
-        Beech.store(req.body, e => res.status(e.code).json(e));
+        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, e => res.status(e.code).json(e));
+        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) {
       throw error;
     }

package/packages/lib/beech.js

@@ -4,6 +4,24 @@ 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 = [];
@@ -20,16 +38,11 @@ module.exports = {
       });
       let sql = 'INSERT INTO ?? (' + keys.join() + ') VALUES (' + escaped.join() + ')';
       const pool = eval("mysql." + passport_config.model.name);
-      pool.query(sql, values, (err) => {
-        if (err) {
-          cb({ code: 500, status: "CREATE_FAILED", error: err });
-        } else {
-          cb({ code: 201, status: "CREATE_SUCCEED", message: "created." });
-        }
+      pool.query(sql, values, (err, result) => {
+        cb(err, result);
       });
-
     } catch (error) {
-      cb({ code: 500, err: error });
+      cb(error, null);
     }
   },
   update(someFields, id, cb) {
@@ -49,15 +62,11 @@ module.exports = {
       values.push(id);
       let sql = 'UPDATE ?? SET ' + keys.join() + ' WHERE id = ?';
       const pool = eval("mysql." + passport_config.model.name);
-      pool.query(sql, values, (err) => {
-        if (err) {
-          cb({ code: 500, status: "UPDATE_FAILED", error: err });
-        } else {
-          cb({ code: 200, status: "UPDATE_SUCCEED", message: "updated." });
-        }
+      pool.query(sql, values, (err, result) => {
+        cb(err, result);
       });
     } catch (error) {
-      cb({ code: 500, err: error });
+      cb(error, null);
     }
   },
 }

package/packages/package.json

@@ -8,21 +8,7 @@
     "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-session": "^1.17.1",
-    "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",