@cloudbase/database 1.4.2 → 1.4.3

package/dist/esm/command.js

@@ -0,0 +1,281 @@
+import { QueryCommand, QUERY_COMMANDS_LITERAL } from './commands/query';
+import { LogicCommand, LOGIC_COMMANDS_LITERAL } from './commands/logic';
+import { UpdateCommand, UPDATE_COMMANDS_LITERAL } from './commands/update';
+import { isArray, isObject, isString } from './utils/type';
+import Aggregation from './aggregate';
+export const Command = {
+    eq(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.EQ, [val]);
+    },
+    neq(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.NEQ, [val]);
+    },
+    lt(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.LT, [val]);
+    },
+    lte(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.LTE, [val]);
+    },
+    gt(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.GT, [val]);
+    },
+    gte(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.GTE, [val]);
+    },
+    in(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.IN, val);
+    },
+    nin(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.NIN, val);
+    },
+    all(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.ALL, val);
+    },
+    elemMatch(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.ELEM_MATCH, [val]);
+    },
+    exists(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.EXISTS, [val]);
+    },
+    size(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.SIZE, [val]);
+    },
+    mod() {
+        if (arguments.length == 1)
+            return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [arguments[0]]);
+        if (arguments.length == 2)
+            return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [[arguments[0], arguments[1]]]);
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, arguments);
+    },
+    geoNear(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_NEAR, [val]);
+    },
+    geoWithin(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_WITHIN, [val]);
+    },
+    geoIntersects(val) {
+        return new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_INTERSECTS, [val]);
+    },
+    and(...__expressions__) {
+        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.AND, expressions);
+    },
+    nor(...__expressions__) {
+        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.NOR, expressions);
+    },
+    or(...__expressions__) {
+        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.OR, expressions);
+    },
+    not(...__expressions__) {
+        const expressions = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.NOT, expressions);
+    },
+    set(val) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.SET, [val]);
+    },
+    remove() {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.REMOVE, []);
+    },
+    inc(val) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.INC, [val]);
+    },
+    mul(val) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MUL, [val]);
+    },
+    push(...args) {
+        let values;
+        if (isObject(args[0]) && args[0].hasOwnProperty('each')) {
+            values = {};
+            const options = args[0];
+            if (options.each !== undefined) {
+                values['$each'] = options.each;
+            }
+            if (options.position !== undefined) {
+                values['$position'] = options.position;
+            }
+            if (options.sort !== undefined) {
+                values['$sort'] = options.sort;
+            }
+            if (options.slice !== undefined) {
+                values['$slice'] = options.slice;
+            }
+        }
+        else if (isArray(args[0])) {
+            values = args[0];
+        }
+        else {
+            values = Array.from(args);
+        }
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PUSH, values);
+    },
+    pull(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PULL, values);
+    },
+    pullAll(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.PULL_ALL, values);
+    },
+    pop() {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.POP, []);
+    },
+    shift() {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.SHIFT, []);
+    },
+    unshift(...__values__) {
+        const values = isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.UNSHIFT, values);
+    },
+    addToSet(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.ADD_TO_SET, values);
+    },
+    rename(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.RENAME, [values]);
+    },
+    bit(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.BIT, [values]);
+    },
+    max(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MAX, [values]);
+    },
+    min(values) {
+        return new UpdateCommand(UPDATE_COMMANDS_LITERAL.MIN, [values]);
+    },
+    expr(values) {
+        return {
+            $expr: values
+        };
+    },
+    jsonSchema(schema) {
+        return {
+            $jsonSchema: schema
+        };
+    },
+    text(values) {
+        if (isString(values)) {
+            return {
+                $search: values.search
+            };
+        }
+        else {
+            return {
+                $search: values.search,
+                $language: values.language,
+                $caseSensitive: values.caseSensitive,
+                $diacriticSensitive: values.diacriticSensitive
+            };
+        }
+    },
+    aggregate: {
+        pipeline() {
+            return new Aggregation();
+        },
+        abs: param => new AggregationOperator('abs', param),
+        add: param => new AggregationOperator('add', param),
+        ceil: param => new AggregationOperator('ceil', param),
+        divide: param => new AggregationOperator('divide', param),
+        exp: param => new AggregationOperator('exp', param),
+        floor: param => new AggregationOperator('floor', param),
+        ln: param => new AggregationOperator('ln', param),
+        log: param => new AggregationOperator('log', param),
+        log10: param => new AggregationOperator('log10', param),
+        mod: param => new AggregationOperator('mod', param),
+        multiply: param => new AggregationOperator('multiply', param),
+        pow: param => new AggregationOperator('pow', param),
+        sqrt: param => new AggregationOperator('sqrt', param),
+        subtract: param => new AggregationOperator('subtract', param),
+        trunc: param => new AggregationOperator('trunc', param),
+        arrayElemAt: param => new AggregationOperator('arrayElemAt', param),
+        arrayToObject: param => new AggregationOperator('arrayToObject', param),
+        concatArrays: param => new AggregationOperator('concatArrays', param),
+        filter: param => new AggregationOperator('filter', param),
+        in: param => new AggregationOperator('in', param),
+        indexOfArray: param => new AggregationOperator('indexOfArray', param),
+        isArray: param => new AggregationOperator('isArray', param),
+        map: param => new AggregationOperator('map', param),
+        range: param => new AggregationOperator('range', param),
+        reduce: param => new AggregationOperator('reduce', param),
+        reverseArray: param => new AggregationOperator('reverseArray', param),
+        size: param => new AggregationOperator('size', param),
+        slice: param => new AggregationOperator('slice', param),
+        zip: param => new AggregationOperator('zip', param),
+        and: param => new AggregationOperator('and', param),
+        not: param => new AggregationOperator('not', param),
+        or: param => new AggregationOperator('or', param),
+        cmp: param => new AggregationOperator('cmp', param),
+        eq: param => new AggregationOperator('eq', param),
+        gt: param => new AggregationOperator('gt', param),
+        gte: param => new AggregationOperator('gte', param),
+        lt: param => new AggregationOperator('lt', param),
+        lte: param => new AggregationOperator('lte', param),
+        neq: param => new AggregationOperator('ne', param),
+        cond: param => new AggregationOperator('cond', param),
+        ifNull: param => new AggregationOperator('ifNull', param),
+        switch: param => new AggregationOperator('switch', param),
+        dateFromParts: param => new AggregationOperator('dateFromParts', param),
+        dateFromString: param => new AggregationOperator('dateFromString', param),
+        dayOfMonth: param => new AggregationOperator('dayOfMonth', param),
+        dayOfWeek: param => new AggregationOperator('dayOfWeek', param),
+        dayOfYear: param => new AggregationOperator('dayOfYear', param),
+        isoDayOfWeek: param => new AggregationOperator('isoDayOfWeek', param),
+        isoWeek: param => new AggregationOperator('isoWeek', param),
+        isoWeekYear: param => new AggregationOperator('isoWeekYear', param),
+        millisecond: param => new AggregationOperator('millisecond', param),
+        minute: param => new AggregationOperator('minute', param),
+        month: param => new AggregationOperator('month', param),
+        second: param => new AggregationOperator('second', param),
+        hour: param => new AggregationOperator('hour', param),
+        week: param => new AggregationOperator('week', param),
+        year: param => new AggregationOperator('year', param),
+        literal: param => new AggregationOperator('literal', param),
+        mergeObjects: param => new AggregationOperator('mergeObjects', param),
+        objectToArray: param => new AggregationOperator('objectToArray', param),
+        allElementsTrue: param => new AggregationOperator('allElementsTrue', param),
+        anyElementTrue: param => new AggregationOperator('anyElementTrue', param),
+        setDifference: param => new AggregationOperator('setDifference', param),
+        setEquals: param => new AggregationOperator('setEquals', param),
+        setIntersection: param => new AggregationOperator('setIntersection', param),
+        setIsSubset: param => new AggregationOperator('setIsSubset', param),
+        setUnion: param => new AggregationOperator('setUnion', param),
+        concat: param => new AggregationOperator('concat', param),
+        dateToString: param => new AggregationOperator('dateToString', param),
+        indexOfBytes: param => new AggregationOperator('indexOfBytes', param),
+        indexOfCP: param => new AggregationOperator('indexOfCP', param),
+        split: param => new AggregationOperator('split', param),
+        strLenBytes: param => new AggregationOperator('strLenBytes', param),
+        strLenCP: param => new AggregationOperator('strLenCP', param),
+        strcasecmp: param => new AggregationOperator('strcasecmp', param),
+        substr: param => new AggregationOperator('substr', param),
+        substrBytes: param => new AggregationOperator('substrBytes', param),
+        substrCP: param => new AggregationOperator('substrCP', param),
+        toLower: param => new AggregationOperator('toLower', param),
+        toUpper: param => new AggregationOperator('toUpper', param),
+        meta: param => new AggregationOperator('meta', param),
+        addToSet: param => new AggregationOperator('addToSet', param),
+        avg: param => new AggregationOperator('avg', param),
+        first: param => new AggregationOperator('first', param),
+        last: param => new AggregationOperator('last', param),
+        max: param => new AggregationOperator('max', param),
+        min: param => new AggregationOperator('min', param),
+        push: param => new AggregationOperator('push', param),
+        stdDevPop: param => new AggregationOperator('stdDevPop', param),
+        stdDevSamp: param => new AggregationOperator('stdDevSamp', param),
+        sum: param => new AggregationOperator('sum', param),
+        let: param => new AggregationOperator('let', param)
+    },
+    project: {
+        slice: param => new ProjectionOperator('slice', param),
+        elemMatch: param => new ProjectionOperator('elemMatch', param)
+    }
+};
+export class AggregationOperator {
+    constructor(name, param) {
+        this['$' + name] = param;
+    }
+}
+export class ProjectionOperator {
+    constructor(name, param) {
+        this['$' + name] = param;
+    }
+}
+export default Command;

