proto.io 0.0.214 → 0.0.216

package/dist/adapters/storage/progres.js

@@ -9,7 +9,7 @@ var QueryStream = require('pg-query-stream');
 var utilsJs = require('@o2ter/utils-js');
 var Decimal = require('decimal.js');
 var utils = require('pg/lib/utils');
-var validator = require('../../internals/validator-DoRPoIs2.js');
+var validator = require('../../internals/validator-BBjOdLiT.js');
 require('@o2ter/crypto-js');
 var _const = require('../../internals/const-C3I6cfav.js');
 var random$1 = require('../../internals/random-nkOQ9U6S.js');
@@ -540,6 +540,399 @@ class QueryCompiler {
     }
 }
 
+//
+//  encode.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 _encodeJsonValue = (value) => {
+    if (_.isArray(value))
+        return sql `jsonb_build_array(${_.map(value, x => _encodeJsonValue(x))})`;
+    if (_.isPlainObject(value))
+        return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
+    return sql `to_jsonb(${{ value }})`;
+};
+const _jsonPopulateInclude = (className, colname, dataType) => {
+    switch (index._typeof(dataType)) {
+        case 'decimal':
+            return sql `jsonb_build_object(
+            '$decimal', CAST(${{ identifier: className }}.${{ identifier: colname }} AS TEXT)
+          ) AS ${{ identifier: colname }}`;
+        case 'date':
+            return sql `jsonb_build_object(
+            '$date', to_char(${{ identifier: className }}.${{ identifier: colname }} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+          ) AS ${{ identifier: colname }}`;
+        default:
+            return sql `${{ identifier: className }}.${{ identifier: colname }}`;
+    }
+};
+const encodeType = (colname, dataType, value) => {
+    if (_.isNil(value))
+        return sql `NULL`;
+    switch (_.isString(dataType) ? dataType : dataType.type) {
+        case 'boolean':
+            if (_.isBoolean(value))
+                return sql `${{ value }}`;
+            break;
+        case 'number':
+            if (_.isNumber(value) && _.isFinite(value))
+                return sql `${{ value }}`;
+            if (value instanceof Decimal)
+                return sql `${{ value: value.toNumber() }}`;
+            break;
+        case 'decimal':
+            if (_.isNumber(value) && _.isFinite(value))
+                return sql `CAST(${{ quote: (new Decimal(value)).toString() }} AS DECIMAL)`;
+            if (value instanceof Decimal)
+                return sql `CAST(${{ quote: value.toString() }} AS DECIMAL)`;
+            break;
+        case 'string':
+            if (_.isString(value))
+                return sql `${{ value }}`;
+            break;
+        case 'string[]':
+            if (_.isArray(value) && _.every(value, x => _.isString(x)))
+                return sql `ARRAY[${_.map(value, x => sql `${{ value: x }}`)}]::TEXT[]`;
+            break;
+        case 'date':
+            if (_.isDate(value))
+                return sql `${{ value }}`;
+            break;
+        case 'object':
+            if (_.isPlainObject(value))
+                return sql `${{ value: index._encodeValue(value) }}`;
+            break;
+        case 'vector':
+            if (!_.isArray(value) || value.length !== index.dimensionOf(dataType))
+                break;
+            if (!_.every(value, x => _.isFinite(x)))
+                break;
+            return sql `${{ value }}::DOUBLE PRECISION[]`;
+        case 'array':
+            if (!_.isArray(value))
+                break;
+            return sql `ARRAY[${_.map(value, x => _encodeJsonValue(index._encodeValue(x)))}]::JSONB[]`;
+        case 'pointer':
+            if (value instanceof index.TObject && value.objectId)
+                return sql `${{ value: `${value.className}$${value.objectId}` }}`;
+            break;
+        case 'relation':
+            if (_.isArray(value) && _.every(value, x => x instanceof index.TObject && x.objectId)) {
+                return sql `${{ value: _.uniq(_.map(value, (x) => `${x.className}$${x.objectId}`)) }}`;
+            }
+            break;
+    }
+    throw Error('Invalid data type');
+};
+const decodeType = (type, value) => {
+    switch (type) {
+        case 'boolean':
+            if (_.isBoolean(value))
+                return value;
+            if (value === 'true')
+                return true;
+            if (value === 'false')
+                return false;
+            break;
+        case 'number':
+            if (_.isNumber(value))
+                return value;
+            if (_.isString(value)) {
+                const float = parseFloat(value);
+                return _.isNaN(float) ? null : float;
+            }
+            break;
+        case 'decimal':
+            if (_.isString(value) || _.isNumber(value))
+                return new Decimal(value);
+            if (value instanceof Decimal)
+                return value;
+            if (_.isPlainObject(value) && _.isString(value.$decimal))
+                return new Decimal(value.$decimal);
+            break;
+        case 'string':
+            if (_.isString(value))
+                return value;
+            break;
+        case 'string[]':
+            if (_.isArray(value) && _.every(value, x => _.isString(x)))
+                return value;
+            break;
+        case 'date':
+            if (_.isDate(value))
+                return value;
+            if (_.isString(value)) {
+                const date = new Date(value);
+                if (isFinite(date.valueOf()))
+                    return date;
+            }
+            if (_.isPlainObject(value) && _.isString(value.$date))
+                return new Date(value.$date);
+            break;
+        case 'object':
+            if (_.isPlainObject(value))
+                return index._decodeValue(value);
+            break;
+        case 'array':
+            if (_.isArray(value))
+                return index._decodeValue(value);
+            break;
+        case 'vector':
+            if (!_.isArray(value))
+                break;
+            if (_.every(value, x => _.isNumber(x))) {
+                return value;
+            }
+            break;
+    }
+    return null;
+};
+
+//
+//  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 isArrayExpression = (expr) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return true;
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value);
+    return false;
+};
+const arrayLength = (expr) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return expr.exprs.length;
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value) ? expr.value.length : 0;
+    return 0;
+};
+const mapExpression = (expr, callback) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return _.map(expr.exprs, x => callback(x));
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value) ? _.map(expr.value, x => callback(new validator.QueryValueExpression(x))) : [];
+    return [];
+};
+const _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
+const encodeTypedQueryExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryKeyExpression) {
+        const { element, dataType } = fetchElement(compiler, parent, expr.key);
+        const _dataType = dataType ? index._typeof(dataType) : null;
+        if (_dataType === 'number') {
+            return [
+                { type: 'number', sql: element },
+                { type: 'decimal', sql: sql `CAST((${element}) AS DECIMAL)` },
+            ];
+        }
+        else if (_dataType === 'decimal') {
+            return [
+                { type: 'decimal', sql: element },
+                { type: 'number', sql: element },
+            ];
+        }
+        else if (_dataType && _PrimitiveValue.includes(_dataType)) {
+            return [{ type: _dataType, sql: element }];
+        }
+    }
+    if (expr instanceof validator.QueryValueExpression) {
+        if (_.isBoolean(expr.value))
+            return [{ type: 'boolean', sql: sql `${{ value: expr.value }}` }];
+        if (_.isNumber(expr.value))
+            return [
+                { type: 'number', sql: sql `${{ value: expr.value }}` },
+                { type: 'decimal', sql: sql `CAST(${{ quote: (new Decimal(expr.value)).toString() }} AS DECIMAL)` },
+            ];
+        if (expr.value instanceof Decimal)
+            return [
+                { type: 'decimal', sql: sql `CAST(${{ quote: expr.value.toString() }} AS DECIMAL)` },
+                { type: 'number', sql: sql `${{ value: expr.value.toNumber() }}` },
+            ];
+        if (_.isString(expr.value))
+            return [{ type: 'string', sql: sql `${{ value: expr.value }}` }];
+        if (_.isDate(expr.value))
+            return [{ type: 'date', sql: sql `${{ value: expr.value }}` }];
+    }
+    if (expr instanceof validator.QueryCoditionalExpression ||
+        expr instanceof validator.QueryComparisonExpression ||
+        expr instanceof validator.QueryNotExpression) {
+        const value = encodeBooleanExpression(compiler, parent, expr);
+        if (value)
+            return [{ type: 'boolean', sql: value }];
+    }
+    if (expr instanceof validator.QueryDistanceExpression) {
+        const value = encodeDistanceQueryExpression(compiler, parent, expr);
+        return [{ type: 'number', sql: value }];
+    }
+};
+const encodeJsonQueryExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryKeyExpression) {
+        const { element, dataType } = fetchElement(compiler, parent, expr.key);
+        if (dataType && index.isPrimitive(dataType)) {
+            switch (index._typeof(dataType)) {
+                case 'boolean': return sql `to_jsonb(${element})`;
+                case 'number': return sql `to_jsonb(${element})`;
+                case 'decimal': return sql `jsonb_build_object('$decimal', CAST(${element} AS TEXT))`;
+                case 'string': return sql `to_jsonb(${element})`;
+                case 'string[]': return sql `to_jsonb(${element})`;
+                case 'date': return sql `jsonb_build_object(
+          '$date', to_char(${element} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+        )`;
+            }
+        }
+        return sql `${element}`;
+    }
+    if (expr instanceof validator.QueryValueExpression) {
+        return _encodeJsonValue(index._encodeValue(expr.value));
+    }
+    if (expr instanceof validator.QueryArrayExpression) {
+        return sql `jsonb_build_array(${_.map(expr.exprs, x => encodeJsonQueryExpression(compiler, parent, x))})`;
+    }
+    const value = encodeQueryExpression(compiler, parent, expr);
+    if (!value)
+        throw Error('Invalid expression');
+    return sql `to_jsonb(${value})`;
+};
+const encodeVectorExpression = (compiler, parent, exprs) => {
+    if (exprs.length === 1) {
+        const [expr] = exprs;
+        if (expr instanceof validator.QueryKeyExpression) {
+            const { element, dataType } = fetchElement(compiler, parent, expr.key);
+            if (!dataType || !index.isVector(dataType))
+                throw Error('Invalid expression');
+            return { sql: element, dimension: dataType.dimension };
+        }
+        if (expr instanceof validator.QueryValueExpression) {
+            if (!_.isArray(expr.value) || !_.every(expr.value, x => _.isFinite(x)))
+                throw Error('Invalid expression');
+            return { sql: sql `${{ value: expr.value }}::DOUBLE PRECISION[]`, dimension: expr.value.length };
+        }
+    }
+    const result = _.map(exprs, x => _.find(encodeTypedQueryExpression(compiler, parent, x), e => e.type === 'number')?.sql);
+    if (_.some(result, x => _.isNil(x)))
+        throw Error('Invalid expression');
+    return { sql: sql `ARRAY[${_.map(result, x => sql `COALESCE(${x}, 0)`)}]`, dimension: result.length };
+};
+const encodeDistanceQueryExpression = (compiler, parent, expr) => {
+    const { sql: left, dimension: d1 } = encodeVectorExpression(compiler, parent, expr.left);
+    const { sql: right, dimension: d2 } = encodeVectorExpression(compiler, parent, expr.right);
+    if (d1 !== d2)
+        throw Error('Invalid expression');
+    const operatorMap = {
+        '$distance': sql `<->`,
+        '$innerProduct': sql `<#>`,
+        '$negInnerProduct': sql `<#>`,
+        '$cosineDistance': sql `<=>`,
+        '$rectilinearDistance': sql `<+>`,
+    };
+    const _expr = sql `
+    CAST(
+      ${left} AS VECTOR(${{ literal: `${d1}` }})
+    )
+    ${operatorMap[expr.type]} 
+    CAST(
+      ${right} AS VECTOR(${{ literal: `${d2}` }})
+    )
+  `;
+    return expr.type === '$innerProduct' ? sql `-1 * (${_expr})` : _expr;
+};
+const matchType = (first, second) => {
+    const found = _.find(first, l => _.some(second, r => l.type === r.type));
+    return found ? [found, _.find(second, r => r.type === found.type)] : undefined;
+};
+const encodeBooleanExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryCoditionalExpression) {
+        const queries = _.compact(_.map(expr.exprs, x => encodeBooleanExpression(compiler, parent, x)));
+        if (_.isEmpty(queries))
+            return;
+        switch (expr.type) {
+            case '$and': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' AND ' }})`;
+            case '$nor': return sql `(${{ literal: _.map(queries, x => sql `NOT (${x})`), separator: ' AND ' }})`;
+            case '$or': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' OR ' }})`;
+        }
+    }
+    if (expr instanceof validator.QueryComparisonExpression) {
+        const operatorMap = {
+            '$eq': nullSafeEqual(),
+            '$ne': nullSafeNotEqual(),
+            '$gt': sql `>`,
+            '$gte': sql `>=`,
+            '$lt': sql `<`,
+            '$lte': sql `<=`,
+        };
+        if (isArrayExpression(expr.left) &&
+            isArrayExpression(expr.right) &&
+            arrayLength(expr.left) === arrayLength(expr.right)) {
+            const _left = mapExpression(expr.left, x => encodeTypedQueryExpression(compiler, parent, x));
+            const _right = mapExpression(expr.right, x => encodeTypedQueryExpression(compiler, parent, x));
+            const mapped = _.compact(_.map(_.zip(_left, _right), ([l, r]) => matchType(l, r)));
+            if (mapped.length === _left.length) {
+                const [l, r] = _.unzip(mapped);
+                return sql `(${_.map(l, x => x.sql)}) ${operatorMap[expr.type]} (${_.map(r, x => x.sql)})`;
+            }
+        }
+        const _left = encodeTypedQueryExpression(compiler, parent, expr.left);
+        const _right = encodeTypedQueryExpression(compiler, parent, expr.right);
+        if (_left && _right) {
+            const matched = matchType(_left, _right);
+            if (matched)
+                return sql `${matched[0].sql} ${operatorMap[expr.type]} ${matched[1].sql}`;
+        }
+        const _left2 = encodeJsonQueryExpression(compiler, parent, expr.left);
+        const _right2 = encodeJsonQueryExpression(compiler, parent, expr.right);
+        return sql `${_left2} ${operatorMap[expr.type]} ${_right2}`;
+    }
+    if (expr instanceof validator.QueryNotExpression) {
+        const _expr = encodeBooleanExpression(compiler, parent, expr.expr);
+        return _expr ? sql `NOT (${_expr})` : undefined;
+    }
+    throw Error('Invalid expression');
+};
+const encodeQueryExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryDistanceExpression) {
+        return encodeDistanceQueryExpression(compiler, parent, expr);
+    }
+    return encodeBooleanExpression(compiler, parent, expr);
+};
+
 //
 //  storage.ts
 //
