oak-domain 2.2.0 → 2.3.1

package/lib/store/checker.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
+exports.createRelationHierarchyCheckers = 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");
+var string_1 = require("../utils/string");
 function translateCheckerInAsyncContext(checker) {
     var _this = this;
     var entity = checker.entity, type = checker.type;
@@ -35,12 +36,11 @@ function translateCheckerInAsyncContext(checker) {
                         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);
+                                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 1: return [4 /*yield*/, (0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter || {})];
                             case 2:
                                 if (_d.sent()) {
                                     return [2 /*return*/, 0];
@@ -117,27 +117,35 @@ function translateCheckerInAsyncContext(checker) {
             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) {
+                    var exprResult, expressionEntity, expr, expressionFilter, _b, result;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.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;
+                                exprResult = expression_1(operation, context, option);
+                                if (!(typeof exprResult === 'string')) return [3 /*break*/, 1];
+                                throw new Exception_1.OakUserUnpermittedException(exprResult || errMsg_2);
+                            case 1:
+                                if (!(exprResult === undefined)) return [3 /*break*/, 2];
+                                return [2 /*return*/, 0];
+                            case 2:
+                                expressionEntity = exprResult.entity, expr = exprResult.expr, expressionFilter = exprResult.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];
+                            case 3:
+                                _b = tslib_1.__read.apply(void 0, [_c.sent(), 1]), result = _b[0];
                                 if (!result) {
                                     // 条件判定为假，抛异常
-                                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_2);
+                                    throw new Exception_1.OakUserUnpermittedException(errMsg_2);
                                 }
-                                return [2 /*return*/, 0];
+                                _c.label = 4;
+                            case 4: return [2 /*return*/, 0];
                         }
                     });
                 });
@@ -196,18 +204,27 @@ function translateCheckerInSyncContext(checker) {
                 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);
+                var exprResult = expression_2(operation, context, option);
+                if (typeof exprResult === 'string') {
+                    throw new Exception_1.OakUserUnpermittedException(exprResult || errMsg_5);
+                }
+                else if (exprResult === undefined) {
+                    return 0;
+                }
+                else {
+                    var expressionEntity = exprResult.entity, expr = exprResult.expr, expressionFilter = exprResult.filter;
+                    var _a = tslib_1.__read(context.select(expressionEntity, {
+                        data: {
+                            $expr: expr,
+                        },
+                        filter: expressionFilter,
+                    }, Object.assign({}, option, { dontCollect: true })), 1), result = _a[0];
+                    if (!result.$expr) {
+                        // 条件判定为假，抛异常
+                        throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_5);
+                    }
+                    return;
                 }
-                return;
             };
         }
         default: {
@@ -216,3 +233,156 @@ function translateCheckerInSyncContext(checker) {
     }
 }
 exports.translateCheckerInSyncContext = translateCheckerInSyncContext;
