mingo

MongoDB query language for in-memory objects

Install

$ npm install mingo

Features

• Dot notation selectors. <array>.<index> and <document>.<field>.
• Query and Projection.
• Aggregation stages with
  • Accumulators
  • Expressions
  • Window operators
• Aggregation variables; $$ROOT, $$CURRENT, $$DESCEND, $$PRUNE, $$KEEP, $$REMOVE, $$NOW
• Filtering and aggregation using streaming.
• Document update support. See Updating Documents.
• Custom type value equality using toString when implemented.

For more documentation on how to use operators see mongodb.

API Documentation.

Distribution

The package provides 3 distributions on NPM.

1. A minified bundle since 6.6.0 for browser targets. See unpkg.
2. A CommonJS module when loaded using require.
3. An ESM module when loaded using import.

Important

Supporting both CJS and ESM modules makes this library subject to the dual package hazard. In backend environments, be consistent with the module loading format to avoid surprises and subtle errors, and use the bundle instead of modules when loading over the network.

Usage

// Use as ESM module
import mingo from "mingo";

// or CommonJS
const mingo = require("mingo");

The public API exports interfacs suitable for most use cases. By default the Query and Aggregator objects add query predicates and projection operators to their context whether one is provided or not. For Aggregator, pipeline stage operators $project, $match, and $sort are also included. All other operators must be explicitly registered using a custom Context.

Loading Operators

To use extra operators, load them into a Context object and configure in your Options. For ESM environments, non-used operators are subject to tree-shaking during bundling.

NB: To avoid surprises, operators loaded into a Context cannot be replaced. Adding a new operator with an existing name is a no-op and does not throw an error. To ensure a specific implementation of an operator is used, it must be the first to be registered in the Context.

import { aggregate, Context } from "mingo";
import { $count } from "mingo/operators/pipeline";

// creates a context with "$count" stage operator
// can also use `Context.init().addPipelineOps({ $count })`.
const context = Context.init({ pipeline: { $count } });

const results = aggregate(
  [
    { _id: 1, score: 10 },
    { _id: 2, score: 60 },
    { _id: 3, score: 100 }
  ],
  [
    // $match will be added to `context` by default.
    { $match: { score: { $gt: 80 } } },
    { $count: "passing_scores" }
  ],
  { context } // pass context as part of options
);

A fully loaded Context with every operator is provided through the module mingo/init/context.

import fullContext from "mingo/init/context";

// include every operator in the context.
const context = fullContext();

// use in options for queries (find) and aggregation (aggregate) to get access to full operator support.

Using query to test objects

import { Query } from "mingo";

// create a query with criteria
// find all grades for homework with score >= 50
let query = new Query({
  type: "homework",
  score: { $gte: 50 }
});

// test if an object matches query
query.test(doc);

Searching and Filtering

import { Query } 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 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 }).skip(100).limit(100);

// count matches. exhausts cursor
cursor.count();

// classic cursor iterator (old school)
while (cursor.hasNext()) {
  console.log(cursor.next());
}

// ES6 iterators (new cool)
for (let value of cursor) {
  console.log(value);
}

// all() to retrieve matched objects. exhausts cursor
cursor.all();

Using $jsonSchema operator

To use the $jsonSchema operator, you must register your own JsonSchemaValidator in the options. No default implementation is provided out of the box so users can use a library with their preferred schema format.

The example below uses Ajv to implement schema validation.

import * as mingo from "mingo"
import type { AnyObject, JsonSchemaValidator } from "mingo/types"
import Ajv, { Schema } from "ajv"

const jsonSchemaValidator: JsonSchemaValidator = (s: AnyObject) => {
  const ajv = new Ajv();
  const v = ajv.compile(s as Schema);
  return (o: AnyObject) => (v(o) ? true : false);
};

const schema = {
  type: "object",
  required: ["item", "qty", "instock"],
  properties: {
    item: { type: "string" },
    qty: { type: "integer" },
    size: {
      type: "object",
      required: ["uom"],
      properties: {
        uom: { type: "string" },
        h: { type: "number" },
        w: { type: "number" },
      },
    },
    instock: { type: "boolean" },
  },
};

// queries documents using schema validation
mingo.find(docs, { $jsonSchema: schema }, {}, { jsonSchemaValidator }).all();

Note: An error is thrown when the $jsonSchema operator is used without a the jsonSchemaValidator configured.

Aggregation Pipeline

import { Aggregator, Context } from "mingo";
import { $group } from "mingo/operators/pipeline";
import { $min } from "mingo/operators/accumulator";

// ensure the required operators are preloaded prior to using them.
const context = Context.init({
  pipeline: { $group },
  accumulator: { $min }
});

let agg = new Aggregator(
  [
    { $match: { type: "homework" } },
    { $group: { _id: "$student_id", score: { $min: "$score" } } },
    { $sort: { _id: 1, score: 1 } }
  ],
  { context }
);

// return an iterator for streaming results
let stream = agg.stream(collection);

// return all results. same as `stream.all()`
let result = agg.run(collection);

Options

