beech-api 3.8.0 → 3.9.0-beta.9-rc

package/packages/lib/src/endpoint.js

@@ -1,6 +1,8 @@
 const walk = require("walk");
 const fs = require("fs");
+const moment = require("moment");
 const { checkRoleMiddlewareWithDefaultProject } = require("../../cli/core/middleware/express/jwtCheckAllow");
+const { Limiter, Duplicater } = require("../../cli/core/middleware/index");
 
 function walkModel(cb) {
   try {
@@ -38,7 +40,38 @@ function walkModel(cb) {
   }
 }
 
-function filterProject(Projects, reqUrl, req, res, cb) {
+function filterProject(Projects, reqUrl, params = "", method = "", req, res, cb) {
+  try {
+    let pj = Projects.shift();
+    let leaveParamsAlone = params.slice(0);
+    let paramsItem = leaveParamsAlone.replace(/^\/|\/$/g, "").split('/');
+    let leaveReqUrlAlone = reqUrl.slice(0);
+    let newParams = params.split("/").filter((e) => (e !== 'undefined')).join("/");
+    let urlWithoutParams = leaveReqUrlAlone.replace(newParams, '').split("?")[0].replace(/\/$/, "");
+    // sub-way for PATCH method
+    urlWithoutParams = (method == "PATCH" || method == "DELETE") ? urlWithoutParams.substring(0, urlWithoutParams.lastIndexOf('/')) : urlWithoutParams;
+    // check match project by url
+    if(pj[1] == urlWithoutParams) {
+      return checkOffset(Object.values(require(pj[0]))[0], req, res, (thenChecked) => {
+        if(thenChecked) {
+          return cb(null, Object.values(require(pj[0]))[0], paramsItem);
+        }
+      });
+    }
+    // Finally recursive filterProject function
+    if (Projects.length > 0) {
+      filterProject(Projects, reqUrl, params, method, req, res, cb);
+    } else {
+      // not match
+      return notfound(res);
+    }
+  } catch (error) {
+    console.log(error);
+    cb(error, null, []);
+  }
+}
+
+function filterProjectForByPass(Projects, reqUrl, req, res, cb) {
   try {
     let pj = Projects.shift();
     let regx = new RegExp(pj[1] + "?[^\/].?[a-zA-Z0-9].*$", 'g');
@@ -57,9 +90,9 @@ function filterProject(Projects, reqUrl, req, res, cb) {
         }
       });
     }
-    // Finally recursive filterProject function
+    // Finally recursive filterProjectForByPass function
     if (Projects.length > 0) {
-      filterProject(Projects, reqUrl, req, res, cb);
+      filterProjectForByPass(Projects, reqUrl, req, res, cb);
     } else {
       // not match
       return notfound(res);
@@ -117,52 +150,350 @@ function errMessage(err, res) {
   }
 }
 
-const byPassCheckRole = (Projects, method, passport_config) => {
-  return async function (req, res, next) {
-    if(passport_config[0] !== undefined) {
-      if(req.params.hash == passport_config[0].replace(/^\/|\/$/g, "")) {
-        return next();
-      } else {
-        if(passport_config[1].jwt_allow === true) {
-          let leaveMeAlone = await Projects.slice(0);
-          await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
-            if(!err) {
-              if(Project.options.defaultEndpoint === undefined || Project.options.defaultEndpoint === true) {
-                // Project is not use options
-                return Credentials(req, res, () => {
-                  return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
+function whereCond(objectCond, cb) {
+  if(typeof objectCond === 'object' && Object.keys(objectCond).length) {
+    let keys = Object.keys(objectCond);
+    let where = {};
+    let orderBy = {};
+    let groupBy = {};
+    // Start Recursive for Check Where condition OR GroupBy OR OrderBy
+    recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, (err, cbWhere, cbGroupBy, cbOrderBy) => {
+      cb(err, cbWhere, cbGroupBy, cbOrderBy);
+    });
+  } else {
+    cb(null, {}, { group: { groupby: [] } }, { order: { orderby: [] } });
+  }
+}
+
+function getValueType(value) {
+  if (typeof value === 'string') {
+    // Check for ISO-like date string with optional time part
+    const isoDateRegex = /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2})?$/;
+    const date = new Date(value);
+    if (!isNaN(date.getTime()) && isoDateRegex.test(value)) {
+      return 'Date';
+    }
+    return 'String';
+  }
+  if (typeof value === 'number' && !isNaN(value)) return 'Number';
+  if (typeof value === 'boolean') return 'Boolean';
+  if (value instanceof Date && !isNaN(value)) return 'Date';
+  if (value === null) return 'Null';
+  if (typeof value === 'undefined') return 'Undefined';
+  if (Array.isArray(value)) return 'Array';
+  if (typeof value === 'function') return 'Function';
+  if (typeof value === 'symbol') return 'Symbol';
+  if (typeof value === 'bigint') return 'BigInt';
+  if (typeof value === 'object') return 'Object';
+  return 'Unknown';
+}
+
+async function recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, cb) {
+  if(keys.length > 0) {
+    let k = keys.shift();
+    // Check param key for Where condition OR GroupBy OR OrderBy
+    if(k == 'orderby') {
+      let oderByValueItemFromQueryString = objectCond[k].replace(/\w+/g, '"$&"').replace(/\[\s*\]/g, '[]');
+      // Check Array syntax from Query String
+      isValidArrayFormat(oderByValueItemFromQueryString, (err, isArray, strArr) => {
+        if(err) {
+          cb(["SyntaxError: Unexpected end of Array or String input", ` (${k})`], null, null, null);
+        } else {
+          let order = JSON.parse(strArr);
+          orderBy[k] = order.length ? order : null;
+          // Recursive re-call function
+          recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, cb);
+        }
+      });
+    } else if(k == 'groupby') {
+      let groupByValueItemFromQueryString = objectCond[k].replace(/\w+/g, '"$&"').replace(/\[\s*\]/g, '[]');
+      // Check Array syntax from Query String
+      isValidArrayFormat(groupByValueItemFromQueryString, (err, isArray, strArr) => {
+        if(err) {
+          cb(["SyntaxError: Unexpected end of Array or String input", ` (${k})`], null, null, null);
+        } else {
+          let group = JSON.parse(strArr);
+          groupBy[k] = group.length ? group : null;
+          // Recursive re-call function
+          recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, cb);
+        }
+      });
+    } else {
+      let fieldValueItemFromQueryString = objectCond[k].replace(/([^[\],]+)/g, '"$1"');
+      let valueItem = objectCond[k].replace(/[\[\]']+/g, '').split(','); //replace(/[\[\]']+/g, '')
+      let cleanValueItem = valueItem.map((e) => e.trim()).filter((e) => e !== '');
+      // Check Array syntax from Query String
+      isValidArrayFormat(fieldValueItemFromQueryString, async (err) => {
+        if(err || cleanValueItem.length < 1) {
+          cb(["SyntaxError: Unexpected end of Array or String input", ` (${k})`], null, null, null);
+        } else {
+          try {
+            where[k] = await (cleanValueItem[1])
+                      ? {
+                          [Op[cleanValueItem[0]]]: (cleanValueItem[1] == 'null') ? null :
+                                              (cleanValueItem[1] == 'true') ? true :
+                                              (cleanValueItem[1] == 'false') ? false :
+                                              (cleanValueItem[0] == 'between' || cleanValueItem[0] == 'notBetween') ? [
+                                                (getValueType(cleanValueItem[1]) == 'Date')
+                                                  ? cleanValueItem[1].split(' ').map(e => e.trim()).length > 1
+                                                    ? moment(new Date(cleanValueItem[1]).toISOString())
+                                                    : moment(new Date(cleanValueItem[1] + ' 00:00:00').toISOString())
+                                                  : cleanValueItem[1],
+                                                (getValueType(cleanValueItem[2]) == 'Date')
+                                                  ? cleanValueItem[2].split(' ').map(e => e.trim()).length > 1
+                                                    ? moment(new Date(cleanValueItem[2]).toISOString())
+                                                    : moment(new Date(cleanValueItem[2] + ' 23:59:59').toISOString())
+                                                  : cleanValueItem[2],
+                                              ] :
+                                              (cleanValueItem[0] == 'or' || cleanValueItem[0] == 'in' || cleanValueItem[0] == 'notIn') ? [...cleanValueItem.slice(1)] :
+                                              (cleanValueItem[0] == 'like') ? [cleanValueItem[1],cleanValueItem[2],cleanValueItem[3]].join("") :
+                                              (cleanValueItem[0] == 'notLike') ? [cleanValueItem[1],cleanValueItem[2],cleanValueItem[3]].join("") :
+                                              (cleanValueItem[0] == 'startsWith') ? cleanValueItem[1] :
+                                              (cleanValueItem[0] == 'endsWith') ? cleanValueItem[1] :
+                                              (cleanValueItem[0] == 'substring') ? cleanValueItem[1] :
+                                              [cleanValueItem[1]]
+                        }
+                      : cleanValueItem[0];
+            // Recursive re-call function
+            recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, cb);
+          } catch (error) {
+            return cb([`Error with (${k})`, error], null, null, null);
+          }
+        }
+      });
+    }
+  } else {
+    // End of recursive function
+    cb(null, where, groupBy, orderBy);
+  }
+}
+
+function isValidArrayFormat(str, cb) {
+  try {
+    const parsed = JSON.parse(str);
+    cb(null, Array.isArray(parsed), str);
+  } catch (err) {
+    cb(err, false, null);
+  }
+}
+
+// function parseRawQuery(search) {
+//   const rawParams = {};
+//   if (search.startsWith('?')) {
+//     const queryString = search.slice(1); // Remove '?'
+//     const pairs = queryString.split('&');
+
+//     for (const pair of pairs) {
+//       const [key, value = ''] = pair.split('=');
+//       if (key) {
+//         rawParams[key] = value;
+//       }
+//     }
+//   }
+//   return rawParams;
+// }
+
+async function findAll(Project, where, offset, group, order, limitRow, cb) {
+  try {
+    await Project.findAll({
+      where,
+      group: (group.groupby) ? group.groupby : [],
+      order: (order.orderby) ? [order.orderby] : [],
+      offset: offset,
+      limit: limitRow,
+    }).then((results) => {
+      cb(null, results)
+    }).catch((error) => {
+      cb(error, null);
+    });
+  } catch (error) {
+    cb(error, null);
+  }
+}
+
+async function retrieving(authEndpoint, Projects, req, res, next) {
+  let params = req.params;
+  let hash = "/" + req.params.hash;
+  // allow official stetragy
+  if(hash == authEndpoint && (params[0] == "/facebook" || params[0] == "/facebook/callback" || params[0] == "/google" || params[0] == "/google/callback")) {
+    return next();
+  }
+  // declare variable for check request with params
+  let leaveMeAlone = await Projects.slice(0);
+  let mergeDuoVar = [req.params.limit, req.params.offset].map((e) => (e || 'undefined')).join("/");
+  let reqUrl = req.originalUrl.replace(_publicPath_, '/');
+  let checkConditionIsQueryOrId = Object.keys(req.query).length
+                                    ? req.query
+                                    : 'undefined';
+  /**
+   * Function whereCond with callback property
+   * 
+   * @where Object|String
+   * 
+   */
+  whereCond(checkConditionIsQueryOrId, async (err, where, groupBy, orderBy) => {
+    if(err) {
+      res.status(400).json({
+        code: 400,
+        status: "BAD_REQUEST",
+        err: String(err),
+      });
+    } else {
+      /**
+       * Filter Project with callback property
+       * 
+       * @err String
+       * @Project Require
+       * @params Object [0=limit, 1=offset]
+       * 
+       */
+      await filterProject(leaveMeAlone, reqUrl, "/".concat(mergeDuoVar), "", req, res, async (err, Project, params) => {
+        if (!err) {
+          try {
+            // declare default limit offset
+            let offset = 0;
+            let limitRow = await (Project.options.limitRows) ? Project.options.limitRows : 100;
+            // check assign limit, offset ?
+            if ((params[0] && params[0]  != 'undefined') && ((params[1] && params[1] != 'undefined') || parseInt(params[1]) === 0)) {
+              // Only case: /limit/offset
+              limitRow = parseInt(params[0]);
+              offset = parseInt(params[1]);
+            }
+            // findAll data
+            await findAll(Project, where, offset, groupBy, orderBy, limitRow, (err, results) => {
+              if(err) {
+                res.status(500).json({
+                  code: 500,
+                  status: "READ_CATCH",
+                  err: String(err),
                 });
               } else {
-                // Method is set
-                if(Project.options.defaultEndpoint[method]) {
-                  if(Project.options.defaultEndpoint[method]["allow"] === undefined || Project.options.defaultEndpoint[method]["allow"] === true) {
-                    if(Project.options.defaultEndpoint[method]["jwt"]?.allow === false) {
-                      // by project jwt_allow is false
-                      return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
-                    } else {
-                      return Credentials(req, res, () => {
-                        return checkRoleMiddlewareWithDefaultProject(Project.options.defaultEndpoint[method].jwt?.broken_role)(req, res, next);
-                      });
-                    }
-                  } else {
-                    return notfound(res);
-                  }
-                } else {
-                  // Method is not set
-                  return Credentials(req, res, () => {
-                    return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
-                  });
-                }
+                // @ return findAll
+                res.json({
+                  code: 200,
+                  status: "SUCCESS",
+                  results,
+                  length: results.length,
+                  limitRow,
+                });
               }
-            } else {
-              return errMessage(err, res);
-            }
-          });
+            });
+          } catch (error) {
+            // @return
+            return errMessage(error, res);
+          }
         } else {
-          // global jwt_allow is false
+          // @return
+          return errMessage(err, res);
+        }
+      });
+    }
+  });
+}
+
+// Duplicater cache for each config, avoid create new instance with same config
+const duplicaterCache = new Map();
+function getDuplicaterInstance(dupConfig = {}) {
+  const key = JSON.stringify(dupConfig || {});
+  if (!duplicaterCache.has(key)) {
+    duplicaterCache.set(key, Duplicater(dupConfig || {}));
+  }
+  return duplicaterCache.get(key);
+}
+
+// Limiter cache for each config, avoid create new instance with same config
+const limiterCache = new Map();
+function getLimiterInstance(rateConfig = {}) {
+  const key = JSON.stringify(rateConfig);
+  if (!limiterCache.has(key)) {
+    limiterCache.set(key, Limiter(rateConfig));
+  }
+  return limiterCache.get(key);
+}
+
+const byPassCheckRole = (Projects, method, passport_config) => {
+  return async function (req, res, next) {
+    try {
+      if(passport_config[0] !== undefined) {
+        if(req.params.hash == passport_config[0].replace(/^\/|\/$/g, "")) {
           return next();
+        } else {
+          if(passport_config[1].jwt_allow === true) {
+            let leaveMeAlone = await Projects.slice(0);
+            await filterProjectForByPass(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
+              if(!err) {
+                // Set Duplicater and Limiter for each project with method
+                const dupConfig = (Project.options?.defaultEndpoint?.[method]?.duplicate_request) ? Project.options.defaultEndpoint[method].duplicate_request : {};
+                const duplicaterMiddleware = getDuplicaterInstance(dupConfig);
+                return duplicaterMiddleware(req, res, (err) => {
+                  if (!err) {
+                    const rateConfig = (Project.options?.defaultEndpoint?.[method]?.rate_limit) ? Project.options.defaultEndpoint[method].rate_limit : {};
+                    const limiterMiddleware = getLimiterInstance(rateConfig);
+                    limiterMiddleware(req, res, (err) => {
+                      if (!err) {
+                        if(Project.options.defaultEndpoint === undefined || Project.options.defaultEndpoint === true) {
+                          // Project is not use options
+                          return Credentials(req, res, () => {
+                            return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
+                          });
+                        } else {
+                          // Method is set
+                          if(Project.options.defaultEndpoint[method]) {
+                            if(Project.options.defaultEndpoint[method]["allow"] === undefined || Project.options.defaultEndpoint[method]["allow"] === true) {
+                              if(Project.options.defaultEndpoint[method]["jwt"]?.allow === false) {
+                                // by project jwt_allow is false
+                                return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
+                              } else {
+                                //return Credentials(req, res, () => {
+                                //  return checkRoleMiddlewareWithDefaultProject(Project.options.defaultEndpoint[method].jwt?.broken_role)(req, res, next);
+                                //});
+                                return Credentials(req, res, () => checkRoleMiddlewareWithDefaultProject(Project.options.defaultEndpoint[method].jwt?.broken_role || null)(req, res, next));
+                              }
+                            } else {
+                              // METHOD.allow is false || METHOD.allow is undefined
+                              return notfound(res);
+                            }
+                          } else if(Project.options.defaultEndpoint[method] === true || Project.options.defaultEndpoint[method] === undefined) {
+                            // Method is not set
+                            return Credentials(req, res, () => {
+                              return checkRoleMiddlewareWithDefaultProject(null)(req, res, next);
+                            });
+                          } else {
+                            // METHOD is false || METHOD is not undefined
+                            return notfound(res);
+                          }
+                        }
+                      } else {
+                        return res.status(429).json({
+                          code: 429,
+                          status: "TOO_MANY_REQUEST",
+                          message: "Too Many Requests.",
+                        });
+                      }
+                    });
+                  } else {
+                    return res.status(409).json({
+                      code: 409,
+                      status: "DUPLICATE_REQUEST",
+                      message: "Duplicate request detected.",
+                    });
+                  }
+                });
+              } else {
+                return errMessage(err, res);
+              }
+            });
+          } else {
+            // global jwt_allow is false
+            return next();
+          }
         }
+      } else {
+        // passport config not found
+        return next();
       }
+    } catch (error) {
+      return errMessage(error, res);
     }
   }
 }
