mingo

What is mingo?

Mingo is a JavaScript library that provides MongoDB-like query and aggregation capabilities for in-memory data processing. It allows you to filter, sort, group, and transform data collections using a syntax similar to MongoDB queries.

What are mingo's main functionalities?

Querying

This feature allows you to perform complex queries on your data collections. The example demonstrates how to filter a list of people to find those older than 26.

const mingo = require('mingo');
const data = [
  { name: 'John', age: 25 },
  { name: 'Jane', age: 30 },
  { name: 'Jim', age: 27 }
];
const query = new mingo.Query({ age: { $gt: 26 } });
const result = query.find(data).all();
console.log(result); // Output: [ { name: 'Jane', age: 30 }, { name: 'Jim', age: 27 } ]

Aggregation

This feature allows you to perform aggregation operations on your data collections. The example demonstrates how to calculate the average salary of people older than 26.

const mingo = require('mingo');
const data = [
  { name: 'John', age: 25, salary: 50000 },
  { name: 'Jane', age: 30, salary: 60000 },
  { name: 'Jim', age: 27, salary: 55000 }
];
const pipeline = [
  { $match: { age: { $gt: 26 } } },
  { $group: { _id: null, averageSalary: { $avg: '$salary' } } }
];
const result = mingo.aggregate(data, pipeline);
console.log(result); // Output: [ { _id: null, averageSalary: 57500 } ]

Projection

This feature allows you to project specific fields from your data collections. The example demonstrates how to retrieve only the 'name' and 'age' fields from a list of people.

const mingo = require('mingo');
const data = [
  { name: 'John', age: 25, salary: 50000 },
  { name: 'Jane', age: 30, salary: 60000 },
  { name: 'Jim', age: 27, salary: 55000 }
];
const query = new mingo.Query({});
const result = query.find(data).project({ name: 1, age: 1 }).all();
console.log(result); // Output: [ { name: 'John', age: 25 }, { name: 'Jane', age: 30 }, { name: 'Jim', age: 27 } ]

Other packages similar to mingo

lodash

Lodash is a JavaScript utility library that provides a wide range of functions for manipulating arrays, objects, and other data structures. While it does not offer MongoDB-like query syntax, it provides similar functionalities for filtering, sorting, and transforming data collections.

underscore

Underscore is another JavaScript utility library similar to Lodash. It provides a set of utility functions for working with arrays, objects, and other data types. Like Lodash, it does not offer MongoDB-like query syntax but provides similar data manipulation capabilities.

json-query

json-query is a library for querying JSON data structures using a simple query language. It provides functionalities for filtering and transforming JSON data, similar to Mingo, but with a different query syntax.

README

mingo

MongoDB query language for in-memory objects

Install

$ npm install mingo

Features

• Supports dot notation for both <array>.<index> and <document>.<field> selectors
• Query and Projection Operators
  • Array Operators
  • Bitwise Operators
  • Comparisons Operators
  • Element Operators
  • Evaluation Operators
  • Logical Operators
  • Projection Operators
• Aggregation Framework Operators
  • Pipeline Operators
  • Accumulator Operators
  • Expression Operators
    • Arithmetic Operators
    • Array Operators
    • Boolean Operators
    • Comparisons Operators
    • Conditional Operators
    • Custom Aggregation Operators
    • Date Operators
    • Literal Operators
    • Miscellaneous Operators
    • Object Operators
    • Set Operators
    • String Operators
    • Trignometry Operators
    • Type Operators
    • Variable Operators
  • Window Operators
• Supports aggregaion variables; $$ROOT, $$CURRENT, $$DESCEND, $$PRUNE, $$KEEP, $$REMOVE, $$NOW
• Filtering and aggregation using streaming.

For documentation on using query operators see mongodb

Browse package docs for modules.

Usage

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

// or vanilla nodeJS
const mingo = require("mingo");

The main module exports Aggregator, Query, aggregate(), find(), and remove(). Only Query and Projection operators are loaded by default when you require the main module. This is done using the side-effect module mingo/init/basic and automatically includes pipeline operators; $project, $skip, $limit, and $sort.

Loading Operators

