oak-domain 2.3.2 → 2.4.0

package/lib/actions/relation.d.ts

@@ -1 +1,5 @@
+import { CascadeRelationItem, RelationHierarchy } from "../types/Entity";
 export declare type GenericRelation = 'owner';
+export declare function convertHierarchyToAuth<R extends string>(hierarchy: RelationHierarchy<R>): {
+    [K in R]?: CascadeRelationItem;
+};

package/lib/actions/relation.js

@@ -1,2 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertHierarchyToAuth = void 0;
+var tslib_1 = require("tslib");
+function convertHierarchyToAuth(hierarchy) {
+    var e_1, _a;
+    var _b;
+    var reverseHierarchy = {};
+    for (var r in hierarchy) {
+        try {
+            for (var _c = (e_1 = void 0, tslib_1.__values(hierarchy[r])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var r2 = _d.value;
+                if (reverseHierarchy[r2]) {
+                    (_b = reverseHierarchy[r2]) === null || _b === void 0 ? void 0 : _b.push(r);
+                }
+                else {
+                    reverseHierarchy[r2] = [r];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    var result = {};
+    for (var r in reverseHierarchy) {
+        result[r] = {
+            cascadePath: '',
+            relations: reverseHierarchy[r],
+        };
+    }
+    return result;
+}
+exports.convertHierarchyToAuth = convertHierarchyToAuth;

package/lib/base-app-domain/Modi/Schema.d.ts

@@ -107,7 +107,7 @@ export declare type SortNode = {
 export declare type Sorter = SortNode[];
 export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
 export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
-export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
+export declare type Aggregation = Omit<DeduceAggregation<Projection, Filter, Sorter>, "id">;
 export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId">> & ({
     entity?: string;
     entityId?: string;
@@ -127,10 +127,8 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
 export declare type UpdateOperation = OakOperation<"update" | ParticularAction | string, UpdateOperationData, Filter, Sorter>;
 export declare type RemoveOperationData = {};
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
-export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
+export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type ModiIdSubQuery = Selection<ModiIdProjection>;
-export declare type NativeAttr = OpAttr;
-export declare type FullAttr = NativeAttr | `modiEntitys$${number}.${ModiEntity.NativeAttr}` | `operEntitys$${number}.${OperEntity.NativeAttr}`;
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;

package/lib/base-app-domain/ModiEntity/Schema.d.ts

@@ -83,7 +83,7 @@ export declare type SortNode = {
 export declare type Sorter = SortNode[];
 export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
 export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
-export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
+export declare type Aggregation = Omit<DeduceAggregation<Projection, Filter, Sorter>, "id">;
 export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "modiId">> & (({
     modiId?: never;
     modi: Modi.CreateSingleOperation;
@@ -142,12 +142,10 @@ export declare type RemoveOperationData = {} & (({
     [k: string]: any;
 });
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
-export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
+export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type ModiIdSubQuery = Selection<ModiIdProjection>;
 export declare type UserIdSubQuery = Selection<UserIdProjection>;
 export declare type ModiEntityIdSubQuery = Selection<ModiEntityIdProjection>;
-export declare type NativeAttr = OpAttr | `modi.${Modi.NativeAttr}` | `entity.${User.NativeAttr}`;
-export declare type FullAttr = NativeAttr;
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;

package/lib/base-app-domain/Oper/Schema.d.ts

@@ -89,7 +89,7 @@ export declare type SortNode = {
 export declare type Sorter = SortNode[];
 export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
 export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
-export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
+export declare type Aggregation = Omit<DeduceAggregation<Projection, Filter, Sorter>, "id">;
 export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "operatorId">> & (({
     operatorId?: never;
     operator?: User.CreateSingleOperation;
@@ -125,11 +125,9 @@ export declare type RemoveOperationData = {} & (({
     operator?: User.UpdateOperation | User.RemoveOperation;
 }));
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
-export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
+export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type UserIdSubQuery = Selection<UserIdProjection>;
 export declare type OperIdSubQuery = Selection<OperIdProjection>;
-export declare type NativeAttr = OpAttr | `operator.${User.NativeAttr}`;
-export declare type FullAttr = NativeAttr | `operEntitys$${number}.${OperEntity.NativeAttr}`;
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;

package/lib/base-app-domain/OperEntity/Schema.d.ts

@@ -92,7 +92,7 @@ export declare type SortNode = {
 export declare type Sorter = SortNode[];
 export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
 export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
-export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
+export declare type Aggregation = Omit<DeduceAggregation<Projection, Filter, Sorter>, "id">;
 export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "operId">> & (({
     operId?: never;
     oper: Oper.CreateSingleOperation;
@@ -157,13 +157,11 @@ export declare type RemoveOperationData = {} & ({
     [k: string]: any;
 });
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
-export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
+export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type OperIdSubQuery = Selection<OperIdProjection>;
 export declare type ModiIdSubQuery = Selection<ModiIdProjection>;
 export declare type UserIdSubQuery = Selection<UserIdProjection>;
 export declare type OperEntityIdSubQuery = Selection<OperEntityIdProjection>;
-export declare type NativeAttr = OpAttr | `oper.${Oper.NativeAttr}` | `entity.${Modi.NativeAttr}` | `entity.${User.NativeAttr}`;
-export declare type FullAttr = NativeAttr;
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;

package/lib/base-app-domain/User/Schema.d.ts

@@ -92,7 +92,7 @@ export declare type SortNode = {
 export declare type Sorter = SortNode[];
 export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
 export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
-export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
+export declare type Aggregation = Omit<DeduceAggregation<Projection, Filter, Sorter>, "id">;
 export declare type CreateOperationData = FormCreateData<OpSchema> & {
     oper$operator?: OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">[]> | Array<OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">>>;
     operEntity$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;
@@ -110,10 +110,8 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
 export declare type UpdateOperation = OakOperation<"update" | RelationAction | string, UpdateOperationData, Filter, Sorter>;
 export declare type RemoveOperationData = {};
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
-export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
+export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type UserIdSubQuery = Selection<UserIdProjection>;
-export declare type NativeAttr = OpAttr;
-export declare type FullAttr = NativeAttr | `opers$${number}.${Oper.NativeAttr}` | `operEntitys$${number}.${OperEntity.NativeAttr}` | `modiEntitys$${number}.${ModiEntity.NativeAttr}`;
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;

package/lib/checkers/index.d.ts

@@ -1,5 +1,5 @@
 import { EntityDict } from '../base-app-domain';
 import { AsyncContext } from '../store/AsyncRowStore';
 import { SyncContext } from '../store/SyncRowStore';
-import { StorageSchema, EntityDict as BaseEntityDict, Checker } from '../types';
-export declare function createDynamicCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];
+import { StorageSchema, EntityDict as BaseEntityDict, Checker, AuthDefDict } from '../types';
+export declare function createDynamicCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>, authDict?: AuthDefDict<ED>): Checker<ED, keyof ED, Cxt>[];

package/lib/checkers/index.js

@@ -4,10 +4,12 @@ exports.createDynamicCheckers = void 0;
 var tslib_1 = require("tslib");
 var checker_1 = require("../store/checker");
 var modi_1 = require("../store/modi");
-function createDynamicCheckers(schema) {
+function createDynamicCheckers(schema, authDict) {
     var checkers = [];
     checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, modi_1.createModiRelatedCheckers)(schema)), false));
-    checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, checker_1.createRelationHierarchyCheckers)(schema)), false));
+    if (authDict) {
+        checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, checker_1.createAuthCheckers)(schema, authDict)), false));
+    }
     return checkers;
 }
 exports.createDynamicCheckers = createDynamicCheckers;

package/lib/compiler/schemalBuilder.js

@@ -337,7 +337,8 @@ function analyzeEntity(filename, path, program, relativePath) {
     var localEnumStringTypes = [];
     var additionalImports = [];
     var localeDef = undefined;
-    var relationHierarchy = undefined;
+    // let relationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
+    // let reverseCascadeRelationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
     ts.forEachChild(sourceFile, function (node) {
         var _a, _b, _c, _d;
         if (ts.isImportDeclaration(node)) {
@@ -795,15 +796,22 @@ function analyzeEntity(filename, path, program, relativePath) {
                         _static = true; // static如果有值只能为true
                     }
                 }
-                else if (ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'RelationHierarchy') {
+                /* else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'RelationHierarchy') {
                     // RelationHierary
-                    (0, assert_1.default)(hasRelationDef, "".concat(moduleName, "\u4E2D\u7684Relation\u5B9A\u4E49\u5728RelationHierarchy\u4E4B\u540E"));
-                    var initializer = declaration.initializer;
-                    (0, assert_1.default)(ts.isObjectLiteralExpression(initializer), "".concat(moduleName, "\u4E2D\u7684RelationHierarchy\u7684\u5B9A\u4E49\u5FC5\u987B\u662F\u521D\u59CB\u5316\u4E3AObjectLiteralExpress"));
+                    assert(hasRelationDef, `${moduleName}中的Relation定义在RelationHierarchy之后`);
+                    const { initializer } = declaration;
+                    assert(ts.isObjectLiteralExpression(initializer!), `${moduleName}中的RelationHierarchy的定义必须是初始化为ObjectLiteralExpress`);
                     relationHierarchy = initializer;
                 }
+                else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'ReverseCascadeRelationHierarchy') {
+                    // ReverseCascadeRelationHierarchy
+                    assert(hasRelationDef, `${moduleName}中的Relation定义在ReverseCascadeRelationHierarchy之后`);
+                    const { initializer } = declaration;
+                    assert(ts.isObjectLiteralExpression(initializer!), `${moduleName}中的RelationHierarchy的定义必须是初始化为ObjectLiteralExpress`);
+                    reverseCascadeRelationHierarchy = initializer;
+                } */
                 else {
-                    throw new Error("".concat(moduleName, "\uFF1A\u4E0D\u80FD\u7406\u89E3\u7684\u5B9A\u4E49\u5185\u5BB9").concat(declaration.name.getText()));
+                    throw new Error("".concat(moduleName, "\uFF1A\u4E0D\u80FD\u7406\u89E3\u7684\u5B9A\u4E49\u5185\u5BB9").concat(declaration.name.text));
                 }
             });
         }
@@ -843,15 +851,25 @@ function analyzeEntity(filename, path, program, relativePath) {
             locale: localeDef,
         });
     }
-    if (hasRelationDef) {
-        (0, assert_1.default)(relationHierarchy, "".concat(filename, "\u4E2D\u7F3A\u5C11\u4E86relationHierarchy\u5B9A\u4E49"));
-        (0, lodash_1.assign)(schema, {
-            relationHierarchy: relationHierarchy,
-        });
+    /* if (hasRelationDef) {
+        if(!relationHierarchy && !reverseCascadeRelationHierarchy){
+            console.warn(`${filename}中定义了Relation,但并没有relationHierarchy或reverseCascadeRelationHierarchy的定义，请注意自主编写权限分配的checker`);
+        }
+        if (relationHierarchy) {
+            assign(schema, {
+                relationHierarchy,
+            });
+        }
+        if (reverseCascadeRelationHierarchy) {
+            assign(schema, {
+                reverseCascadeRelationHierarchy,
+            });
+        }
     }
     else {
-        (0, assert_1.default)(!relationHierarchy, "".concat(filename, "\u4E2D\u5177\u6709relationHierarchy\u5B9A\u4E49\u4F46\u6CA1\u6709Relation\u5B9A\u4E49"));
-    }
+        assert(!relationHierarchy, `${filename}中具有relationHierarchy定义但没有Relation定义`);
+        assert(!reverseCascadeRelationHierarchy, `${filename}中具有reverseCascadeRelationHierarchy定义但没有Relation定义`)
+    } */
     (0, lodash_1.assign)(Schema, (_a = {},
         _a[moduleName] = schema,
         _a));
@@ -1783,7 +1801,6 @@ function constructActions(statements, entity) {
         factory.createLiteralTypeNode(factory.createStringLiteral("action"))
     ])), factory.createTypeAliasDeclaration(undefined, [factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
         factory.createTypeReferenceNode(factory.createIdentifier("DeduceAggregation"), [
-            factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined),
             factory.createTypeReferenceNode(factory.createIdentifier("Projection"), undefined),
             factory.createTypeReferenceNode(factory.createIdentifier("Filter"), undefined),
             factory.createTypeReferenceNode(factory.createIdentifier("Sorter"), undefined)
@@ -1939,6 +1956,11 @@ function constructActions(statements, entity) {
     var reverseOneNodes = [];
     if (ReversePointerEntities[entity]) {
         if (ReversePointerRelations[entity]) {
+            var schemaAttrs = Schema[entity].schemaAttrs;
+            var questionToken = schemaAttrs.find(function (ele) {
+                var name = ele.name;
+                return name.text === 'entity';
+            }).questionToken;
             try {
                 for (var _q = tslib_1.__values(ReversePointerRelations[entity]), _r = _q.next(); !_r.done; _r = _q.next()) {
                     var one = _r.value;
@@ -1956,10 +1978,8 @@ function constructActions(statements, entity) {
                         factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), undefined, factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')))
                     ]);
                     var noCascadeNode = factory.createTypeLiteralNode([
-                        factory.createPropertySignature(undefined, factory.createIdentifier('entity'), undefined, // 反向指针好像不能为空，以后或许会有特例  by Xc
-                        factory.createLiteralTypeNode(factory.createStringLiteral("".concat((0, string_1.firstLetterLowerCase)(one))))),
-                        factory.createPropertySignature(undefined, factory.createIdentifier('entityId'), undefined, // 反向指针好像不能为空，以后或许会有特例  by Xc
-                        factory.createTypeReferenceNode(factory.createIdentifier("String"), [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]))
+                        factory.createPropertySignature(undefined, factory.createIdentifier('entity'), questionToken, factory.createLiteralTypeNode(factory.createStringLiteral("".concat((0, string_1.firstLetterLowerCase)(one))))),
+                        factory.createPropertySignature(undefined, factory.createIdentifier('entityId'), questionToken, factory.createTypeReferenceNode(factory.createIdentifier("String"), [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]))
                     ]);
                     if (Schema[one].static) {
                         reverseOneNodes.push(noCascadeNode);
@@ -2584,8 +2604,7 @@ function constructActions(statements, entity) {
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Operation"), undefined, factory.createUnionTypeNode([
         factory.createTypeReferenceNode(factory.createIdentifier("CreateOperation"), undefined),
         factory.createTypeReferenceNode(factory.createIdentifier("UpdateOperation"), undefined),
-        factory.createTypeReferenceNode(factory.createIdentifier("RemoveOperation"), undefined),
-        factory.createTypeReferenceNode(factory.createIdentifier("SelectOperation"), undefined)
+        factory.createTypeReferenceNode(factory.createIdentifier("RemoveOperation"), undefined)
     ])));
 }
 var initialStatements = function () { return [
@@ -2642,7 +2661,6 @@ var initialStatements = function () { return [
 function outputSubQuery(outputDir, printer) {
     var statements = [];
     if (process.env.COMPLING_AS_LIB) {
-        statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("Selection"))])), factory.createStringLiteral((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(1)), undefined));
     }
     for (var entity in Schema) {
         // import * as User from '../User/Schema';
@@ -2755,7 +2773,8 @@ function outputSchema(outputDir, printer) {
         constructSorter(statements, entity);
         constructActions(statements, entity);
         constructQuery(statements, entity);
-        constructFullAttrs(statements, entity);
+        // 现在FullAttrs和NativeAttrs似乎没什么用，还会引起递归
+        // constructFullAttrs(statements, entity);
         var makeActionArguments = [];
         if (ActionAsts[entity]) {
             makeActionArguments.push(factory.createTypeReferenceNode('Action'));
@@ -2787,6 +2806,9 @@ function outputSchema(outputDir, printer) {
         if (ActionAsts[entity]) {
             EntityDefAttrs.push(factory.createPropertySignature(undefined, factory.createIdentifier("ParticularAction"), undefined, factory.createTypeReferenceNode(factory.createIdentifier('ParticularAction'), undefined)));
         }
+        if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef)) {
+            EntityDefAttrs.push(factory.createPropertySignature(undefined, factory.createIdentifier("Relation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Relation'), undefined)));
+        }
         statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("EntityDef"), undefined, factory.createTypeLiteralNode(EntityDefAttrs)));
         var result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), Schema[entity].sourceFile);
         var fileName = path_1.default.join(outputDir, entity, 'Schema.ts');
@@ -3045,13 +3067,19 @@ function outputStorage(outputDir, printer) {
     var entityAssignments = [];
     for (var entity in Schema) {
         var indexExpressions = [];
-        var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType, _static = _a.static, relationHierarchy = _a.relationHierarchy;
+        var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType, _static = _a.static, hasRelationDef = _a.hasRelationDef;
         var fromSchemaSpecifiers = [
             factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))
         ];
-        if (relationHierarchy) {
-            fromSchemaSpecifiers.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier("Relation")));
-        }
+        /* if (relationHierarchy || reverseCascadeRelationHierarchy) {
+            fromSchemaSpecifiers.push(
+                factory.createImportSpecifier(
+                    false,
+                    undefined,
+                    factory.createIdentifier("Relation")
+                )
+            );
+        } */
         var statements = [
             factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("StorageDesc"))])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Storage")), undefined),
             factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromSchemaSpecifiers)), factory.createStringLiteral("./Schema"), undefined)
@@ -3110,15 +3138,43 @@ function outputStorage(outputDir, printer) {
         if (indexExpressions.length > 0) {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("indexes"), factory.createArrayLiteralExpression(indexExpressions, true)));
         }
-        if (relationHierarchy) {
-            propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("relationHierarchy"), relationHierarchy));
+        /* if (relationHierarchy) {
+            propertyAssignments.push(
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("relationHierarchy"),
+                    relationHierarchy,
+                )
+            );
+        }
+        if (reverseCascadeRelationHierarchy) {
+            propertyAssignments.push(
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("reverseCascadeRelationHierarchy"),
+                    reverseCascadeRelationHierarchy,
+                )
+            );
+        } */
+        if (hasRelationDef) {
+            var type = hasRelationDef.type;
+            if (ts.isUnionTypeNode(type)) {
+                var types = type.types;
+                var relationTexts = types.map(function (ele) {
+                    (0, assert_1.default)(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal));
+                    return ele.literal.text;
+                });
+                propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("relation"), factory.createArrayLiteralExpression(relationTexts.map(function (ele) { return factory.createStringLiteral(ele); }))));
+            }
+            else {
+                (0, assert_1.default)(ts.isLiteralTypeNode(type));
+                (0, assert_1.default)(ts.isStringLiteral(type.literal));
+                propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("relation"), factory.createArrayLiteralExpression([
+                    type.literal
+                ])));
+            }
         }
         var sdTypeArguments = [
             factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)
         ];
