Convert package to file, some simple improvements

src/utils/mongoose-api-query.js

@@ -0,0 +1,206 @@
+export default function apiQueryPlugin(schema) {
+
+  schema.statics.apiQuery = function (rawParams, cb) {
+    const model = this;
+    const params = model.apiQueryParams(rawParams);
+
+    let // Create the Mongoose Query object.
+      query = model
+        .find(params.searchParams)
+        .limit(params.per_page)
+        .skip((params.page - 1) * params.per_page);
+
+    if (params.sort) query = query.sort(params.sort);
+
+    if (cb) {
+      query.exec(cb);
+    } else {
+      return query;
+    }
+  };
+
+  schema.statics.apiQueryParams = function (rawParams) {
+    const model = this;
+
+    const convertToBoolean = str => {
+      if (str.toLowerCase() === 'true' ||
+        str.toLowerCase() === 't' ||
+        str.toLowerCase() === 'yes' ||
+        str.toLowerCase() === 'y' ||
+        str === '1') {
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    //changed
+    const searchParams = {};
+
+    let query;
+    let page = 1;
+    let per_page = 100;
+    let sort = false;
+
+    const parseSchemaForKey = (schema, keyPrefix, lcKey, val, operator) => {
+
+      let paramType = false;
+
+      const addSearchParam = val => {
+        const key = keyPrefix + lcKey;
+
+        if (typeof searchParams[key] !== 'undefined') {
+          for (i in val) {
+            searchParams[key][i] = val[i];
+          }
+        } else {
+          searchParams[key] = val;
+        }
+      };
+
+      let matches = lcKey.match(/(.+)\.(.+)/);
+      if (matches) {
+        // parse subschema
+        if (schema.paths[matches[1]].constructor.name === 'DocumentArray' ||
+          schema.paths[matches[1]].constructor.name === 'Mixed') {
+          parseSchemaForKey(schema.paths[matches[1]].schema, `${matches[1]}.`, matches[2], val, operator)
+        }
+
+      } else if (typeof schema === 'undefined') {
+        paramType = 'String';
+
+      } else if (typeof schema.paths[lcKey] === 'undefined') {
+        // nada, not found
+      } else if (operator === 'near') {
+        paramType = 'Near';
+      } else if (schema.paths[lcKey].constructor.name === 'SchemaBoolean') {
+        paramType = 'Boolean';
+      } else if (schema.paths[lcKey].constructor.name === 'SchemaString') {
+        paramType = 'String';
+      } else if (schema.paths[lcKey].constructor.name === 'SchemaNumber') {
+        paramType = 'Number';
+      } else if (schema.paths[lcKey].constructor.name === 'ObjectId') {
+        paramType = 'ObjectId';
+      }//changed
+      else if (schema.paths[lcKey].constructor.name === 'SchemaArray') {
+        paramType = 'Array';
+      }
+
+      if (paramType === 'Boolean') {
+        addSearchParam(convertToBoolean(val));
+      } else if (paramType === 'Number') {
+        if (val.match(/([0-9]+,?)/) && val.match(',')) {
+          if (operator === 'all') {
+            addSearchParam({ $all: val.split(',') });
+          } else if (operator === 'nin') {
+            addSearchParam({ $nin: val.split(',') });
+          } else if (operator === 'mod') {
+            addSearchParam({ $mod: [val.split(',')[0], val.split(',')[1]] });
+          } else {
+            addSearchParam({ $in: val.split(',') });
+          }
+        } else if (val.match(/([0-9]+)/)) {
+          if (operator === 'gt' ||
+            operator === 'gte' ||
+            operator === 'lt' ||
+            operator === 'lte' ||
+            operator === 'ne') {
+            var newParam = {};
+            newParam[`$${operator}`] = val;
+            addSearchParam(newParam);
+          } else {//changed
+            addSearchParam(parseInt(val));
+          }
+        }
+      } else if (paramType === 'String') {
+        if (val.match(',')) {
+          const options = val.split(',').map(str => new RegExp(str, 'i'));
+
+          if (operator === 'all') {
+            addSearchParam({ $all: options });
+          } else if (operator === 'nin') {
+            addSearchParam({ $nin: options });
+          } else {
+            addSearchParam({ $in: options });
+          }
+        } else if (val.match(/([0-9]+)/)) {
+          if (operator === 'gt' ||
+            operator === 'gte' ||
+            operator === 'lt' ||
+            operator === 'lte') {
+            var newParam = {};
+            newParam[`$${operator}`] = val;
+            addSearchParam(newParam);
+          } else {
+            addSearchParam(val);
+          }
+        } else if (operator === 'ne' || operator === 'not') {
+          const neregex = new RegExp(val, 'i');
+          addSearchParam({ '$not': neregex });
+        } else if (operator === 'exact') {
+          addSearchParam(val);
+        } else {
+          addSearchParam({ $regex: val, $options: '-i' });
+        }
+      } else if (paramType === 'Near') {
+        // divide by 69 to convert miles to degrees
+        const latlng = val.split(',');
+        const distObj = { $near: [parseFloat(latlng[0]), parseFloat(latlng[1])] };
+        if (typeof latlng[2] !== 'undefined') {
+          distObj.$maxDistance = parseFloat(latlng[2]) / 69;
+        }
+        addSearchParam(distObj);
+      } else if (paramType === 'ObjectId') {
+        addSearchParam(val);
+      } else if (paramType === 'Array') {
+        addSearchParam(val);
+        console.log(lcKey)
+
+      }
+
+    };
+
+    const parseParam = (key, val) => {
+      const lcKey = key;
+      let operator = val.match(/\{(.*)\}/);
+      var val = val.replace(/\{(.*)\}/, '');
+
+      if (operator) operator = operator[1];
+
+      if (val === '') {
+        return;
+      } else if (lcKey === 'page') {
+        page = val;
+      } else if (lcKey === 'per_page') {
+        per_page = parseInt(val);
+      } else if (lcKey === 'sort_by') {
+        const parts = val.split(',');
+        sort = {};
+        sort[parts[0]] = parts.length > 1 ? parts[1] : 1;
+      } else {
+        parseSchemaForKey(model.schema, '', lcKey, val, operator);
+      }
+    };
+
+    // Construct searchParams
+    for (const key in rawParams) {
+      const separatedParams = rawParams[key].match(/\{\w+\}(.[^\{\}]*)/g);
+
+      if (separatedParams === null) {
+        parseParam(key, rawParams[key]);
+      } else {
+        for (var i = 0, len = separatedParams.length; i < len; ++i) {
+          parseParam(key, separatedParams[i]);
+        }
+      }
+    }
+
+    return {
+      searchParams,
+      page,
+      per_page,
+      sort
+    };
+  };
+
+}