proto.io 0.0.216 → 0.0.218

package/dist/internals/{validator-BBjOdLiT.js → validator-B5yHpyvb.js}

@@ -1,10 +1,101 @@
 'use strict';
 
 var _ = require('lodash');
-var index = require('./index-B8TESzd9.js');
+var index = require('./index-CLKTEIj0.js');
 var Decimal = require('decimal.js');
 var _private = require('./private-Ciddhure.js');
 
+//
+//  expressions.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const TZeroParamExprKeys = [
+    '$now',
+    '$rand',
+];
+const TUnaryExprKeys = [
+    '$abs',
+    '$neg',
+    '$sqrt',
+    '$cbrt',
+    '$ceil',
+    '$floor',
+    '$round',
+    '$exp',
+    '$ln',
+    '$log2',
+    '$log10',
+    '$sin',
+    '$cos',
+    '$tan',
+    '$asin',
+    '$acos',
+    '$atan',
+    '$asinh',
+    '$acosh',
+    '$atanh',
+    '$sinh',
+    '$cosh',
+    '$tanh',
+    '$degrees',
+    '$radians',
+    '$sign',
+    '$size',
+    '$lower',
+    '$upper',
+];
+const TBinaryExprKeys = [
+    '$divide',
+    '$subtract',
+    '$log',
+    '$pow',
+    '$atan2',
+    '$trim',
+    '$ltrim',
+    '$rtrim',
+    '$first',
+    '$last',
+    '$ldrop',
+    '$rdrop',
+];
+const TTernaryExprKeys = [
+    '$lpad',
+    '$rpad',
+];
+const TListExprKeys = [
+    '$add',
+    '$multiply',
+    '$ifNull',
+    '$concat',
+];
+const TDistanceExprKeys = [
+    '$distance',
+    '$innerProduct',
+    '$negInnerProduct',
+    '$cosineDistance',
+    '$rectilinearDistance',
+];
+
 //
 //  keys.ts
 //
@@ -51,13 +142,6 @@ const TConditionalKeys = [
     '$nor',
     '$or',
 ];
-const TDistanceKeys = [
-    '$distance',
-    '$innerProduct',
-    '$negInnerProduct',
-    '$cosineDistance',
-    '$rectilinearDistance',
-];
 
 //
 //  utils.ts