@@ -182,101 +513,24 @@ function Base() {
               resolve([_passport_config_.auth_endpoint || "/authentication", _passport_config_]);
             } else {
               // passport config not found
-              resolve([passport_config_auth, _passport_config_]);
+              resolve([passport_config_auth, {}]);
             }
           });
           // passport conifg promise
           checkPassport.then((passport_config) => {
             if(Projects.length) {
-              // GET method with ALL data, default: limit rows 100
-              endpoint.get("/:hash", (req, res, next) => byPassCheckRole(Projects, "GET", passport_config)(req, res, next), async (req, res, next) => {
-                let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
-                  if (!err) {
-                    try {
-                      const results = await Project.findAll({
-                        offset: 0,
-                        limit: (Project.options.limitRows) ? Project.options.limitRows : 100,
-                      });
-                      // @ return
-                      await res.json({
-                        code: 200,
-                        status: "SUCCESS",
-                        results,
-                        length: results.length,
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
+              // GET method with /:limit/:offset
+              endpoint.get("/:hash([a-zA-Z0-9-]+)*/:limit([0-9]+)/:offset([0-9]+)", (req, res, next) => byPassCheckRole(Projects, "GET", passport_config)(req, res, next), async (req, res, next) => {
+                await retrieving(passport_config[0], Projects, req, res, next);
               });
-              // GET method with id
-              endpoint.get("/:hash/:id", (req, res, next) => byPassCheckRole(Projects, "GET", passport_config)(req, res, next), async (req, res, next) => {
-                // allow official stetragy
-                if(req.params.id == "google" || req.params.id == "facebook") {
-                  return next();
-                }
-                // filter GET project
-                let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
-                  if (!err) {
-                    try {
-                      const results = await Project.findByPk(req.params.id);
-                      // @ return
-                      await res.json({
-                        code: 200,
-                        status: "SUCCESS",
-                        results,
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
-              });
-              // GET method with :limit and :offset
-              endpoint.get("/:hash/:limit/:offset", (req, res, next) => byPassCheckRole(Projects, "GET", passport_config)(req, res, next), async (req, res, next) => {
-                // allow official stetragy
-                if(req.params.limit == "google" || req.params.limit == "facebook" || req.params.offset == "callback") {
-                  return next();
-                }
-                // filter GET limit,offset project
-                let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
-                  if (!err) {
-                    try {
-                      const results = await Project.findAll({
-                        offset: parseInt(req.params.offset) || 0,
-                        limit: (parseInt(req.params.limit) === 0) ? 0 : parseInt(req.params.limit),
-                      });
-                      // @ return
-                      await res.json({
-                        code: 200,
-                        status: "SUCCESS",
-                        results,
-                        length: results.length,
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
+
+              // GET method only hash/*
+              endpoint.get("/:hash([a-zA-Z0-9-]+)*", (req, res, next) => byPassCheckRole(Projects, "GET", passport_config)(req, res, next), async (req, res, next) => {
+                await retrieving(passport_config[0], Projects, req, res, next);
               });
+
               // POST method
-              endpoint.post("/:hash", (req, res, next) => byPassCheckRole(Projects, "POST", passport_config)(req, res, next), async (req, res, next) => {
+              endpoint.post("/:hash*", (req, res, next) => byPassCheckRole(Projects, "POST", passport_config)(req, res, next), async (req, res, next) => {
                 // Check auth request match send next
                 if(passport_config[0] !== undefined) {
                   if(req.params.hash == passport_config[0].replace(/^\/|\/$/g, "")) {
@@ -285,58 +539,103 @@ function Base() {
                 }
                 // When lost IF
                 let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
+                let reqUrl = req.originalUrl.replace(_publicPath_, '/');
+                let bodyIsArray = Array.isArray(req.body);
+                await filterProject(leaveMeAlone, reqUrl, "", "", req, res, async (err, Project) => {
                   if (!err) {
                     try {
                       // Leave pool by project for check pool error
                       let pool = Project.sequelize;
-                      // Store with body
-                      await Project.create(req.body).then((created) => {
-                        // @return
-                        res.status(201).json({
-                          code: 201,
-                          status: "CREATE_SUCCESS",
-                          createdId: (created.id) ? created.id : created[Project.primaryKeyAttributes[0]],
-                        });
-                      }).catch((error) => {
-                        if(pool.options.logging) {
-                          // @return with all error
-                          res.status(501).json({
-                            code: 501,
-                            status: "CREATE_FAILED",
-                            error: error,
-                          });
-                        } else {
-                          if(error.sql) {
-                            delete error.sql;
-                            if(error.errors) {
-                              delete error.errors;
-                            }
-                            if(error.parent) {
-                              delete error.parent;
-                            }
-                            if(error.original) {
-                              delete error.original.sql;
-                              if(error.original.parameters) {
-                                delete error.original.parameters;
-                              }
-                            }
-                            if(error.parameters) {
-                              delete error.parameters;
-                            }
-                            // @return with some error
-                            res.status(501).json({
-                              code: 501,
-                              status: "CREATE_FAILED",
-                              error: error,
+                      // Transaction create
+                      Project.transaction(async t => {
+                        try {
+                          if (bodyIsArray) {
+                            // Store with bulk body
+                            const bulkCreated = await Project.bulkCreate(req.body, { transaction: t });
+                            await t.commit();
+                            // @return
+                            res.status(201).json({
+                              code: 201,
+                              status: "CREATE_SUCCESS",
+                              mode: {
+                                type: "BULK",
+                                affectedRows: bulkCreated.length,
+                              },
+                              createdId: [
+                                ...bulkCreated.map(item => (item.id) ? item.id : item[Project.primaryKeyAttributes[0]]),
+                              ],
                             });
                           } else {
-                            // @return with some string error
+                            // Store with single body
+                            const singleCreated = await Project.create(req.body, { transaction: t });
+                            await t.commit();
+                            // @return
+                            res.status(201).json({
+                              code: 201,
+                              status: "CREATE_SUCCESS",
+                              mode: {
+                                type: "SINGLE",
+                                affectedRows: 1,
+                              },
+                              createdId: (singleCreated.id) ? singleCreated.id : singleCreated[Project.primaryKeyAttributes[0]],
+                            });
+                          }
+                        } catch (error) {
+                          await t.rollback();
+                          if(pool.options.logging) {
+                            // @return with all error
                             res.status(501).json({
                               code: 501,
                               status: "CREATE_FAILED",
-                              error: String(error),
+                              mode: {
+                                debug: true,
+                                type: (bodyIsArray) ? "BULK" : "SINGLE",
+                                affectedRows: 0,
+                              },
+                              error: error,
                             });
+                          } else {
+                            if(error.sql) {
+                              delete error.sql;
+                              if(error.errors) {
+                                delete error.errors;
+                              }
+                              if(error.parent) {
+                                delete error.parent;
+                              }
+                              if(error.original) {
+                                delete error.original.sql;
+                                if(error.original.parameters) {
+                                  delete error.original.parameters;
+                                }
+                              }
+                              if(error.parameters) {
+                                delete error.parameters;
+                              }
+                              // @return with some error
+                              res.status(501).json({
+                                code: 501,
+                                status: "CREATE_FAILED",
+                                mode: {
+                                  debug: false,
+                                  type: (bodyIsArray) ? "BULK" : "SINGLE",
+                                  affectedRows: 0,
+                                },
+                                error: error,
+                              });
+                            } else {
+                              // @return with some string error
+                              res.status(501).json({
+                                code: 501,
+                                status: "CREATE_FAILED",
+                                mode: {
+                                  debug: false,
+                                  type: (bodyIsArray) ? "BULK" : "SINGLE",
+                                  affectedRows: 0,
+                                },
+                                error: String(error),
+                              });
+                            }
                           }
                         }
                       });
@@ -350,70 +649,111 @@ function Base() {
                   }
                 });
               });
+
               // PATCH method
-              endpoint.patch("/:hash/:id", (req, res, next) => byPassCheckRole(Projects, "PATCH", passport_config)(req, res, next), async (req, res, next) => {
+              endpoint.patch("/:hash*/:id([a-zA-Z0-9-]+)", (req, res, next) => byPassCheckRole(Projects, "PATCH", passport_config)(req, res, next), async (req, res, next) => {
                 let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
+                let reqUrl = req.originalUrl.replace(_publicPath_, '/');
+                await filterProject(leaveMeAlone, reqUrl, "", "PATCH", req, res, async (err, Project) => {
                   if (!err) {
                     try {
-                      // Leave pool by project for check pool error
-                      let pool = Project.sequelize;
-                      // Assign update pk
-                      let updatePk = {
-                        [Project.primaryKeyAttributes[0]]: req.params.id
-                      };
-                      // Patch with body
-                      await Project.update(req.body, {
-                        where: updatePk,
-                      }).then((updated) => {
-                        // @return
-                        res.status(200).json({
-                          code: 200,
-                          status: "UPDATE_SUCCESS",
-                          result: {
-                            updateId: req.params.id,
-                            affectedRows: updated[0],
+                      // Check body is empty
+                      if(Object.keys(req.body).length === 0) {
+                        return res.status(400).json({
+                          code: 400,
+                          status: "BAD_REQUEST",
+                          message: "Bad request.",
+                          info: {
+                            status: "BAD_ENTIRY",
+                            message: "Unprocessable Entity.",
                           },
                         });
-                      }).catch((error) => {
-                        if(pool.options.logging) {
-                          // @return with all error
-                          res.status(501).json({
-                            code: 501,
-                            status: "UPDATE_FAILED",
-                            error: error,
-                          });
-                        } else {
-                          if(error.sql) {
-                            delete error.sql;
-                            if(error.parent) {
-                              delete error.parent;
-                            }
-                            if(error.original) {
-                              delete error.original.sql;
-                              if(error.original.parameters) {
-                                delete error.original.parameters;
-                              }
-                            }
-                            if(error.parameters) {
-                              delete error.parameters;
-                            }
-                            if(error.errors) {
-                              delete error.errors;
-                            }
-                            // @return with some error
-                            res.status(501).json({
-                              code: 501,
-                              status: "UPDATE_FAILED",
-                              error: error,
+                      }
+                      // Leave pool by project for check pool error
+                      let pool = Project.sequelize;
+                      // Transaction update|patch
+                      Project.transaction(async t => {
+                        try {
+                          // Assign update pk
+                          let updatePk = { [Project.primaryKeyAttributes[0]]: req.params.id };
+                          // Patch with body
+                          const updated = await Project.update(req.body, {
+                            where: updatePk,
+                          }, { transaction: t });
+                          if(updated[0]) {
+                            await t.commit();
+                            // @return
+                            res.status(200).json({
+                              code: 200,
+                              status: "UPDATE_SUCCESS",
+                              mode: {
+                                debug: true,
+                              },
+                              result: {
+                                updateId: req.params.id,
+                                affectedRows: updated[0],
+                              },
                             });
                           } else {
-                            // @return with some string error
+                            await t.rollback();
+                            res.status(406).json({
+                              code: 406,
+                              status: "NOT_ACCEPTABLE",
+                              result: {
+                                affectedRows: updated[0],
+                              },
+                            });
+                          }
+                        } catch (error) {
+                          await t.rollback();
+                          if(pool.options.logging) {
+                            // @return with all error
                             res.status(501).json({
                               code: 501,
                               status: "UPDATE_FAILED",
-                              error: String(error),
+                              mode: {
+                                debug: false,
+                              },
+                              error: error,
                             });
+                          } else {
+                            if(error.sql) {
+                              delete error.sql;
+                              if(error.parent) {
+                                delete error.parent;
+                              }
+                              if(error.original) {
+                                delete error.original.sql;
+                                if(error.original.parameters) {
+                                  delete error.original.parameters;
+                                }
+                              }
+                              if(error.parameters) {
+                                delete error.parameters;
+                              }
+                              if(error.errors) {
+                                delete error.errors;
+                              }
+                              // @return with some error
+                              res.status(501).json({
+                                code: 501,
+                                status: "UPDATE_FAILED",
+                                mode: {
+                                  debug: false,
+                                },
+                                error: error,
+                              });
+                            } else {
+                              // @return with some string error
+                              res.status(501).json({
+                                code: 501,
+                                status: "UPDATE_FAILED",
+                                mode: {
+                                  debug: false,
+                                },
+                                error: String(error),
+                              });
+                            }
                           }
                         }
                       });
@@ -427,81 +767,94 @@ function Base() {
                   }
                 });
               });
+
               // DELETE method
-              endpoint.delete("/:hash/:id", (req, res, next) => byPassCheckRole(Projects, "DELETE", passport_config)(req, res, next), async (req, res, next) => {
+              endpoint.delete("/:hash*/:id([a-zA-Z0-9-]+)", (req, res, next) => byPassCheckRole(Projects, "DELETE", passport_config)(req, res, next), async (req, res, next) => {
                 let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), req, res, async (err, Project) => {
+                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), "", "DELETE", req, res, async (err, Project) => {
                   if (!err) {
                     try {
                       // Leave pool by project for check pool error
                       let pool = Project.sequelize;
-                      // Assign delete pk
-                      let deletePk = {
-                        [Project.primaryKeyAttributes[0]]: req.params.id
-                      };
-                      // Delete with params
-                      await Project.destroy({
-                        where: deletePk,
-                      }).then((deleted) => {
-                        if (deleted) {
-                          // @return
-                          res.status(200).json({
-                            code: 200,
-                            status: "DELETE_SUCCESS",
-                            result: {
-                              deleteId: req.params.id,
-                              affectedRows: deleted,
-                            },
-                          });
-                        } else {
-                          res.status(406).json({
-                            code: 406,
-                            status: "NOT_ACCEPTABLE",
-                            result: {
-                              deleteId: req.params.id,
-                              affectedRows: deleted,
-                            },
-                          });
-                        }
-                      }).catch((error) => {
-                        if(pool.options.logging) {
-                          // @return with all error
-                          res.status(501).json({
-                            code: 501,
-                            status: "DELETE_FAILED",
-                            error: error,
-                          });
-                        } else {
-                          if(error.sql) {
-                            delete error.sql;
-                            if(error.parent) {
-                              delete error.parent;
-                            }
-                            if(error.original) {
-                              delete error.original.sql;
-                              if(error.original.parameters) {
-                                delete error.original.parameters;
-                              }
-                            }
-                            if(error.parameters) {
-                              delete error.parameters;
-                            }
-                            if(error.errors) {
-                              delete error.errors;
-                            }
-                            // @return with some error
-                            res.status(501).json({
-                              code: 501,
-                              status: "DELETE_FAILED",
-                              error: error,
+                      // Transaction update|patch
+                      Project.transaction(async t => {
+                        try {
+                          // Assign delete pk
+                          let deletePk = { [Project.primaryKeyAttributes[0]]: req.params.id };
+                          // Delete with params
+                          const deleted = await Project.destroy({
+                            where: deletePk,
+                          }, { transaction: t });
+                          if (deleted) {
+                            await t.commit();
+                            // @return
+                            res.status(200).json({
+                              code: 200,
+                              status: "DELETE_SUCCESS",
+                              result: {
+                                deleteId: req.params.id,
+                                affectedRows: deleted,
+                              },
                             });
                           } else {
-                            // @return with some string error
+                            await t.rollback();
+                            res.status(406).json({
+                              code: 406,
+                              status: "NOT_ACCEPTABLE",
+                              result: {
+                                affectedRows: deleted,
+                              },
+                            });
+                          }
+                        } catch (error) {
+                          if(pool.options.logging) {
+                            // @return with all error
                             res.status(501).json({
                               code: 501,
                               status: "DELETE_FAILED",
-                              error: String(error),
+                              mode: {
+                                debug: true,
+                              },
+                              error: error,
                             });
+                          } else {
+                            if(error.sql) {
+                              delete error.sql;
+                              if(error.parent) {
+                                delete error.parent;
+                              }
+                              if(error.original) {
+                                delete error.original.sql;
+                                if(error.original.parameters) {
+                                  delete error.original.parameters;
+                                }
+                              }
+                              if(error.parameters) {
+                                delete error.parameters;
+                              }
+                              if(error.errors) {
+                                delete error.errors;
+                              }
+                              // @return with some error
+                              res.status(501).json({
+                                code: 501,
+                                status: "DELETE_FAILED",
+                                mode: {
+                                  debug: false,
+                                },
+                                error: error,
+                              });
+                            } else {
+                              // @return with some string error
+                              res.status(501).json({
+                                code: 501,
+                                status: "DELETE_FAILED",
+                                mode: {
+                                  debug: false,
+                                },
+                                error: String(error),
+                              });
+                            }
                           }
                         }
                       });