oak-domain 2.0.2 → 2.0.3

package/lib/store/checker.js

@@ -1,165 +1,218 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var filter_1 = require("../store/filter");
-var Exception_1 = require("../types/Exception");
-var actionDef_1 = require("./actionDef");
-function translateCheckerInAsyncContext(checker) {
-    var _this = this;
-    var entity = checker.entity, type = checker.type;
-    switch (type) {
-        case 'data': {
-            var checkerFn_1 = checker.checker;
-            return (function (_a, context) {
-                var operation = _a.operation;
-                return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var data;
-                    return tslib_1.__generator(this, function (_b) {
-                        data = operation.data;
-                        checkerFn_1(data, context);
-                        return [2 /*return*/, 0];
-                    });
-                });
-            });
-        }
-        case 'row': {
-            var filter_2 = checker.filter, errMsg_1 = checker.errMsg, inconsistentRows_1 = checker.inconsistentRows;
-            return (function (_a, context, option) {
-                var operation = _a.operation;
-                return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var operationFilter, action, filter2, entity2, selection2, rows2, data_1, rows2, data_2;
-                    var _b, _c;
-                    return tslib_1.__generator(this, function (_d) {
-                        switch (_d.label) {
-                            case 0:
-                                operationFilter = operation.filter, action = operation.action;
-                                (0, assert_1.default)(operationFilter);
-                                filter2 = typeof filter_2 === 'function' ? filter_2(context, option) : filter_2;
-                                if (!['select', 'count', 'stat'].includes(action)) return [3 /*break*/, 1];
-                                operation.filter = (0, filter_1.addFilterSegment)(operationFilter, filter2);
-                                return [2 /*return*/, 0];
-                            case 1: return [4 /*yield*/, (0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)];
-                            case 2:
-                                if (_d.sent()) {
-                                    return [2 /*return*/, 0];
-                                }
-                                if (!inconsistentRows_1) return [3 /*break*/, 4];
-                                entity2 = inconsistentRows_1.entity, selection2 = inconsistentRows_1.selection;
-                                return [4 /*yield*/, context.select(entity2, selection2(operationFilter), {
-                                        dontCollect: true,
-                                        blockTrigger: true,
-                                    })];
-                            case 3:
-                                rows2 = _d.sent();
-                                data_1 = {};
-                                rows2.forEach(function (ele) {
-                                    var _a;
-                                    return Object.assign(data_1, (_a = {},
-                                        _a[ele.id] = ele,
-                                        _a));
-                                });
-                                throw new Exception_1.OakRowInconsistencyException({
-                                    a: 's',
-                                    d: (_b = {},
-                                        _b[entity2] = data_1,
-                                        _b)
-                                }, errMsg_1);
-                            case 4: return [4 /*yield*/, context.select(entity, {
-                                    data: (0, actionDef_1.getFullProjection)(entity, context.getSchema()),
-                                    filter: Object.assign({}, operationFilter, {
-                                        $not: filter2,
-                                    })
-                                }, {
-                                    dontCollect: true,
-                                    blockTrigger: true,
-                                })];
-                            case 5:
-                                rows2 = _d.sent();
-                                data_2 = {};
-                                rows2.forEach(function (ele) {
-                                    var _a;
-                                    return Object.assign(data_2, (_a = {},
-                                        _a[ele.id] = ele,
-                                        _a));
-                                });
-                                throw new Exception_1.OakRowInconsistencyException({
-                                    a: 's',
-                                    d: (_c = {},
-                                        _c[entity] = data_2,
-                                        _c)
-                                }, errMsg_1);
-                        }
-                    });
-                });
-            });
-        }
-        case 'relation': {
-            var relationFilter_1 = checker.relationFilter;
-            return (function (_a, context, option) {
-                var operation = _a.operation;
-                return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    return tslib_1.__generator(this, function (_b) {
-                        if (context.isRoot()) {
-                            return [2 /*return*/, 0];
-                        }
-                        // 对后台而言，将生成的relationFilter加到filter之上(select可以在此加以权限的过滤)
-                        operation.filter = (0, filter_1.combineFilters)([operation.filter, relationFilter_1(context, option)]);
-                        return [2 /*return*/, 0];
-                    });
-                });
-            });
-        }
-        default: {
-            (0, assert_1.default)(false);
-        }
-    }
-}
-exports.translateCheckerInAsyncContext = translateCheckerInAsyncContext;
-function translateCheckerInSyncContext(checker) {
-    var entity = checker.entity, type = checker.type;
-    switch (type) {
-        case 'data': {
-            var checkerFn_2 = checker.checker;
-            return function (operation, context) { return checkerFn_2(operation.data, context); };
-        }
-        case 'row': {
-            var filter_3 = checker.filter, errMsg_2 = checker.errMsg;
-            return function (operation, context, option) {
-                var operationFilter = operation.filter, action = operation.action;
-                var filter2 = typeof filter_3 === 'function' ? filter_3(context, option) : filter_3;
-                (0, assert_1.default)(operationFilter);
-                if (['select', 'count', 'stat'].includes(action)) {
-                    operation.filter = (0, filter_1.addFilterSegment)(operationFilter, filter2);
-                    return 0;
-                }
-                else {
-                    if ((0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)) {
-                        return;
-                    }
-                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_2);
-                }
-            };
-        }
-        case 'relation': {
-            var filter_4 = checker.relationFilter, errMsg_3 = checker.errMsg;
-            return function (operation, context, option) {
-                if (context.isRoot()) {
-                    return;
-                }
-                var filter2 = typeof filter_4 === 'function' ? filter_4(context, option) : filter_4;
-                var operationFilter = operation.filter;
-                (0, assert_1.default)(operationFilter);
-                if ((0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)) {
-                    return;
-                }
-                throw new Exception_1.OakUserUnpermittedException(errMsg_3);
-            };
-        }
-        default: {
-            (0, assert_1.default)(false);
-        }
-    }
-}
-exports.translateCheckerInSyncContext = translateCheckerInSyncContext;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var filter_1 = require("../store/filter");
+var Exception_1 = require("../types/Exception");
+var actionDef_1 = require("./actionDef");
+function translateCheckerInAsyncContext(checker) {
+    var _this = this;
+    var entity = checker.entity, type = checker.type;
+    switch (type) {
+        case 'data': {
+            var checkerFn_1 = checker.checker;
+            return (function (_a, context) {
+                var operation = _a.operation;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var data;
+                    return tslib_1.__generator(this, function (_b) {
+                        data = operation.data;
+                        checkerFn_1(data, context);
+                        return [2 /*return*/, 0];
+                    });
+                });
+            });
+        }
+        case 'row': {
+            var filter_2 = checker.filter, errMsg_1 = checker.errMsg, inconsistentRows_1 = checker.inconsistentRows;
+            return (function (_a, context, option) {
+                var operation = _a.operation;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var operationFilter, action, filter2, entity2, selection2, rows2, data_1, rows2, data_2;
+                    var _b, _c;
+                    return tslib_1.__generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                operationFilter = operation.filter, action = operation.action;
+                                (0, assert_1.default)(operationFilter);
+                                filter2 = typeof filter_2 === 'function' ? filter_2(operation, context, option) : filter_2;
+                                if (!['select', 'count', 'stat'].includes(action)) return [3 /*break*/, 1];
+                                operation.filter = (0, filter_1.addFilterSegment)(operationFilter, filter2);
+                                return [2 /*return*/, 0];
+                            case 1: return [4 /*yield*/, (0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)];
+                            case 2:
+                                if (_d.sent()) {
+                                    return [2 /*return*/, 0];
+                                }
+                                if (!inconsistentRows_1) return [3 /*break*/, 4];
+                                entity2 = inconsistentRows_1.entity, selection2 = inconsistentRows_1.selection;
+                                return [4 /*yield*/, context.select(entity2, selection2(operationFilter), {
+                                        dontCollect: true,
+                                        blockTrigger: true,
+                                    })];
+                            case 3:
+                                rows2 = _d.sent();
+                                data_1 = {};
+                                rows2.forEach(function (ele) {
+                                    var _a;
+                                    return Object.assign(data_1, (_a = {},
+                                        _a[ele.id] = ele,
+                                        _a));
+                                });
+                                throw new Exception_1.OakRowInconsistencyException({
+                                    a: 's',
+                                    d: (_b = {},
+                                        _b[entity2] = data_1,
+                                        _b)
+                                }, errMsg_1);
+                            case 4: return [4 /*yield*/, context.select(entity, {
+                                    data: (0, actionDef_1.getFullProjection)(entity, context.getSchema()),
+                                    filter: Object.assign({}, operationFilter, {
+                                        $not: filter2,
+                                    })
+                                }, {
+                                    dontCollect: true,
+                                    blockTrigger: true,
+                                })];
+                            case 5:
+                                rows2 = _d.sent();
+                                data_2 = {};
+                                rows2.forEach(function (ele) {
+                                    var _a;
+                                    return Object.assign(data_2, (_a = {},
+                                        _a[ele.id] = ele,
+                                        _a));
+                                });
+                                throw new Exception_1.OakRowInconsistencyException({
+                                    a: 's',
+                                    d: (_c = {},
+                                        _c[entity] = data_2,
+                                        _c)
+                                }, errMsg_1);
+                        }
+                    });
+                });
+            });
+        }
+        case 'relation': {
+            var relationFilter_1 = checker.relationFilter;
+            return (function (_a, context, option) {
+                var operation = _a.operation;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_b) {
+                        if (context.isRoot()) {
+                            return [2 /*return*/, 0];
+                        }
+                        // 对后台而言，将生成的relationFilter加到filter之上(select可以在此加以权限的过滤)
+                        operation.filter = (0, filter_1.combineFilters)([operation.filter, relationFilter_1(operation, context, option)]);
+                        return [2 /*return*/, 0];
+                    });
+                });
+            });
+        }
+        case 'expression':
+        case 'expressionRelation': {
+            var expression_1 = checker.expression, errMsg_2 = checker.errMsg;
+            return (function (_a, context, option) {
+                var operation = _a.operation;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var _b, expressionEntity, expr, expressionFilter, _c, result;
+                    return tslib_1.__generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                if (context.isRoot() && type === 'expressionRelation') {
+                                    return [2 /*return*/, 0];
+                                }
+                                _b = expression_1(operation, context, option), expressionEntity = _b.entity, expr = _b.expr, expressionFilter = _b.filter;
+                                return [4 /*yield*/, context.select(expressionEntity, {
+                                        data: {
+                                            $expr: expr,
+                                        },
+                                        filter: expressionFilter,
+                                    }, Object.assign({}, option, { dontCollect: true }))];
+                            case 1:
+                                _c = tslib_1.__read.apply(void 0, [_d.sent(), 1]), result = _c[0];
+                                if (!result) {
+                                    // 条件判定为假，抛异常
+                                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_2);
+                                }
+                                return [2 /*return*/, 0];
+                        }
+                    });
+                });
+            });
+        }
+        default: {
+            (0, assert_1.default)(false);
+        }
+    }
+}
+exports.translateCheckerInAsyncContext = translateCheckerInAsyncContext;
+function translateCheckerInSyncContext(checker) {
+    var entity = checker.entity, type = checker.type;
+    switch (type) {
+        case 'data': {
+            var checkerFn_2 = checker.checker;
+            return function (operation, context) { return checkerFn_2(operation.data, context); };
+        }
+        case 'row': {
+            var filter_3 = checker.filter, errMsg_3 = checker.errMsg;
+            return function (operation, context, option) {
+                var operationFilter = operation.filter, action = operation.action;
+                var filter2 = typeof filter_3 === 'function' ? filter_3(operation, context, option) : filter_3;
+                (0, assert_1.default)(operationFilter);
+                if (['select', 'count', 'stat'].includes(action)) {
+                    operation.filter = (0, filter_1.addFilterSegment)(operationFilter, filter2);
+                    return 0;
+                }
+                else {
+                    if ((0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)) {
+                        return;
+                    }
+                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_3);
+                }
+            };
+        }
+        case 'relation': {
+            var filter_4 = checker.relationFilter, errMsg_4 = checker.errMsg;
+            return function (operation, context, option) {
+                if (context.isRoot()) {
+                    return;
+                }
+                var filter2 = typeof filter_4 === 'function' ? filter_4(operation, context, option) : filter_4;
+                var operationFilter = operation.filter;
+                (0, assert_1.default)(operationFilter);
+                if ((0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter)) {
+                    return;
+                }
+                throw new Exception_1.OakUserUnpermittedException(errMsg_4);
+            };
+        }
+        case 'expression':
+        case 'expressionRelation': {
+            var expression_2 = checker.expression, errMsg_5 = checker.errMsg;
+            return function (operation, context, option) {
+                if (context.isRoot() && type === 'expressionRelation') {
+                    return;
+                }
+                var _a = expression_2(operation, context, option), expressionEntity = _a.entity, expr = _a.expr, expressionFilter = _a.filter;
+                var _b = tslib_1.__read(context.select(expressionEntity, {
+                    data: {
+                        $expr: expr,
+                    },
+                    filter: expressionFilter,
+                }, Object.assign({}, option, { dontCollect: true })), 1), result = _b[0];
+                if (!result.$expr) {
+                    // 条件判定为假，抛异常
+                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_5);
+                }
+                return;
+            };
+        }
+        default: {
+            (0, assert_1.default)(false);
+        }
+    }
+}
+exports.translateCheckerInSyncContext = translateCheckerInSyncContext;

