proto.io 0.0.216 → 0.0.217

package/dist/internals/{validator-LNgZGT_l.mjs → validator-CEcBF4Cn.mjs}

@@ -1,8 +1,99 @@
 import _ from 'lodash';
-import { T as TObject, l as isPrimitiveValue, m as isValue, k as _isTypeof, c as isPrimitive, j as isVector, b as isShape, s as shapePaths, a as isRelation, i as isPointer, h as _typeof } from './index-BzDsTt4R.mjs';
+import { T as TObject, l as isPrimitiveValue, m as isValue, c as isPrimitive, j as isVector, k as _isTypeof, b as isShape, s as shapePaths, a as isRelation, i as isPointer, h as _typeof } from './index-BzDsTt4R.mjs';
 import Decimal from 'decimal.js';
 import { P as PVK } from './private-CNw40LZ7.mjs';
 
+//
+//  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
 //
@@ -49,13 +140,6 @@ const TConditionalKeys = [
     '$nor',
     '$or',
 ];
-const TDistanceKeys = [
-    '$distance',
-    '$innerProduct',
-    '$negInnerProduct',
-    '$cosineDistance',
-    '$rectilinearDistance',
-];
 
 //
 //  utils.ts
@@ -81,7 +165,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);
@@ -113,7 +197,7 @@ 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 TObject && rhs instanceof TObject) {
         if (lhs.className !== rhs.className)
@@ -146,7 +230,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))) {
@@ -225,6 +309,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
 //
@@ -249,6 +599,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 = [];
@@ -257,16 +610,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)));
                 }
@@ -430,6 +812,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;
@@ -488,7 +1181,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 (isPrimitive(dataType))
+            return [dataType.type];
+        if (isVector(dataType))
+            return [_.omit(dataType, 'default')];
+        return [dataType];
     }
 }
 class QueryValueExpression extends QueryExpression {
@@ -510,9 +1211,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 [];
     }
 }
@@ -834,7 +1535,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',
@@ -845,7 +1546,7 @@ const accumulatorExprKeys = [
     '$varPop',
     '$varSamp'
 ];
-const accumulatorNoParamKeys = [
+const TZeroParamAccumulatorKeys = [
     '$count'
 ];
 
@@ -876,11 +1577,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 ?? {};
@@ -909,7 +1610,7 @@ class QueryAccumulator {
         return;
     }
 }
-class QueryNoParamAccumulator extends QueryAccumulator {
+class QueryZeroParamAccumulator extends QueryAccumulator {
     type;
     constructor(type) {
         super();
@@ -930,7 +1631,7 @@ class QueryNoParamAccumulator extends QueryAccumulator {
         }
     }
 }
-class QueryExprAccumulator extends QueryAccumulator {
+class QueryUnaryAccumulator extends QueryAccumulator {
     type;
     expr;
     constructor(type, expr) {
@@ -939,13 +1640,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);
@@ -1389,5 +2090,5 @@ class QueryValidator {
     }
 }
 
-export { FieldSelectorExpression as F, QueryValidator as Q, QueryExpression as a, resolveDataType as b, QuerySelector as c, QueryCoditionalSelector as d, QueryFieldSelector as e, QueryExpressionSelector as f, QueryKeyExpression as g, QueryValueExpression as h, QueryCoditionalExpression as i, QueryComparisonExpression as j, QueryNotExpression as k, QueryDistanceExpression as l, QueryArrayExpression as m, QueryNoParamAccumulator as n, QueryExprAccumulator as o, QueryPercentileAccumulator as p, resolveColumn as r };
-//# sourceMappingURL=validator-LNgZGT_l.mjs.map
+export { FieldSelectorExpression as F, QueryValidator as Q, QueryExpression as a, resolveDataType as b, QuerySelector as c, QueryCoditionalSelector as d, QueryFieldSelector as e, QueryExpressionSelector as f, QueryArrayExpression as g, QueryValueExpression as h, QueryKeyExpression as i, QueryCoditionalExpression as j, QueryComparisonExpression as k, QueryNotExpression as l, QueryDistanceExpression as m, QueryZeroParamExpression as n, QueryUnaryExpression as o, QueryBinaryExpression as p, QueryListExpression as q, resolveColumn as r, QueryTernaryExpression as s, QueryCondExpression as t, QueryZeroParamAccumulator as u, QueryUnaryAccumulator as v, QueryPercentileAccumulator as w };
+//# sourceMappingURL=validator-CEcBF4Cn.mjs.map