beech-api 3.8.0 → 3.9.75

package/packages/lib/src/endpoint.js

@@ -1,532 +1,947 @@
-const walk = require("walk");
-const fs = require("fs");
-const { checkRoleMiddlewareWithDefaultProject } = require("../../cli/core/middleware/express/jwtCheckAllow");
-
-function walkModel(cb) {
-  try {
-    let jsfiles = [];
-    let walker = walk.walk(appRoot + "/src/models", { followLinks: false });
-    // Walk file on push
-    walker.on("file", (root, stat, next) => {
-      jsfiles.push(root + "/" + stat.name);
-      next();
-    });
-    // Walking
-    walker.on("end", () => {
-      let preProject = [];
-      if(jsfiles.length) {
-        jsfiles.forEach((file, k) => {
-          let schemaPath = "@/models" + file.split("models")[1].replace(/\\/g, "/");
-          let endpoint = file
-            .split("models")[1]
-            .replace(/\\/g, "/")
-            .replace(/_/g, "-")
-            .toLowerCase()
-            .slice(0, -3);
-          preProject.push([schemaPath, endpoint]);
-          if (jsfiles.length == k + 1) {
-            cb(null, preProject);
-          }
-        });
-      } else {
-        // model not found.
-        cb(null, preProject);
-      }
-    });
-  } catch (error) {
-    cb(error, null);
-  }
-}
-
-function filterProject(Projects, reqUrl, req, res, cb) {
-  try {
-    let pj = Projects.shift();
-    let regx = new RegExp(pj[1] + "?[^\/].?[a-zA-Z0-9].*$", 'g');
-    let regxMatch = reqUrl.match(regx);
-    let regxMatchLength = (regxMatch) ? regxMatch.length: 0;
-    if (pj[1] == reqUrl) {
-      return checkOffset(Object.values(require(pj[0]))[0], req, res, (thenChecked) => {
-        if(thenChecked) {
-          return cb(null, Object.values(require(pj[0]))[0]);
-        }
-      });
-    } else if(regxMatchLength) {
-      return checkOffset(Object.values(require(pj[0]))[0], req, res, (thenChecked) => {
-        if(thenChecked) {
-          return cb(null, Object.values(require(pj[0]))[0]);
-        }
-      });
-    }
-    // Finally recursive filterProject function
-    if (Projects.length > 0) {
-      filterProject(Projects, reqUrl, req, res, cb);
-    } else {
-      // not match
-      return notfound(res);
-    }
-  } catch (error) {
-    cb(error, null);
-  }
-}
-
-function checkOffset(Project, req, res, cb) {
-  if (!Project) {
-    return notfound(res);
-  }
-  // check offset is Ingeter as well as Zero number
-  let offset = req.params.offset || undefined;
-  let limit = req.params.limit || undefined;
-  let offsetRegxMatch = (offset !== undefined) ? offset.match(/^[0-9]+$/) : undefined;
-  let limitRegxMatch = (limit !== undefined) ? limit.match(/^[0-9]+$/) : undefined;
-  if (offsetRegxMatch && limitRegxMatch) {
-    cb(true);
-  } else {
-    if(offset === undefined) {
-      cb(true);
-    } else {
-      return notfound(res);
-    }
-  }
-}
-
-function notfound(res) {
-  return res.status(404).json({
-    code: 404,
-    status: "404_NOT_FOUND",
-    message: "The Endpoint not found!.",
-  });
-}
-
-function errMessage(err, res) {
-  let errTurnOffDbDefine = JSON.stringify(err.toString()).match(/'define'/);
-  let errTurnOffDbOption = JSON.stringify(err.toString()).match(/'options'/);
-  if(errTurnOffDbDefine || errTurnOffDbOption) {
-    // @return
-    return res.status(500).json({
-      code: 500,
-      status: "ERR_INTERNAL_SERVER",
-      message: "Database connection name is CLOSED.",
-    });
-  } else {
-    // @return
-    return res.status(500).json({
-      code: 500,
-      status: "ERR_INTERNAL_SERVER",
-      message: err.toString(),
-    });
-  }
-}
-
-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);
-                });
-              } 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);
-                  });
-                }
-              }
-            } else {
-              return errMessage(err, res);
-            }
-          });
-        } else {
-          // global jwt_allow is false
-          return next();
-        }
-      }
-    }
-  }
-}
-
-function Base() {
-  return new Promise((resolve, reject) => {
-    try {
-      walkModel((err, Projects) => {
-        if (err) {
-          reject(err);
-        } else {
-          const checkPassport = new Promise((resolve) => {
-            const passport_config_file = appRoot + "/passport.config.js";
-            let passport_config_auth = undefined;
-            if (fs.existsSync(passport_config_file)) {
-              const _passport_config_ = require(passport_config_file);
-              resolve([_passport_config_.auth_endpoint || "/authentication", _passport_config_]);
-            } else {
-              // passport config not found
-              resolve([passport_config_auth, _passport_config_]);
-            }
-          });
-          // 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 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);
-                  }
-                });
-              });
-              // POST method
-              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, "")) {
-                    return next();
-                  }
-                }
-                // When lost IF
-                let leaveMeAlone = await Projects.slice(0);
-                await filterProject(leaveMeAlone, req.originalUrl.replace(_publicPath_, '/'), 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,
-                            });
-                          } else {
-                            // @return with some string error
-                            res.status(501).json({
-                              code: 501,
-                              status: "CREATE_FAILED",
-                              error: String(error),
-                            });
-                          }
-                        }
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
-              });
-              // PATCH method
-              endpoint.patch("/:hash/:id", (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) => {
-                  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],
-                          },
-                        });
-                      }).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,
-                            });
-                          } else {
-                            // @return with some string error
-                            res.status(501).json({
-                              code: 501,
-                              status: "UPDATE_FAILED",
-                              error: String(error),
-                            });
-                          }
-                        }
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
-              });
-              // DELETE method
-              endpoint.delete("/:hash/:id", (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) => {
-                  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,
-                            });
-                          } else {
-                            // @return with some string error
-                            res.status(501).json({
-                              code: 501,
-                              status: "DELETE_FAILED",
-                              error: String(error),
-                            });
-                          }
-                        }
-                      });
-                    } catch (error) {
-                      // @return
-                      return errMessage(error, res);
-                    }
-                  } else {
-                    // @return
-                    return errMessage(err, res);
-                  }
-                });
-              });
-            }
-            // resolve it.
-            resolve(true);
-          }).catch((err) => {
-            reject(err);
-          });
-        }
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-
-module.exports = { Base };
+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 {
+    let jsfiles = [];
+    let walker = walk.walk(appRoot + "/src/models", { followLinks: false });
+    // Walk file on push
+    walker.on("file", (root, stat, next) => {
+      jsfiles.push(root + "/" + stat.name);
+      next();
+    });
+    // Walking
+    walker.on("end", () => {
+      let preProject = [];
+      if(jsfiles.length) {
+        jsfiles.forEach((file, k) => {
+          let schemaPath = "@/models" + file.split("models")[1].replace(/\\/g, "/");
+          let endpoint = file
+            .split("models")[1]
+            .replace(/\\/g, "/")
+            .replace(/_/g, "-")
+            .toLowerCase()
+            .slice(0, -3);
+          preProject.push([schemaPath, endpoint]);
+          if (jsfiles.length == k + 1) {
+            cb(null, preProject);
+          }
+        });
+      } else {
+        // model not found.
+        cb(null, preProject);
+      }
+    });
+  } catch (error) {
+    cb(error, null);
+  }
+}
+
+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');
+    let regxMatch = reqUrl.match(regx);
+    let regxMatchLength = (regxMatch) ? regxMatch.length: 0;
+    if (pj[1] == reqUrl) {
+      return checkOffset(Object.values(require(pj[0]))[0], req, res, (thenChecked) => {
+        if(thenChecked) {
+          return cb(null, Object.values(require(pj[0]))[0]);
+        }
+      });
+    } else if(regxMatchLength) {
+      return checkOffset(Object.values(require(pj[0]))[0], req, res, (thenChecked) => {
+        if(thenChecked) {
+          return cb(null, Object.values(require(pj[0]))[0]);
+        }
+      });
+    }
+    // Finally recursive filterProjectForByPass function
+    if (Projects.length > 0) {
+      filterProjectForByPass(Projects, reqUrl, req, res, cb);
+    } else {
+      // not match
+      return notfound(res);
+    }
+  } catch (error) {
+    cb(error, null);
+  }
+}
+
+function checkOffset(Project, req, res, cb) {
+  if (!Project) {
+    return notfound(res);
+  }
+  // check offset is Ingeter as well as Zero number
+  let offset = req.params.offset || undefined;
+  let limit = req.params.limit || undefined;
+  let offsetRegxMatch = (offset !== undefined) ? offset.match(/^[0-9]+$/) : undefined;
+  let limitRegxMatch = (limit !== undefined) ? limit.match(/^[0-9]+$/) : undefined;
+  if (offsetRegxMatch && limitRegxMatch) {
+    cb(true);
+  } else {
+    if(offset === undefined) {
+      cb(true);
+    } else {
+      return notfound(res);
+    }
+  }
+}
+
+function notfound(res) {
+  return res.status(404).json({
+    code: 404,
+    status: "404_NOT_FOUND",
+    message: "The Endpoint not found!.",
+  });
+}
+
+function errMessage(err, res) {
+  let errTurnOffDbDefine = JSON.stringify(err.toString()).match(/'define'/);
+  let errTurnOffDbOption = JSON.stringify(err.toString()).match(/'options'/);
+  if(errTurnOffDbDefine || errTurnOffDbOption) {
+    // @return
+    return res.status(500).json({
+      code: 500,
+      status: "ERR_INTERNAL_SERVER",
+      message: "Database connection name is CLOSED.",
+    });
+  } else {
+    // @return
+    return res.status(500).json({
+      code: 500,
+      status: "ERR_INTERNAL_SERVER",
+      message: err.toString(),
+    });
+  }
+}
+
+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);
+          return;
+        } 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);
+          return;
+        } else {
+          let group = JSON.parse(strArr);
+          groupBy[k] = group.length ? group : null;
+          // Recursive re-call function
+          recursiveWhereCond(keys, objectCond, where, groupBy, orderBy, cb);
+        }
+      });
+    } else {
+      // 1. Get raw value, force to String and replace %22 to double quote "
+      let rawInput = objectCond[k];
+      if (Array.isArray(rawInput)) {
+        rawInput = rawInput.join(",");
+      }
+      let decodedQueryString = String(rawInput).replace(/%22/g, '"').replace(/'/g, '"');
+      // 2. Advanced decoding logic (works for all operations like LIKE, EQUAL, IN, BETWEEN)
+      // Force to look for groups of language codes (% followed by two hexadecimal digits like %E0, %B8)
+      // It will capture consecutive codes as a single group and decode them together for accuracy
+      decodedQueryString = decodedQueryString.replace(/(?:%[0-9A-F]{2})+/gi, (match) => {
+        try {
+          return decodeURIComponent(match);
+        } catch (e) {
+          // This fallback will attempt to decode each %XX sequence individually, which can help recover partial decoding even if the full group is malformed
+          return match.replace(/%([0-9A-F]{2})/gi, (subMatch) => {
+            try { return decodeURIComponent(subMatch); } catch { return subMatch; }
+          });
+        }
+      });
+      // 3. Special handling for BETWEEN and NOT BETWEEN operations to ensure date formats are preserved correctly
+      let isBetweenOp = decodedQueryString.toLowerCase().includes('between') || decodedQueryString.toLowerCase().includes('notbetween');
+      if (isBetweenOp) {
+        try {
+          let arrayMatch = decodedQueryString.match(/\[\s*(between|notbetween)\s*,\s*(\[.*\])\s*\]/i);
+          if (arrayMatch && arrayMatch[2]) {
+            let op = arrayMatch[1];
+            let dateArrayStr = arrayMatch[2];
+            if (!dateArrayStr.includes('"')) {
+              dateArrayStr = dateArrayStr.replace(/([^\[\],]+)/g, '"$1"');
+            }
+            let parsedDates = JSON.parse(dateArrayStr);
+            if (Array.isArray(parsedDates) && parsedDates.length >= 2) {
+              // Trim and remove any extraneous quotes from the parsed date strings
+              let dateStart = parsedDates[0].trim().replace(/"/g, '');
+              let dateEnd = parsedDates[1].trim().replace(/"/g, '');
+              // Ensure that if the date string is in a format like "2026-05-17 00:00:00", it is converted to "2026-05-17T00:00:00" for proper Date parsing
+              dateStart = dateStart.replace(' ', 'T');
+              dateEnd = dateEnd.replace(' ', 'T');
+              decodedQueryString = `[${op},${dateStart},${dateEnd}]`;
+            }
+          }
+        } catch (err) {
+          cb(["SyntaxError: Invalid format for BETWEEN/NOT BETWEEN operation", ` (${k})`], null, null, null);
+          return;
+        }
+      }
+      // 4. Format the decoded query string to prepare for Sequelize operators
+      let fieldValueItemFromQueryString = decodedQueryString.replace(/([^[\]," ]+)/g, '"$1"').replace(/""/g, '"');
+      let valueItem = decodedQueryString.replace(/[\[\]']+/g, '').replace(/"/g, '').split(',');
+      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);
+          return;
+        } else {
+          try {
+            let targetValue = cleanValueItem[1];
+            if (cleanValueItem[0] === 'like' || cleanValueItem[0] === 'notLike') {
+              targetValue = cleanValueItem.slice(1).join("");
+            }
+            where[k] = (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')
+                                                    ? (() => {
+                                                        let mDate = moment(cleanValueItem[1]);
+                                                        if (cleanValueItem[1].length <= 10 && !cleanValueItem[1].includes(':')) {
+                                                          mDate.startOf('day');
+                                                        }
+                                                        return mDate.format('YYYY-MM-DD HH:mm:ss');
+                                                      })()
+                                                    : cleanValueItem[1],
+                                                  (getValueType(cleanValueItem[2]) == 'Date')
+                                                    ? (() => {
+                                                        let mDate = moment(cleanValueItem[2]);
+                                                        if (cleanValueItem[2].length <= 10 && !cleanValueItem[2].includes(':')) {
+                                                          mDate.endOf('day');
+                                                        }
+                                                        return mDate.format('YYYY-MM-DD HH:mm:ss');
+                                                      })()
+                                                    : cleanValueItem[2],
+                                                ] :
+                                                (cleanValueItem[0] == 'or' || cleanValueItem[0] == 'in' || cleanValueItem[0] == 'notIn') ? [...cleanValueItem.slice(1)] :
+                                                (cleanValueItem[0] == 'like') ? targetValue :
+                                                (cleanValueItem[0] == 'notLike') ? targetValue :
+                                                (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 {
+                // @ return findAll
+                res.json({
+                  code: 200,
+                  status: "SUCCESS",
+                  results,
+                  length: results.length,
+                  limitRow,
+                });
+              }
+            });
+          } catch (error) {
+            // @return
+            return errMessage(error, res);
+          }
+        } else {
+          // @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);
+    }
+  }
+}
+
+function Base() {
+  return new Promise((resolve, reject) => {
+    try {
+      walkModel((err, Projects) => {
+        if (err) {
+          reject(err);
+        } else {
+          const checkPassport = new Promise((resolve) => {
+            const passport_config_file = appRoot + "/passport.config.js";
+            let passport_config_auth = undefined;
+            if (fs.existsSync(passport_config_file)) {
+              const _passport_config_ = require(passport_config_file);
+              resolve([_passport_config_.auth_endpoint || "/authentication", _passport_config_]);
+            } else {
+              // passport config not found
+              resolve([passport_config_auth, {}]);
+            }
+          });
+          // passport conifg promise
+          checkPassport.then((passport_config) => {
+            if(Projects.length) {
+              // 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 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) => {
+                // Check auth request match send next
+                if(passport_config[0] !== undefined) {
+                  if(req.params.hash == passport_config[0].replace(/^\/|\/$/g, "")) {
+                    return next();
+                  }
+                }
+                // When lost IF
+                let leaveMeAlone = await Projects.slice(0);
+                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;
+                      // 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 {
+                            // 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",
+                              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),
+                              });
+                            }
+                          }
+                        }
+                      });
+                    } catch (error) {
+                      // @return
+                      return errMessage(error, res);
+                    }
+                  } else {
+                    // @return
+                    return errMessage(err, res);
+                  }
+                });
+              });
+
+              // PATCH method
+              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);
+                let reqUrl = req.originalUrl.replace(_publicPath_, '/');
+                await filterProject(leaveMeAlone, reqUrl, "", "PATCH", req, res, async (err, Project) => {
+                  if (!err) {
+                    try {
+                      // 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.",
+                          },
+                        });
+                      }
+                      // 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 {
+                            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",
+                              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),
+                              });
+                            }
+                          }
+                        }
+                      });
+                    } catch (error) {
+                      // @return
+                      return errMessage(error, res);
+                    }
+                  } else {
+                    // @return
+                    return errMessage(err, res);
+                  }
+                });
+              });
+
+              // DELETE method
+              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_, '/'), "", "DELETE", req, res, async (err, Project) => {
+                  if (!err) {
+                    try {
+                      // Leave pool by project for check pool error
+                      let pool = Project.sequelize;
+                      // 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 {
+                            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",
+                              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),
+                              });
+                            }
+                          }
+                        }
+                      });
+                    } catch (error) {
+                      // @return
+                      return errMessage(error, res);
+                    }
+                  } else {
+                    // @return
+                    return errMessage(err, res);
+                  }
+                });
+              });
+            }
+            // resolve it.
+            resolve(true);
+          }).catch((err) => {
+            reject(err);
+          });
+        }
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+module.exports = { Base };