package/dist/esm/commands/logic.d.ts

@@ -0,0 +1,24 @@
+import { InternalSymbol } from '../helper/symbol';
+export declare const AND = "and";
+export declare const OR = "or";
+export declare const NOT = "not";
+export declare const NOR = "nor";
+export declare enum LOGIC_COMMANDS_LITERAL {
+    AND = "and",
+    OR = "or",
+    NOT = "not",
+    NOR = "nor"
+}
+export declare class LogicCommand {
+    fieldName: string | InternalSymbol;
+    operator: LOGIC_COMMANDS_LITERAL | string;
+    operands: any[];
+    _internalType: InternalSymbol;
+    constructor(operator: LOGIC_COMMANDS_LITERAL | string, operands: any, fieldName?: string | InternalSymbol);
+    _setFieldName(fieldName: string): LogicCommand;
+    and(...__expressions__: LogicCommand[]): LogicCommand;
+    or(...__expressions__: LogicCommand[]): LogicCommand;
+}
+export declare function isLogicCommand(object: any): object is LogicCommand;
+export declare function isKnownLogicCommand(object: any): object is LogicCommand;
+export default LogicCommand;

package/dist/esm/commands/logic.js

@@ -0,0 +1,74 @@
+import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_LOGIC_COMMAND } from '../helper/symbol';
+import { isQueryCommand } from './query';
+export const AND = 'and';
+export const OR = 'or';
+export const NOT = 'not';
+export const NOR = 'nor';
+export var LOGIC_COMMANDS_LITERAL;
+(function (LOGIC_COMMANDS_LITERAL) {
+    LOGIC_COMMANDS_LITERAL["AND"] = "and";
+    LOGIC_COMMANDS_LITERAL["OR"] = "or";
+    LOGIC_COMMANDS_LITERAL["NOT"] = "not";
+    LOGIC_COMMANDS_LITERAL["NOR"] = "nor";
+})(LOGIC_COMMANDS_LITERAL || (LOGIC_COMMANDS_LITERAL = {}));
+export class LogicCommand {
+    constructor(operator, operands, fieldName) {
+        this._internalType = SYMBOL_LOGIC_COMMAND;
+        Object.defineProperties(this, {
+            _internalType: {
+                enumerable: false,
+                configurable: false,
+            },
+        });
+        this.operator = operator;
+        this.operands = operands;
+        this.fieldName = fieldName || SYMBOL_UNSET_FIELD_NAME;
+        if (this.fieldName !== SYMBOL_UNSET_FIELD_NAME) {
+            if (Array.isArray(operands)) {
+                operands = operands.slice();
+                this.operands = operands;
+                for (let i = 0, len = operands.length; i < len; i++) {
+                    const query = operands[i];
+                    if (isLogicCommand(query) || isQueryCommand(query)) {
+                        operands[i] = query._setFieldName(this.fieldName);
+                    }
+                }
+            }
+            else {
+                const query = operands;
+                if (isLogicCommand(query) || isQueryCommand(query)) {
+                    operands = query._setFieldName(this.fieldName);
+                }
+            }
+        }
+    }
+    _setFieldName(fieldName) {
+        const operands = this.operands.map(operand => {
+            if (operand instanceof LogicCommand) {
+                return operand._setFieldName(fieldName);
+            }
+            else {
+                return operand;
+            }
+        });
+        const command = new LogicCommand(this.operator, operands, fieldName);
+        return command;
+    }
+    and(...__expressions__) {
+        const expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        expressions.unshift(this);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.AND, expressions, this.fieldName);
+    }
+    or(...__expressions__) {
+        const expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        expressions.unshift(this);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.OR, expressions, this.fieldName);
+    }
+}
+export function isLogicCommand(object) {
+    return object && (object instanceof LogicCommand) && (object._internalType === SYMBOL_LOGIC_COMMAND);
+}
+export function isKnownLogicCommand(object) {
+    return isLogicCommand && (object.operator.toUpperCase() in LOGIC_COMMANDS_LITERAL);
+}
+export default LogicCommand;