-        if (relationHierarchy) {
-            sdTypeArguments.push(factory.createTypeReferenceNode(factory.createIdentifier("Relation"), undefined));
-        }
         statements.push(factory.createVariableStatement([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("desc"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("StorageDesc"), sdTypeArguments), factory.createObjectLiteralExpression(propertyAssignments, true))], ts.NodeFlags.Const)));
         var result_2 = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), sourceFile);
         var filename_1 = path_1.default.join(outputDir, entity, 'Storage.ts');

package/lib/store/CascadeStore.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter, AggregationResult } from "../types/Entity";
+import { EntityDict, OperateOption, SelectOption, OperationResult, AggregationResult } from "../types/Entity";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { RowStore } from '../types/RowStore';
 import { StorageSchema } from '../types/Storage';
@@ -51,14 +51,14 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
      * @param filter
      * @returns
      */
-    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: DeduceFilter<ED[T]['Schema']>): {
+    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter']): {
         data: Record<string, any>;
         beforeFns: (() => R)[];
         afterFns: (() => R)[];
     };
     protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
-    protected preProcessDataUpdated<T extends keyof ED>(data: ED[T]['Update']['data']): void;
-    judgeRelation(entity: keyof ED, attr: string): string | 2 | 1 | string[] | 0;
+    protected preProcessDataUpdated(data: Record<string, any>): void;
+    judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0;
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
      * @param entity