+function createRelationHierarchyCheckers(schema) {
+    var checkers = [];
+    var _loop_1 = function (entity) {
+        var e_1, _a;
+        var relationHierarchy = schema[entity].relationHierarchy;
+        if (relationHierarchy) {
+            // 先build反向hierarchy的map
+            var reverseHierarchy_1 = {};
+            for (var r in relationHierarchy) {
+                try {
+                    for (var _b = (e_1 = void 0, tslib_1.__values(relationHierarchy[r])), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var r2 = _c.value;
+                        if (!reverseHierarchy_1[r2]) {
+                            reverseHierarchy_1[r2] = [r];
+                        }
+                        else {
+                            reverseHierarchy_1[r2].push(r);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            // 对userEntity对象的授权和回收建立checker
+            var userEntityName_1 = "user".concat((0, string_1.firstLetterUpperCase)(entity));
+            var entityIdAttr_1 = "".concat(entity, "Id");
+            checkers.push({
+                entity: userEntityName_1,
+                action: 'create',
+                type: 'expressionRelation',
+                expression: function (operation, context) {
+                    var _a;
+                    var data = operation.data;
+                    var _b = data, relation = _b.relation, _c = entityIdAttr_1, entityId = _b[_c];
+                    var legalRelations = reverseHierarchy_1[relation];
+                    if (!legalRelations) {
+                        return undefined;
+                    }
+                    if (legalRelations.length === 0) {
+                        return '这是不应该跑出来的情况，请杀程序员祭天';
+                    }
+                    var userId = context.getCurrentUserId();
+                    return {
+                        entity: userEntityName_1,
+                        expr: {
+                            $gt: [{
+                                    '#attr': '$$createAt$$',
+                                }, 0]
+                        },
+                        filter: (_a = {
+                                userId: userId
+                            },
+                            _a[entityIdAttr_1] = entityId,
+                            _a.relation = {
+                                $in: legalRelations,
+                            },
+                            _a)
+                    };
+                },
+                errMsg: '越权操作',
+            });
+            var _loop_2 = function (r) {
+                checkers.push({
+                    entity: userEntityName_1,
+                    action: 'remove',
+                    type: 'expressionRelation',
+                    expression: function (operation, context) {
+                        var _a, _b;
+                        var userId = context.getCurrentUserId();
+                        var filter = operation.filter;
+                        var legalRelations = reverseHierarchy_1[r];
+                        if (legalRelations.length === 0) {
+                            return '这是不应该跑出来的情况，请杀程序员祭天';
+                        }
+                        return {
+                            entity: userEntityName_1,
+                            expr: {
+                                $gt: [{
+                                        '#attr': '$$createAt$$',
+                                    }, 0]
+                            },
+                            filter: (_a = {
+                                    userId: userId
+                                },
+                                _a[entityIdAttr_1] = {
+                                    $in: {
+                                        entity: userEntityName_1,
+                                        data: (_b = {},
+                                            _b[entityIdAttr_1] = 1,
+                                            _b),
+                                        filter: filter,
+                                    }
+                                },
+                                _a.relation = {
+                                    $in: legalRelations,
+                                },
+                                _a),
+                        };
+                    },
+                    errMsg: '越权操作',
+                });
+            };
+            for (var r in reverseHierarchy_1) {
+                _loop_2(r);
+            }
+            /* // 一个人不能授权给自己，也不能删除自己的授权
+            checkers.push({
+                entity: userEntityName as keyof ED,
+                action: 'create' as ED[keyof ED]['Action'],
+                type: 'data',
+                checker: (data, context) => {
+                    assert(!(data instanceof Array));
+                    const { userId } = data as ED[keyof ED]['CreateSingle']['data'];
+                    const userId2 = context.getCurrentUserId(true);
+                    if (userId === userId2) {
+                        throw new OakDataException('不允许授权给自己');
+                    }
+                }
+            });
+
+            checkers.push({
+                entity: userEntityName as keyof ED,
+                action: 'remove' as ED[keyof ED]['Action'],
+                type: 'row',
+                filter: (operation, context) => {
+                    const userId = context.getCurrentUserId(true);
+                    if (userId) {
+                        return {
+                            userId: {
+                                $ne: userId,
+                            },
+                        };
+                    }
+                    console.warn(`没有当前用户但在删除权限，请检查。对象是${entity}`);
+                    return {};
+                },
+                errMsg: '不允许回收自己的授权',
+            }); */
+            // 转让权限现在用update动作，只允许update userId给其它人
+            // todo 等实现的时候再写
+        }
+    };
+    for (var entity in schema) {
+        _loop_1(entity);
+    }
+    return checkers;
+}
+exports.createRelationHierarchyCheckers = createRelationHierarchyCheckers;

package/lib/store/filter.d.ts

@@ -97,3 +97,4 @@ export declare function makeTreeAncestorFilter<ED extends EntityDict, T extends
  */
 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>;
+export declare function checkFilterRepel<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean | Promise<boolean>;

package/lib/store/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.judgeValueRelation = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
+exports.checkFilterRepel = exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.judgeValueRelation = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var types_1 = require("../types");
@@ -502,7 +502,7 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
                     var logicQueries = filter[attr2];
                     var results = logicQueries.map(function (logicQuery) { return judgeFilter2ValueRelation(entity, schema, attr, logicQuery, conditionalFilterAttrValue, contained); });
                     // 如果filter的多个算子是and关系，则只要有一个包含此条件就是包含，只要有一个与此条件相斥就是相斥
-                    // 如果filter的多个算子是or关系，则必须所有的条件都包含此条件才是包含，必须所有的条件都与此条件相斥才是相斥
+                    // 如果filter的多个算子是or关系，则必须所有的条件都包含此条件才是包含，必须所有的条件都与此条件相斥才是相斥                    
                     if (attr2 === '$and') {
                         if (results.includes(true)) {
                             return true;
@@ -520,25 +520,17 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
                 }
                 case '$not': {
                     /*
-                    * 若filter的not条件被conditionalFilterAttrValue包容，则说明两者互斥
-                    * 若filter的not条件被conditionalFilterAttrValue的not条件所包容，则说明此条件包容conditionalFilterAttrValue
-                    *   但两条规则都没法应用，会无限递归
+                    * 若filter的not条件被conditionalFilterAttrValue条件包容，则说明两者互斥
+                    * filter包容conditionalFilterAttrValue条件暂时无法由其not条件推论出来
                     */
                     var logicQuery = filter[attr2];
-                    /* if (contained && judgeFilterRelation(entity, schema, {
-                        [attr2]: {
-                            $not: conditionalFilterAttrValue
-                        }
-                    }, logicQuery, contained)) {
-                        return true;
-                    } */
-                    if (!contained && judgeFilterRelation(entity, schema, (_a = {}, _a[attr2] = conditionalFilterAttrValue, _a), logicQuery, contained)) {
+                    if (!contained && judgeFilterRelation(entity, schema, logicQuery, (_a = {}, _a[attr] = conditionalFilterAttrValue, _a), true)) {
                         return true;
                     }
                     break;
                 }
                 default: {
-                    break;
+                    (0, assert_1.default)(false);
                 }
             }
         }
@@ -566,6 +558,7 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
             }
         }
     }
+    // 到这里说明无法判断相容或者相斥，安全起见全返回false
     return false;
 }
 /**
@@ -584,15 +577,15 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
                     var logicQueries = conditionalFilter[attr];
                     var results = logicQueries.map(function (logicQuery) { return judgeFilterRelation(entity, schema, filter, logicQuery, contained); });
                     if (contained) {
-                        // 如果是包容关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当被filter所包容
+                        // 如果是包容关系，or和and需要全部被包容
                         if (results.includes(false)) {
                             return false;
                         }
                     }
                     else if (!contained) {
-                        // 如果是相斥关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当与filter所相斥
-                        if (!results.includes(true)) {
-                            return false;
+                        // 如果是相斥关系，and只需要和一个相斥，or需要和全部相斥
+                        if (attr === '$and' && results.includes(true) || attr === '$or' && !results.includes(false)) {
+                            return true;
                         }
                     }
                     else {
@@ -602,12 +595,19 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
                 }
                 case '$not': {
                     /**
-                     * 若filter与not所定义的filter相斥，则filter与conditionalFilter相容
-                     * 若filter与not所定义的filter相容，则filter与conditionalFilter相斥
+                     * 若filter与conditionalFilter not所定义的部分相斥，则filter与conditionalFilter相容
+                     * 若filter将conditionalFilter not所定义的部分包容，则filter与conditionalFilter相斥
                      */
                     var logicQuery = conditionalFilter[attr];