package/dist/esm/commands/query.d.ts

@@ -0,0 +1,73 @@
+import { LogicCommand } from './logic';
+import { InternalSymbol } from '../helper/symbol';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from '../geo/index';
+import { CenterSphere } from '../typings';
+export declare const EQ = "eq";
+export declare const NEQ = "neq";
+export declare const GT = "gt";
+export declare const GTE = "gte";
+export declare const LT = "lt";
+export declare const LTE = "lte";
+export declare const IN = "in";
+export declare const NIN = "nin";
+export declare const ALL = "all";
+export declare const ELEM_MATCH = "elemMatch";
+export declare const EXISTS = "exists";
+export declare const SIZE = "size";
+export declare const MOD = "mod";
+export declare enum QUERY_COMMANDS_LITERAL {
+    EQ = "eq",
+    NEQ = "neq",
+    GT = "gt",
+    GTE = "gte",
+    LT = "lt",
+    LTE = "lte",
+    IN = "in",
+    NIN = "nin",
+    ALL = "all",
+    ELEM_MATCH = "elemMatch",
+    EXISTS = "exists",
+    SIZE = "size",
+    MOD = "mod",
+    GEO_NEAR = "geoNear",
+    GEO_WITHIN = "geoWithin",
+    GEO_INTERSECTS = "geoIntersects"
+}
+export declare class QueryCommand extends LogicCommand {
+    operator: QUERY_COMMANDS_LITERAL;
+    constructor(operator: QUERY_COMMANDS_LITERAL, operands: any, fieldName?: string | InternalSymbol);
+    toJSON(): {
+        ['$ne']: any;
+    } | {
+        [x: string]: any;
+        $ne?: undefined;
+    };
+    _setFieldName(fieldName: string): QueryCommand;
+    eq(val: any): LogicCommand;
+    neq(val: any): LogicCommand;
+    gt(val: any): LogicCommand;
+    gte(val: any): LogicCommand;
+    lt(val: any): LogicCommand;
+    lte(val: any): LogicCommand;
+    in(list: any[]): LogicCommand;
+    nin(list: any[]): LogicCommand;
+    geoNear(val: IGeoNearOptions): LogicCommand;
+    geoWithin(val: IGeoWithinOptions): LogicCommand;
+    geoIntersects(val: IGeoIntersectsOptions): LogicCommand;
+}
+export declare function isQueryCommand(object: any): object is QueryCommand;
+export declare function isKnownQueryCommand(object: any): object is QueryCommand;
+export declare function isComparisonCommand(object: any): object is QueryCommand;
+export default QueryCommand;
+export interface IGeoNearOptions {
+    geometry: Point;
+    maxDistance?: number;
+    minDistance?: number;
+}
+export interface IGeoWithinOptions {
+    geometry?: Polygon | MultiPolygon;
+    centerSphere?: CenterSphere;
+}
+export interface IGeoIntersectsOptions {
+    geometry: Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
+}

