@thisisagile/easy-mongo/dist/Stages.d.ts

Add support for MongoDB

import { Filter, FindOptions } from './MongoProvider';
import { Currency, Get, Id, OneOrMore, Optional, PartialRecord } from '@thisisagile/easy';
export declare const asc = 1;
export declare const desc = -1;
export type Accumulators = '$sum' | '$count' | '$multiply' | '$avg' | '$first' | '$last' | '$min' | '$max' | '$push' | '$addToSet' | '$size';
export type Accumulator = PartialRecord<Accumulators, Filter>;
export declare class FilterBuilder<Options> {
    private filters;
    constructor(filters: {
        [K in keyof Options]: (v: Options[K]) => Filter;
    });
    from: (q?: Partial<Options>) => Filter;
}
type Sort = Record<string, typeof asc | typeof desc>;
export declare class SortBuilder {
    private sorts;
    constructor(sorts: Record<string, Sort>);
    get keys(): string[];
    from: (s?: {
        s?: string;
    }, alt?: string) => Optional<Filter>;
}
export declare class IncludeBuilder {
    private includes;
    constructor(includes: Record<string, (string | Record<string, 1>)[]>);
    get keys(): string[];
    from: (i?: {
        i?: string;
    }, alt?: string) => Optional<Filter>;
}
export declare const stages: {
    root: string;
    current: string;
    id: string;
    decode: {
        object: (f: Filter) => any;
        fields: (f: Filter) => any;
        fieldsArrays: (f: Filter) => any;
        id: (f: Filter | string) => any;
    };
    match: {
        match: (f: Record<string, Get<Optional<Filter>, string>>) => {
            $match: any;
        };
        filter: <Options>(filters: { [K in keyof Options]: (v: Options[K]) => Filter; }) => FilterBuilder<Options>;
        or: (...filters: Filter[]) => {
            $or: any[];
        };
        gt: (value: Filter) => {
            $gt: Filter;
        };
        gte: (value: Filter) => {
            $gte: Filter;
        };
        lt: (value: Filter) => {
            $lt: Filter;
        };
        lte: (value: Filter) => {
            $lte: Filter;
        };
        isIn: (value: OneOrMore<unknown>, separator?: string) => {
            $in: unknown;
        };
        notIn: (value: OneOrMore<unknown>, separator?: string) => {
            $nin: unknown;
        };
        after: (date: unknown) => {
            $gte: Filter;
        };
        before: (date: unknown) => {
            $lt: Filter;
        };
        anywhere: (q: string) => {
            $regex: string;
            $options: string;
        };
        money: (currency: Currency, value: Filter) => (key: string) => any;
    };
    sort: {
        sort: ($sort: Sort) => {
            $sort: Sort;
        } | undefined;
        sorter: (sorts: Record<string, Sort>) => SortBuilder;
        asc: (key: string) => {
            $sort: Sort;
        } | undefined;
        desc: (key: string) => {
            $sort: Sort;
        } | undefined;
    };
    group: {
        group: (fields: Record<string, Accumulator>) => {
            by: (by: Filter) => {
                $group: any;
            };
        };
        date: (format?: string) => (key: string) => {
            $dateToString: {
                date: string;
                format: string;
            };
        };
        count: () => Accumulator;
        sum: (from?: string) => Accumulator;
        avg: (from?: string) => {
            $avg: string;
        };
        multiply: (...multiply: string[]) => {
            $multiply: string[];
        };
        first: (from?: string) => Accumulator;
        last: (from?: string) => Accumulator;
        min: (from?: string) => Accumulator;
        max: (from?: string) => Accumulator;
        addToSet: (from?: string) => Accumulator;
        push: (from?: string) => Accumulator;
        size: (from?: string) => Accumulator;
    };
    search: {
        search: (f: Record<string, Get<Filter, string>>) => Optional<{
            $search: any;
        }>;
        auto: (value?: Id) => (key: string) => Optional<{
            autocomplete: {
                path: string;
                query: NonNullable<string | number>[];
            };
        }>;
        fuzzy: (value?: string, maxEdits?: number) => (key?: string) => Optional<{
            text: {
                query: string;
                path: string | {
                    wildcard: string;
                } | undefined;
                fuzzy: {
                    maxEdits: number;
                };
            };
        }>;
    };
    set: {
        set: (f: Record<string, Get<Filter, string>>) => {
            $set: any;
        };
        score: () => {
            $meta: string;
        };
    };
    skip: {
        skip: (o?: FindOptions) => Optional<Filter>;
        take: (o?: FindOptions) => Optional<Filter>;
    };
    project: {
        include: (...includes: (string | Record<string, 1 | string>)[]) => Optional<Filter>;
        exclude: (...excludes: (string | Record<string, 0>)[]) => Optional<Filter>;
        includes: (includes: Record<string, (string | Record<string, 1>)[]>) => IncludeBuilder;
        project: (project?: Filter) => Optional<{
            $project: NonNullable<Partial<unknown> | ({
                _id?: import("mongodb").Condition<import("bson").ObjectId> | undefined;
            } & import("mongodb").RootFilterOperators<import("mongodb").WithId<unknown>>)>;
        }>;
        date: (key: string, format?: string) => {
            format?: string | undefined;
            $toDate: string;
        };
        duration: (from: string, to: string) => {
            $divide: (number | {
                $subtract: {
                    format?: string | undefined;
                    $toDate: string;
                }[];
            })[];
        };
    };
    replaceWith: {
        replaceWith: (f?: Filter) => Optional<Filter>;
        merge: (...objects: Filter[]) => Optional<Filter>;
        rootAnd: (...objects: Filter[]) => Optional<Filter>;
        currentAnd: (...objects: Filter[]) => Optional<Filter>;
        reroot: (prop: string) => Filter;
        concat: (...props: string[]) => Optional<Filter>;
    };
    facet: {
        facet: (f: Record<string, OneOrMore<Get<Optional<Filter>, string>>>) => {
            $facet: any;
        };
        unwind: (from?: string) => (f?: string) => {
            $unwind: string;
        };
        count: (from?: string) => (f?: string) => {
            $sortByCount: string;
        };
        data: () => never[];
    };
    unwind: {
        unwind: (prop?: string) => {
            $unwind: string;
        };
    };
};
export {};