@@ -83,7 +167,7 @@ const TDistanceKeys = [
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const isNum = (x) => _.isNumber(x) || x instanceof BigInt || x instanceof Decimal;
+const isNum$1 = (x) => _.isNumber(x) || x instanceof BigInt || x instanceof Decimal;
 const equalNum = (lhs, rhs) => {
     if (lhs instanceof Decimal && rhs instanceof Decimal) {
         return lhs.equals(rhs);
@@ -115,14 +199,14 @@ const lessNum = (lhs, rhs) => {
 const equal = (lhs, rhs) => {
     if (_.isNil(lhs) && _.isNil(rhs))
         return true;
-    if (isNum(lhs) && isNum(rhs))
+    if (isNum$1(lhs) && isNum$1(rhs))
         return equalNum(lhs, rhs);
     if (lhs instanceof index.TObject && rhs instanceof index.TObject) {
         if (lhs.className !== rhs.className)
             return false;
-        if (_.isNil(lhs.objectId) && _.isNil(rhs.objectId))
+        if (_.isNil(lhs.id) && _.isNil(rhs.id))
             return lhs === rhs;
-        return lhs.objectId === rhs.objectId;
+        return lhs.id === rhs.id;
     }
     else if (lhs instanceof index.TObject || rhs instanceof index.TObject) {
         return false;
@@ -148,7 +232,7 @@ const lessThan = (lhs, rhs) => {
         return lhs < rhs;
     if (_.isDate(lhs) && _.isDate(rhs))
         return lhs < rhs;
-    if (isNum(lhs) && isNum(rhs))
+    if (isNum$1(lhs) && isNum$1(rhs))
         return lessNum(lhs, rhs);
     if (_.isArray(lhs) && _.isArray(rhs)) {
         for (const i of _.range(Math.min(lhs.length, rhs.length))) {
@@ -162,9 +246,9 @@ const lessThan = (lhs, rhs) => {
     if (lhs instanceof index.TObject && rhs instanceof index.TObject) {
         if (lhs.className !== rhs.className)
             return false;
-        if (_.isNil(lhs.objectId) && _.isNil(rhs.objectId))
+        if (_.isNil(lhs.id) && _.isNil(rhs.id))
             return false;
-        return (lhs.objectId ?? '') < (rhs.objectId ?? '');
+        return (lhs.id ?? '') < (rhs.id ?? '');
     }
     else if (lhs instanceof index.TObject || rhs instanceof index.TObject) {
         return false;
@@ -227,6 +311,272 @@ const cosine = (v1, v2) => {
     return _.sumBy(_.zip(v1, v2), ([a, b]) => a * b) / Math.sqrt(s1 * s2);
 };
 
+//
+//  utils.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const isNum = (x) => _.isNumber(x) || x instanceof Decimal;
+const MathUtils = {
+    sum: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.add(lhs, rhs);
+        return lhs + rhs;
+    },
+    subtract: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.sub(lhs, rhs);
+        return lhs - rhs;
+    },
+    multiply: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.mul(lhs, rhs);
+        return lhs * rhs;
+    },
+    divide: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.div(lhs, rhs);
+        return lhs / rhs;
+    },
+    abs: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.abs();
+        return Math.abs(lhs);
+    },
+    neg: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.neg();
+        return -lhs;
+    },
+    ceil: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.ceil();
+        return Math.ceil(lhs);
+    },
+    floor: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.floor();
+        return Math.floor(lhs);
+    },
+    round: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.round();
+        return Math.round(lhs);
+    },
+    exp: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.exp();
+        return Math.exp(lhs);
+    },
+    sqrt: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.sqrt();
+        return Math.sqrt(lhs);
+    },
+    cbrt: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.cbrt();
+        return Math.cbrt(lhs);
+    },
+    mod: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.mod(lhs, rhs);
+        return lhs % rhs;
+    },
+    pow: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.pow(lhs, rhs);
+        return Math.pow(lhs, rhs);
+    },
+    log: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.log(lhs, rhs);
+        return Math.log(lhs) / Math.log(rhs);
+    },
+    log10: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.log();
+        return Math.log10(lhs);
+    },
+    log2: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.log(2);
+        return Math.log2(lhs);
+    },
+    ln: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.ln();
+        return Math.log(lhs);
+    },
+    sin: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.sin();
+        return Math.sin(lhs);
+    },
+    cos: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.cos();
+        return Math.cos(lhs);
+    },
+    tan: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.tan();
+        return Math.tan(lhs);
+    },
+    asin: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.asin();
+        return Math.asin(lhs);
+    },
+    acos: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.acos();
+        return Math.acos(lhs);
+    },
+    atan: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.atan();
+        return Math.atan(lhs);
+    },
+    sinh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.sinh();
+        return Math.sinh(lhs);
+    },
+    cosh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.cosh();
+        return Math.cosh(lhs);
+    },
+    tanh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.tanh();
+        return Math.tanh(lhs);
+    },
+    asinh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.asinh();
+        return Math.asinh(lhs);
+    },
+    acosh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.acosh();
+        return Math.acosh(lhs);
+    },
+    atanh: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return lhs.atanh();
+        return Math.atanh(lhs);
+    },
+    atan2: (lhs, rhs) => {
+        if (!isNum(lhs) || !isNum(rhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal || rhs instanceof Decimal)
+            return Decimal.atan2(lhs, rhs);
+        return Math.atan2(lhs, rhs);
+    },
+    degrees: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return Decimal.div(Decimal.mul(lhs, 180), Math.PI);
+        return (lhs * 180) / Math.PI;
+    },
+    radians: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return Decimal.div(Decimal.mul(lhs, Math.PI), 180);
+        return (lhs * Math.PI) / 180;
+    },
+    sign: (lhs) => {
+        if (!isNum(lhs))
+            throw Error('Invalid operation');
+        if (lhs instanceof Decimal)
+            return Decimal.sign(lhs);
+        return Math.sign(lhs);
+    },
+};
+
 //
 //  expressions.ts
 //
