mingo

import { Iterator } from "./lazy"; import { AnyVal, Callback, HashFunction, Predicate, RawArray, RawObject, WindowOperatorInput } from "./types"; /** * 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 type CollectionResolver = (name: string) => Array<RawObject>; /** Specification for collation options */ export interface CollationSpec { readonly locale: string; readonly caseLevel?: boolean; readonly caseFirst?: "upper" | "lower" | "off"; readonly strength?: 1 | 2 | 3; readonly numericOrdering?: boolean; readonly alternate?: string; readonly maxVariable?: never; readonly backwards?: never; } /** * JSON schema validator */ export 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 { /** 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. @default true. */ readonly useStrictMode: boolean; /** Enable or disable custom script execution via $where, $accumulator, and $function operators. @default true. */ readonly scriptEnabled: boolean; /** Enable or disable falling back to the global context for operators. @default true. */ readonly useGlobalContext: boolean; /** Hash function to replace the Effective Java 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. Required in order to use the operator. */ readonly jsonSchemaValidator?: JsonSchemaValidator; /** Global variables. */ readonly variables?: Readonly<RawObject>; /** Extra references to operators to be used for processing. */ readonly context: Context; } interface LocalData { /** The groupId computed for a group of documents. */ readonly groupId?: AnyVal; /** Local user-defind variables. */ readonly variables?: RawObject; } /** Custom type to facilitate type checking for global options */ export declare class ComputeOptions implements Options { private _opts; /** Reference to the root object when processing subgraphs of the object. */ private _root; private _local?; /** The current time in milliseconds. Remains the same throughout all stages of the aggregation pipeline. */ readonly timestamp: number; private constructor(); /** * Initialize new ComputeOptions. * * @param options * @param root * @param local * @returns {ComputeOptions} */ static init(options: Options, root?: AnyVal, local?: LocalData): ComputeOptions; /** Updates the internal mutable state. */ update(root?: AnyVal, local?: LocalData): ComputeOptions; getOptions(): Options; get root(): unknown; get local(): LocalData; get idKey(): string; get collation(): CollationSpec; get processingMode(): ProcessingMode; get useStrictMode(): boolean; get scriptEnabled(): boolean; get useGlobalContext(): boolean; get hashFunction(): HashFunction; get collectionResolver(): CollectionResolver; get jsonSchemaValidator(): JsonSchemaValidator; get variables(): Readonly<RawObject>; get context(): Context; } /** * Creates an Option from another where required keys are initialized. * @param options Options */ export declare function initOptions(options: Partial<Options>): Options; /** * Supported cloning modes. * - "deep": Performs a recursive deep clone of the object. * - "copy": Performs a shallow copy of the object. * - "none": No cloning. Uses the value as given. */ export type CloneMode = "deep" | "copy" | "none"; export interface UpdateOptions { /** Specifies whether to deep clone values to persist in the internal store. @default "copy". */ readonly cloneMode?: CloneMode; /** Options to use for processing queries. Unless overriden 'useStrictMode' is false. */ readonly queryOptions?: Partial<Options>; } /** * The different groups of operators */ export declare enum OperatorType { ACCUMULATOR = "accumulator", EXPRESSION = "expression", PIPELINE = "pipeline", PROJECTION = "projection", QUERY = "query", WINDOW = "window" } export type AccumulatorOperator<R = AnyVal> = (collection: RawArray, expr: AnyVal, options: Options) => R; export type ExpressionOperator<R = AnyVal> = (obj: RawObject, expr: AnyVal, options: Options) => R; export type PipelineOperator = (collection: Iterator, expr: AnyVal, options: Options) => Iterator; export type ProjectionOperator = (obj: RawObject, expr: AnyVal, selector: string, options: Options) => AnyVal; export type QueryOperator = (selector: string, value: AnyVal, options: Options) => (obj: RawObject) => boolean; export type WindowOperator = (obj: RawObject, array: RawObject[], expr: WindowOperatorInput, options: Options) => AnyVal; /** Interface for update operators */ export type UpdateOperator = (obj: RawObject, expr: RawObject, arrayFilters: RawObject[], options: UpdateOptions) => string[]; export type Operator = AccumulatorOperator | ExpressionOperator | PipelineOperator | ProjectionOperator | QueryOperator | WindowOperator; /** Map of operator functions */ export type OperatorMap = Record<string, Operator>; type ContextMap = Partial<{ [OperatorType.ACCUMULATOR]: Record<string, AccumulatorOperator>; [OperatorType.EXPRESSION]: Record<string, ExpressionOperator>; [OperatorType.PIPELINE]: Record<string, PipelineOperator>; [OperatorType.PROJECTION]: Record<string, ProjectionOperator>; [OperatorType.QUERY]: Record<string, QueryOperator>; [OperatorType.WINDOW]: Record<string, WindowOperator>; }>; type AccumulatorOps = Record<string, AccumulatorOperator>; type ExpressionOps = Record<string, ExpressionOperator>; type ProjectionOps = Record<string, ProjectionOperator>; type QueryOps = Record<string, QueryOperator>; type PipelineOps = Record<string, PipelineOperator>; type WindowOps = Record<string, WindowOperator>; export declare class Context { private readonly operators; private constructor(); static init(ops?: ContextMap): Context; static from(ctx: Context): Context; private addOperators; addAccumulatorOps(ops: AccumulatorOps): Context; addExpressionOps(ops: ExpressionOps): Context; addQueryOps(ops: QueryOps): Context; addPipelineOps(ops: PipelineOps): Context; addProjectionOps(ops: ProjectionOps): Context; addWindowOps(ops: WindowOps): Context; getOperator(type: OperatorType, name: string): Callback | null; } /** * Register fully specified operators for the given operator class. * * @param type The operator type * @param operators Map of the operators */ export declare function useOperators(type: OperatorType, operators: OperatorMap): void; /** * Overrides the current global context with this new one. * * @param context The new context to override the global one with. */ /** * Returns the operator function or undefined if it is not found * @param type Type of operator * @param operator Name of the operator */ export declare function getOperator(type: OperatorType, operator: string, options: Pick<Options, "useGlobalContext" | "context">): Operator; /** * 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 | null, options?: Options): 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 {};