-                    if (judgeFilterRelation(entity, schema, filter, logicQuery, !contained)) {
-                        return true;
+                    if (contained) {
+                        if (!judgeFilterRelation(entity, schema, filter, logicQuery, false)) {
+                            return false;
+                        }
+                    }
+                    else {
+                        if (judgeFilterRelation(entity, schema, filter, logicQuery, true)) {
+                            return true;
+                        }
                     }
                     break;
                 }
@@ -655,8 +655,8 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
  * @returns
  */
 function contains(entity, schema, filter, conditionalFilter) {
-    // return judgeFilterRelation(entity, schema, filter, conditionalFilter, true);
-    return false;
+    return judgeFilterRelation(entity, schema, filter, conditionalFilter, true);
+    // return false;
 }
 exports.contains = contains;
 /**
@@ -675,8 +675,8 @@ exports.contains = contains;
  */
 function repel(entity, schema, filter1, filter2) {
     // todo
-    // return judgeFilterRelation(entity, schema, filter1, filter2, false);
-    return false;
+    return judgeFilterRelation(entity, schema, filter1, filter2, false);
+    // return false;
 }
 exports.repel = repel;
 /**
@@ -853,3 +853,26 @@ function checkFilterContains(entity, context, contained, filter) {
     return count === 0;
 }
 exports.checkFilterContains = checkFilterContains;
+function checkFilterRepel(entity, context, filter1, filter2) {
+    if (!filter2) {
+        throw new types_1.OakRowInconsistencyException();
+    }
+    var schema = context.getSchema();
+    // 优先判断两个条件是否相容
+    if (repel(entity, schema, filter2, filter1)) {
+        return true;
+    }
+    // 再判断两者同时成立时取得的行数是否为0
+    var filter3 = combineFilters([filter2, filter1]);
+    var count = context.count(entity, {
+        filter: filter3,
+    }, {
+        dontCollect: true,
+        blockTrigger: true,
+    });
+    if (count instanceof Promise) {
+        return count.then(function (count2) { return count2 !== 0; });
+    }
+    return count !== 0;
+}
+exports.checkFilterRepel = checkFilterRepel;

package/lib/store/modi.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var action_1 = require("../actions/action");
 var lodash_1 = require("../utils/lodash");
 var uuid_1 = require("../utils/uuid");
+var assert_1 = tslib_1.__importDefault(require("assert"));
 function createOperationsFromModies(modies) {
     return modies.map(function (modi) {
         return {
@@ -86,12 +87,45 @@ function createModiRelatedCheckers(schema) {
             action: restActions,
             type: 'row',
             filter: function (operation, context, option) {
-                if (option.modiParentId && option.modiParentEntity) {
-                    // 如果本身也是创建modi就允许通过
+                /**
+                 * 只有一种情况可以通过，即当前是在更新和active的modi所指向同一个父更新对象。
+                 * 比如：先申请了一个公司（company），再申请修改公司（companyApplyment），这时所有的active modi都指向此条companyApplyment
+                 *      这时：
+                 *          1）再申请一条新的修改公司（create companyApplyment），应被拒绝
+                 *          2）申请修改原来的companyApplyment(update companyApplyment)，可以通过
+                 *          3）在其它路径上对此company对象进行直接的更新，应被拒绝
+                 */
+                if (option.modiParentEntity) {
+                    var _a = option, modiParentEntity = _a.modiParentEntity, modiParentId = _a.modiParentId;
+                    (0, assert_1.default)(modiParentEntity);
+                    (0, assert_1.default)(modiParentId);
                     return {
                         id: {
-                            $exists: true,
-                        },
+                            $nin: {
+                                entity: 'modiEntity',
+                                data: {
+                                    entityId: 1,
+                                },
+                                filter: {
+                                    entity: entity,
+                                    modi: {
+                                        iState: 'active',
+                                        $or: [
+                                            {
+                                                entity: {
+                                                    $ne: modiParentEntity,
+                                                },
+                                            },
+                                            {
+                                                entityId: {
+                                                    $ne: modiParentId,
+                                                },
+                                            }
+                                        ],
+                                    },
+                                },
+                            },
+                        }
                     };
                 }
                 return {
@@ -111,7 +145,7 @@ function createModiRelatedCheckers(schema) {
                     }
                 };
             },
