proto.io 0.0.213 → 0.0.214

package/dist/internals/{index-D8O7SinR.js → validator-DoRPoIs2.js}

@@ -3,6 +3,7 @@
 var _ = require('lodash');
 var index = require('./index-B8TESzd9.js');
 var Decimal = require('decimal.js');
+var _private = require('./private-Ciddhure.js');
 
 //
 //  keys.ts
@@ -309,6 +310,9 @@ class QueryExpression {
     eval(value) {
         return true;
     }
+    evalType(schema, className) {
+        return [];
+    }
 }
 class QueryCoditionalExpression extends QueryExpression {
     type;
@@ -344,6 +348,9 @@ class QueryCoditionalExpression extends QueryExpression {
             case '$or': return _.some(this.exprs, expr => expr.eval(value));
         }
     }
+    evalType(schema, className) {
+        return ['boolean'];
+    }
 }
 class QueryComparisonExpression extends QueryExpression {
     type;
@@ -377,6 +384,9 @@ class QueryComparisonExpression extends QueryExpression {
             case '$ne': return !equal(this.left.eval(value), this.right.eval(value));
         }
     }
+    evalType(schema, className) {
+        return ['boolean'];
+    }
 }
 class QueryNotExpression extends QueryExpression {
     expr;
@@ -396,6 +406,9 @@ class QueryNotExpression extends QueryExpression {
     eval(value) {
         return !this.expr.eval(value);
     }
+    evalType(schema, className) {
+        return ['boolean'];
+    }
 }
 class QueryArrayExpression extends QueryExpression {
     exprs;
@@ -415,6 +428,9 @@ class QueryArrayExpression extends QueryExpression {
     eval(value) {
         return _.map(this.exprs, x => x.eval(value));
     }
+    evalType(schema, className) {
+        return ['array'];
+    }
 }
 class QueryDistanceExpression extends QueryExpression {
     type;
@@ -453,6 +469,9 @@ class QueryDistanceExpression extends QueryExpression {
             case '$rectilinearDistance': return rectilinearDistance(left, right);
         }
     }
+    evalType(schema, className) {
+        return ['number'];
+    }
 }
 class QueryKeyExpression extends QueryExpression {
     key;
@@ -469,6 +488,10 @@ class QueryKeyExpression extends QueryExpression {
     eval(value) {
         return getValue(value, this.key);
     }
+    evalType(schema, className) {
+        const { paths: [, ...subpath], dataType } = resolveColumn(schema, className, this.key);
+        return _.isEmpty(subpath) ? [dataType] : [];
+    }
 }
 class QueryValueExpression extends QueryExpression {
     value;
@@ -479,6 +502,21 @@ class QueryValueExpression extends QueryExpression {
     eval(value) {
         return value;
     }
+    evalType(schema, className) {
+        if (_.isDate(this.value))
+            return ['date'];
+        if (_.isBoolean(this.value))
+            return ['boolean'];
+        if (_.isArray(this.value))
+            return ['array'];
+        if (_.isString(this.value))
+            return ['string'];
+        if (_.isNumber(this.value))
+            return ['number', 'decimal'];
+        if (this.value instanceof Decimal)
+            return ['decimal', 'number'];
+        return [];
+    }
 }
 
 //
@@ -774,17 +812,563 @@ class QueryExpressionSelector extends QuerySelector {
     }
 }
 
+//
+//  accumulators.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 accumulatorExprKeys = [
+    '$max',
+    '$min',
+    '$sum',
+    '$avg',
+    '$stdDevPop',
+    '$stdDevSamp',
+    '$varPop',
+    '$varSamp'
+];
+const accumulatorNoParamKeys = [
+    '$count'
+];
+
+//
+//  accumulators.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.
+//
+class QueryAccumulator {
+    static decode(query) {
+        for (const [key, expr] of _.toPairs(query)) {
+            if (_.includes(accumulatorExprKeys, key)) {
+                return new QueryExprAccumulator(key, QueryExpression.decode(expr ?? [], false));
+            }
+            else if (_.includes(accumulatorNoParamKeys, key)) {
+                return new QueryNoParamAccumulator(key);
+            }
+            else {
+                throw Error('Invalid expression');
+            }
+        }
+        throw Error('Invalid expression');
+    }
+    simplify() {
+        return this;
+    }
+    keyPaths() {
+        return [];
+    }
+    mapKey(callback) {
+        return this;
+    }
+    evalType(schema, className) {
+        return;
+    }
+}
+class QueryNoParamAccumulator extends QueryAccumulator {
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    simplify() {
+        return this;
+    }
+    keyPaths() {
+        return [];
+    }
+    mapKey(callback) {
+        return this;
+    }
+    evalType(schema, className) {
+        switch (this.type) {
+            case '$count': return 'number';
+        }
+    }
+}
+class QueryExprAccumulator extends QueryAccumulator {
+    type;
+    expr;
+    constructor(type, expr) {
+        super();
+        this.type = type;
+        this.expr = expr;
+    }
+    simplify() {
+        return new QueryExprAccumulator(this.type, this.expr.simplify());
+    }
+    keyPaths() {
+        return this.expr?.keyPaths() ?? [];
+    }
+    mapKey(callback) {
+        return new QueryExprAccumulator(this.type, this.expr.mapKey(callback));
+    }
+    evalType(schema, className) {
+        const [dataType] = this.expr?.evalType(schema, className) ?? [];
+        if (_.isNil(dataType))
+            return;
+        switch (this.type) {
+            case '$max': return index._isTypeof(dataType, ['number', 'decimal', 'string', 'date']) ? dataType : undefined;
+            case '$min': return index._isTypeof(dataType, ['number', 'decimal', 'string', 'date']) ? dataType : undefined;
+            case '$avg': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+            case '$sum': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+            case '$stdDevPop': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+            case '$stdDevSamp': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+            case '$varPop': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+            case '$varSamp': return index._isTypeof(dataType, ['number', 'decimal']) ? dataType : undefined;
+        }
+    }
+}
+
+//
+//  validator.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 recursiveCheck = (x, stack) => {
+    if (_.indexOf(stack, x) !== -1)
+        throw Error('Recursive data detected');
+    if (_.isRegExp(x) || index.isPrimitiveValue(x) || x instanceof index.TObject)
+        return;
+    const children = _.isArray(x) ? x : _.values(x);
+    children.forEach(v => recursiveCheck(v, [...stack, x]));
+};
+const resolveDataType = (schema, classname, path) => {
+    let fields = schema[classname].fields;
+    let last;
+    for (const key of _.toPath(path)) {
+        const dataType = fields[key];
+        if (_.isNil(dataType))
+            throw Error(`Invalid path: ${path}`);
+        if (index.isPrimitive(dataType) || index.isVector(dataType))
+            return dataType;
+        if (index.isShape(dataType)) {
+            fields = dataType.shape;
+            continue;
+        }
+        if (_.isNil(schema[dataType.target]))
+            throw Error(`Invalid path: ${path}`);
+        fields = schema[dataType.target].fields;
+        last = dataType;
+    }
+    return last;
+};
+const resolveColumn = (schema, className, path) => {
+    const _schema = schema[className] ?? {};
+    let [colname, ...subpath] = path.split('.');
+    let dataType = _schema.fields[colname];
+    while (dataType && !_.isEmpty(subpath) && index.isShape(dataType)) {
+        const [key, ...remain] = subpath;
+        if (!dataType.shape[key])
+            break;
+        dataType = dataType.shape[key];
+        colname = `${colname}.${key}`;
+        subpath = remain;
+    }
+    return {
+        paths: [colname, ...subpath],
+        dataType,
+    };
+};
+class QueryValidator {
+    proto;
+    acls;
+    options;
+    static patterns = {
+        path: /^[a-z_][\w-]*(\[\d+\]|\.\d*|\.[a-z_][\w-]*)*$/gi,
+        className: /^[a-z_][\w]*$/gi,
+        fieldName: /^[a-z_][\w-]*$/gi,
+        digits: /^\d+$/g,
+    };
+    _rperm(className) {
+        if (this.options.master)
+            return [];
+        const check = _.intersection(this.schema[className]?.additionalObjectPermissions?.read, this.acls);
+        if (!_.isEmpty(check))
+            return [];
+        return [{ _rperm: { $intersect: this.acls } }];
+    }
+    _wperm(className) {
+        if (this.options.master)
+            return [];
+        const check = _.intersection(this.schema[className]?.additionalObjectPermissions?.update, this.acls);
+        if (!_.isEmpty(check))
+            return [];
+        return [{ _wperm: { $intersect: this.acls } }];
+    }
+    _expiredAt = { $or: [{ _expired_at: { $eq: null } }, { _expired_at: { $gt: new Date() } }] };
+    constructor(proto, acls, options) {
+        this.proto = proto;
+        this.acls = _.uniq(['*', ...acls]);
+        this.options = options;
+    }
+    get schema() {
+        return this.proto.schema;
+    }
+    get objectIdSize() {
+        return this.proto[_private.PVK].options.objectIdSize;
+    }
+    static recursiveCheck(...x) {
+        recursiveCheck(x, []);
+    }
+    validateKeyPerm(key, type, schema) {
+        key = _.first(key?.split('.')) ?? key;
+        if (_.isEmpty(key) || (!_.has(schema.fields, key) && !index.TObject.defaultKeys.includes(key)))
+            throw Error(`Invalid key: ${key}`);
+        if (type === 'read' && index.TObject.defaultKeys.includes(key))
+            return true;
+        if (type !== 'read' && index.TObject.defaultReadonlyKeys.includes(key))
+            return false;
+        if (!this.options.disableSecurity && _.includes(schema.secureFields, key))
+            return false;
+        return this.options.master || !_.every(schema.fieldLevelPermissions?.[key]?.[type] ?? ['*'], x => !_.includes(this.acls, x));
+    }
+    validateCLPs(className, ...keys) {
+        if (!_.has(this.schema, className))
+            throw Error('No permission');
+        return this.options.master || this.proto[_private.PVK].validateCLPs(className, this.acls, keys);
+    }
+    validateForeignField(dataType, type, errorMeg) {
+        if (_.isNil(dataType.foreignField))
+            return;
+        const foreignField = resolveDataType(this.schema, dataType.target, dataType.foreignField);
+        if (_.isNil(foreignField) || _.isString(foreignField))
+            throw Error(errorMeg);
+        if (index.isPrimitive(foreignField))
+            throw Error(errorMeg);
+        if (foreignField.type === 'relation' && !_.isNil(foreignField.foreignField))
+            throw Error(errorMeg);
+        if (!this.validateKeyPerm(dataType.foreignField, type, this.schema[dataType.target]))
+            throw Error('No permission');
+    }
+    validateKey(className, key, type, validator) {
+        const schema = this.schema[className] ?? {};
+        const _key = _.isArray(key) ? key.join('.') : key;
+        if (!_key.match(validator))
+            throw Error(`Invalid key: ${_key}`);
+        const [colname, ..._subpath] = _.toPath(_key);
+        if (!this.validateKeyPerm(colname, type, schema))
+            return false;
+        if (_.isEmpty(_subpath) && index.TObject.defaultKeys.includes(colname))
+            return true;
+        if (_.isEmpty(_subpath))
+            return true;
+        const { paths: [_colname, ...subpath], dataType } = resolveColumn(this.schema, className, _key);
+        const isElem = _.first(subpath)?.match(QueryValidator.patterns.digits);
+        if (isElem) {
+            if (dataType === 'array' || dataType === 'string[]')
+                return true;
+            if (!_.isString(dataType) && dataType.type !== 'relation')
+                return false;
+        }
+        if (index.isPrimitive(dataType))
+            return true;
+        if (index.isVector(dataType))
+            return true;
+        const relations = [];
+        if (index.isShape(dataType)) {
+            for (const { type } of index.shapePaths(dataType)) {
+                if (!index.isPrimitive(type) && !index.isVector(type))
+                    relations.push(type);
+            }
+        }
+        else {
+            relations.push(dataType);
+        }
+        for (const relation of relations) {
+            if (_.isNil(this.schema[relation.target]))
+                return false;
+            if (type === 'read' && !this.validateCLPs(relation.target, 'get'))
+                return false;
+            if (relation.type === 'relation')
+                this.validateForeignField(relation, type, `Invalid key: ${_key}`);
+        }
+        if (index.isShape(dataType)) {
+            if (!_.isEmpty(subpath))
+                throw Error(`Invalid key: ${_key}`);
+            return true;
+        }
+        const _sub = isElem ? subpath.slice(1) : subpath;
+        return _.isEmpty(_sub) || this.validateKey(dataType.target, _sub, type, validator);
+    }
+    validateFields(className, values, type, validator) {
+        const _values = { ...values };
+        for (const key of _.keys(_values)) {
+            if (!this.validateKey(className, key, type, validator))
+                throw Error('No permission');
+        }
+        return _values;
+    }
+    decodeGroupMatches(className, groupMatches) {
+        const result = _.mapValues(groupMatches, m => _.mapValues(m, x => QueryAccumulator.decode(x).simplify()));
+        for (const [colname, group] of _.entries(result)) {
+            const dataType = resolveDataType(this.schema, className, colname);
+            if (!dataType || !index.isRelation(dataType))
+                throw Error(`Invalid relation key: ${colname}`);
+            for (const key of _.keys(group)) {
+                if (!key.match(QueryValidator.patterns.fieldName))
+                    throw Error(`Invalid field name: ${key}`);
+            }
+        }
+        return result;
+    }
+    decodeIncludes(className, includes, groupMatches) {
+        const schema = this.schema[className] ?? {};
+        const _includes = [];
+        const populates = {};
+        for (const include of includes) {
+            if (include === '*') {
+                const primitive = _.pickBy(schema.fields, (v, k) => index.isPrimitive(v) && this.validateKeyPerm(k, 'read', schema));
+                const shapedObject = _.pickBy(schema.fields, (v, k) => index.isShape(v) && this.validateKeyPerm(k, 'read', schema));
+                _includes.push(..._.keys(primitive), ..._.flatMap(shapedObject, (v, k) => _.flatMap(index.shapePaths(v), x => index.isPrimitive(x.type) ? [`${k}.${x.path}`] : [])));
+            }
+            else {
+                const { paths: [colname, ...subpath], dataType } = resolveColumn(this.schema, className, include);
+                if (!this.validateKeyPerm(colname, 'read', schema))
+                    throw Error('No permission');
+                if (index.isPointer(dataType) || index.isRelation(dataType)) {
+                    if (!this.validateCLPs(dataType.target, 'get'))
+                        throw Error('No permission');
+                    if (dataType.type === 'relation')
+                        this.validateForeignField(dataType, 'read', `Invalid include: ${include}`);
+                    const isDigit = _.first(subpath)?.match(QueryValidator.patterns.digits);
+                    const _subpath = index.isRelation(dataType) && isDigit ? _.slice(subpath, 1) : subpath;
+                    populates[colname] = populates[colname] ?? { className: dataType.target, subpaths: [], groupMatches: {} };
+                    const s = _.first(_subpath);
+                    if (!s || !groupMatches[colname]?.[s]) {
+                        populates[colname].subpaths.push(_.isEmpty(_subpath) ? '*' : _subpath.join('.'));
+                        populates[colname].groupMatches = _.mapKeys(_.pickBy(groupMatches, (x, k) => _.startsWith(k, `${colname}.`)), (x, k) => k.slice(colname.length + 1));
+                    }
+                }
+                else if (_.isEmpty(subpath) && index.isShape(dataType)) {
+                    for (const { path, type } of index.shapePaths(dataType)) {
+                        if (index.isPrimitive(type) || index.isVector(type)) {
+                            _includes.push(`${colname}.${path}`);
+                        }
+                        else {
+                            if (!this.validateCLPs(type.target, 'get'))
+                                throw Error('No permission');
+                            if (type.type === 'relation')
+                                this.validateForeignField(type, 'read', `Invalid include: ${include}`);
+                            populates[`${colname}.${path}`] = populates[`${colname}.${path}`] ?? { className: type.target, subpaths: [], groupMatches: {} };
+                            populates[`${colname}.${path}`].subpaths.push('*');
+                            populates[`${colname}.${path}`].groupMatches = _.mapKeys(_.pickBy(groupMatches, (x, k) => _.startsWith(k, `${colname}.${path}.`)), (x, k) => k.slice(`${colname}.${path}`.length + 1));
+                        }
+                    }
+                }
+                else if (_.isEmpty(subpath) || _.includes(['object', 'array'], index._typeof(dataType))) {
+                    _includes.push(colname);
+                }
+                else {
+                    throw Error(`Invalid include: ${include}`);
+                }
+            }
+        }
+        for (const [key, populate] of _.toPairs(populates)) {
+            const subpaths = this.decodeIncludes(populate.className, populate.subpaths, populate.groupMatches);
+            _includes.push(..._.map(subpaths, x => `${key}.${x}`));
+        }
+        _includes.push(...index.TObject.defaultKeys);
+        return _.uniq(_includes);
+    }
+    decodeSort(sort) {
+        if (_.isArray(sort)) {
+            return _.map(sort, s => ({
+                order: s.order,
+                expr: QueryExpression.decode(s.expr, false).simplify(),
+            }));
+        }
+        return sort;
+    }
+    decodeMatches(className, matches, includes) {
+        const schema = this.schema[className] ?? {};
+        const _matches = {};
+        const _includes = _.groupBy(_.map(includes, x => resolveColumn(this.schema, className, x)), ({ paths: [colname] }) => colname);
+        for (const [colname, [{ dataType }]] of _.entries(_includes)) {
+            if (!this.validateKeyPerm(colname, 'read', schema))
+                continue;
+            if (index.isPrimitive(dataType) || index.isVector(dataType) || index.isShape(dataType))
+                continue;
+            _matches[colname] = {
+                matches: this.decodeMatches(dataType.target, {}, includes.filter(x => x.startsWith(`${colname}.`)).map(x => x.slice(colname.length + 1))),
+            };
+        }
+        for (const [colname, match] of _.toPairs(matches)) {
+            if (!this.validateKeyPerm(colname, 'read', schema))
+                throw Error('No permission');
+            const { paths: [_colname, ...subpath], dataType } = resolveColumn(this.schema, className, colname);
+            if (index.isPointer(dataType) && !_.isEmpty(subpath)) {
+                _matches[_colname] = {
+                    matches: this.decodeMatches(dataType.target, { [subpath.join('.')]: match }, includes.filter(x => x.startsWith(`${_colname}.`)).map(x => x.slice(_colname.length + 1))),
+                };
+            }
+            else if (index.isRelation(dataType)) {
+                if (!this.validateCLPs(dataType.target, 'get'))
+                    throw Error('No permission');
+                this.validateForeignField(dataType, 'read', `Invalid match: ${colname}`);
+                const groupMatches = this.decodeGroupMatches(dataType.target, match.groupMatches ?? {});
+                _matches[_colname] = {
+                    ...match,
+                    groupMatches,
+                    filter: QuerySelector.decode(_.castArray(match.filter)).simplify(),
+                    matches: this.decodeMatches(dataType.target, match.matches ?? {}, includes.filter(x => x.startsWith(`${_colname}.`)).map(x => x.slice(_colname.length + 1))),
+                    sort: match.sort && this.decodeSort(match.sort),
+                };
+            }
+            else {
+                throw Error(`Invalid match: ${colname}`);
+            }
+        }
+        return _matches;
+    }
+    validateRelatedBy(className, relation) {
+        if (!this.validateCLPs(relation.className, 'get'))
+            throw Error('No permission');
+        if (!this.validateKey(relation.className, relation.key, 'read', QueryValidator.patterns.path))
+            throw Error('No permission');
+        const { dataType } = resolveColumn(this.schema, relation.className, relation.key);
+        if (!index.isPointer(dataType) && !index.isRelation(dataType))
+            throw Error(`Invalid relation key: ${relation.key}`);
+        if (className && dataType.target !== className)
+            throw Error(`Invalid relation key: ${relation.key}`);
+        if (index.isRelation(dataType) && dataType.foreignField) {
+            this.validateForeignField(dataType, 'read', `Invalid relation key: ${relation.key}`);
+            this.validateRelatedBy(null, { className: dataType.target, key: dataType.foreignField });
+        }
+    }
+    decodeQuery(query, action) {
+        if ('relatedBy' in query && query.relatedBy)
+            this.validateRelatedBy(query.className, query.relatedBy);
+        const filter = QuerySelector.decode([
+            ...action === 'read' ? this._rperm(query.className) : this._wperm(query.className),
+            ..._.castArray(query.filter),
+            this._expiredAt,
+        ]).simplify();
+        const groupMatches = this.decodeGroupMatches(query.className, query.groupMatches ?? {});
+        const matchKeyPaths = (matches) => _.flatMap(matches, (match, key) => [
+            ..._.keys(match.sort),
+            ...QuerySelector.decode(match.filter ?? []).keyPaths(),
+            ...matchKeyPaths(match.matches ?? {}),
+            ..._.keys(match.groupMatches),
+            ..._.flatMap(_.values(match.groupMatches), x => QueryAccumulator.decode(x).keyPaths()),
+        ].map(x => `${key}.${x}`));
+        const sort = query.sort && this.decodeSort(query.sort);
+        const keyPaths = _.uniq([
+            ...query.includes ?? ['*'],
+            ..._.isArray(sort) ? _.flatMap(sort, s => s.expr.keyPaths()) : _.keys(sort),
+            ...filter.keyPaths(),
+            ...matchKeyPaths(query.matches ?? {}),
+            ..._.keys(groupMatches),
+            ..._.flatMap(_.values(groupMatches), m => _.flatMap(_.values(m), x => x.keyPaths())),
+        ]);
+        const includes = this.decodeIncludes(query.className, keyPaths, groupMatches);
+        const matches = this.decodeMatches(query.className, query.matches ?? {}, includes);
+        return {
+            ...query,
+            groupMatches,
+            filter,
+            matches,
+            includes,
+            sort,
+            objectIdSize: this.objectIdSize,
+            extraFilter: (className) => QuerySelector.decode([...this._rperm(className), this._expiredAt]).simplify(),
+        };
+    }
+    isGetMethod(query) {
+        const objectIds = [];
+        if (query instanceof QueryCoditionalSelector && query.type === '$and') {
+            for (const expr of query.exprs) {
+                if (expr instanceof QueryFieldSelector &&
+                    expr.field === '_id' &&
+                    expr.expr.type === '$eq') {
+                    if (!_.isString(expr.expr.value))
+                        return false;
+                    objectIds.push(expr.expr.value);
+                }
+            }
+        }
+        else if (query instanceof QueryFieldSelector &&
+            query.field === '_id' &&
+            query.expr.type === '$eq') {
+            if (!_.isString(query.expr.value))
+                return false;
+            objectIds.push(query.expr.value);
+        }
+        return _.uniq(objectIds).length === 1;
+    }
+}
+
 exports.FieldSelectorExpression = FieldSelectorExpression;
 exports.QueryArrayExpression = QueryArrayExpression;
 exports.QueryCoditionalExpression = QueryCoditionalExpression;
 exports.QueryCoditionalSelector = QueryCoditionalSelector;
 exports.QueryComparisonExpression = QueryComparisonExpression;
 exports.QueryDistanceExpression = QueryDistanceExpression;
-exports.QueryExpression = QueryExpression;
+exports.QueryExprAccumulator = QueryExprAccumulator;
 exports.QueryExpressionSelector = QueryExpressionSelector;
 exports.QueryFieldSelector = QueryFieldSelector;
 exports.QueryKeyExpression = QueryKeyExpression;
+exports.QueryNoParamAccumulator = QueryNoParamAccumulator;
 exports.QueryNotExpression = QueryNotExpression;
 exports.QuerySelector = QuerySelector;
+exports.QueryValidator = QueryValidator;
 exports.QueryValueExpression = QueryValueExpression;
-//# sourceMappingURL=index-D8O7SinR.js.map
+exports.resolveColumn = resolveColumn;
+exports.resolveDataType = resolveDataType;
+//# sourceMappingURL=validator-DoRPoIs2.js.map