MongoDB query library is huge and you may not need all the operators. If using this library on the server-side where bundle size is not a concern, 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

To support tree-shaking for client side bundles, you can import and register specific operators that will be used in your application.

ES6

import { useOperators, OperatorType } from "mingo/core";
import { $trunc } from "mingo/operators/expression/trunc";
import { $bucket } from "mingo/operators/pipeline/bucket";

useOperators(OperatorType.EXPRESSION, { $trunc });
useOperators(OperatorType.PIPELINE, { $bucket });

ES5

const core = require("mingo/core");
const $trunc = require("mingo/operators/expression/trunc").$trunc;
const $bucket = require("mingo/operators/pipeline/bucket").$bucket;
const useOperators = core.useOperators;
const OperatorType = core.OperatorType;

useOperators(OperatorType.EXPRESSION, { $trunc: $trunc });
useOperators(OperatorType.PIPELINE, { $bucket: $bucket });

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 { RawObject } from "mingo/types"
import { JsonSchemaValidator } from "mingo/core"
import Ajv, { Schema } from "ajv"

const jsonSchemaValidator: JsonSchemaValidator = (s: RawObject) => {
  const ajv = new Ajv();
  const v = ajv.compile(s as Schema);
  return (o: RawObject) => (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
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 } 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);

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.

interface Options {
  /** The key that is used to lookup the ID value of a document. @default "_id" */
  readonly idKey?: string;
  /** The collation specification for string sorting operations. */
  readonly collation?: CollationSpec;
  /** Determines how to treat inputs and outputs. @default ProcessingMode.CLONE_OFF */
  readonly processingMode?: ProcessingMode;
  /**
   * Enforces strict MongoDB compatibilty. See readme for differences. @default true.
   * When disabled, the $elemMatch projection operator returns all matching nested documents instead of only the first.
   */
  readonly useStrictMode?: boolean;
  /**
   * Enables or disables custom script execution.
   * When disabled, you cannot use operations that execute custom code, such as the $where, $accumulator, and $function.
   * @default true
   */
  readonly scriptEnabled?: boolean;
  /** Hash function to replace the somewhat weaker default implementation. */
  readonly hashFunction?: HashFunction;
  /** Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`. */
  readonly collectionResolver?: CollectionResolver;
  /** JSON schema validator to use with the '$jsonSchema' operator. This is required in order to use the operator. */
  readonly jsonSchemaValidator?: JsonSchemaValidator;
  /** Global variables. */
  readonly variables?: Readonly<RawObject>;
}

Adding Custom Operators

Custom operators can be added with the useOperators(type, operatorMap) where type is the kind of operators to add, and operatorMap is mapping of function names beginning with $ to their implementations for the specific operator type.

Once an operator has been registered the function referenced cannot be replaced. This ensures that behaviour of mingo remain consistent at runtime.

Each operator type function has a different signature and must be registered correctly otherwise the result will be unexpected.

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

Pre-loaded operators defined here cannot be overridden. These include;

• All query operators.
• All projection operators.
• Expression operators for boolean and comparison.
• Pipeline operators; $project, $skip, $limit, and $sort.

Differences from MongoDB

1. There is no concept of a collection. Input data is either an array of objects or a generator function to support streaming.
2. Does not support server specific operators. E.g. $collStat, $planCacheStats, $listSessions.
3. Does not support GeoJSON query operators.
4. Does not support query operators; $comment, $meta, $text.
5. Does not support aggregation expression operators; $toObjectId, $binarySize, bsonSize.
6. Agregation pipeline operator $merge enforces unique constraint on the lookup field at runtime.
7. Custom function evaluation operators; $where, $function, and $accumulator, do not accept strings as the function body.
8. Custom function evaluation operators are enabled by default. They can be disabled with the scriptEnabled option.
9. Custom function evaluation operator $accumulator does not support the merge option.
10. The $jsonSchema operator requires the user to register their own validator using the jsonSchemaValidator option.

Benefits

• 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

Contributing

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

To validate correct behaviour and semantics of operators, you may also test against mongoplayground.net.

License

MIT

Changelog

6.2.2 / 2023-01/05

• Distribute package for both commongJS and as ES6 module.