package/lib/store/TriggerExecutor.js

@@ -32,15 +32,15 @@ var TriggerExecutor = /** @class */ (function () {
     TriggerExecutor.prototype.registerChecker = function (checker) {
         var entity = checker.entity, action = checker.action, type = checker.type, conditionalFilter = checker.conditionalFilter;
         var triggerName = "".concat(String(entity)).concat(action, "\u6743\u9650\u68C0\u67E5-").concat(this.counter++);
-        var fn = (0, checker_1.translateCheckerInAsyncContext)(checker);
+        var _a = (0, checker_1.translateCheckerInAsyncContext)(checker), fn = _a.fn, when = _a.when;
         var trigger = {
             checkerType: type,
             name: triggerName,
-            priority: checker.priority || 2,
+            priority: checker.priority || 20,
             entity: entity,
             action: action,
             fn: fn,
-            when: 'before',
+            when: when,
             filter: conditionalFilter,
         };
         this.registerTrigger(trigger);
@@ -59,7 +59,7 @@ var TriggerExecutor = /** @class */ (function () {
             throw new Error("\u4E0D\u53EF\u6709\u540C\u540D\u7684\u89E6\u53D1\u5668\u300C".concat(trigger.name, "\u300D"));
         }
         if (typeof trigger.priority !== 'number') {
-            trigger.priority = 1; // 默认最低
+            trigger.priority = 10; // 默认值
         }
         if (trigger.filter) {
             (0, assert_1.default)(typeof trigger.action === 'string' && trigger.action !== 'create'
@@ -205,6 +205,7 @@ var TriggerExecutor = /** @class */ (function () {
                             (0, assert_1.default)(operation.action !== 'create');
                             var filter = trigger.filter;
                             var filterr = typeof filter === 'function' ? filter(operation, context, option) : filter;
+                            (0, assert_1.default)(!(filterr instanceof Promise));
                             var filterRepelled = (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter);
                             if (filterRepelled) {
                                 continue;
@@ -228,28 +229,37 @@ var TriggerExecutor = /** @class */ (function () {
             else {
                 // 异步context
                 var execPreTrigger_1 = function (idx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var trigger, filter, filterr, filterRepelled, number;
-                    return tslib_1.__generator(this, function (_a) {
-                        switch (_a.label) {
+                    var trigger, filter, filterr, _a, filterRepelled, number;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
                             case 0:
                                 if (idx >= preTriggers_2.length) {
                                     return [2 /*return*/];
                                 }
                                 trigger = preTriggers_2[idx];
-                                if (!trigger.filter) return [3 /*break*/, 2];
+                                if (!trigger.filter) return [3 /*break*/, 5];
                                 (0, assert_1.default)(operation.action !== 'create');
                                 filter = trigger.filter;
-                                filterr = typeof filter === 'function' ? filter(operation, context, option) : filter;
-                                return [4 /*yield*/, (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter)];
+                                if (!(typeof filter === 'function')) return [3 /*break*/, 2];
+                                return [4 /*yield*/, filter(operation, context, option)];
                             case 1:
-                                filterRepelled = _a.sent();
+                                _a = _b.sent();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                _a = filter;
+                                _b.label = 3;
+                            case 3:
+                                filterr = _a;
+                                return [4 /*yield*/, (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter)];
+                            case 4:
+                                filterRepelled = _b.sent();
                                 if (filterRepelled) {
                                     return [2 /*return*/, execPreTrigger_1(idx + 1)];
                                 }
-                                _a.label = 2;
-                            case 2: return [4 /*yield*/, trigger.fn({ operation: operation }, context, option)];
-                            case 3:
-                                number = _a.sent();
+                                _b.label = 5;
+                            case 5: return [4 /*yield*/, trigger.fn({ operation: operation }, context, option)];
+                            case 6:
+                                number = _b.sent();
                                 if (number > 0) {
                                     this.logger.info("\u89E6\u53D1\u5668\u300C".concat(trigger.name, "\u300D\u6210\u529F\u89E6\u53D1\u4E86\u300C").concat(number, "\u300D\u884C\u6570\u636E\u66F4\u6539"));
                                 }
@@ -258,28 +268,37 @@ var TriggerExecutor = /** @class */ (function () {
                     });
                 }); };
                 var execCommitTrigger_1 = function (idx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var trigger, filter, filterr, filterRepelled;
-                    return tslib_1.__generator(this, function (_a) {
-                        switch (_a.label) {
+                    var trigger, filter, filterr, _a, filterRepelled;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
                             case 0:
                                 if (idx >= commitTriggers_1.length) {
                                     return [2 /*return*/];
                                 }
                                 trigger = commitTriggers_1[idx];
-                                if (!trigger.filter) return [3 /*break*/, 2];
+                                if (!trigger.filter) return [3 /*break*/, 5];
                                 (0, assert_1.default)(operation.action !== 'create');
                                 filter = trigger.filter;
-                                filterr = typeof filter === 'function' ? filter(operation, context, option) : filter;
-                                return [4 /*yield*/, (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter)];
+                                if (!(typeof filter === 'function')) return [3 /*break*/, 2];
+                                return [4 /*yield*/, filter(operation, context, option)];
                             case 1:
-                                filterRepelled = _a.sent();
+                                _a = _b.sent();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                _a = filter;
+                                _b.label = 3;
+                            case 3:
+                                filterr = _a;
+                                return [4 /*yield*/, (0, filter_1.checkFilterRepel)(entity, context, filterr, operation.filter)];
+                            case 4:
+                                filterRepelled = _b.sent();
                                 if (filterRepelled) {
                                     return [2 /*return*/, execCommitTrigger_1(idx + 1)];
                                 }
-                                _a.label = 2;
-                            case 2: return [4 /*yield*/, this.preCommitTrigger(entity, operation, trigger, context, option)];
-                            case 3:
-                                _a.sent();
+                                _b.label = 5;
+                            case 5: return [4 /*yield*/, this.preCommitTrigger(entity, operation, trigger, context, option)];
+                            case 6:
+                                _b.sent();
                                 return [2 /*return*/, execCommitTrigger_1(idx + 1)];
                         }
                     });

package/lib/store/checker.d.ts

@@ -1,7 +1,13 @@
-import { Checker, EntityDict, OperateOption, SelectOption, StorageSchema, Trigger } from "../types";
+import { AuthDefDict, Checker, EntityDict, OperateOption, SelectOption, StorageSchema, Trigger } from "../types";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { AsyncContext } from "./AsyncRowStore";
 import { SyncContext } from './SyncRowStore';
-export declare function translateCheckerInAsyncContext<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(checker: Checker<ED, keyof ED, Cxt>): Trigger<ED, keyof ED, Cxt>['fn'];
-export declare function translateCheckerInSyncContext<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED>>(checker: Checker<ED, T, Cxt>): (operation: ED[T]['Operation'], context: Cxt, option: OperateOption | SelectOption) => void;
-export declare function createRelationHierarchyCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];
+export declare function translateCheckerInAsyncContext<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(checker: Checker<ED, keyof ED, Cxt>): {
+    fn: Trigger<ED, keyof ED, Cxt>['fn'];
+    when: 'before' | 'after';
+};
+export declare function translateCheckerInSyncContext<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED>>(checker: Checker<ED, T, Cxt>): {
+    fn: (operation: ED[T]['Operation'], context: Cxt, option: OperateOption | SelectOption) => void;
+    when: 'before' | 'after';
+};
+export declare function createAuthCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>, authDict: AuthDefDict<ED>): Checker<ED, keyof ED, Cxt>[];