@thisisagile/easy-mongo 15.8.4 → 15.8.6

package/dist/index.d.mts

@@ -0,0 +1,361 @@
+import * as _thisisagile_easy from '@thisisagile/easy';
+import { Mapper, PropertyOptions, Field, Get, Json, MapOptions, Database, Condition, LogicalCondition, Text, Sort as Sort$1, SortDirection, FetchOptions, OneOrMore, PageList, Id, JsonValue, Gateway, List, Optional, Func, RequireAtLeastOne, DateTime, Filter as Filter$1, PartialRecord } from '@thisisagile/easy';
+import { StrictFilter, MongoClient, Collection as Collection$1, FindOptions as FindOptions$1, IndexSpecification, CreateIndexesOptions, FindCursor, Document, AggregationCursor } from 'mongodb';
+
+declare class Collection extends Mapper {
+    protected readonly map: {
+        field: <T = unknown>(name: string, options?: PropertyOptions<T> | undefined) => Field;
+        item: (property: string, options?: PropertyOptions<unknown> | undefined) => _thisisagile_easy.Property<unknown>;
+        ignore: (property?: string | undefined) => _thisisagile_easy.Mapping;
+        skipIn: (property: string) => _thisisagile_easy.Mapping;
+        skipOut: (property: string) => _thisisagile_easy.Mapping;
+        func: (property: string, funcIn: Get<_thisisagile_easy.Optional<_thisisagile_easy.JsonValue>, Json>, funcOut: Get<_thisisagile_easy.Optional<_thisisagile_easy.JsonValue>, Json>) => _thisisagile_easy.Mapping;
+        add: (funcIn: Get<_thisisagile_easy.JsonValue, Json>) => _thisisagile_easy.Mapping;
+        map: (mapper: _thisisagile_easy.Construct<Mapper, any>, property?: string | undefined) => _thisisagile_easy.Mapping;
+        propsToList: (...maps: _thisisagile_easy.Mapping[]) => _thisisagile_easy.Mapping;
+        list: (mapper: _thisisagile_easy.Mapping, property: string) => _thisisagile_easy.Mapping;
+    };
+    readonly id: Field;
+    constructor(options?: MapOptions);
+    get db(): Database;
+    get provider(): MongoProvider;
+    where: (...conditions: Get<Condition, this>[]) => Json;
+    match: (condition: Get<Condition | LogicalCondition, this>) => Json;
+    group: (...conditions: Get<Condition, this>[]) => Json;
+    google: (value: unknown) => Condition;
+    search: (key: Text) => Field;
+    sort: (...conditions: Sort$1[]) => Record<string, SortDirection>;
+    out(to?: Json): Json;
+}
+
+type Projection = Record<string, 0 | 1>;
+type FindOptions = FetchOptions & {
+    projection?: Projection;
+};
+type Filter<T = unknown> = StrictFilter<T>;
+type Query = Condition | LogicalCondition | Filter<any>;
+type IndexOptions = {
+    unique?: boolean;
+    filter?: Query;
+    languageOverride?: string;
+    languageDefault?: string;
+};
+type Indexes = OneOrMore<string | Field | Sort$1 | Record<string, 1 | -1>>;
+declare class MongoProvider {
+    readonly coll: Collection;
+    protected client?: Promise<MongoClient> | undefined;
+    protected static readonly clients: {
+        [key: string]: Promise<MongoClient>;
+    };
+    constructor(coll: Collection, client?: Promise<MongoClient> | undefined);
+    static client(db: Database): Promise<MongoClient>;
+    cluster(): Promise<MongoClient>;
+    toMongoJson(query: Query): Json;
+    find(query: Query, options?: FindOptions): Promise<PageList<Json>>;
+    all(options?: FindOptions): Promise<PageList<Json>>;
+    byId(id: Id, options?: FindOptions): Promise<Json>;
+    by(key: string, value: JsonValue, options?: FindOptions): Promise<PageList<Json>>;
+    group(qs: Filter<any>[]): Promise<PageList<Json>>;
+    aggregate(qs: Filter<any>[]): Promise<PageList<Json>>;
+    add(item: Json): Promise<Json>;
+    update(item: Json): Promise<Json>;
+    remove(id: Id): Promise<boolean>;
+    count(query?: Query): Promise<number>;
+    createIndex(indexes: Indexes, options?: IndexOptions): Promise<string>;
+    createPartialIndex(indexes: Indexes, filter: Query, options?: Omit<IndexOptions, 'filter'>): Promise<string>;
+    createTextIndex(indexes: OneOrMore<Field | string>, options?: IndexOptions): Promise<string>;
+    collection(): Promise<Collection$1>;
+    protected toFindOptions(options?: FindOptions): FindOptions$1 & {
+        total: boolean;
+    };
+    protected toIndexSpecification(index: Indexes): IndexSpecification;
+    protected toCreateIndexesOptions(options?: IndexOptions): CreateIndexesOptions;
+    protected toArray(cursor: FindCursor<Document> | AggregationCursor<Document>, options?: {
+        take?: number;
+        skip?: number;
+        total?: number;
+    }): Promise<PageList<Json>>;
+}
+
+declare class MongoGateway implements Gateway<FindOptions> {
+    readonly collection: Collection;
+    readonly provider: MongoProvider;
+    constructor(collection: Collection, provider?: MongoProvider);
+    all(options?: FindOptions): Promise<PageList<Json>>;
+    byId(id: Id): Promise<Json | undefined>;
+    by(key: string, value: JsonValue, options?: FindOptions): Promise<PageList<Json>>;
+    byIds(...ids: Id[]): Promise<List<Json>>;
+    find(q: JsonValue | Condition | LogicalCondition, options?: FindOptions): Promise<PageList<Json>>;
+    search(q: JsonValue, options?: FindOptions): Promise<PageList<Json>>;
+    filter(options?: FindOptions): Promise<PageList<Json>>;
+    exists(id: Id): Promise<boolean>;
+    aggregate(...filters: Optional<Filter>[]): Promise<PageList<Json>>;
+    count(...filters: Optional<Filter>[]): Promise<number>;
+    match(f: Filter): Promise<PageList<Json>>;
+    add(item: Json): Promise<Json>;
+    update(item: Json): Promise<Json>;
+    remove(id: Id): Promise<boolean>;
+}
+
+type FuzzyOptions = {
+    maxEdits: number;
+    prefixLength: number;
+    maxExpansions: number;
+};
+type Facet = {
+    path: string;
+    type: 'string';
+    numBuckets: number;
+} | {
+    path: string;
+    type: 'number';
+    boundaries: number[];
+    default?: string;
+} | {
+    path: string;
+    type: 'date';
+    boundaries: Date[];
+    default?: string;
+};
+type Operator = Func<Optional<object>, string>;
+type Clause = object | Operator;
+type Clauses = Record<string, Clause>;
+type SearchDefinition = Record<string, (v: string | number) => RequireAtLeastOne<{
+    should?: Clauses;
+    filter?: Clauses;
+    must?: Clauses;
+    mustNot?: Clauses;
+    sort?: Record<string, 1 | -1>;
+    facet?: Facet;
+}>>;
+type Compound = {
+    must: OneOrMore<Clauses>;
+    should: OneOrMore<Clauses>;
+    mustNot: OneOrMore<Clauses>;
+    filter: OneOrMore<Clauses>;
+};
+declare const lucene: {
+    clause: (c: Clauses) => List<unknown>;
+    clauses: (cs: OneOrMore<Clauses>) => unknown[];
+    search: (c: Partial<Compound>, index?: string) => {
+        $search: {
+            compound: any;
+            index?: string | undefined;
+        };
+    };
+    searchWithDef: (query: Record<string, string | number>, options: SearchDefinition, index?: string) => {
+        $search: {
+            sort?: Record<string, 1 | -1> | undefined;
+            compound: Partial<Compound>;
+            index?: string | undefined;
+        };
+    };
+    searchMeta: (query: Record<string, string | number>, def: SearchDefinition, index?: string) => {
+        $searchMeta: {
+            facet: {
+                operator: {
+                    compound: Partial<Compound>;
+                };
+                facets: {
+                    [x: string]: Facet | undefined;
+                };
+            };
+            index?: string | undefined;
+        };
+    };
+    exists: () => Operator;
+    text: (value?: OneOrMore<unknown>, fuzzy?: Partial<FuzzyOptions>) => Operator;
+    wildcard: (value?: OneOrMore<unknown>) => Operator;
+    lt: (value: unknown) => Operator;
+    lte: (value: unknown) => Operator;
+    gt: (value: unknown) => Operator;
+    gte: (value: unknown) => Operator;
+    after: (date: unknown) => Operator;
+    before: (date: unknown) => Operator;
+    between: (after: unknown, before: unknown) => Operator;
+    facets: (def: SearchDefinition) => {
+        [x: string]: Facet | undefined;
+    };
+    facet: {
+        string: (path: string, numBuckets?: number) => Facet;
+        number: (path: string, boundaries: List<number>, alt?: string) => Facet;
+        date: (path: string, boundaries: List<DateTime>, alt?: string) => Facet;
+    };
+};
+
+declare const toFilters: (facets: unknown) => Filter$1[];
+declare class AtlasSearchGateway extends MongoGateway {
+    readonly searchDef: SearchDefinition;
+    readonly sortDef: Record<string, Record<string, 1 | -1>>;
+    constructor(collection: Collection, searchDef: SearchDefinition, sortDef?: Record<string, Record<string, 1 | -1>>, provider?: MongoProvider);
+    query: (query: Record<keyof typeof this$1.searchDef, string | number>) => Promise<PageList<Json>>;
+}
+
+declare const asc = 1;
+declare const desc = -1;
+type Accumulators = '$sum' | '$count' | '$avg' | '$first' | '$last' | '$min' | '$max' | '$push';
+type Accumulator = PartialRecord<Accumulators, Filter>;
+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>;
+declare class SortBuilder {
+    private sorts;
+    constructor(sorts: Record<string, Sort>);
+    get keys(): string[];
+    from: (s?: {
+        s?: string | undefined;
+    }, alt?: string) => Optional<Filter>;
+}
+declare class IncludeBuilder {
+    private includes;
+    constructor(includes: Record<string, (string | Record<string, 1>)[]>);
+    get keys(): string[];
+    from: (i?: {
+        i?: string | undefined;
+    }, alt?: string) => Optional<Filter>;
+}
+declare const stages: {
+    root: string;
+    current: string;
+    id: string;
+    decode: {
+        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>;
+        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;
+        };
+    };
+    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;
+        };
+        first: (from?: string) => Accumulator;
+        last: (from?: string) => Accumulator;
+        min: (from?: string) => Accumulator;
+        max: (from?: string) => Accumulator;
+        push: (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>)[]) => Optional<Filter>;
+        exclude: (...excludes: (string | Record<string, 0>)[]) => Optional<Filter>;
+        includes: (includes: Record<string, (string | Record<string, 1>)[]>) => IncludeBuilder;
+    };
+    replaceWith: {
+        replaceWith: (f?: Filter) => Optional<Filter>;
+        merge: (...objects: Filter[]) => Optional<Filter>;
+        rootAnd: (...objects: Filter[]) => Optional<Filter>;
+        currentAnd: (...objects: Filter[]) => 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[];
+    };
+};
+
+declare const toMongoType: (input: unknown) => Json;
+
+export { Accumulator, Accumulators, AtlasSearchGateway, Clause, Clauses, Collection, Facet, Filter, FilterBuilder, FindOptions, IncludeBuilder, IndexOptions, Indexes, MongoGateway, MongoProvider, Operator, Projection, Query, SearchDefinition, SortBuilder, asc, desc, lucene, stages, toFilters, toMongoType };