human-to-mongo-query v1.2.0

Mapping more-or-less human-readeable query language to native MongoDB queries.

Example

const mapQuery = require('human-to-mongo-queries');


const query = {
  firstName: 'John',
  lastName: { notEqualTo: 'Doe' },
  age: {
    any: [
      20,
      { lessThan: 55 },
      { greaterThan: 5 },
      { lessThanOrEquals: 45 },
      { greaterThanOrEquals: 15 },
      { in: [16, 26, 32] },
      { notIn: [17, 27, 33] },
    ]
  },
  pets: {
    containsElement: {
      and: [
        { kind: { any: [{ equalsTo: 'cat' }, { notEqualTo: 'dog' }] } },
        { age: { lessThan: 5 } }
      ]
    }
  }
};

const result = map(givenQuery);

/**
`result` will have the following value

{
  firstName: 'John',
  lastName: { $ne: 'Doe' },
  age: {
    $or: [
      20,
      { $lt: 55 },
      { $gt: 5 },
      { $lte: 45 },
      { $gte: 15 },
      { $in: [16, 26, 32] },
      { $nin: [17, 27, 33] },
    ]
  },
  pets: {
    $elemMatch: {
      $and: [
        { kind: { $or: [{ $eq: 'cat' }, { $ne: 'dog' }] } },
        { age: { $lt: 5 } }
      ]
    }
  }
}

Available operators

Comparison operators

• equalsTo - maps to Mongo $eq;

  Example:

  {
    "name": { "equalsTo": "John" }
  }

  Will be translated to:

  {
    "name": { "$eq": "John" }
  }

• notEqualTo - maps to Mongo $ne;

  Example:

  {
    "name": { "notEqualTo": "John" }
  }

  Will be translated to:

  {
    "name": { "$ne": "John" }
  }

• greaterThan - maps to Mongo $gt;

  Example:

  {
    "age": { "greaterThan": 21 }
  }

  Will be translated to:

  {
    "age": { "$gt": 21 }
  }

• greaterThanOrEquals - maps to Mongo $gte;

  Example:

  {
    "name": { "greaterThanOrEquals": 21 }
  }

  Will be translated to:

  {
    "name": { "$gte": 21 }
  }

• lessThan - maps to Mongo $lt;

  Example:

  {
    "name": { "lessThan": 21 }
  }

  Will be translated to:

  {
    "name": { "$lt": 21 }
  }

• lessThanOrEquals - maps to Mongo $lte;

  Example:

  {
    "name": { "lessThanOrEquals": 21 }
  }

  Will be translated to:

  {
    "name": { "$lt": 21 }
  }

• in - maps to Mongo $in;

  Example:

  {
    "name": { "in": ["John", "Jack", "Jim"] }
  }

  Will be translated to:

  {
    "name": { "$in": ["John", "Jack", "Jim"] }
  }

• notIn - maps to Mongo $nin;

  Example:

  {
    "name": { "notIn": ["John", "Jack", "Jim"] }
  }

  Will be translated to:

  {
    "name": { "$nin": ["John", "Jack", "Jim"] }
  }

• exists - maps to Mongo $exists;

  Example:

  {
    "name": { "exists": true }
  }

  Will be translated to:

  {
    "name": { "$exists": true }
  }

• arrayLength - maps to Mongo $size;

  • Note: This operator will work only in case of strict equality. Use $where statement if length comparison is needed.

  Example:

  {
    "phones": { "arrayLength": 1 }
  }

  Will be translated to:

  {
    "phones": { "$size": 1 }
  }

Logical operator

• and - $and true if all conditions are true

  Example:

  {
    "name": {
      "and": [
        { "notEqualTo": "John" },
        { "notEqualTo": "Jack" },
        { "notEqualTo": "Jim" }
      ]
    }
  }

  Will be translated to:

  {
    "name": {
      "$and": [
        { "$ne": "John" },
        { "$ne": "Jack" },
        { "$ne": "Jim" }
      ]
    }
  }

• any - $or true if any of conditions is true

  Example:

  {
    "name": {
      "any": [
        { "equalTo": "John" },
        { "equalTo": "Jack" },
        { "equalTo": "Jim" }
      ]
    }
  }

  Will be translated to:

  {
    "name": {
      "$or": [
        { "$eq": "John" },
        { "$eq": "Jack" },
        { "$eq": "Jim" }
      ]
    }
  }

• none - $nor true if all conditions are false

  Example:

  {
    "name": {
      "none": [
        { "equalTo": "John" },
        { "equalTo": "Jack" },
        { "equalTo": "Jim" }
      ]
    }
  }

  Will be translated to:

  {
    "name": {
      "$nor": [
        { "$eq": "John" },
        { "$eq": "Jack" },
        { "$eq": "Jim" }
      ]
    }
  }

Projection Operators

• containsElement - perform comparison on arrays of objects. Maps to $elemMatch projection.

  • Note: use equalsTo operator if types of values are primitive (boolean, string, number)

  Example

  {
    "pets": {
      "containsElement": {
        "and": [
          { "kind": { "any": [{ "equalsTo": "cat" }, { "notEqualTo": "dog" }] } },
          { "age": { "lessThan": 5 } }
        ]
      }
    }
  }

  Will be matted to:

  {
    "pets": {
      "$elemMatch": {
        "$and": [
          { "kind": { "$or": [{ "$eq": "cat" }, { "$ne": "dog" }] } },
          { "age": { "$lt": 5 } }
        ]
      }
    }
  }