@@ -251,6 +601,9 @@ const cosine = (v1, v2) => {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
+const combineNumericTypes = (...list) => {
+    return _.some(_.flattenDeep(list), x => x === 'decimal') ? ['decimal'] : ['number'];
+};
 class QueryExpression {
     static decode(expr, dollerSign) {
         const exprs = [];
@@ -259,16 +612,45 @@ class QueryExpression {
                 if (_.includes(TConditionalKeys, key) && _.isArray(query)) {
                     exprs.push(new QueryCoditionalExpression(key, _.map(query, x => QueryExpression.decode(x, dollerSign))));
                 }
+                else if (_.includes(TZeroParamExprKeys, key)) {
+                    exprs.push(new QueryZeroParamExpression(key));
+                }
+                else if (_.includes(TUnaryExprKeys, key)) {
+                    exprs.push(new QueryUnaryExpression(key, QueryExpression.decode(query, dollerSign)));
+                }
+                else if (_.includes(TBinaryExprKeys, key) && _.isArray(query) && query.length === 2) {
+                    const [left, right] = query;
+                    exprs.push(new QueryBinaryExpression(key, QueryExpression.decode(left, dollerSign), QueryExpression.decode(right, dollerSign)));
+                }
+                else if (_.includes(TTernaryExprKeys, key) && _.isArray(query) && query.length === 3) {
+                    const [first, second, last] = query;
+                    exprs.push(new QueryTernaryExpression(key, QueryExpression.decode(first, dollerSign), QueryExpression.decode(second, dollerSign), QueryExpression.decode(last, dollerSign)));
+                }
+                else if (_.includes(TListExprKeys, key) && _.isArray(query)) {
+                    if (query.length === 0)
+                        throw Error('Invalid expression');
+                    exprs.push(new QueryListExpression(key, _.map(query, x => QueryExpression.decode(x, dollerSign))));
+                }
                 else if (_.includes(TComparisonKeys, key) && _.isArray(query) && query.length === 2) {
                     const [left, right] = query;
                     exprs.push(new QueryComparisonExpression(key, QueryExpression.decode(left, dollerSign), QueryExpression.decode(right, dollerSign)));
                 }
-                else if (_.includes(TDistanceKeys, key) && _.isArray(query) && query.length === 2) {
+                else if (_.includes(TDistanceExprKeys, key) && _.isArray(query) && query.length === 2) {
                     const [left, right] = query;
                     const _left = _.isArray(left) ? _.map(left, x => QueryExpression.decode(x, dollerSign)) : QueryExpression.decode(left, dollerSign);
                     const _right = _.isArray(right) ? _.map(right, x => QueryExpression.decode(x, dollerSign)) : QueryExpression.decode(right, dollerSign);
                     exprs.push(new QueryDistanceExpression(key, _.castArray(_left), _.castArray(_right)));
                 }
+                else if (key === '$cond' && _.isPlainObject(query)) {
+                    const { branch: _branch, default: defaultCase } = query;
+                    const branch = _.castArray(_branch ?? []);
+                    if (branch.length === 0)
+                        throw Error('Invalid expression');
+                    exprs.push(new QueryCondExpression(_.map(branch, ({ case: c, then: t }) => ({
+                        case: QueryExpression.decode(c, dollerSign),
+                        then: QueryExpression.decode(t, dollerSign),
+                    })), QueryExpression.decode(defaultCase, dollerSign)));
+                }
                 else if (key === '$not') {
                     exprs.push(new QueryNotExpression(QueryExpression.decode(query, dollerSign)));
                 }
@@ -432,6 +814,317 @@ class QueryArrayExpression extends QueryExpression {
         return ['array'];
     }
 }
+class QueryZeroParamExpression extends QueryExpression {
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    eval(value) {
+        switch (this.type) {
+            case '$now': return new Date();
+            case '$rand': return Math.random();
+        }
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$now': return ['date'];
+            case '$rand': return ['number', 'decimal'];
+        }
+    }
+}
+class QueryUnaryExpression extends QueryExpression {
+    type;
+    expr;
+    constructor(type, expr) {
+        super();
+        this.type = type;
+        this.expr = expr;
+    }
+    simplify() {
+        return new QueryUnaryExpression(this.type, this.expr.simplify());
+    }
+    keyPaths() {
+        return this.expr.keyPaths();
+    }
+    mapKey(callback) {
+        return new QueryUnaryExpression(this.type, this.expr.mapKey(callback));
+    }
+    eval(value) {
+        switch (this.type) {
+            case '$abs': return MathUtils.abs(this.expr.eval(value));
+            case '$neg': return MathUtils.neg(this.expr.eval(value));
+            case '$sqrt': return MathUtils.sqrt(this.expr.eval(value));
+            case '$cbrt': return MathUtils.cbrt(this.expr.eval(value));
+            case '$ceil': return MathUtils.ceil(this.expr.eval(value));
+            case '$floor': return MathUtils.floor(this.expr.eval(value));
+            case '$round': return MathUtils.round(this.expr.eval(value));
+            case '$exp': return MathUtils.exp(this.expr.eval(value));
+            case '$ln': return MathUtils.ln(this.expr.eval(value));
+            case '$log2': return MathUtils.log2(this.expr.eval(value));
+            case '$log10': return MathUtils.log10(this.expr.eval(value));
+            case '$sin': return MathUtils.sin(this.expr.eval(value));
+            case '$cos': return MathUtils.cos(this.expr.eval(value));
+            case '$tan': return MathUtils.tan(this.expr.eval(value));
+            case '$asin': return MathUtils.asin(this.expr.eval(value));
+            case '$acos': return MathUtils.acos(this.expr.eval(value));
+            case '$atan': return MathUtils.atan(this.expr.eval(value));
+            case '$asinh': return MathUtils.asinh(this.expr.eval(value));
+            case '$acosh': return MathUtils.acosh(this.expr.eval(value));
+            case '$atanh': return MathUtils.atanh(this.expr.eval(value));
+            case '$sinh': return MathUtils.sinh(this.expr.eval(value));
+            case '$cosh': return MathUtils.cosh(this.expr.eval(value));
+            case '$tanh': return MathUtils.tanh(this.expr.eval(value));
+            case '$degrees': return MathUtils.degrees(this.expr.eval(value));
+            case '$radians': return MathUtils.radians(this.expr.eval(value));
+            case '$sign': return MathUtils.sign(this.expr.eval(value));
+            case '$size':
+                {
+                    const v = this.expr.eval(value);
+                    if (!_.isArray(v) && !_.isString(v))
+                        throw Error('Invalid value');
+                    return v.length;
+                }
+            case '$lower': return _.toLower(this.expr.eval(value));
+            case '$upper': return _.toUpper(this.expr.eval(value));
+        }
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$abs': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$neg': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$sqrt': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$cbrt': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$ceil': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$floor': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$round': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$exp': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$ln': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$log2': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$log10': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$sin': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$cos': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$tan': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$asin': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$acos': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$atan': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$asinh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$acosh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$atanh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$sinh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$cosh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$tanh': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$degrees': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$radians': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$sign': return combineNumericTypes(this.expr.evalType(schema, className));
+            case '$size': return ['number'];
+            case '$lower': return ['string'];
+            case '$upper': return ['string'];
+        }
+    }
+}
+class QueryBinaryExpression extends QueryExpression {
+    type;
+    left;
+    right;
+    constructor(type, left, right) {
+        super();
+        this.type = type;
+        this.left = left;
+        this.right = right;
+    }
+    simplify() {
+        return new QueryBinaryExpression(this.type, this.left.simplify(), this.right.simplify());
+    }
+    keyPaths() {
+        return _.uniq([
+            ...this.left.keyPaths(),
+            ...this.right.keyPaths(),
+        ]);
+    }
+    mapKey(callback) {
+        return new QueryBinaryExpression(this.type, this.left.mapKey(callback), this.right.mapKey(callback));
+    }
+    eval(value) {
+        const left = this.left.eval(value);
+        const right = this.right?.eval(value);
+        switch (this.type) {
+            case '$divide': return MathUtils.divide(left, right);
+            case '$subtract': return MathUtils.subtract(left, right);
+            case '$log': return MathUtils.log(left, right);
+            case '$pow': return MathUtils.pow(left, right);
+            case '$atan2': return MathUtils.atan2(left, right);
+            case '$trim':
+                if (!_.isString(left) || !_.isString(right))
+                    throw Error('Invalid value');
+                return _.trim(left, right);
+            case '$ltrim':
+                if (!_.isString(left) || !_.isString(right))
+                    throw Error('Invalid value');
+                return _.trimStart(left, right);
+            case '$rtrim':
+                if (!_.isString(left) || !_.isString(right))
+                    throw Error('Invalid value');
+                return _.trimEnd(left, right);
+            case '$first':
+                if (!_.isArray(left) && !_.isString(left))
+                    throw Error('Invalid value');
+                if (!_.isSafeInteger(right) || right <= 0)
+                    throw Error('Invalid value');
+                return _.isString(left) ? left.slice(0, right) : _.take(left, right);
+            case '$last':
+                if (!_.isArray(left) && !_.isString(left))
+                    throw Error('Invalid value');
+                if (!_.isSafeInteger(right) || right <= 0)
+                    throw Error('Invalid value');
+                return _.isString(left) ? left.slice(-right) : _.takeRight(left, right);
+            case '$ldrop':
+                if (!_.isArray(left) && !_.isString(left))
+                    throw Error('Invalid value');
+                if (!_.isSafeInteger(right) || right <= 0)
+                    throw Error('Invalid value');
+                return _.isString(left) ? left.slice(right) : _.drop(left, right);
+            case '$rdrop':
+                if (!_.isArray(left) && !_.isString(left))
+                    throw Error('Invalid value');
+                if (!_.isSafeInteger(right) || right <= 0)
+                    throw Error('Invalid value');
+                return _.isString(left) ? left.slice(0, -right) : _.dropRight(left, right);
+        }
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$divide':
+            case '$subtract':
+            case '$log':
+            case '$pow':
+            case '$atan2':
+                return combineNumericTypes(this.left.evalType(schema, className), this.right.evalType(schema, className));
+            case '$trim':
+            case '$ltrim':
+            case '$rtrim':
+                return ['string'];
+            case '$first':
+            case '$last':
+            case '$ldrop':
+            case '$rdrop':
+                return _.intersection(this.left.evalType(schema, className), ['string', 'string[]', 'array']);
+        }
+    }
+}
+class QueryTernaryExpression extends QueryExpression {
+    type;
+    first;
+    second;
+    last;
+    constructor(type, first, second, last) {
+        super();
+        this.type = type;
+        this.first = first;
+        this.second = second;
+        this.last = last;
+    }
+    simplify() {
+        return new QueryTernaryExpression(this.type, this.first.simplify(), this.second.simplify(), this.last.simplify());
+    }
+    keyPaths() {
+        return _.uniq([
+            ...this.first.keyPaths(),
+            ...this.second.keyPaths(),
+            ...this.last.keyPaths(),
+        ]);
+    }
+    mapKey(callback) {
+        return new QueryTernaryExpression(this.type, this.first.mapKey(callback), this.second.mapKey(callback), this.last.mapKey(callback));
+    }
+    eval(value) {
+        const first = this.first.eval(value);
+        const second = this.second.eval(value);
+        const last = this.last.eval(value);
+        switch (this.type) {
+            case '$lpad':
+                if (!_.isString(first) || !_.isSafeInteger(second) || !_.isString(last))
+                    throw Error('Invalid value');
+                return _.padStart(first, second, last);
+            case '$rpad':
+                if (!_.isString(first) || !_.isSafeInteger(second) || !_.isString(last))
+                    throw Error('Invalid value');
+                return _.padEnd(first, second, last);
+        }
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$lpad':
+            case '$rpad':
+                return ['string'];
+        }
+    }
+}
+class QueryListExpression extends QueryExpression {
+    type;
+    exprs;
+    constructor(type, exprs) {
+        super();
+        this.type = type;
+        this.exprs = exprs;
+    }
+    simplify() {
+        return new QueryListExpression(this.type, _.map(this.exprs, x => x.simplify()));
+    }
+    keyPaths() {
+        return _.uniq(_.flatMap(this.exprs, x => x.keyPaths()));
+    }
+    mapKey(callback) {
+        return new QueryListExpression(this.type, _.map(this.exprs, x => x.mapKey(callback)));
+    }
+    eval(value) {
+        switch (this.type) {
+            case '$add': return _.isEmpty(this.exprs) ? undefined : _.reduce(this.exprs, (a, b) => MathUtils.sum(a, b.eval(value)), 0);
+            case '$multiply': return _.isEmpty(this.exprs) ? undefined : _.reduce(this.exprs, (a, b) => MathUtils.multiply(a, b.eval(value)), 1);
+            case '$ifNull': return _.find(_.map(this.exprs, x => x.eval(value)), x => !_.isNil(x));
+            case '$concat': return _.join(_.map(this.exprs, x => x.eval(value)), '');
+        }
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$add': return combineNumericTypes(..._.map(this.exprs, x => x.evalType(schema, className)));
+            case '$multiply': return combineNumericTypes(..._.map(this.exprs, x => x.evalType(schema, className)));
+            case '$ifNull': return _.intersection(..._.map(this.exprs, x => x.evalType(schema, className)));
+            case '$concat': return ['string'];
+        }
+    }
+}
+class QueryCondExpression extends QueryExpression {
+    branch;
+    default;
+    constructor(branch, defaultCase) {
+        super();
+        this.branch = branch;
+        this.default = defaultCase;
+    }
+    simplify() {
+        return new QueryCondExpression(_.map(this.branch, ({ case: c, then: t }) => ({ case: c.simplify(), then: t.simplify() })), this.default.simplify());
+    }
+    keyPaths() {
+        return _.uniq([
+            ..._.flatMap(this.branch, ({ case: c, then: t }) => [...c.keyPaths(), ...t.keyPaths()]),
+            ...this.default.keyPaths(),
+        ]);
+    }
+    mapKey(callback) {
+        return new QueryCondExpression(_.map(this.branch, ({ case: c, then: t }) => ({ case: c.mapKey(callback), then: t.mapKey(callback) })), this.default.mapKey(callback));
+    }
+    eval(value) {
+        for (const { case: c, then: t } of this.branch) {
+            if (c.eval(value))
+                return t.eval(value);
+        }
+        return this.default.eval(value);
+    }
+    evalType(schema, className) {
+        return _.intersection(..._.map(this.branch, ({ then: t }) => t.evalType(schema, className)), this.default.evalType(schema, className));
+    }
+}
 class QueryDistanceExpression extends QueryExpression {
     type;
     left;
@@ -490,7 +1183,15 @@ class QueryKeyExpression extends QueryExpression {
     }
     evalType(schema, className) {
         const { paths: [, ...subpath], dataType } = resolveColumn(schema, className, this.key);
-        return _.isEmpty(subpath) ? [dataType] : [];
+        if (!_.isEmpty(subpath))
+            return [];
+        if (_.isString(dataType))
+            return [dataType];
+        if (index.isPrimitive(dataType))
+            return [dataType.type];
+        if (index.isVector(dataType))
+            return [_.omit(dataType, 'default')];
+        return [dataType];
     }
 }
 class QueryValueExpression extends QueryExpression {
@@ -512,9 +1213,9 @@ class QueryValueExpression extends QueryExpression {
         if (_.isString(this.value))
             return ['string'];
         if (_.isNumber(this.value))
-            return ['number', 'decimal'];
+            return ['number'];
         if (this.value instanceof Decimal)
-            return ['decimal', 'number'];
+            return ['decimal'];
         return [];
     }
 }
