mingo/core.d.ts

import { Iterator } from "./lazy";
import { AnyVal, Callback, Collection, Predicate, RawObject } from "./types";
import { HashFunction, resolve } from "./util";
/**
 * Resolves the given string to a Collection.
 * This is useful for operators that require a second collection to use such as $lookup and $out.
 * The collection is not cached and will be resolved each time it is used.
 */
export declare type CollectionResolver = (name: string) => Collection;
/** Specification for collation options */
export interface CollationSpec {
    readonly locale: string;
    readonly caseLevel?: boolean;
    readonly caseFirst?: string;
    readonly strength?: number;
    readonly numericOrdering?: boolean;
    readonly alternate?: string;
    readonly maxVariable?: string;
    readonly backwards?: boolean;
}
/**
 * JSON schema validator
 */
export declare type JsonSchemaValidator = (schema: RawObject) => Predicate<RawObject>;
/**
 * This controls how input and output documents are processed to meet different application needs.
 * Each mode has different trade offs for; immutability, reference sharing, and performance.
 */
export declare enum ProcessingMode {
    /**
     * Clone inputs prior to processing, and the outputs if some objects graphs may be shared.
     * Use this option to keep input collection immutable and to get distinct output objects.
     *
     * Note: This option is expensive and reduces performance.
     */
    CLONE_ALL = "CLONE_ALL",
    /**
     * Clones inputs prior to processing.
     * This option will return output objects with shared graphs in their path if specific operators are used.
     * Use this option to keep the input collection immutable.
     *
     */
    CLONE_INPUT = "CLONE_INPUT",
    /**
     * Clones the output to return distinct objects with no shared paths.
     * This option modifies the input collection and during processing.
     */
    CLONE_OUTPUT = "CLONE_OUTPUT",
    /**
     * Turn off cloning and modifies the input collection as needed.
     * This option will also return output objects with shared paths in their graph when specific operators are used.
     *
     * This option provides the greatest speedup for the biggest tradeoff. When using the aggregation pipeline, you can use
     * the "$out" operator to collect immutable intermediate results.
     *
     * @default
     */
    CLONE_OFF = "CLONE_OFF"
}
/**
 * Generic options interface passed down to all operators
 */
export interface Options extends RawObject {
    /** The key string that is used to lookup the ID value of a document. */
    readonly idKey?: string;
    /** The collation specification for string operations. */
    readonly collation?: CollationSpec;
    /** Processing mode that determines how to treat inputs and outputs. */
    readonly processingMode?: ProcessingMode;
    /** Hash function to replace the somewhat weaker default implementation. */
    readonly hashFunction?: HashFunction;
    /** Function to resolve collections from an external source. */
    readonly collectionResolver?: CollectionResolver;
    /** JSON schema validator to use with the $jsonSchema operator. Required to use the operator. */
    readonly jsonSchemaValidator?: JsonSchemaValidator;
}
interface ComputeOptions extends Options {
    readonly root?: RawObject;
}
/**
 * Creates an Option from another required keys are initialized
 * @param options Options
 */
export declare function makeOptions(options?: Options): Options;
/**
 * The different groups of operators
 */
export declare enum OperatorType {
    ACCUMULATOR = "accumulator",
    EXPRESSION = "expression",
    PIPELINE = "pipeline",
    PROJECTION = "projection",
    QUERY = "query"
}
export declare type AccumulatorOperator = (collection: Collection, expr: AnyVal, options?: Options) => AnyVal;
export declare type ExpressionOperator = (obj: RawObject, expr: AnyVal, options?: Options) => AnyVal;
export declare type PipelineOperator = (collection: Iterator, expr: AnyVal, options?: Options) => Iterator;
export declare type ProjectionOperator = (obj: RawObject, expr: AnyVal, field: string, options?: Options) => AnyVal;
export declare type QueryOperator = (selector: string, value: AnyVal, options?: Options) => (obj: RawObject) => boolean;
/** Map of operator functions */
export declare type OperatorMap = Record<string, AccumulatorOperator | ExpressionOperator | PipelineOperator | ProjectionOperator | QueryOperator>;
/** Spec for Query and Project operators where the value of the selector is resolved. */
declare type SelectorOperator<R> = (selector: string, lhs: AnyVal, rhs: AnyVal, options?: Options) => R;
export declare type AddOperatorsMap = Record<string, AccumulatorOperator | ExpressionOperator | PipelineOperator | SelectorOperator<AnyVal>>;
/**
 * Register fully specified operators for the given operator class.
 *
 * @param cls Category of the operator
 * @param operators Name of operator
 */
export declare function useOperators(cls: OperatorType, operators: OperatorMap): void;
/**
 * Returns the operator function or null if it is not found
 * @param cls Category of the operator
 * @param operator Name of the operator
 */
export declare function getOperator(cls: OperatorType, operator: string): Callback<AnyVal> | null;
/** Context used for creating new operators */
export interface OperatorContext {
    readonly computeValue: typeof computeValue;
    readonly resolve: typeof resolve;
}
/**
 * Add new operators
 *
 * @param operatorType the operator class to extend
 * @param operatorFactory a callback that accepts internal object state and returns an object of new operators.
 */
export declare function addOperators(operatorType: OperatorType, operatorFactory: (context: OperatorContext) => AddOperatorsMap): void;
/**
 * Computes the value of the expression on the object for the given operator
 *
 * @param obj the current object from the collection
 * @param expr the expression for the given field
 * @param operator the operator to resolve the field with
 * @param options {Object} extra options
 * @returns {*}
 */
export declare function computeValue(obj: AnyVal, expr: AnyVal, operator: string, options?: ComputeOptions): AnyVal;
/**
 * Redact an object
 * @param  {Object} obj The object to redact
 * @param  {*} expr The redact expression
 * @param  {*} options  Options for value
 * @return {*} returns the result of the redacted object
 */
export declare function redact(obj: RawObject, expr: AnyVal, options: ComputeOptions): AnyVal;
export {};