@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.5

package/node_modules/@cloudbase/database/dist/esm/command.d.ts

@@ -0,0 +1,175 @@
+import { QueryCommand } from './commands/query';
+import { LogicCommand } from './commands/logic';
+import { UpdateCommand } from './commands/update';
+import Aggregation from './aggregate';
+export type IQueryCondition = Record<string, any> | LogicCommand;
+export declare const Command: {
+    eq(val: any): QueryCommand;
+    neq(val: any): QueryCommand;
+    lt(val: any): QueryCommand;
+    lte(val: any): QueryCommand;
+    gt(val: any): QueryCommand;
+    gte(val: any): QueryCommand;
+    in(val: any): QueryCommand;
+    nin(val: any): QueryCommand;
+    all(val: any): QueryCommand;
+    elemMatch(val: any): QueryCommand;
+    exists(val: boolean): QueryCommand;
+    size(val: number): QueryCommand;
+    mod(val: number[]): QueryCommand;
+    geoNear(val: any): QueryCommand;
+    geoWithin(val: any): QueryCommand;
+    geoIntersects(val: any): QueryCommand;
+    and(...__expressions__: IQueryCondition[]): LogicCommand;
+    nor(...__expressions__: IQueryCondition[]): LogicCommand;
+    or(...__expressions__: IQueryCondition[]): LogicCommand;
+    not(...__expressions__: IQueryCondition[]): LogicCommand;
+    set(val: any): UpdateCommand;
+    remove(): UpdateCommand;
+    inc(val: number): UpdateCommand;
+    mul(val: number): UpdateCommand;
+    push(...args: any[]): UpdateCommand;
+    pull(values: any): UpdateCommand;
+    pullAll(values: any): UpdateCommand;
+    pop(): UpdateCommand;
+    shift(): UpdateCommand;
+    unshift(...__values__: any[]): UpdateCommand;
+    addToSet(values: any): UpdateCommand;
+    rename(values: any): UpdateCommand;
+    bit(values: any): UpdateCommand;
+    max(values: any): UpdateCommand;
+    min(values: any): UpdateCommand;
+    expr(values: AggregationOperator): {
+        $expr: AggregationOperator;
+    };
+    jsonSchema(schema: any): {
+        $jsonSchema: any;
+    };
+    text(values: string | {
+        search: string;
+        language?: string;
+        caseSensitive?: boolean;
+        diacriticSensitive: boolean;
+    }): {
+        $search: {
+            (regexp: string | RegExp): number;
+            (searcher: {
+                [Symbol.search](string: string): number;
+            }): number;
+        };
+        $language?: undefined;
+        $caseSensitive?: undefined;
+        $diacriticSensitive?: undefined;
+    } | {
+        $search: string;
+        $language: string;
+        $caseSensitive: boolean;
+        $diacriticSensitive: boolean;
+    };
+    aggregate: {
+        pipeline(): Aggregation;
+        abs: (param: any) => AggregationOperator;
+        add: (param: any) => AggregationOperator;
+        ceil: (param: any) => AggregationOperator;
+        divide: (param: any) => AggregationOperator;
+        exp: (param: any) => AggregationOperator;
+        floor: (param: any) => AggregationOperator;
+        ln: (param: any) => AggregationOperator;
+        log: (param: any) => AggregationOperator;
+        log10: (param: any) => AggregationOperator;
+        mod: (param: any) => AggregationOperator;
+        multiply: (param: any) => AggregationOperator;
+        pow: (param: any) => AggregationOperator;
+        sqrt: (param: any) => AggregationOperator;
+        subtract: (param: any) => AggregationOperator;
+        trunc: (param: any) => AggregationOperator;
+        arrayElemAt: (param: any) => AggregationOperator;
+        arrayToObject: (param: any) => AggregationOperator;
+        concatArrays: (param: any) => AggregationOperator;
+        filter: (param: any) => AggregationOperator;
+        in: (param: any) => AggregationOperator;
+        indexOfArray: (param: any) => AggregationOperator;
+        isArray: (param: any) => AggregationOperator;
+        map: (param: any) => AggregationOperator;
+        range: (param: any) => AggregationOperator;
+        reduce: (param: any) => AggregationOperator;
+        reverseArray: (param: any) => AggregationOperator;
+        size: (param: any) => AggregationOperator;
+        slice: (param: any) => AggregationOperator;
+        zip: (param: any) => AggregationOperator;
+        and: (param: any) => AggregationOperator;
+        not: (param: any) => AggregationOperator;
+        or: (param: any) => AggregationOperator;
+        cmp: (param: any) => AggregationOperator;
+        eq: (param: any) => AggregationOperator;
+        gt: (param: any) => AggregationOperator;
+        gte: (param: any) => AggregationOperator;
+        lt: (param: any) => AggregationOperator;
+        lte: (param: any) => AggregationOperator;
+        neq: (param: any) => AggregationOperator;
+        cond: (param: any) => AggregationOperator;
+        ifNull: (param: any) => AggregationOperator;
+        switch: (param: any) => AggregationOperator;
+        dateFromParts: (param: any) => AggregationOperator;
+        dateFromString: (param: any) => AggregationOperator;
+        dayOfMonth: (param: any) => AggregationOperator;
+        dayOfWeek: (param: any) => AggregationOperator;
+        dayOfYear: (param: any) => AggregationOperator;
+        isoDayOfWeek: (param: any) => AggregationOperator;
+        isoWeek: (param: any) => AggregationOperator;
+        isoWeekYear: (param: any) => AggregationOperator;
+        millisecond: (param: any) => AggregationOperator;
+        minute: (param: any) => AggregationOperator;
+        month: (param: any) => AggregationOperator;
+        second: (param: any) => AggregationOperator;
+        hour: (param: any) => AggregationOperator;
+        week: (param: any) => AggregationOperator;
+        year: (param: any) => AggregationOperator;
+        literal: (param: any) => AggregationOperator;
+        mergeObjects: (param: any) => AggregationOperator;
+        objectToArray: (param: any) => AggregationOperator;
+        allElementsTrue: (param: any) => AggregationOperator;
+        anyElementTrue: (param: any) => AggregationOperator;
+        setDifference: (param: any) => AggregationOperator;
+        setEquals: (param: any) => AggregationOperator;
+        setIntersection: (param: any) => AggregationOperator;
+        setIsSubset: (param: any) => AggregationOperator;
+        setUnion: (param: any) => AggregationOperator;
+        concat: (param: any) => AggregationOperator;
+        dateToString: (param: any) => AggregationOperator;
+        indexOfBytes: (param: any) => AggregationOperator;
+        indexOfCP: (param: any) => AggregationOperator;
+        split: (param: any) => AggregationOperator;
+        strLenBytes: (param: any) => AggregationOperator;
+        strLenCP: (param: any) => AggregationOperator;
+        strcasecmp: (param: any) => AggregationOperator;
+        substr: (param: any) => AggregationOperator;
+        substrBytes: (param: any) => AggregationOperator;
+        substrCP: (param: any) => AggregationOperator;
+        toLower: (param: any) => AggregationOperator;
+        toUpper: (param: any) => AggregationOperator;
+        meta: (param: any) => AggregationOperator;
+        addToSet: (param: any) => AggregationOperator;
+        avg: (param: any) => AggregationOperator;
+        first: (param: any) => AggregationOperator;
+        last: (param: any) => AggregationOperator;
+        max: (param: any) => AggregationOperator;
+        min: (param: any) => AggregationOperator;
+        push: (param: any) => AggregationOperator;
+        stdDevPop: (param: any) => AggregationOperator;
+        stdDevSamp: (param: any) => AggregationOperator;
+        sum: (param: any) => AggregationOperator;
+        let: (param: any) => AggregationOperator;
+    };
+    project: {
+        slice: (param: any) => ProjectionOperator;
+        elemMatch: (param: any) => ProjectionOperator;
+    };
+};
+declare class AggregationOperator {
+    constructor(name: any, param: any);
+}
+declare class ProjectionOperator {
+    constructor(name: any, param: any);
+}
+export default Command;