package/dist/esm/commands/query.js

@@ -0,0 +1,141 @@
+import { LogicCommand } from './logic';
+import { SYMBOL_QUERY_COMMAND } from '../helper/symbol';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from '../geo/index';
+import { isNumber } from '../utils/type';
+import { Validate } from '../validate';
+export const EQ = 'eq';
+export const NEQ = 'neq';
+export const GT = 'gt';
+export const GTE = 'gte';
+export const LT = 'lt';
+export const LTE = 'lte';
+export const IN = 'in';
+export const NIN = 'nin';
+export const ALL = 'all';
+export const ELEM_MATCH = 'elemMatch';
+export const EXISTS = 'exists';
+export const SIZE = 'size';
+export const MOD = 'mod';
+export var QUERY_COMMANDS_LITERAL;
+(function (QUERY_COMMANDS_LITERAL) {
+    QUERY_COMMANDS_LITERAL["EQ"] = "eq";
+    QUERY_COMMANDS_LITERAL["NEQ"] = "neq";
+    QUERY_COMMANDS_LITERAL["GT"] = "gt";
+    QUERY_COMMANDS_LITERAL["GTE"] = "gte";
+    QUERY_COMMANDS_LITERAL["LT"] = "lt";
+    QUERY_COMMANDS_LITERAL["LTE"] = "lte";
+    QUERY_COMMANDS_LITERAL["IN"] = "in";
+    QUERY_COMMANDS_LITERAL["NIN"] = "nin";
+    QUERY_COMMANDS_LITERAL["ALL"] = "all";
+    QUERY_COMMANDS_LITERAL["ELEM_MATCH"] = "elemMatch";
+    QUERY_COMMANDS_LITERAL["EXISTS"] = "exists";
+    QUERY_COMMANDS_LITERAL["SIZE"] = "size";
+    QUERY_COMMANDS_LITERAL["MOD"] = "mod";
+    QUERY_COMMANDS_LITERAL["GEO_NEAR"] = "geoNear";
+    QUERY_COMMANDS_LITERAL["GEO_WITHIN"] = "geoWithin";
+    QUERY_COMMANDS_LITERAL["GEO_INTERSECTS"] = "geoIntersects";
+})(QUERY_COMMANDS_LITERAL || (QUERY_COMMANDS_LITERAL = {}));
+export class QueryCommand extends LogicCommand {
+    constructor(operator, operands, fieldName) {
+        super(operator, operands, fieldName);
+        this.operator = operator;
+        this._internalType = SYMBOL_QUERY_COMMAND;
+    }
+    toJSON() {
+        switch (this.operator) {
+            case QUERY_COMMANDS_LITERAL.IN:
+            case QUERY_COMMANDS_LITERAL.NIN:
+                return {
+                    ['$' + this.operator]: this.operands
+                };
+            case QUERY_COMMANDS_LITERAL.NEQ:
+                return {
+                    ['$ne']: this.operands[0]
+                };
+            default:
+                return {
+                    ['$' + this.operator]: this.operands[0]
+                };
+        }
+    }
+    _setFieldName(fieldName) {
+        const command = new QueryCommand(this.operator, this.operands, fieldName);
+        return command;
+    }
+    eq(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.EQ, [val], this.fieldName);
+        return this.and(command);
+    }
+    neq(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.NEQ, [val], this.fieldName);
+        return this.and(command);
+    }
+    gt(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.GT, [val], this.fieldName);
+        return this.and(command);
+    }
+    gte(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.GTE, [val], this.fieldName);
+        return this.and(command);
+    }
+    lt(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.LT, [val], this.fieldName);
+        return this.and(command);
+    }
+    lte(val) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.LTE, [val], this.fieldName);
+        return this.and(command);
+    }
+    in(list) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.IN, list, this.fieldName);
+        return this.and(command);
+    }
+    nin(list) {
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.NIN, list, this.fieldName);
+        return this.and(command);
+    }
+    geoNear(val) {
+        if (!(val.geometry instanceof Point)) {
+            throw new TypeError(`"geometry" must be of type Point. Received type ${typeof val.geometry}`);
+        }
+        if (val.maxDistance !== undefined && !isNumber(val.maxDistance)) {
+            throw new TypeError(`"maxDistance" must be of type Number. Received type ${typeof val.maxDistance}`);
+        }
+        if (val.minDistance !== undefined && !isNumber(val.minDistance)) {
+            throw new TypeError(`"minDistance" must be of type Number. Received type ${typeof val.minDistance}`);
+        }
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_NEAR, [val], this.fieldName);
+        return this.and(command);
+    }
+    geoWithin(val) {
+        if (!(val.geometry instanceof MultiPolygon) &&
+            !(val.geometry instanceof Polygon) &&
+            !Validate.isCentersPhere(val.centerSphere)) {
+            throw new TypeError(`"geometry" must be of type Polygon or MultiPolygon. Received type ${typeof val.geometry}`);
+        }
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_WITHIN, [val], this.fieldName);
+        return this.and(command);
+    }
+    geoIntersects(val) {
+        if (!(val.geometry instanceof Point) &&
+            !(val.geometry instanceof LineString) &&
+            !(val.geometry instanceof Polygon) &&
+            !(val.geometry instanceof MultiPoint) &&
+            !(val.geometry instanceof MultiLineString) &&
+            !(val.geometry instanceof MultiPolygon)) {
+            throw new TypeError(`"geometry" must be of type Point, LineString, Polygon, MultiPoint, MultiLineString or MultiPolygon. Received type ${typeof val.geometry}`);
+        }
+        const command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_INTERSECTS, [val], this.fieldName);
+        return this.and(command);
+    }
+}
+export function isQueryCommand(object) {
+    return object && object instanceof QueryCommand && object._internalType === SYMBOL_QUERY_COMMAND;
+}
+export function isKnownQueryCommand(object) {
+    return isQueryCommand(object) && object.operator.toUpperCase() in QUERY_COMMANDS_LITERAL;
+}
+export function isComparisonCommand(object) {
+    return isQueryCommand(object);
+}
+export default QueryCommand;

