mingo

By default, importing from mingo loads all operators, which can prevent tree-shaking in bundlers. To optimize your bundle size, you can import from base modules (e.g., mingo/core, mingo/aggregator) and manually register only the operators you need using a Context object.

Operators loaded into a Context are immutable. Registering an existing operator name is a no-op and does not throw an error.

import { Context } from "mingo/core";
import { Aggregator } from "mingo/aggregator";
import { $match, $count } from "mingo/operators/pipeline";
import { $gt } from "mingo/operators/expression/comparison";

// creates a context with only operators needed for execution.
const context = Context.init({
  pipeline: { $count, $match },
  expression: { $gt }
});

const agg = new Aggregator(
  [{ $match: { score: { $gt: 80 } } }, { $count: "passing_scores" }],
  { context } // pass context as part of options
);

const result = agg.run([
  { _id: 1, score: 10 },
  { _id: 2, score: 60 },
  { _id: 3, score: 100 }
]);

The $jsonSchema operator requires a custom JsonSchemaValidator to be provided in the options, as mingo does not provide a default implementation. You can use libraries like Ajv to implement this.

import 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();

Mingo provides a suite of window function operators designed to perform computations over a sliding window or a sequence of documents. These operators allow you to access neighboring values, calculate moving averages, perform ranking, or apply transformations based on the position or value of documents within a sorted stream.

Available window operators include:

• denseRank: Calculates dense ranking.
• derivative: Calculates the derivative of a sequence.
• documentNumber: Assigns a sequence number to documents.
• expMovingAvg: Calculates the exponential moving average.
• integral: Calculates the integral of a sequence.
• linearFill: Performs linear interpolation to fill missing values.
• locf: Last Observation Carried Forward (fills missing values with the last known value).
• minMaxScaler: Scales values to a specific range (typically 0 to 1).
• rank: Calculates standard ranking.
• shift: Shifts values by a specified offset.

You can customize the behavior of query and aggregation operations using an options object. Key configuration areas include:

• Strictness & Compatibility: Use useStrictMode (defaults to true) to enforce MongoDB compatibility. When false, $elemMatch returns all matches, empty strings are coerced to false, and $type returns JS native type names.
• Error Handling: Set failOnError to false to return null on invalid operations instead of throwing an error.
• Security: Set scriptEnabled to false to disable operators that execute custom code like $where, $accumulator, and $function.
• Data Handling:
  • idKey: Specify the key used for ID lookups (defaults to "_id").
  • processingMode: Controls whether inputs are modified during processing (defaults to CLONE_OFF).
  • collectionResolver: A function (string) => AnyObject[] used by $lookup, $out, and $merge to resolve collection names to arrays.
• Extensions:
  • context: An object to load specific operators or register custom ones.
  • jsonSchemaValidator: A validator function (schema: AnyObject) => (document: AnyObject) => boolean required for the $jsonSchema operator.
• Other: collation for string sorting, hashFunction for custom hashing, and variables for global variables passed to all operators.

// Example of an options object
const options = {
  useStrictMode: true,
  failOnError: false,
  idKey: '_id',
  scriptEnabled: true
};

// These options are passed during the instantiation of Query or Aggregation
const query = new mingo.Query({ a: 1 }, options);
const aggregation = new mingo.Aggregation([{ $match: { a: 1 } }], options);