Query and aggregation operations can be configured with options to enabled different features or customize how documents are processed. Some options are only relevant to specific operators and need not be specified if not required.

Custom Operators

Custom operators can be registered using a Context object via the context option which is the recommended way since 6.4.2. Context provides a container for operators, that the execution engine will use to process queries. The useOperators(...) function is available to register operators globally but it is deprecated and will be removed in 7.0.0.

NB: Note that the execution engine will first try to find the operator in the context and fallback to the global context when not found if the useGlobalContext option is true.

Operators must conform to the signatures of their types.

• AccumulatorOperator
• ExpressionOperator
• ProjectionOperator
• PipelineOperator
• WindowOperator
• QueryOperator

To define custom operators, the following imports are useful.

const mingo = require("mingo");
const util = require("mingo/util");

Custom Operator Examples

// this example creates a query operator that checks is a value is between a boundary.
const $between = (selector, args, options) => {
  return obj => {
    const value = util.resolve(obj, selector, { unwrapArray: true });
    return value >= args[0] && value <= args[1];
  };
};
// a test collection
const collection = [
  { a: 1, b: 1 },
  { a: 7, b: 1 },
  { a: 10, b: 6 },
  { a: 20, b: 10 }
];

Register custom operator using the context option.

The custom operator is registered with a user-provided context object that is passed an option to the query. The context will be searched for operators used in a query and fallback to the global context when not found.

const context = mingo.Context.init().addQueryOps({ $between });
// must specify context option to make operator available
const result = mingo
  .find(collection, { a: { $between: [5, 10] } }, {}, { context })
  .all();

console.log(result); // output => [ { a: 7, b: 1 }, { a: 10, b: 6 } ]

Updating Documents

An update operation can be performed using the update function from the mingo/updater module. Unlike other operations in the library, this only works on a single object. The query and aggregation operators are powerful enough to use for transforming arrays of documents and should be preferred when dealing with multiple objects. update returns an array of all paths that were updated. It also supports arrayFilters for applicable operators. To detect whether a change occurred you can check the length of the returned array.

All operators as of MongoDB 5.0 are supported except the positional array operator $.

Examples

import { update } from "mingo";
// all update operators are automatically loaded.

const obj = {
  firstName: "John",
  lastName: "Wick",
  age: 40,
  friends: ["Scooby", "Shagy", "Fred"]
};

// returns array of modified paths if value changed.
update(obj, { $set: { firstName: "Bob", lastName: "Doe" } }); // ["firstName", "lastName"]

// update nested values.
update(obj, { $pop: { friends: 1 } }); // ["friends"] => friends: ["Scooby", "Shagy"]
// update nested value path
update(obj, { $unset: { "friends.1": "" } }); // ["friends.1"] => friends: ["Scooby", null]
// update with condition
update(obj, { $set: { "friends.$[e]": "Velma" } }, [{ e: null }]); // ["friends"] => friends: ["Scooby", "Velma"]
// empty array returned if value has not changed.
update(obj, { $set: { firstName: "Bob" } }); // [] => no change to object.

You can also create a preconfigured updater function.

import { createUpdater } from "mingo/updater";

// configure updater to deep clone passed values. clone mode defaults to "copy".
const updateState = createUpdater({ cloneMode: "deep" });

const state = { people: ["Fred", "John"] };
const newPeople = ["Amy", "Mark"];

console.log(state.people); // ["Fred", "John"]

updateState(state, { $set: { people: newPeople } });

newPeople.push("Jason");

console.log(state.people); // ["Amy", "Mark"]
console.log(newPeople); // ["Amy", "Mark", "Jason"]

Differences from MongoDB

Below is a description of how this library differs from the full MongoDB query engine.

1. There is no concept of a collection. Input is an array, generator or iterable of objects.
2. Support a single numeric type number.
3. Does not support types "minKey", "maxKey", "timestamp", or "binData".
4. Does not support server specific operators. E.g. $collStat, $planCacheStats, $listSessions.
5. Does not support geometry query operators.
6. Does not support query operators dependent on persistent storage; $comment, $meta, $text.
7. Does not support positional query or update operator $.
8. Does not support server specific expression operators; $toObjectId, $binarySize, bsonSize.
9. Aggregation pipeline operator $merge enforces unique constraint on the lookup field during input processing.
10. Custom function evaluation operators; $where, $function, and $accumulator, do not accept strings as the function body.
11. Custom function evaluation operators are enabled by default. They can be disabled with the scriptEnabled option.
12. Custom function evaluation operator $accumulator does not support the merge option.
13. The $jsonSchema operator requires the user to register their own validator using the jsonSchemaValidator configuration.

Benefits

• Declarative data driven API.
• Usable on both frontend and backend.
• Provides an alternative to writing custom code for transforming objects.
• Validate MongoDB queries without running a server.
• Well documented. MongoDB query language is among the best available and has great documentation.

Contributing

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

To validate correct behaviour and semantics of operators, you may also test against mongoplayground.net. Credit to the author @feliix.

A big thank you to all users and CONTRIBUTORS of this library.

License

MIT