package/dist/esm/commands/update.d.ts

@@ -0,0 +1,29 @@
+import { InternalSymbol } from '../helper/symbol';
+export declare enum UPDATE_COMMANDS_LITERAL {
+    SET = "set",
+    REMOVE = "remove",
+    INC = "inc",
+    MUL = "mul",
+    PUSH = "push",
+    PULL = "pull",
+    PULL_ALL = "pullAll",
+    POP = "pop",
+    SHIFT = "shift",
+    UNSHIFT = "unshift",
+    ADD_TO_SET = "addToSet",
+    BIT = "bit",
+    RENAME = "rename",
+    MAX = "max",
+    MIN = "min"
+}
+export declare class UpdateCommand {
+    fieldName: string | InternalSymbol;
+    operator: UPDATE_COMMANDS_LITERAL;
+    operands: any;
+    _internalType: InternalSymbol;
+    constructor(operator: UPDATE_COMMANDS_LITERAL, operands?: any, fieldName?: string | InternalSymbol);
+    _setFieldName(fieldName: string): UpdateCommand;
+}
+export declare function isUpdateCommand(object: any): object is UpdateCommand;
+export declare function isKnownUpdateCommand(object: any): object is UpdateCommand;
+export default UpdateCommand;

package/dist/esm/commands/update.js