-            errMsg: "\u66F4\u65B0\u7684\u5BF9\u8C61".concat(entity, "\u4E0A\u6709\u5C1A\u672A\u7ED3\u675F\u7684modi"),
+            errMsg: '您请求的更新对象上还有正在申请的更新，请等该更新结束后再试',
         });
     };
     for (var entity in schema) {

package/lib/store/relation.js

@@ -24,9 +24,11 @@ function judgeRelation(schema, entity, attr) {
         return 1;
     }
     if (attr.includes('$')) {
-        var entity2 = attr.slice(0, attr.indexOf('$'));
+        var firstDelimiter = attr.indexOf('$');
+        var entity2 = attr.slice(0, firstDelimiter);
         (0, assert_1.default)(schema.hasOwnProperty(entity2));
-        var foreignKey = attr.slice(attr.indexOf('$') + 1);
+        var secondDelemiter = attr.indexOf('$', firstDelimiter + 1);
+        var foreignKey = attr.slice(firstDelimiter + 1, secondDelemiter > 0 ? secondDelemiter : attr.length);
         var _c = schema, _d = entity2, attributes2 = _c[_d].attributes;
         if (foreignKey === 'entity') {
             // 基于反指对象的反向关联

package/lib/store/selection.js

@@ -181,7 +181,7 @@ function reinforceSelection(schema, entity, selection) {
                         necessaryAttrs.push("".concat(attr, "Id"));
                         checkProjectionNode(rel, projectionNode[attr]);
                     }
-                    else if (rel instanceof Array) {
+                    else if (rel instanceof Array && !attr.endsWith('$$aggr')) {
                         var data_1 = projectionNode[attr].data;
                         if (rel[1]) {
                             checkNode(data_1, [rel[1]]);
@@ -189,7 +189,7 @@ function reinforceSelection(schema, entity, selection) {
                         else {
                             checkNode(data_1, ['entity', 'entityId']);
                         }
-                        checkProjectionNode(rel[0], data_1);
+                        reinforceSelection(schema, rel[0], projectionNode[attr]);
                     }
                 }
             }

package/lib/types/Auth.d.ts

@@ -3,12 +3,17 @@ import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
 import { RefOrExpression } from "./Expression";
 export declare type CheckerType = 'relation' | 'row' | 'data' | 'expression' | 'expressionRelation';
+/**
+ * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
+ * 被转化成trigger的filter条件，详细可看trigger中的说明
+ */
 export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'data';
     entity: T;
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
     checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -21,6 +26,7 @@ export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt ex
         entity: keyof ED;
         selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];
     };
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -29,6 +35,7 @@ export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, C
     action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
     relationFilter: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'];
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type ExpressionChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -39,8 +46,9 @@ export declare type ExpressionChecker<ED extends EntityDict, T extends keyof ED,
         entity: T2;
         expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
         filter: ED[T2]['Selection']['filter'];
-    };
+    } | undefined | string;
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type ExpressionRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -51,7 +59,8 @@ export declare type ExpressionRelationChecker<ED extends EntityDict, T extends k
         entity: T2;
         expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
         filter: ED[T2]['Selection']['filter'];
