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

package/packages/lib/src/endpoint.js

@@ -1,5 +1,6 @@
 const walk = require("walk");
 const fs = require("fs");
+const moment = require("moment");
 const { checkRoleMiddlewareWithDefaultProject } = require("../../cli/core/middleware/express/jwtCheckAllow");
 
 function walkModel(cb) {
@@ -38,7 +39,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 +89,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,6 +149,247 @@ function errMessage(err, res) {
   }
 }
 
+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 {
+                // @ 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);
+        }
+      });
+    }
+  });
+}
+
 const byPassCheckRole = (Projects, method, passport_config) => {
   return async function (req, res, next) {
     if(passport_config[0] !== undefined) {
@@ -125,7 +398,7 @@ const byPassCheckRole = (Projects, method, passport_config) => {
       } 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) => {
+          await filterProjectForByPass(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
@@ -145,13 +418,17 @@ const byPassCheckRole = (Projects, method, passport_config) => {
                       });
                     }
                   } else {
+                    // METHOD.allow is false || METHOD.allow is undefined
                     return notfound(res);
                   }
-                } else {
+                } 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 {
@@ -163,6 +440,9 @@ const byPassCheckRole = (Projects, method, passport_config) => {
           return next();
         }
       }
+    } else {
+      // passport config not found
+      return next();
     }
   }
 }
@@ -182,101 +462,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 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/: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 :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,7 +488,8 @@ 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_, '/');
+                await filterProject(leaveMeAlone, reqUrl, "", "", req, res, async (err, Project) => {
                   if (!err) {
                     try {
                       // Leave pool by project for check pool error
@@ -350,18 +554,18 @@ 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
-                      };
+                      let updatePk = { [Project.primaryKeyAttributes[0]]: req.params.id };
                       // Patch with body
                       await Project.update(req.body, {
                         where: updatePk,
@@ -427,18 +631,17 @@ 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
-                      };
+                      let deletePk = { [Project.primaryKeyAttributes[0]]: req.params.id };
                       // Delete with params
                       await Project.destroy({
                         where: deletePk,

package/packages/lib/src/schema.js

@@ -5,9 +5,12 @@ function Schema(Sequelize) {
     define: (table, schemaProps = {}, elementProps = {}) => {
       try {
         let Project = Sequelize.define(table, schemaProps, elementProps);
+        //Sequelize.options.charset = "utf8";
+        //Sequelize.options.define.charset = "utf8";
+        //Sequelize.options.define.dialectOptions.collate = "utf8_unicode_ci";
         return Object.assign(Project, {
           query: (
-            rawSql,
+            rawSql = "",
             props = {
               model: Project,
               mapToModel: false,