beech-api 3.7.23 → 3.8.0

package/README.md

@@ -1,38 +1,36 @@
 [![N|Solid](https://i.ibb.co/NKxx9NQ/beech320.jpg)](https://github.com/bombkiml)
 
 # Beech API framework
+#### Stable v.3.8.0 (LTS)
 
-[![beech-api release](https://img.shields.io/github/v/release/bombkiml/beech-api)](https://github.com/bombkiml/beech-api/releases/)
+[![beech-api release](https://img.shields.io/github/v/release/bombkiml/beech-api)](https://github.com/bombkiml/beech-api/releases/tag/3.8.0)
 [![PyPI license](https://shields.io/pypi/l/ansicolortags.svg)](https://github.com/bombkiml/beech-api/blob/master/README.md)
 
-## What is Beech API ?
+# What is Beech API ?
 
-`Beech API` is a Node.js framework it's help you with very easy create API project under [Node.js](https://nodejs.org)
+The Beech API is API framework, It's help you with very easy to create API project under [Node.js](https://nodejs.org)
 
-## Why Beech API ?
-
-`Beech API` is a Very easy for using, very feather framework, easy to installation, easy to implementation, and high security.
-
-## Powered by Node.js & Express.js
-
-![N|Solid](https://i.ibb.co/CQqYZkK/node-epressjs.jpg)
-
-## Environment
+# Environment
 
 - [`Node.js`](https://nodejs.org) >= 14.19.0+ (recommended)
 
-## Installation
+# Installation
 
 Beech API requires Node.js version 14.19.0 or above. You can manage multiple versions of Node on the same machine with [nvm](https://github.com/creationix/nvm) or [nvm-windows](https://github.com/coreybutler/nvm-windows). So, Let's go to install `beech-api`
 
 ```sh
-// NPM
+# NPM
 $ npm install beech-api --global
 
-// Yarn
+# Yarn
 $ yarn global add beech-api
 ```
 
+Installation demo:
+
+[Demo](https://i.ibb.co/hySFxy3/install-beech720-1.gif)
+![Alt Text](https://i.ibb.co/hySFxy3/install-beech720-1.gif)
+
 After installation, you will have access to the `beech-app` binary in your command line.
 You can check you have the right version with this command:
 
@@ -40,7 +38,7 @@ You can check you have the right version with this command:
 $ beech-app --version
 ```
 
-## Creating a project
+# Creating a project
 
 Create a new project run:
 
@@ -52,14 +50,14 @@ Run your project:
 $ cd hello-world
 
 $ npm start
-// OR
+# OR
 $ yarn start
 ```
 
 ❓ **Note:** The Beech API it's start server at [http://localhost:9000](http://localhost:9000) you can change new a port in `app.config.js` file.
 
 
-## Upgrade to latest version ##
+# Upgrade to latest version
 The Beech API upgrade to latest version command avariable :
 
 ```sh
@@ -70,7 +68,7 @@ $ beech-app update
 $ beech-app update -g, --global
 ```
 
-## Beech CLI tool available ##
+# Beech CLI tool available
 After installation, you will have access to the `beech` binary in your command line.
 The `beech` command has a number of options and you can explore them all by running:
 
@@ -96,13 +94,13 @@ The following commands are available:
   $ beech make <model> -M, --model    Create a new Models file.
   $ beech make <helper> --helper      Create a new Helpers file.
   $ beech passport init               Initialize authentication with passport-jwt.
-  $ beech add-on init                 Initialize add-on file.
+  $ beech skd init                    Initialize Job Scheduler file.
   $ beech key:generate, key:gen       Re-Generate application key (Dangerous!).
   $ beech hash:<text>                 Hash text for Access to Database connection.
 ```
 ❓ **Note:** Every to create new project will be generated new ``app_key`` in ``app.config.js`` file, If you can re-generate. Can use command ``$ beech key:generate`` or ``$ beech key:gen``
 
-## Database connection ##
+# Database connection
 
 You might connection to Database with `database_config` object in `app.config.js` file. Anything can support to multiple Database connections.
 
@@ -116,11 +114,11 @@ In case Access to Database must to Hash the `username` and `password` with Beech
 ```sh
 // Hash database username
 $ beech hash:root
-Output: m42BVxQ6Q4kLdRX7xS_Hm7WbQiNqShJDvw9SfuLCgI431oafWBtQJoJDnoCL
+Output: m42BVxQ6Q4kLdRX7xS_Hm7WbQiNqShJDvw9SLCgI431oafWBtQJoJDnoCL
 
 // Hash database password
 $ beech hash:password
-Output: FjgcgJPylkV7EeQJjea_EeifPwaHVO9onD3T4ATk3YYAyvprdrQejtMGu3dcDS0ejA
+Output: FjgcgJPylkV7EeQJjea_EeifPwaHVO9onD3ATk3YYAyvjtMGu3dcDS0ejA
 
 ```
 Example:
@@ -136,13 +134,27 @@ database_config: [
     dialect: "mysql",
     name: "mysql_my_store_db",
     host: "localhost",
-    username: "m42BVxQ6Q4kLdRX7xS_Hm7WbQiNqShJDvw9SfuLCgI431oafWBtQJoJDnoCL",
-    password: "FjgcgJPylkV7EeQJjea_EeifPwaHVO9onD3T4ATk3YYAyvprdrQejtMGu3dcDS0ejA",
+    username: "m42BVxQ6Q4kLdRX7xS_Hm7WbQiNqShJDvw9SLCgI431oafWBtQJoJDnoCL",
+    password: "FjgcgJPylkV7EeQJjea_EeifPwaHVO9onD3ATk3YYAyvjtMGu3dcDS0ejA",
     database: "my_store_db",
     port: "3306",
+
+    // Specify global options, which are used when Define is called.
+    define: {
+      charset: "utf8",
+      freezeTableName: true,
+      ...
+    },
+
+    timezone: "+07:00", // Example: GMT+2
+    // or use a named timezone supported by Intl.Locale
+    // timezone: 'America/Los_Angeles',
+
+    logging: console.log, // SQL trace logs
+
     is_connect: true, // boolean, Turn ON/OFF to connect
   },
-  
+
   ...
 
 ],
@@ -151,9 +163,9 @@ database_config: [
 ```
 ❓ **Caution! :**  Every re-new generate `app_key`. Must to new Hash your Access and change to ALL Database connections.
 
-## Part of generate file
+# Part of generate file
 
-### # Generate Endpoints ###
+## # Generate Endpoints
 
 The `endpoints` keep the endpoints basic request files currently support `GET`, `POST`, `PUT`, `PATCH` and `DELETE`.
 
@@ -162,27 +174,32 @@ So, you might create new endpoints with constant `endpoint` object variable in `
 ```sh
 $ beech make endpointName
 ```
-**Example ***(Basic)***** : Fruits endpoints. 
+You might using [special] `-R, --require` for choose Model(s) used for that endpoint.
+
+### Example ***(Basic)*** : Fruit endpoints.
 
-📂 fruits-endpoints.js
+📂 fruit-endpoints.js
 ```js
 exports.init = () => {
 
   // GET method
-  endpoint.get("/fruits", Credentials, (req, res) => {
+  endpoint.get("/fruit", Credentials, (req, res) => {
     // @response
     res.json({
       code: 200,
-      message: "Got a GET request.",
+      status: "SUCCESS",
+      message: "GET /fruit request.",
     });
   });
 
 
   // POST method
-  endpoint.post("/fruits", Credentials, (req, res) => {
+  endpoint.post("/fruit", Credentials, (req, res) => {
     // @response
     res.json({
       code: 200,
+      status: "SUCCESS",
+      message: "POST request at /fruit",
       result: {
         id: req.body.id,
         name: req.body.name,
@@ -192,21 +209,23 @@ exports.init = () => {
 
 
   // PUT method
-  endpoint.put("/fruits/:id", Credentials, (req, res) => {
+  endpoint.put("/fruit/:id", Credentials, (req, res) => {
     // @response
     res.json({
       code: 200,
-      message: "Got a PUT request /fruits/" + req.params.id,
+      status: "SUCCESS",
+      message: "PUT request at /fruit/" + req.params.id,
     });
   });
 
 
   // DELETE method
-  endpoint.delete("/fruits/:id", Credentials, (req, res) => {
+  endpoint.delete("/fruit/:id", Credentials, (req, res) => {
     // @response
     res.json({
       code: 200,
-      message: "Got a DELETE request /fruits/" + req.params.id,
+      status: "SUCCESS",
+      message: "DELETE request at /fruit/" + req.params.id,
     });
   });
 
@@ -215,30 +234,23 @@ exports.init = () => {
 }
 ```
 
-**Example ***(Sequelize)***** : Fruits endpoints. 
+### Example ***(Sequelize)*** : Fruit endpoints. 
 
-📂 fruits-endpoints.js
+📂 fruit-endpoints.js
 ```js
-  // You can declare Base with Beech Core for initial default endpoint [GET, POST, PATCH, DELETE]
-  const { Base } = require("beech-api"); 👈
-
-  // Model schema & function
-  const { Fruits } = require("@/models/Fruits");
+  // Require Model schema, Function & Others
+  const { Fruit } = require("@/models/Fruit");
 
   exports.init = () => {
 
-    // initialize Fruits Model
-    Base([Fruits]); 👈 // It's like magic creating endpoints for you (CRUD) ✨
-
-    // Now you can request /fruits with methods GET, POST, PATCH and DELETE
-    // (C) POST:   /fruits       with { body }
-    // (R) GET:    /fruits       /:limit?/:offset?
-    // (U) PATCH:  /fruits/:id   with { body }
-    // (D) DELETE: /fruits/:id
-
-    // Other GET method
-    endpoint.get('/example-fruits', (req, res) => {
-      ...
+    // GET method
+    endpoint.get('/fruit', async (req, res) => {
+      // example call Fruit model for get data
+      res.json({
+        code: 200,
+        status: "SUCCESS",
+        results: await Fruit.findAll();
+      });
     });
 
     ...
@@ -247,17 +259,17 @@ exports.init = () => {
 ```
 
 
-### # Generate Models ###
+## # Generate Models ###
 
-The `models` keep the files of function(s) for retriving, inserting, updating and deleting with SQL data. for understanding you might make model name same your table name in `src/models` folder.
+The `models` keep the files of function(s) data managemnets for Retriving, Creating, Updating and Destroying (CRUD). for understanding you might make model name same your table name inside `src/models` folder.
 
 ```sh
 $ beech make modelName --model
 ```
 
-**Example ***(Basic)***** : Fruits model.
+### Example ***(Basic)*** : Fruit model.
 
-📂 Fruits.js
+📂 Fruit.js
 ```js
 module.exports = {
 
@@ -272,10 +284,10 @@ module.exports = {
   },
 
   // Example basic function get data from MySQL table
-  getFruits() {
+  getFruit() {
 
-    // call example mysql `mysql.default_db` connection name
-    mysql.default_db.query("SELECT * FROM fruits", (err, results) => {
+    // calling Pool connection name by `mysql.default_db`
+    mysql.default_db.query("SELECT * FROM fruit", (err, results) => {
 
       if (err) { throw err }
       return results;
@@ -287,64 +299,208 @@ module.exports = {
 };
 ```
 
-**Example ***(Sequelize)***** : Fruits model.
+### Example ***(Sequelize)*** : Fruit model.
 
   You can asign more DataTypes, Learn more : [Sequelize docs](https://sequelize.org/docs/v6/core-concepts/model-basics/#data-types)
 
-📂Fruits.js
+📂Fruit.js
 ```js
 const { Schema } = require("beech-api");
 
 // Define table Schema with `Schema(sql.default_db)` connection name
-const Fruits = Schema(sql.default_db).define("fruits", {
+const Fruit = Schema(sql.default_db).define("fruit", {
   fruit_id: {
-    field: "id", // Ref: field `id` in fruits table
+    field: "id", // Rename PK field to fruit_id Ref: `id` field in fruit table
     type: DataTypes.INTEGER,
     autoIncrement: true,
     primaryKey: true
   },
-  fruitsName: DataTypes.STRING,
-  fruitsQty: DataTypes.INTEGER,
-  fruitsPrice: {
+  friut_uuid: {
+    field: "uuid",
+    type: DataTypes.STRING(100),
+    allowNull: true,
+    defaultValue: DataTypes.UUIDV4,
+  },
+  fruitName: DataTypes.STRING,
+  fruitQty: DataTypes.INTEGER,
+  fruitPrice: {
     type: DataTypes.INTEGER,
     allowNull: false, // Allow null feilds
   },
-  createdAt: DataTypes.DATE,
-  updatedAt: DataTypes.DATE,
+  createdAt: {
+    type: DataTypes.DATE,
+    allowNull: false,
+    defaultValue: DataTypes.NOW,
+  },
+  updatedAt: {
+    type: DataTypes.DATE,
+    allowNull: true,
+  },
+}, {
+  // Enables timestamps with createdAt and updatedAt
+  timestamps: true,
+  // Custom field names createdAt and updatedAt
+  createdAt: "createdAt",
+  updatedAt: "updatedAt",
 });
 
+Fruit.options = {
+  // Choose one for Allow magic generate default Endpoint (CRUD), It's like magic creating The endpoints for you (CRUD) ✨
+
+  // Option 1: Allow all methods
+  defaultEndpoint: true,
+
+  // Option 2: Allow with specific per methods
+  defaultEndpoint: {
+    GET: true,
+    POST: false,
+    PATCH: {
+      allow: true, // allow Auto-Endpoint
+      jwt: {
+        allow: true, // allow JWT
+        broken_role: [
+          { role: [1, 2] },
+        ],
+      },
+    },
+    DELETE: false,
+  },
+
+  limitRows: 100, // Limit rows default 100
+
+};
+
 // Example Finder by id (ORM), Learn more: https://sequelize.org/docs/v6/core-concepts/model-querying-finders/
-function exampleFindOneFruitsById(id) {
-  return Fruits.findOne({ where: { id: id } });
+function exampleFindOneFruitById(id) {
+  return Fruit.findOne({ where: { id: id } });
 }
 
-// Example Raw Query, Learn more: https://sequelize.org/docs/v6/core-concepts/raw-queries/
-function exampleGetAllFruits(id) {
-  return Fruits.query("SELECT * FROM fruits");
-}
 
 // Example Raw Query with Model Instances. This allows you to easily map a query to a predefined model
-function exampleGetAllFruitsWithModelInstance(id) {
-  return Fruits.query("SELECT * FROM fruits", {
-    model: Fruits, // When JOIN table needed register that table [Fruits, ...]
+function exampleGetAllFruitWithModelInstance(id) {
+  return Fruit.query("SELECT * FROM fruit", {
+    model: Fruit, // When JOIN table needed register that table [Fruit, ...]
     mapToModel: true // pass true here if you have any mapped fields
   });
 }
 
+// Example Raw Query, Learn more: https://sequelize.org/docs/v6/core-concepts/raw-queries/
+function exampleGetAllFruit(id) {
+  return Fruit.query("SELECT * FROM fruit");
+}
+
 ...
 
 // Export Schema, Function, ...
 module.exports = {
-  Fruits,
-  exampleFindFruitsById,
-  exampleGetAllFruits,
-  exampleGetAllFruitsWithModelInstance,
+  Fruit,
+  exampleFindOneFruitById,
+  exampleGetAllFruitWithModelInstance,
+  exampleGetAllFruit,
   ...
 };
 ```
+#### That's cool! It's like magic creating The endpoints for you (CRUD) ✨
+
+Now! you can request to `/fruit` with methods GET, POST, PATCH and DELETE like this.
+
+| Efficacy |  Method  |        Endpoint        |    Body    |
+|:---------|:---------|:-----------------------|:-----------|
+|  Create  |  POST    | /fruit                 |     { }    |
+|  Read    |  GET     | /fruit                 |     No     |
+|  Read    |  GET     | /fruit/:id             |     No     |
+|  Read    |  GET     | /fruit/:limit/:offset  |     No     |
+|  Update  |  PATCH   | /fruit/:id             |     { }    |
+|  Delete  |  DELETE  | /fruit/:id             |     No     |
+
+## # Transactions
+
+Sequelize does not use transactions by default. However, for production-ready usage of Sequelize, you should definitely configure Sequelize to use transactions.
+
+Beech use Sequelize supports three ways of using transactions:
+
+- ### Way 1 - Disorganized transactions :
+```js
+// First, we start a transaction from your connection and save it into a variable
+const t = await Fruit.transaction();
+
+try {
+
+  // Then, we do some calls passing this transaction as an option:
+  const fruit = await Fruit.create({ fruitName: 'Banana', fruitQty: '5', }, { transaction: t });
+  await fruit.addSibling({ fruitName: 'Litle', fruitQty: '2', }, { transaction: t }); // Error function
+
+  // If the execution reaches this line, no errors were thrown.
+  // We commit the transaction.
+  await t.commit();
+
+} catch (error) {
+
+  // If the execution reaches this line, an error was thrown.
+  // We rollback the transaction.
+  await t.rollback();
+
+}
+```
 
+- ### Way 2 - Organized transactions :
+```js
+// First, we start a transaction from your connection and save it into a variable
+Fruit.transaction(async t => {
+  try {
+
+    // Then, we do some calls passing this transaction as an option:
+    const fruit = await Fruit.create({ fruitName: 'Banana', fruitQty: '5', }, { transaction: t });
+    await fruit.addSibling({ fruitName: 'Litle', fruitQty: '2', }, { transaction: t }); // Error function
+
+    // If the execution reaches this line, no errors were thrown.
+    // We commit the transaction.
+    await t.commit();
+
+  } catch (error) {
 
-### # Generate Helpers ###
+    // If the execution reaches this line, an error was thrown.
+    // We rollback the transaction.
+    await t.rollback();
+
+  }
+});
+```
+
+- ### Way 3 - Transactions set Isolation levels :
+
+The possible [isolations levels](https://sequelize.org/docs/v6/other-topics/transactions/#isolation-levels) to use when starting a transaction:
+
+```js
+const { Transaction } = require('sequelize');
+
+// First, we start a transaction from your connection and save it into a variable
+Fruit.transaction(
+  {
+    isolationLevel: Transaction.ISOLATION_LEVELS.SERIALIZABLE,
+  },
+  async t => {
+    try {
+
+      // Then, we do some calls passing this transaction as an option:
+      const fruit = await Fruit.create({ fruitName: 'Banana', fruitQty: '5', }, { transaction: t });
+      await fruit.addSibling({ fruitName: 'Litle', fruitQty: '2', }, { transaction: t }); // Error function
+
+      // If the execution reaches this line, no errors were thrown.
+      // We commit the transaction.
+      await t.commit();
+
+    } catch (error) {
+
+      // If the execution reaches this line, an error was thrown.
+      // We rollback the transaction.
+      await t.rollback();
+
+    }
+});
+```
+
+## # Generate Helpers ###
 
 The `helpers` keep the files of functions for process specific something in the project. So, you might create the `helpers` in path `src/helpers` folder.
 
@@ -352,7 +508,7 @@ The `helpers` keep the files of functions for process specific something in the
 $ beech make helperName --helper
 ```
 
-**Example:** Text editor helper.
+***Example:*** Text editor helper.
 
 📂 TextEditor.js
 ```js
@@ -371,11 +527,11 @@ module.exports = {
 };
 ```
 
-## Authentication (passport-jwt)
+# Authentication (passport-jwt)
 
 Passport is authentication middleware for Node. It is designed to serve a singular purpose: authenticate requests. When writing modules, encapsulation is a virtue, so Passport delegates all other functionality to the application. This separation of concerns keeps code clean and maintainable, and makes Passport extremely easy to integrate into an application.
 
-Passport-jwt initiation :
+### Passport-jwt Initialization
 
 ```sh
 $ beech passport init
@@ -386,7 +542,7 @@ After passport initialized the `passport.config.js` it's appeared
 📂 passport.config.js
 ```js
 module.exports = {
-  // allow using passport-jwt
+  // Allow for using passport-jwt
   jwt_allow: true,
 
   // custom authenticaiton endpoint name, default `/authentication`
@@ -398,6 +554,11 @@ module.exports = {
   // token expiry time (seconds), default 86400 sec. it's expired in 24 hr.
   token_expired: 86400,
 
+  // Allow for using global jwt broken role
+  jwt_broken_role: [
+    // { role: [1, 2, 9] },
+  ],
+
   model: {
     // Main sql connection name. You must make sure connection name like inside `app.config.js` file and choose one connection name.
     name: "default_db",
@@ -410,10 +571,27 @@ module.exports = {
     password_field: "",
 
     // JWT playload data, You can add it. Example: ["name", "email", ...]
-    fields: []
+    fields: [],
+
+    // Other fields add for authentication.
+    guard: {
+      // Basic guard field, Example: ["pin", "hint", "2fa"]
+      guard_field: [],
+
+      // Advanced guard jwt request (needed some logical from front-end)
+      advanced_guard: {
+        allow: false,
+        entity: "", // default entity `timing`
+        secret: "top_secret",
+        time_expired: {
+          minutes: 1, // should length [0-60]
+          seconds: 0, // should length [0-60]
+        },
+      },
+    },
   },
 
-  // allow using request with app_key (Every request needed app_key headers)
+  // Allow for using request with app_key entity (Every request must be using the app_key entity in headers)
   app_key_allow: false
 
   ...
@@ -421,7 +599,7 @@ module.exports = {
 };
 ```
 
-***Authentication structure :*** Simple ``users`` table:
+**Authentication structure :** Simple ``users`` table:
 ```
 ==============================================================
 |  id  |  username | password |     name     |     email     |
@@ -434,10 +612,10 @@ When you config passport with ```users``` table already. You will got Auth endpo
 ```js
 POST:  "/authentication"               // Request token
 POST:  "/authentication/create"        // Create new Auth data
-PATCH: "/authentication/update/:id"    // Update old Auth data
+PATCH: "/authentication/update/:id"    // Update old Auth data (needed id)
 ```
 
-Example :
+***XHR Example :***
 
 ```js
 // Request with body for gether Token
@@ -460,7 +638,7 @@ POST: "/authentication/create"
 
 // Request with body for Update Auth data
 PATCH: "/authentication/update/1"
-Bearer Authorization: your_token
+headers: Authorization: Bearer <your_token>
 {
   username: "update_bombkiml",
   password: "update_secret",
@@ -469,7 +647,88 @@ Bearer Authorization: your_token
 }
 ```
 
-### Beech auth managements with User ###
+# Beech Two Factor (2FA)
+You can easy using 2 Factor authenticate with ```guard_field``` inside ```passport.config.js``` file and add your Guard field ex: ```2fa``` field for Authenticate Conditions.
+
+## # Usage guard (2FA, Other)
+
+📂 passport.config.js
+```js
+module.exports = {
+  ...
+
+  guard: {
+    // Other fields add for authenticate, exmaple ["pin", "hint", "2fa"]
+    guard_field: ["2fa"], 👈 // your feild guard.
+
+    ...
+  },
+
+  ...
+
+}
+```
+
+## # Beech Advanced Guard (Timing)
+Advance Guard for Protection your Endpoint with Timing. You can allow in object ```advance_guard``` inside ```passport.config.js``` file. So let's go add your Advance Guard Configuration.
+
+📂 passport.config.js
+```js
+module.exports = {
+  ...
+
+  guard: {
+    ...
+
+    // Advanced guard jwt request (needed some logical from front-end)
+    advanced_guard: {
+      allow: false, 👈 // advanced guard allow for All Endpoint.
+      entity: "", // default entity `timing`
+      secret: "your_advance_guard_secret",
+      time_expired: {
+        minutes: 1, // should length [0-60]
+        seconds: 0, // should length [0-60]
+      },
+    },
+  },
+
+  ...
+
+}
+
+```
+
+<b>After configure</b>, You must add some logic in your front-end like this.
+
+Before add logic, We needed [```beech-auth0```](https://github.com/bombkiml/beech-auth0) and [```moment.js```](https://momentjs.com) for apply in Policy.
+
+```sh
+# NPM
+$ npm install --save beech-auth0 moment
+
+# Yarn
+$ yarn add beech-auth0 moment
+```
+Now! you can add some logic.
+```js
+const { Auth0 } = require("beech-auth0");
+const moment = require("moment");
+
+// Get UNIX TIME with moment
+let unix_time = moment().unix();
+
+// Auth0 Policy.
+Auth0(unix_time, 'your_advance_guard_secret', (error, hashing) => {
+  
+  // Your XHR request for All Endpoint.
+  POST: "/authentication"
+  headers: timing: hashing, 👈 // Assign advance guard entity to headers with callback hashing.
+
+});
+
+```
+
+## # Beech User Auth Managements ###
 You can easy management `users` data with Beech, Only ```Store, Update``` NO ```Delete```, Anything you can make DELETE endpoint by yourself
 
 ```js
@@ -513,12 +772,12 @@ Update(data, id, (err, updated) => {
 });
 ```
 
-## Beech with Official Strategy
+# Beech with Official Strategy
 
 Latest supported with ``Google`` and ``Facebook`` Strategy.
 
 
-### Google Strategy
+## # Google Strategy
 
 
 The Google OAuth 2.0 authentication strategy authenticates users using a Google account and OAuth 2.0 tokens. The strategy requires a verify callback, which accepts these credentials and calls done providing a user, as well as options specifying a client ID, client secret, and callback URL.
@@ -535,7 +794,7 @@ strategy: {
 
   google: {
 
-    // Allow using google strategy
+    // Allow for using google strategy
     allow: true,
 
     // Authen profile store fields available: `google_id`, `name`, `email`, `photos`, `locate`
@@ -577,7 +836,7 @@ Place a button on the application's login page, prompting the user to sign in wi
 ❓ **Note:** The URL "``/authentication``" will be follow by ``auth_endpoint`` when you custom it.
 
 
-### Facebook Strategy
+## # Facebook Strategy
 
 
 Facebook Login allows users to sign in using their Facebook account. Support for Faceboook Login is provided by the ``passport-facebook`` package.
@@ -594,7 +853,7 @@ strategy: {
 
   facebook: {
 
-    // Allow using facebook strategy
+    // Allow for using facebook strategy
     allow: true,
 
     // Authen profile store fields available: `facebook_id`, `name`, `email`, `photos`, `locate`
@@ -641,16 +900,35 @@ Place a button on the application's login page, prompting the user to sign in wi
 
 ❓ **Note:** The URL "``/authentication``" will be follow by ``auth_endpoint`` when you custom it.
 
-## CORS Origin allowments
+# CORS Origin & Server Configuration
 The origin array to the callback can be any value allowed for the origin option of the middleware. Certain CORS requests are considered `complex` and require an initial OPTIONS request (called the `pre-flight request`). You can allowed CORS origin inside file `beech.config.js`
 
 📂 beech.config.js
 ```js
 module.exports = {
   defineConfig: {
+    // Base public path when served in development or production.
+    base: process.env.NODE_ENV === "production"
+          ? "/my-api/" // For Production
+          : "/", // For Development
+
     server: {
+      // Client request allow origin whitelist
       origin: ["http://example.com", "http://my-webapp:8080", "https://cat.io"],
       originSensitive: false, // Sensitive with contrasts wording
+
+      // API Request rate limit (Disabled for Remove it.)
+      rateLimit: {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        limit: 100, // Limit each IP to 100 requests per `window` (here, per 15 minutes).
+        // store: ... , // Redis, Memcached, etc.
+        // See more: https://www.npmjs.com/package/express-rate-limit#Configuration
+      },
+
+      // API Duplicate Request (Disabled for Set expiration to 0 zero.)
+      duplicateRequest: {
+        expiration: 500, // Can't duplicate request for 5 milliseconds each IP requests per `window`
+      },
     },
   },
 }
@@ -658,16 +936,95 @@ module.exports = {
 
 ❓ **Note:** When you must to allowed all Origin. You can assign `*` or `[]` null value to `origin` variable.
 
+## # Custom Endpoint Specific Rate Limit
+When you need assign specific request Endpoint with [express-rate-limit](https://www.npmjs.com/package/express-rate-limit), You can managemnet with Beech object ```rateLimit``` for your custom Rate Limit like this.
 
-## Databases managements
+```js
+const { rateLimit } = require("beech-api").Express;
 
-### # Migrations & Seeder
+// Specific of your rate limit
+const specificRateLimit1 = rateLimit({
+  windowMs: 5 * 60 * 1000, // 5 minutes
+  limit: 20,
+  // more...
+});
+
+// Your Endpoints...
+endpoint.get("/banana", specificRateLimit1, (req, res) => {
+  ...
+});
+
+...
+```
+
+## # Custom Endpoint Specific Slow Down
+**DON'T DO IT.** &nbsp; Because it's annoying to users.
+
+When you need assign specific request Endpoint with [express-slow-down](https://www.npmjs.com/package/express-slow-down), You can managemnet with Beech object ```slowDown``` for your custom Slow Down like this.
+
+```js
+const { slowDown } = require("beech-api").Express;
+
+// Specific of your slow down
+const specificSlowDown1 = slowDown({
+  windowMs: 15 * 60 * 1000,      // 15 minutes
+  delayAfter: 5,                 // Allow 5 requests per 15 minutes.
+  delayMs: (hits) => hits * 100, // Add 100 ms of delay to every request after the 5th one.
+  // more...
+  
+  /**
+   * So:
+   *
+   * - requests 1-5 are not delayed.
+   * - request 6 is delayed by 600ms
+   * - request 7 is delayed by 700ms
+   * - request 8 is delayed by 800ms
+   *
+   * and so on. After 15 minutes, the delay is reset to 0.
+   */
+});
+
+// Your Endpoints...
+endpoint.get("/banana", specificSlowDown1, (req, res) => {
+  ...
+});
+
+...
+```
+
+## # Custom Endpoint Specific Duplicate Request
+This middleware to Limit each IP duplicated requests per window.
+
+When you need assign specific request Endpoint with duplicate request use [express-duplicate-request](https://github.com/bombkiml/express-duplicate-request), You can managemnet with Beech object ```duplicateRequest``` for your custom Duplicate Request like this.
+
+```js
+const { duplicateRequest } = require("beech-api").Express;
+
+// Specific of your duplicate request
+const specificDup1 = duplicateRequest({
+  expiration: 500, // Can't duplicate request for 5 milliseconds, Should 0 to disabled
+  // more...
+});
+
+// Your Endpoints...
+endpoint.get("/banana", specificDup1, (req, res) => {
+  ...
+});
+
+...
+```
+
+
+
+# Databases managements
+
+## # Migrations & Seeder
 
 Just like you use Git / SVN to manage changes in your source code, you can use migrations to keep track of changes to the database. With migrations you can transfer your existing database into another state and vice versa: Those state transitions are saved in migration files, which describe how to get to the new state and how to revert the changes in order to get back to the old state.
 
 You will need [Sequelize CLI.](https://github.com/sequelize/cli) The CLI ships support for [migrations](https://sequelize.org/v5/manual/migrations.html) and project.
 
-### # Usage
+## # Usage
 
 To create an empty project you will need to execute `init` command
 
@@ -682,7 +1039,7 @@ This will create following folders inside `databases` folder.
 - `migrations`, contains all migration files.
 - `seeders`, contains all seed files.
 
-### # Configuration
+## # Configuration
 
 Before continuing further we will need to tell CLI how to connect to database. To do that let's open default config file `databases/config/database.json` It looks something like this:
 
@@ -716,7 +1073,7 @@ Before continuing further we will need to tell CLI how to connect to database. T
 
 ❓ **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
+## # Creating first Migrations
 
 Create `model` use `model:generate` command. This command requires two options.
 
@@ -729,7 +1086,7 @@ Let's create a model name example `User`. See more about of [Datatypes](https://
 $ npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string,birhday:date
 ```
 
-### # Migrations Up and Down
+## # Migrations Up and Down
 
 Until this step, we haven't inserted anything into the database. We have just created required model and migration files for our first model User.
 
@@ -744,7 +1101,7 @@ Until this step, we haven't inserted anything into the database. We have just cr
   $ npx sequelize-cli db:migrate:undo
   ```
 
-### # Creating First Seeder
+## # Creating First Seeder
 
 To manage all data migrations you can use seeders. Seed files are some change in data that can be used to populate database table with sample data or test data.
 
@@ -754,7 +1111,7 @@ Let's create a seed file which will add a demo user to our User table.
 $ npx sequelize-cli seed:generate --name user
 ```
 
-### # Seeder Up and Down
+## # Seeder Up and Down
 
 In last step you have create a seed file. It's still not committed to database. To do that we need to run a simple command.
 
@@ -784,7 +1141,7 @@ In last step you have create a seed file. It's still not committed to database.
   $ npx sequelize-cli db:seed:undo:all
   ```
 
-## Testing
+# Testing
 
 Test using [Jest](https://jestjs.io/en/) for testing the project. Jest is a delightful JavaScript Testing Framework with a focus on simplicity. Learn more [Jest docs](https://jestjs.io/docs/en/getting-started.html)
 
@@ -792,13 +1149,13 @@ So, When you make the new endpoints it's automatic create test file end with `.s
 
 Example endpoints testing :
 
-📂 fruits-endpoints.spec.js
+📂 fruit-endpoints.spec.js
 ```js
-const endpoint = baseUrl.concat("/fruits/fruits");
+const endpoint = baseUrl.concat("/fruit");
 
 describe("Test endpoint : " + endpoint, () => {
   it("Truthy!", () => {
-    expect("/fruits/fruits").toBeTruthy();
+    expect("/fruit").toBeTruthy();
   });
 
   it("Respond with basic GET status code 200", (done) => {
@@ -811,26 +1168,13 @@ 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>
+# Implementation
 
-# 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)
+## # 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**
+- ### **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/).
 
@@ -839,14 +1183,14 @@ Docker builds images automatically by reading the instructions from a Dockerfile
 FROM node:14.19-alpine
 ENV NODE_ENV=production
 WORKDIR /usr/src/api
-COPY ["package.json", "package-lock.json*", "npm-shrinkwrap.json*", "./"]
+COPY ["package.json", "package-lock.json*", "./"]
 RUN npm install --production --silent && mv node_modules .
 COPY . .
 EXPOSE 9000
 CMD ["node", "./node_modules/beech-api/packages/cli/beech"]
 ```
 
-- **Docker build image**
+- ### **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.
 
@@ -856,16 +1200,16 @@ $ docker build -t <imageName> .
 
 ❓ **Note:** You can specify a repository and tag at which to save the new image : ``` $ docker build -t <imageName>:<tags> . ```
 
-- **Run docker**
+- ### **Run docker**
 
   After create ``image`` you can run docker engine following :
 
-  - **Docker Container (Standalone)**
+  - ### **Docker Container (Standalone)**
   ```sh
   $ docker run -d -p 9000:9000 --name <containerName> <imageName>
   ```
 
-  - **Create Docker Swarm (Cluster)**
+  - ### **Create Docker Swarm (Cluster)**
   ```sh
   # Initiate swarm
   $ docker swarm init
@@ -874,42 +1218,20 @@ $ docker build -t <imageName> .
   $ docker service create --replicas <instances> --name <containerName> --publish 9000:9000 <imageName>
   ```
 
+## # 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/).
 
-## 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.
-
-Installation the package:
-
-```
-$ npm install line-api
-```
-
-Create file `Line.js` in `src/helpers` folder and copy code below:
-
-📂 Line.js
-```js
-const Line = require("line-api");
-
-module.exports = {
+```sh
+# Start service as standalone
+$ pm2 start ./node_modules/beech-api/packages/cli/beech --name <serviceName>
 
-  notify(message, token) {
-    const notify = new Line.Notify({
-      token: token
-    });
-    notify
-      .send({
-        message: message
-      })
-      .then(console.log);
-  }
+# OR
 
-};
+# Start service as cluster mode
+$ pm2 start ./node_modules/beech-api/packages/cli/beech --name <serviceName> -i <instances>
 ```
 
-Enjoy.
-
-## Development
+# Development
 
 Want to contribute or join for great job!, You can contact to me via
 
@@ -917,6 +1239,6 @@ Want to contribute or join for great job!, You can contact to me via
 - E-mail: nattapat.jquery@gmail.com
 - Facebook: [https://www.facebook.com/bombkiml](https://www.facebook.com/bombkiml)
 
-## License
+# License
 
 The Beech API framework is open-sourced software licensed under the [MIT license.](https://opensource.org/licenses/MIT)