package/node_modules/@cloudbase/database/dist/esm/command.js

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

package/node_modules/@cloudbase/database/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/node_modules/@cloudbase/database/dist/esm/commands/logic.js

@@ -0,0 +1,84 @@
+import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_LOGIC_COMMAND } from '../helper/symbol';
+import { isQueryCommand } from './query';
+export var AND = 'and';
+export var OR = 'or';
+export var NOT = 'not';
+export var 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 = {}));
+var LogicCommand = (function () {
+    function LogicCommand(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 (var i = 0, len = operands.length; i < len; i++) {
+                    var query = operands[i];
+                    if (isLogicCommand(query) || isQueryCommand(query)) {
+                        operands[i] = query._setFieldName(this.fieldName);
+                    }
+                }
+            }
+            else {
+                var query = operands;
+                if (isLogicCommand(query) || isQueryCommand(query)) {
+                    operands = query._setFieldName(this.fieldName);
+                }
+            }
+        }
+    }
+    LogicCommand.prototype._setFieldName = function (fieldName) {
+        var operands = this.operands.map(function (operand) {
+            if (operand instanceof LogicCommand) {
+                return operand._setFieldName(fieldName);
+            }
+            else {
+                return operand;
+            }
+        });
+        var command = new LogicCommand(this.operator, operands, fieldName);
+        return command;
+    };
+    LogicCommand.prototype.and = function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        expressions.unshift(this);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.AND, expressions, this.fieldName);
+    };
+    LogicCommand.prototype.or = function () {
+        var __expressions__ = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            __expressions__[_i] = arguments[_i];
+        }
+        var expressions = Array.isArray(arguments[0]) ? arguments[0] : Array.from(arguments);
+        expressions.unshift(this);
+        return new LogicCommand(LOGIC_COMMANDS_LITERAL.OR, expressions, this.fieldName);
+    };
+    return LogicCommand;
+}());
+export { LogicCommand };
+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/node_modules/@cloudbase/database/dist/esm/commands/query.d.ts

@@ -0,0 +1,68 @@
+import { LogicCommand } from './logic';
+import { InternalSymbol } from '../helper/symbol';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from '../geo/index';
+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(): {
+        [x: string]: any;
+    };
+    _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;
+}
+export interface IGeoIntersectsOptions {
+    geometry: Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
+}