@@ -836,7 +1537,7 @@ class QueryExpressionSelector extends QuerySelector {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const accumulatorExprKeys = [
+const TUnaryAccumulatorKeys = [
     '$max',
     '$min',
     '$most',
@@ -847,7 +1548,7 @@ const accumulatorExprKeys = [
     '$varPop',
     '$varSamp'
 ];
-const accumulatorNoParamKeys = [
+const TZeroParamAccumulatorKeys = [
     '$count'
 ];
 
@@ -878,11 +1579,11 @@ const accumulatorNoParamKeys = [
 class QueryAccumulator {
     static decode(query) {
         for (const [key, expr] of _.toPairs(query)) {
-            if (_.includes(accumulatorExprKeys, key)) {
-                return new QueryExprAccumulator(key, QueryExpression.decode(expr ?? [], false));
+            if (_.includes(TUnaryAccumulatorKeys, key)) {
+                return new QueryUnaryAccumulator(key, QueryExpression.decode(expr ?? [], false));
             }
-            else if (_.includes(accumulatorNoParamKeys, key)) {
-                return new QueryNoParamAccumulator(key);
+            else if (_.includes(TZeroParamAccumulatorKeys, key)) {
+                return new QueryZeroParamAccumulator(key);
             }
             else if (key === '$percentile') {
                 const { input, p, mode = 'discrete' } = expr ?? {};
@@ -911,7 +1612,7 @@ class QueryAccumulator {
         return;
     }
 }
-class QueryNoParamAccumulator extends QueryAccumulator {
+class QueryZeroParamAccumulator extends QueryAccumulator {
     type;
     constructor(type) {
         super();
@@ -932,7 +1633,7 @@ class QueryNoParamAccumulator extends QueryAccumulator {
         }
     }
 }
-class QueryExprAccumulator extends QueryAccumulator {
+class QueryUnaryAccumulator extends QueryAccumulator {
     type;
     expr;
     constructor(type, expr) {
@@ -941,13 +1642,13 @@ class QueryExprAccumulator extends QueryAccumulator {
         this.expr = expr;
     }
     simplify() {
-        return new QueryExprAccumulator(this.type, this.expr.simplify());
+        return new QueryUnaryAccumulator(this.type, this.expr.simplify());
     }
     keyPaths() {
         return this.expr.keyPaths();
     }
     mapKey(callback) {
-        return new QueryExprAccumulator(this.type, this.expr.mapKey(callback));
+        return new QueryUnaryAccumulator(this.type, this.expr.mapKey(callback));
     }
     evalType(schema, className) {
         const [dataType] = this.expr.evalType(schema, className);
@@ -1368,7 +2069,7 @@ class QueryValidator {
         };
     }
     isGetMethod(query) {
-        const objectIds = [];
+        const ids = [];
         if (query instanceof QueryCoditionalSelector && query.type === '$and') {
             for (const expr of query.exprs) {
                 if (expr instanceof QueryFieldSelector &&
@@ -1376,7 +2077,7 @@ class QueryValidator {
                     expr.expr.type === '$eq') {
                     if (!_.isString(expr.expr.value))
                         return false;
-                    objectIds.push(expr.expr.value);
+                    ids.push(expr.expr.value);
                 }
             }
         }
@@ -1385,29 +2086,35 @@ class QueryValidator {
             query.expr.type === '$eq') {
             if (!_.isString(query.expr.value))
                 return false;
-            objectIds.push(query.expr.value);
+            ids.push(query.expr.value);
         }
-        return _.uniq(objectIds).length === 1;
+        return _.uniq(ids).length === 1;
     }
 }
 
 exports.FieldSelectorExpression = FieldSelectorExpression;
 exports.QueryArrayExpression = QueryArrayExpression;
+exports.QueryBinaryExpression = QueryBinaryExpression;
 exports.QueryCoditionalExpression = QueryCoditionalExpression;
 exports.QueryCoditionalSelector = QueryCoditionalSelector;
 exports.QueryComparisonExpression = QueryComparisonExpression;
+exports.QueryCondExpression = QueryCondExpression;
 exports.QueryDistanceExpression = QueryDistanceExpression;
-exports.QueryExprAccumulator = QueryExprAccumulator;
 exports.QueryExpression = QueryExpression;
 exports.QueryExpressionSelector = QueryExpressionSelector;
 exports.QueryFieldSelector = QueryFieldSelector;
 exports.QueryKeyExpression = QueryKeyExpression;
-exports.QueryNoParamAccumulator = QueryNoParamAccumulator;
+exports.QueryListExpression = QueryListExpression;
 exports.QueryNotExpression = QueryNotExpression;
 exports.QueryPercentileAccumulator = QueryPercentileAccumulator;
 exports.QuerySelector = QuerySelector;
+exports.QueryTernaryExpression = QueryTernaryExpression;
+exports.QueryUnaryAccumulator = QueryUnaryAccumulator;
+exports.QueryUnaryExpression = QueryUnaryExpression;
 exports.QueryValidator = QueryValidator;
 exports.QueryValueExpression = QueryValueExpression;
+exports.QueryZeroParamAccumulator = QueryZeroParamAccumulator;
+exports.QueryZeroParamExpression = QueryZeroParamExpression;
 exports.resolveColumn = resolveColumn;
 exports.resolveDataType = resolveDataType;
-//# sourceMappingURL=validator-BBjOdLiT.js.map
+//# sourceMappingURL=validator-B5yHpyvb.js.map