@@ -705,9 +1098,13 @@ class SqlStorage {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
         const _matchesType = self._matchesType(compiler, query);
-        const _query = compiler._selectQuery({ ...query, sort: {} }, {
-            sort: sql `ORDER BY ${self.dialect.random(opts ?? {})}`,
-        });
+        const _query = compiler._selectQuery({ ...query, sort: {} }, ({ fetchName }) => ({
+            sort: sql `ORDER BY ${self.dialect.random(opts?.weight ? _.first(encodeTypedQueryExpression(compiler, {
+                name: fetchName,
+                className: query.className,
+                groupMatches: query.groupMatches,
+            }, opts.weight))?.sql : undefined)}`,
+        }));
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
@@ -951,8 +1348,8 @@ const encodeSortKey = (compiler, parent, key) => {
     const { element } = fetchElement(compiler, parent, key);
     return element;
 };
-const random = (opts) => {
-    return opts.weight ? sql `-ln(random()) / ${{ identifier: opts.weight }}` : sql `random()`;
+const random = (weight) => {
+    return weight ? sql `-ln(random()) / ${weight}` : sql `random()`;
 };
 
 //
@@ -1190,180 +1587,13 @@ class PostgresDriver extends PostgresClientDriver {
             if (_channel === channel)
                 callback(payload);
         });
-        return () => {
-            release();
-            if (this.pubsub?.isEmpty())
-                this._release_pubsub();
-        };
-    }
-}
-
-//
-//  encode.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 _encodeJsonValue = (value) => {
-    if (_.isArray(value))
-        return sql `jsonb_build_array(${_.map(value, x => _encodeJsonValue(x))})`;
-    if (_.isPlainObject(value))
-        return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
-    return sql `to_jsonb(${{ value }})`;
-};
-const _jsonPopulateInclude = (className, colname, dataType) => {
-    switch (index._typeof(dataType)) {
-        case 'decimal':
-            return sql `jsonb_build_object(
-            '$decimal', CAST(${{ identifier: className }}.${{ identifier: colname }} AS TEXT)
-          ) AS ${{ identifier: colname }}`;
-        case 'date':
-            return sql `jsonb_build_object(
-            '$date', to_char(${{ identifier: className }}.${{ identifier: colname }} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
-          ) AS ${{ identifier: colname }}`;
-        default:
-            return sql `${{ identifier: className }}.${{ identifier: colname }}`;
-    }
-};
-const encodeType = (colname, dataType, value) => {
-    if (_.isNil(value))
-        return sql `NULL`;
-    switch (_.isString(dataType) ? dataType : dataType.type) {
-        case 'boolean':
-            if (_.isBoolean(value))
-                return sql `${{ value }}`;
-            break;
-        case 'number':
-            if (_.isNumber(value) && _.isFinite(value))
-                return sql `${{ value }}`;
-            if (value instanceof Decimal)
-                return sql `${{ value: value.toNumber() }}`;
-            break;
-        case 'decimal':
-            if (_.isNumber(value) && _.isFinite(value))
-                return sql `CAST(${{ quote: (new Decimal(value)).toString() }} AS DECIMAL)`;
-            if (value instanceof Decimal)
-                return sql `CAST(${{ quote: value.toString() }} AS DECIMAL)`;
-            break;
-        case 'string':
-            if (_.isString(value))
-                return sql `${{ value }}`;
-            break;
-        case 'string[]':
-            if (_.isArray(value) && _.every(value, x => _.isString(x)))
-                return sql `ARRAY[${_.map(value, x => sql `${{ value: x }}`)}]::TEXT[]`;
-            break;
-        case 'date':
-            if (_.isDate(value))
-                return sql `${{ value }}`;
-            break;
-        case 'object':
-            if (_.isPlainObject(value))
-                return sql `${{ value: index._encodeValue(value) }}`;
-            break;
-        case 'vector':
-            if (!_.isArray(value) || value.length !== index.dimensionOf(dataType))
-                break;
-            if (!_.every(value, x => _.isFinite(x)))
-                break;
-            return sql `${{ value }}::DOUBLE PRECISION[]`;
-        case 'array':
-            if (!_.isArray(value))
-                break;
-            return sql `ARRAY[${_.map(value, x => _encodeJsonValue(index._encodeValue(x)))}]::JSONB[]`;
-        case 'pointer':
-            if (value instanceof index.TObject && value.objectId)
-                return sql `${{ value: `${value.className}$${value.objectId}` }}`;
-            break;
-        case 'relation':
-            if (_.isArray(value) && _.every(value, x => x instanceof index.TObject && x.objectId)) {
-                return sql `${{ value: _.uniq(_.map(value, (x) => `${x.className}$${x.objectId}`)) }}`;
-            }
-            break;
-    }
-    throw Error('Invalid data type');
-};
-const decodeType = (type, value) => {
-    switch (type) {
-        case 'boolean':
-            if (_.isBoolean(value))
-                return value;
-            if (value === 'true')
-                return true;
-            if (value === 'false')
-                return false;
-            break;
-        case 'number':
-            if (_.isNumber(value))
-                return value;
-            if (_.isString(value)) {
-                const float = parseFloat(value);
-                return _.isNaN(float) ? null : float;
-            }
-            break;
-        case 'decimal':
-            if (_.isString(value) || _.isNumber(value))
-                return new Decimal(value);
-            if (value instanceof Decimal)
-                return value;
-            if (_.isPlainObject(value) && _.isString(value.$decimal))
-                return new Decimal(value.$decimal);
-            break;
-        case 'string':
-            if (_.isString(value))
-                return value;
-            break;
-        case 'string[]':
-            if (_.isArray(value) && _.every(value, x => _.isString(x)))
-                return value;
-            break;
-        case 'date':
-            if (_.isDate(value))
-                return value;
-            if (_.isString(value)) {
-                const date = new Date(value);
-                if (isFinite(date.valueOf()))
-                    return date;
-            }
-            if (_.isPlainObject(value) && _.isString(value.$date))
-                return new Date(value.$date);
-            break;
-        case 'object':
-            if (_.isPlainObject(value))
-                return index._decodeValue(value);
-            break;
-        case 'array':
-            if (_.isArray(value))
-                return index._decodeValue(value);
-            break;
-        case 'vector':
-            if (!_.isArray(value))
-                break;
-            if (_.every(value, x => _.isNumber(x))) {
-                return value;
-            }
-            break;
+        return () => {
+            release();
+            if (this.pubsub?.isEmpty())
+                this._release_pubsub();
+        };
     }
-    return null;
-};
+}
 
 //
 //  update.ts
