Updated Fork from original, Given a Mongoose model and an array of URI params, construct a query for use in a search API. 

hodaraadam

mongoose-string-query

module.exports = exports = function apiQueryPlugin (schema) {

  schema.statics.apiQuery = function(rawParams, cb) {

      , params = model.apiQueryParams(rawParams);

    query = model.find(params.searchParams).limit(params.per_page).skip((params.page - 1) * params.per_page)

    if (params.sort) query = query.sort(params.sort)

  schema.statics.apiQueryParams = function(rawParams) {

    var convertToBoolean = function (str) {

      if (str.toLowerCase() === "true" ||

    var parseSchemaForKey = function (schema, keyPrefix, lcKey, val, operator) {

      var addSearchParam = function (val) {

        if (typeof searchParams[key] !== 'undefined') {

            searchParams[key][i] = val[i];

      if (matches = lcKey.match(/(.+)\.(.+)/)) {

        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") {

      } else if (typeof schema.paths[lcKey] === "undefined"){

      } else if (schema.paths[lcKey].constructor.name === "SchemaBoolean") {

      } else if (schema.paths[lcKey].constructor.name === "SchemaString") {

      } else if (schema.paths[lcKey].constructor.name === "SchemaNumber") {

      } else if (schema.paths[lcKey].constructor.name === "ObjectId") {

       else if (schema.paths[lcKey].constructor.name === "SchemaArray") {

      } else if (schema.paths[lcKey].constructor.name === "SchemaArray") {

        addSearchParam(convertToBoolean(val));

      } else if (paramType === "Number") {

        if (val.match(/([0-9]+,?)/) && val.match(',')) {

            addSearchParam({$all: val.split(',')});

          } else if (operator === "nin") {

            addSearchParam({$nin: val.split(',')});

          } else if (operator === "mod") {

            addSearchParam({$mod: [val.split(',')[0], val.split(',')[1]]});

            addSearchParam({$in: val.split(',')});

        } else if (val.match(/([0-9]+)/)) {

            newParam["$" + operator] = val;

            addSearchParam(parseInt(val));

      } else if (paramType === "String") {

          var options = val.split(',').map(function(str){

            addSearchParam({$all: options});

            addSearchParam({$nin: options});

            addSearchParam({$in: options});

        } else if (operator === "ne" || operator === "not") {

          var neregex = new RegExp(val,"i");

          addSearchParam({'$not': neregex});

        } else if (operator === "exact") {

          addSearchParam({$regex: val, $options: "-i"});

        // divide by 69 to convert miles to degrees

        var distObj = {$near: [parseFloat(latlng[0]), parseFloat(latlng[1])]};

        if (typeof latlng[2] !== 'undefined') {

          distObj.$maxDistance = parseFloat(latlng[2]) / 69;

      } else if (paramType === "ObjectId") {

      } else if (paramType === "Array") {

    var parseParam = function (key, val) {

        , operator = val.match(/\{(.*)\}/)

        , val = val.replace(/\{(.*)\}/, '');

      if (operator) operator = operator[1];

        sort[parts[0]] = parts.length > 1 ? parts[1] : 1;

        parseSchemaForKey(model.schema, "", lcKey, val, operator);

      var separatedParams = rawParams[key].match(/\{\w+\}(.[^\{\}]*)/g);

        for (var i = 0, len = separatedParams.length; i < len; ++i) {

          parseParam(key, separatedParams[i]);

  "author": "Adam Hodara <hodaraadam@gmail.com>",

  "description": "Updated Fork from original, Given a Mongoose model and an array of URI params, construct a query for use in a search API.",

  "keywords": ["mongoose", "query", "search", "parameters"],

    "pretest": "node load_fixtures.js; node app.js",

  "homepage": "https://github.com/surfer77/mongoose-query"

This is a fork and updated package to work with current versions of express and mongoose from the 4 year old deprecated and unresponsive mongoose-api-query package

This is a working and updated fork from the great mongoose-api-query package that is deprecated and hasn't been updated for 3 years.

If you use Mongoose to help serve results for API calls, you might be used to handling calls like:

    /monsters?color=purple&eats_humans=true

mongoose-query handles some of that busywork for you. Pass in a vanilla object (e.g. req.query) and query conditions will be cast to their appropriate types according to your Mongoose schema. For example, if you have a boolean defined in your schema, we'll convert the `eats_humans=true` to a boolean for searching.

It also adds a ton of additional search operators, like `less than`, `greater than`, `not equal`, `near` (for geosearch), `in`, and `all`. You can find a full list below.

When searching strings, by default it does a partial, case-insensitive match. (Which is not the default in MongoDB.)

Apply the plugin to any schema in the usual Mongoose fashion:

Then call it like you would using `Model.find`. This returns a Mongoose.Query:

Or pass a callback in and it will run `.exec` for you:

Monster.apiQuery(req.query, function(err, monsters){...

const mongooseApiQuery = require('mongoose-query')

const mongooseApiQuery = require('mongoose-string-query')

`t`, `y`, and `1` are all aliases for `true`:

Matches only where `kale` and `beets` are both present:

geo near, with (optional) radius in miles:

/monsters?latlon={near}38.8977,-77.0366,10

/monsters?page=4&per_page=25 		// per_page defaults to 10

Do you have a property defined in your schema like `data: {}`, that can have anything inside it? You can search that, too, and it will be treated as a string.

This is a list of the optional search operators you can use for each SchemaType.

- `number={all}123,456` - Both 123 and 456 must be present

- `number={nin}123,456` - Neither 123 nor 456

- `number={in}123,456` - Either 123 or 456

- `number={mod}10,2` - Where (number / 10) has remainder 2

- `string={all}match,batch` - Both match *and* batch must be present

- `string={nin}match,batch` - Neither match nor batch

- `string={in}match,batch` - Either match or batch

- `string={exact}CoFeEe` - Case-sensitive exact match of "CoFeEe"

- `latlon={near}37,-122,5` Near 37,-122, with a 5 mile max radius

- `latlon={near}37,-122` Near 37,-122, no radius limit. Automatically sorts by distance

		@@ -34,3 +34,2 @@ module.exports = exports = function apiQueryPlugin (schema) {

		//changed
		var searchParams = {}
		@@ -80,4 +79,3 @@ , query
		paramType = "ObjectId";
		}//changed
		else if (schema.paths[lcKey].constructor.name === "SchemaArray") {
		} else if (schema.paths[lcKey].constructor.name === "SchemaArray") {
		paramType = "Array";
		@@ -108,3 +106,3 @@ }
		addSearchParam(newParam);
		} else {//changed
		} else {
		addSearchParam(parseInt(val));
		@@ -157,3 +155,2 @@ }
		addSearchParam(val);
		console.log(lcKey )

		@@ -160,0 +157,0 @@ }

		{
		"name": "mongoose-string-query",
		"version": "0.1.5pre",
		"version": "0.1.7",
		"author": "Adam Hodara <hodaraadam@gmail.com>",
		@@ -5,0 +5,0 @@ "description": "Updated Fork from original, Given a Mongoose model and an array of URI params, construct a query for use in a search API.",

Improved metrics

Worsened metrics

		## Overview

		This is a fork and updated package to work with current versions of express and mongoose from the 4 year old deprecated and unresponsive mongoose-api-query package
		This is a working and updated fork from the great mongoose-api-query package that is deprecated and hasn't been updated for 3 years.


		If you use Mongoose to help serve results for API calls, you might be used to handling calls like:
		@@ -38,4 +37,7 @@

		const mongooseApiQuery = require('mongoose-query')
		```
		const mongooseApiQuery = require('mongoose-string-query')

		```

		`t`, `y`, and `1` are all aliases for `true`:
		@@ -42,0 +44,0 @@