@@ -0,0 +1,44 @@
+import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_UPDATE_COMMAND } from '../helper/symbol';
+export var UPDATE_COMMANDS_LITERAL;
+(function (UPDATE_COMMANDS_LITERAL) {
+    UPDATE_COMMANDS_LITERAL["SET"] = "set";
+    UPDATE_COMMANDS_LITERAL["REMOVE"] = "remove";
+    UPDATE_COMMANDS_LITERAL["INC"] = "inc";
+    UPDATE_COMMANDS_LITERAL["MUL"] = "mul";
+    UPDATE_COMMANDS_LITERAL["PUSH"] = "push";
+    UPDATE_COMMANDS_LITERAL["PULL"] = "pull";
+    UPDATE_COMMANDS_LITERAL["PULL_ALL"] = "pullAll";
+    UPDATE_COMMANDS_LITERAL["POP"] = "pop";
+    UPDATE_COMMANDS_LITERAL["SHIFT"] = "shift";
+    UPDATE_COMMANDS_LITERAL["UNSHIFT"] = "unshift";
+    UPDATE_COMMANDS_LITERAL["ADD_TO_SET"] = "addToSet";
+    UPDATE_COMMANDS_LITERAL["BIT"] = "bit";
+    UPDATE_COMMANDS_LITERAL["RENAME"] = "rename";
+    UPDATE_COMMANDS_LITERAL["MAX"] = "max";
+    UPDATE_COMMANDS_LITERAL["MIN"] = "min";
+})(UPDATE_COMMANDS_LITERAL || (UPDATE_COMMANDS_LITERAL = {}));
+export class UpdateCommand {
+    constructor(operator, operands, fieldName) {
+        this._internalType = SYMBOL_UPDATE_COMMAND;
+        Object.defineProperties(this, {
+            _internalType: {
+                enumerable: false,
+                configurable: false,
+            },
+        });
+        this.operator = operator;
+        this.operands = operands;
+        this.fieldName = fieldName || SYMBOL_UNSET_FIELD_NAME;
+    }
+    _setFieldName(fieldName) {
+        const command = new UpdateCommand(this.operator, this.operands, fieldName);
+        return command;
+    }
+}
+export function isUpdateCommand(object) {
+    return object && (object instanceof UpdateCommand) && (object._internalType === SYMBOL_UPDATE_COMMAND);
+}
+export function isKnownUpdateCommand(object) {
+    return isUpdateCommand(object) && (object.operator.toUpperCase() in UPDATE_COMMANDS_LITERAL);
+}
+export default UpdateCommand;

package/dist/esm/config/app.config.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    db_doc_size_limit: number;
+    db_realtime_ping_interval: number;
+    db_realtime_pong_wait_timeout: number;
+};
+export default _default;