@@ -1651,232 +1881,6 @@ const updateOperation = (paths, dataType, operation) => {
     throw Error('Invalid update operation');
 };
 
-//
-//  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 isArrayExpression = (expr) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return true;
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value);
-    return false;
-};
-const arrayLength = (expr) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return expr.exprs.length;
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value) ? expr.value.length : 0;
-    return 0;
-};
-const mapExpression = (expr, callback) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return _.map(expr.exprs, x => callback(x));
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value) ? _.map(expr.value, x => callback(new validator.QueryValueExpression(x))) : [];
-    return [];
-};
-const _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
-const encodeTypedQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryKeyExpression) {
-        const { element, dataType } = fetchElement(compiler, parent, expr.key);
-        const _dataType = dataType ? index._typeof(dataType) : null;
-        if (_dataType === 'number') {
-            return [
-                { type: 'number', sql: element },
-                { type: 'decimal', sql: sql `CAST((${element}) AS DECIMAL)` },
-            ];
-        }
-        else if (_dataType === 'decimal') {
-            return [
-                { type: 'decimal', sql: element },
-                { type: 'number', sql: element },
-            ];
-        }
-        else if (_dataType && _PrimitiveValue.includes(_dataType)) {
-            return [{ type: _dataType, sql: element }];
-        }
-    }
-    if (expr instanceof validator.QueryValueExpression) {
-        if (_.isBoolean(expr.value))
-            return [{ type: 'boolean', sql: sql `${{ value: expr.value }}` }];
-        if (_.isNumber(expr.value))
-            return [
-                { type: 'number', sql: sql `${{ value: expr.value }}` },
-                { type: 'decimal', sql: sql `CAST(${{ quote: (new Decimal(expr.value)).toString() }} AS DECIMAL)` },
-            ];
-        if (expr.value instanceof Decimal)
-            return [
-                { type: 'decimal', sql: sql `CAST(${{ quote: expr.value.toString() }} AS DECIMAL)` },
-                { type: 'number', sql: sql `${{ value: expr.value.toNumber() }}` },
-            ];
-        if (_.isString(expr.value))
-            return [{ type: 'string', sql: sql `${{ value: expr.value }}` }];
-        if (_.isDate(expr.value))
-            return [{ type: 'date', sql: sql `${{ value: expr.value }}` }];
-    }
-    if (expr instanceof validator.QueryCoditionalExpression ||
-        expr instanceof validator.QueryComparisonExpression ||
-        expr instanceof validator.QueryNotExpression) {
-        const value = encodeBooleanExpression(compiler, parent, expr);
-        if (value)
-            return [{ type: 'boolean', sql: value }];
-    }
-    if (expr instanceof validator.QueryDistanceExpression) {
-        const value = encodeDistanceQueryExpression(compiler, parent, expr);
-        return [{ type: 'number', sql: value }];
-    }
-};
-const encodeJsonQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryKeyExpression) {
-        const { element, dataType } = fetchElement(compiler, parent, expr.key);
-        if (dataType && index.isPrimitive(dataType)) {
-            switch (index._typeof(dataType)) {
-                case 'boolean': return sql `to_jsonb(${element})`;
-                case 'number': return sql `to_jsonb(${element})`;
-                case 'decimal': return sql `jsonb_build_object('$decimal', CAST(${element} AS TEXT))`;
-                case 'string': return sql `to_jsonb(${element})`;
-                case 'string[]': return sql `to_jsonb(${element})`;
-                case 'date': return sql `jsonb_build_object(
-          '$date', to_char(${element} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
-        )`;
-            }
-        }
-        return sql `${element}`;
-    }
-    if (expr instanceof validator.QueryValueExpression) {
-        return _encodeJsonValue(index._encodeValue(expr.value));
-    }
-    if (expr instanceof validator.QueryArrayExpression) {
-        return sql `jsonb_build_array(${_.map(expr.exprs, x => encodeJsonQueryExpression(compiler, parent, x))})`;
-    }
-    const value = encodeQueryExpression(compiler, parent, expr);
-    if (!value)
-        throw Error('Invalid expression');
-    return sql `to_jsonb(${value})`;
-};
-const encodeVectorExpression = (compiler, parent, exprs) => {
-    if (exprs.length === 1) {
-        const [expr] = exprs;
-        if (expr instanceof validator.QueryKeyExpression) {
-            const { element, dataType } = fetchElement(compiler, parent, expr.key);
-            if (!dataType || !index.isVector(dataType))
-                throw Error('Invalid expression');
-            return { sql: element, dimension: dataType.dimension };
-        }
-        if (expr instanceof validator.QueryValueExpression) {
-            if (!_.isArray(expr.value) || !_.every(expr.value, x => _.isFinite(x)))
-                throw Error('Invalid expression');
-            return { sql: sql `${{ value: expr.value }}::DOUBLE PRECISION[]`, dimension: expr.value.length };
-        }
-    }
-    const result = _.map(exprs, x => _.find(encodeTypedQueryExpression(compiler, parent, x), e => e.type === 'number')?.sql);
-    if (_.some(result, x => _.isNil(x)))
-        throw Error('Invalid expression');
-    return { sql: sql `ARRAY[${_.map(result, x => sql `COALESCE(${x}, 0)`)}]`, dimension: result.length };
-};
-const encodeDistanceQueryExpression = (compiler, parent, expr) => {
-    const { sql: left, dimension: d1 } = encodeVectorExpression(compiler, parent, expr.left);
-    const { sql: right, dimension: d2 } = encodeVectorExpression(compiler, parent, expr.right);
-    if (d1 !== d2)
-        throw Error('Invalid expression');
-    const operatorMap = {
-        '$distance': sql `<->`,
-        '$innerProduct': sql `<#>`,
-        '$negInnerProduct': sql `<#>`,
-        '$cosineDistance': sql `<=>`,
-        '$rectilinearDistance': sql `<+>`,
-    };
-    const _expr = sql `
-    CAST(
-      ${left} AS VECTOR(${{ literal: `${d1}` }})
-    )
-    ${operatorMap[expr.type]} 
-    CAST(
-      ${right} AS VECTOR(${{ literal: `${d2}` }})
-    )
-  `;
-    return expr.type === '$innerProduct' ? sql `-1 * (${_expr})` : _expr;
-};
-const matchType = (first, second) => {
-    const found = _.find(first, l => _.some(second, r => l.type === r.type));
-    return found ? [found, _.find(second, r => r.type === found.type)] : undefined;
-};
-const encodeBooleanExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryCoditionalExpression) {
-        const queries = _.compact(_.map(expr.exprs, x => encodeBooleanExpression(compiler, parent, x)));
-        if (_.isEmpty(queries))
-            return;
-        switch (expr.type) {
-            case '$and': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' AND ' }})`;
-            case '$nor': return sql `(${{ literal: _.map(queries, x => sql `NOT (${x})`), separator: ' AND ' }})`;
-            case '$or': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' OR ' }})`;
-        }
-    }
-    if (expr instanceof validator.QueryComparisonExpression) {
-        const operatorMap = {
-            '$eq': nullSafeEqual(),
-            '$ne': nullSafeNotEqual(),
-            '$gt': sql `>`,
-            '$gte': sql `>=`,
-            '$lt': sql `<`,
-            '$lte': sql `<=`,
-        };
-        if (isArrayExpression(expr.left) &&
-            isArrayExpression(expr.right) &&
-            arrayLength(expr.left) === arrayLength(expr.right)) {
-            const _left = mapExpression(expr.left, x => encodeTypedQueryExpression(compiler, parent, x));
-            const _right = mapExpression(expr.right, x => encodeTypedQueryExpression(compiler, parent, x));
-            const mapped = _.compact(_.map(_.zip(_left, _right), ([l, r]) => matchType(l, r)));
-            if (mapped.length === _left.length) {
-                const [l, r] = _.unzip(mapped);
-                return sql `(${_.map(l, x => x.sql)}) ${operatorMap[expr.type]} (${_.map(r, x => x.sql)})`;
-            }
-        }
-        const _left = encodeTypedQueryExpression(compiler, parent, expr.left);
-        const _right = encodeTypedQueryExpression(compiler, parent, expr.right);
-        if (_left && _right) {
-            const matched = matchType(_left, _right);
-            if (matched)
-                return sql `${matched[0].sql} ${operatorMap[expr.type]} ${matched[1].sql}`;
-        }
-        const _left2 = encodeJsonQueryExpression(compiler, parent, expr.left);
-        const _right2 = encodeJsonQueryExpression(compiler, parent, expr.right);
-        return sql `${_left2} ${operatorMap[expr.type]} ${_right2}`;
-    }
-    if (expr instanceof validator.QueryNotExpression) {
-        const _expr = encodeBooleanExpression(compiler, parent, expr.expr);
-        return _expr ? sql `NOT (${_expr})` : undefined;
-    }
-    throw Error('Invalid expression');
-};
-const encodeQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryDistanceExpression) {
-        return encodeDistanceQueryExpression(compiler, parent, expr);
-    }
-    return encodeBooleanExpression(compiler, parent, expr);
-};
-
 //
 //  populate.ts
 //