-    };
+    } | undefined | string;
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt> | ExpressionChecker<ED, T, Cxt> | ExpressionRelationChecker<ED, T, Cxt>;

package/lib/types/Entity.d.ts

@@ -73,6 +73,7 @@ export interface EntityDef {
     Action: string;
     ParticularAction?: string;
     Selection: Omit<DeduceSelection<this['Schema']>, 'action'>;
+    Aggregation: Omit<DeduceAggregation<this['Schema'], DeduceProjection<this['Schema']>, DeduceFilter<this['Schema']>, DeduceSorter<this['Schema']>>, 'action'>;
     Operation: DeduceOperation<this['Schema']>;
     Create: DeduceCreateOperation<this['Schema']>;
     CreateSingle: DeduceCreateSingleOperation<this['Schema']>;
@@ -90,7 +91,18 @@ declare type DeduceProjection<SH extends GeneralEntityShape> = {
     '#id'?: NodeId;
 } & {
     [K in keyof SH]?: number | OtmSubProjection | any;
-} & Partial<ExprOp<keyof SH>>;
+} & Partial<ExprOp<keyof SH | string>>;
+export declare type AggregationOp = `#max-${number}` | `#min-${number}` | `#avg-${number}` | `#count-${number}` | `#sum-${number}`;
+export declare type DeduceAggregationData<SH extends GeneralEntityShape, P extends DeduceProjection<SH>> = {
+    [A in AggregationOp]?: P;
+} & {
+    '#aggr'?: P;
+};
+export declare type AggregationResult<SH extends GeneralEntityShape> = Array<{
+    [A in AggregationOp]?: number | string;
+} & {
+    '#data'?: Partial<SH>;
+}>;
 export declare type AttrFilter<SH extends GeneralEntityShape> = {
     [K in keyof SH]: any;
 };
@@ -104,6 +116,7 @@ export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
 };
 export declare type DeduceSorter<SH extends GeneralEntityShape> = Array<DeduceSorterItem<SH>>;
 export declare type DeduceSelection<SH extends GeneralEntityShape> = Selection<DeduceProjection<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
+export declare type DeduceAggregation<SH extends GeneralEntityShape, P extends DeduceProjection<SH>, F extends DeduceFilter<SH>, S extends DeduceSorter<SH>> = Omit<Operation<'aggregate', DeduceAggregationData<SH, P>, F, S>, 'action'>;
 export declare type DeduceCreateOperationData<SH extends GeneralEntityShape> = {
     id: string;
 } & {
@@ -137,6 +150,9 @@ export declare type RemoveOpResult<ED extends EntityDict, T extends keyof ED> =
     e: T;
     f?: DeduceFilter<ED[T]['Schema']>;
 };
+export declare type RelationHierarchy<R extends string> = {
+    [K in R]?: R[];
+};
 export declare type SelectOpResult<ED extends EntityDict> = {
     a: 's';
     d: {
@@ -156,4 +172,19 @@ export declare type Configuration = {
     actionType?: ActionType;
     static?: boolean;
 };
+export declare type Exportation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+    name: string;
+    id: string;
+    entity: T;
+    projection: ED[T]['Selection']['data'];
+    headers: K[];
+    fn: (data: ED[T]['Schema']) => Partial<Record<K, string | number | boolean | null>>;
+};
+export declare type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+    name: string;
+    id: string;
+    entity: T;
+    headers: K[];
+    fn: (data: Partial<Record<K, string | number | boolean>>) => ED[T]['CreateSingle']['data'];
+};
 export {};