package/lib/store/filter.d.ts

@@ -1,99 +1,99 @@
-import { StorageSchema } from '../types';
-import { EntityDict } from "../types/Entity";
-import { AsyncContext } from './AsyncRowStore';
-import { SyncContext } from './SyncRowStore';
-export declare function addFilterSegment<ED extends EntityDict, T extends keyof ED>(...filters: ED[T]['Selection']['filter'][]): ED[T]["Selection"]["filter"];
-export declare function unionFilterSegment<ED extends EntityDict, T extends keyof ED>(...filters: ED[T]['Selection']['filter'][]): ED[T]["Selection"]["filter"];
-export declare function combineFilters<ED extends EntityDict, T extends keyof ED>(filters: Array<ED[T]['Selection']['filter']>, union?: true): ED[T]["Selection"]["filter"];
-/**
- * 判断value1表达的单个属性查询与同属性上value2表达的查询是包容还是相斥
- * 相容即value1所表达的查询结果一定被value2表达的查询结果所包含，例如：
- * value1: {
- *  $eq: 12
- * }
- * value2: {
- *  $gt: 8,
- * }
- * 此时value1相容value2
- *
- * 相斥即value1所表达的查询结果与value2一定毫无联系，例如：
- * value1: {
- *  $gt: 8,
- * }
- * value2: {
- *  $lt: 2,
- * }
- *
- *
- * @param value1
- * @param value2
- * @attention: 1)这里的测试不够充分，有些算子之间的相容或相斥可能有遗漏, 2)有新的算子加入需要修改代码
- */
-export declare function judgeValueRelation(value1: any, value2: any, contained: boolean): boolean;
-/**
- *
- * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
- * filter = {
- *      a: 1
- *      b: 2,
- *      c: 3,
- * },
- * conditionalFilter = {
- *      a: 1
- * }
- * 则包含
- * @param entity
- * @param schema
- * @param filter
- * @param conditionalFilter
- * @returns
- */
-export declare function contains<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Selection']['filter'], conditionalFilter: ED[T]['Selection']['filter']): boolean;
-/**
- * 判断filter1和filter2是否相斥，即filter1和filter2查询的结果一定没有交集
- * filter1 = {
- *      a: 2
- * },
- * filter2 = {
- *      a: 1
- * }
- * 则包含
- * @param entity
- * @param schema
- * @param filter
- * @param conditionalFilter
- */
-export declare function repel<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;
-/**
- * 从filter中判断是否有确定的id对象，如果有则返回这些id，没有返回空数组
- * @param filter
- * @returns
- */
-export declare function getRelevantIds<ED extends EntityDict, T extends keyof ED>(filter: ED[T]['Selection']['filter']): string[];
-/**
- * 判断两个过滤条件是否完全一致
- * @param entity
- * @param schema
- * @param filter1
- * @param filter2
- */
-export declare function same<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;
-/**
- * 寻找在树形结构中满足条件的数据行的上层数据
- * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更高层的“浙江省”和“中国”，即可构造出满足条件的filter
- * @param entity
- * @param parentKey parentId属性名
- * @param filter 查询当前行的条件
- * @param level
- */
-export declare function makeTreeAncestorFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
-/**
- * 寻找在树形结构中满足条件的数据行的下层数据
- * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更低层的“西湖区”，即可构造出满足条件的filter
- * @param entity
- * @param parentKey parentId属性名
- * @param filter 查询当前行的条件
- * @param level
- */
-export declare function makeTreeDescendantFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
-export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter']): boolean | Promise<boolean>;
+import { StorageSchema } from '../types';
+import { EntityDict } from "../types/Entity";
+import { AsyncContext } from './AsyncRowStore';
+import { SyncContext } from './SyncRowStore';
+export declare function addFilterSegment<ED extends EntityDict, T extends keyof ED>(...filters: ED[T]['Selection']['filter'][]): ED[T]["Selection"]["filter"];
+export declare function unionFilterSegment<ED extends EntityDict, T extends keyof ED>(...filters: ED[T]['Selection']['filter'][]): ED[T]["Selection"]["filter"];
+export declare function combineFilters<ED extends EntityDict, T extends keyof ED>(filters: Array<ED[T]['Selection']['filter']>, union?: true): ED[T]["Selection"]["filter"];
+/**
+ * 判断value1表达的单个属性查询与同属性上value2表达的查询是包容还是相斥
+ * 相容即value1所表达的查询结果一定被value2表达的查询结果所包含，例如：
+ * value1: {
+ *  $eq: 12
+ * }
+ * value2: {
+ *  $gt: 8,
+ * }
+ * 此时value1相容value2
+ *
+ * 相斥即value1所表达的查询结果与value2一定毫无联系，例如：
+ * value1: {
+ *  $gt: 8,
+ * }
+ * value2: {
+ *  $lt: 2,
+ * }
+ *
+ *
+ * @param value1
+ * @param value2
+ * @attention: 1)这里的测试不够充分，有些算子之间的相容或相斥可能有遗漏, 2)有新的算子加入需要修改代码
+ */
+export declare function judgeValueRelation(value1: any, value2: any, contained: boolean): boolean;
+/**
+ *
+ * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
+ * filter = {
+ *      a: 1
+ *      b: 2,
+ *      c: 3,
+ * },
+ * conditionalFilter = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ * @returns
+ */
+export declare function contains<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Selection']['filter'], conditionalFilter: ED[T]['Selection']['filter']): boolean;
+/**
+ * 判断filter1和filter2是否相斥，即filter1和filter2查询的结果一定没有交集
+ * filter1 = {
+ *      a: 2
+ * },
+ * filter2 = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ */
+export declare function repel<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;
+/**
+ * 从filter中判断是否有确定的id对象，如果有则返回这些id，没有返回空数组
+ * @param filter
+ * @returns
+ */
+export declare function getRelevantIds<ED extends EntityDict, T extends keyof ED>(filter: ED[T]['Selection']['filter']): string[];
+/**
+ * 判断两个过滤条件是否完全一致
+ * @param entity
+ * @param schema
+ * @param filter1
+ * @param filter2
+ */
+export declare function same<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;
+/**
+ * 寻找在树形结构中满足条件的数据行的上层数据
+ * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更高层的“浙江省”和“中国”，即可构造出满足条件的filter
+ * @param entity
+ * @param parentKey parentId属性名
+ * @param filter 查询当前行的条件
+ * @param level
+ */
+export declare function makeTreeAncestorFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
+/**
+ * 寻找在树形结构中满足条件的数据行的下层数据
+ * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更低层的“西湖区”，即可构造出满足条件的filter
+ * @param entity
+ * @param parentKey parentId属性名
+ * @param filter 查询当前行的条件
+ * @param level
+ */
+export declare function makeTreeDescendantFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
+export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter']): boolean | Promise<boolean>;