@@ -1993,30 +1997,67 @@ const selectPopulate = (compiler, parent, populate, field) => {
                     }
                 }
                 else if (expr instanceof validator.QueryExprAccumulator) {
-                    const op = {
-                        '$max': 'MAX',
-                        '$min': 'MIN',
-                        '$avg': 'AVG',
-                        '$sum': 'SUM',
-                        '$stdDevPop': 'STDDEV_POP',
-                        '$stdDevSamp': 'STDDEV_SAMP',
-                        '$varPop': 'VAR_POP',
-                        '$varSamp': 'VAR_SAMP',
-                    }[expr.type];
                     if (!expr.expr)
                         throw Error('Invalid expression');
                     const exprs = encodeTypedQueryExpression(compiler, populate, expr.expr);
                     const value = _.first(exprs)?.sql;
+                    if (!value)
+                        throw Error('Invalid expression');
+                    switch (expr.type) {
+                        case '$most':
+                            columns.push(sql `
+                (
+                  SELECT MODE() WITHIN GROUP (ORDER BY (${value})) FROM (
+                    ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                  ) ${{ identifier: populate.name }}
+                ) AS ${{ identifier: `${field}.${key}` }}
+              `);
+                            break;
+                        default:
+                            {
+                                const op = {
+                                    '$max': 'MAX',
+                                    '$min': 'MIN',
+                                    '$avg': 'AVG',
+                                    '$sum': 'SUM',
+                                    '$stdDevPop': 'STDDEV_POP',
+                                    '$stdDevSamp': 'STDDEV_SAMP',
+                                    '$varPop': 'VAR_POP',
+                                    '$varSamp': 'VAR_SAMP',
+                                }[expr.type];
+                                columns.push(sql `
+                  (
+                    SELECT ${{ literal: op }}(${value}) FROM (
+                      ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                    ) ${{ identifier: populate.name }}
+                  ) AS ${{ identifier: `${field}.${key}` }}
+                `);
+                            }
+                            break;
+                    }
+                }
+                else if (expr instanceof validator.QueryPercentileAccumulator) {
+                    const op = {
+                        'discrete': 'PERCENTILE_DISC',
+                        'continuous': 'PERCENTILE_CONT',
+                    }[expr.mode];
+                    if (!expr.input)
+                        throw Error('Invalid expression');
+                    const exprs = encodeTypedQueryExpression(compiler, populate, expr.input);
+                    const value = _.first(exprs)?.sql;
                     if (!value)
                         throw Error('Invalid expression');
                     columns.push(sql `
             (
-              SELECT ${{ literal: op }}(${value}) FROM (
+              SELECT ${{ literal: op }}(${{ value: expr.p }}) WITHIN GROUP (ORDER BY (${value})) FROM (
                 ${_selectRelationPopulate(compiler, parent, populate, field, false)}
               ) ${{ identifier: populate.name }}
             ) AS ${{ identifier: `${field}.${key}` }}
           `);
                 }
+                else {
+                    throw Error('Invalid expression');
+                }
             }
         }
         else {