Wondering what’s next for npm?Check out our public roadmap! »

    TypeScript icon, indicating that this package has built-in type declarations

    4.1.2 • Public • Published


    MongoDB query language for in-memory objects

    version build status npm Codecov Code Quality: Javascript Total Alerts


    $ npm install mingo


    For documentation on using query operators see mongodb



    // Use as es6 module
    import mingo from 'mingo'
    // or vanilla nodeJS
    const mingo = require('mingo')

    Change in 4.x.x

    The $where operator is not loaded by default and must be explicitly registered if required. See documentation for preferred alternatives.

    Changes in 3.0.0

    Default exports and operators

    The default export of the main module only includes Aggregator, Query, aggregate(), find(), and remove().

    Only Query and Projection operators are loaded by default when using the main module. This is done using the side-effect module mingo/init/basic, and also automatically includes pipeline operators $project, $skip, $limit, and $sort.

    If your application uses most of the available operators or you do not care about bundle size, you can load all operators as shown below.

    // Note that doing this effectively imports the entire library into your bundle and unused operators cannot be tree shaked
    import 'mingo/init/system'

    Or from the node CLI

    node -r 'mingo/init/system' myscript.js

    Custom Operators

    The addOperators function for registering custom operators and helper constants have been moved to mingo/core. The constants OP_XXX have been deprecated and replace with an enum type OperatorType also in mingo/core. The values defined include;

    • QUERY

    Lastly, the function argument to addOperators(operatorType, fn) now accepts an object with the these two internal functions;

    • computeValue(obj: AnyVal, expr: AnyVal, operator: string, options?: ComputeOptions): AnyVal
    • resolve(obj: AnyVal, selector: string, options?: ResolveOptions): AnyVal

    Any extra utility may be imported directly from the specific module.

    Importing submodules

    Submodule imports are supported for both ES6 and ES5.

    The following two examples are equivalent.


    This work natively in typescript since it knows how to load commonJS modules as ES6. You may optionally install the esm module to use this syntax.

    import { $unwind } from 'mingo/operators/pipeline'


    Unlike the ES6 version, it is necessary to specify the operator module in the path to avoid loading any extras

    const $unwind = require('mingo/operators/pipeline/unwind').$unwind


    To support tree-shaking, you may import and register specific operators that will be used in your application.

    import { useOperators, OperatorType } from 'mingo/core'
    import { $trunc } from 'mingo/operators/expression'
    import { $bucket } from 'mingo/operators/pipeline'
    useOperators(OperatorType.EXPRESSION, { $trunc, $floor })
    useOperators(OperatorType.PIPELINE, { $bucket })

    Using query object to test objects

    import mingo from 'mingo'
    // create a query with criteria
    // find all grades for homework with score >= 50
    let query = new mingo.Query({
      type: "homework",
      score: { $gte: 50 }
    // test if an object matches query

    Searching and Filtering

    import mingo from 'mingo'
    // input is either an Array or any iterable source (i.e Object{next:Function}) including ES6 generators.
    let criteria = { score: { $gt: 10 } }
    let query = new mingo.Query(criteria)
    // filter collection with find()
    let cursor = query.find(collection)
    // alternatively use shorthand
    // cursor = mingo.find(collection, criteria)
    // sort, skip and limit by chaining
    cursor.sort({student_id: 1, score: -1})
    // count matches. exhausts cursor
    // classic cursor iterator (old school)
    while (cursor.hasNext()) {
    // ES6 iterators (new cool)
    for (let value of cursor) {
    // all() to retrieve matched objects. exhausts cursor

    Aggregation Pipeline

    import { Aggregator } from 'mingo/aggregator'
    import { useOperators, OperatorType } from 'mingo/core'
    import { $match, $group } from 'mingo/operators/pipeline'
    import { $min } from 'mingo/operators/accumulator'
    // ensure the required operators are preloaded prior to using them.
    useOperators(OperatorType.PIPELINE, { $match, $group })
    useOperators(OperatorType.ACCUMULATOR, { $min })
    let agg = new Aggregator([
      {'$match': { "type": "homework"}},
      {'$group': {'_id':'$student_id', 'score':{$min:'$score'}}},
      {'$sort': {'_id': 1, 'score': 1}}
    // return an iterator for streaming results
    let stream = agg.stream(collection)
    // return all results. same as `stream.all()`
    let result = agg.run(collection)


    • Better alternative to writing custom code for transforming collection of objects
    • Quick validation of MongoDB queries without the need for a database
    • MongoDB query language is among the best in the market and is well documented


    • Squash changes into one commit
    • Run npm test to build and execute unit tests
    • Submit pull request




    npm i mingo

    DownloadsWeekly Downloads






    Unpacked Size

    347 kB

    Total Files


    Last publish


    • avatar