oak-domain 1.1.6 → 1.1.8

package/lib/actions/action.d.ts

@@ -4,11 +4,13 @@ export declare type AppendOnlyAction = ReadOnlyAction | 'create';
 export declare type ExcludeUpdateAction = AppendOnlyAction | 'remove';
 export declare type ExcludeRemoveAction = AppendOnlyAction | 'update';
 export declare type GenericAction = 'update' | ExcludeUpdateAction;
+export declare type RelationAction = 'grant' | 'revoke';
 export declare const readOnlyActions: string[];
 export declare const appendOnlyActions: string[];
 export declare const excludeUpdateActions: string[];
 export declare const exludeRemoveActions: string[];
 export declare const genericActions: string[];
+export declare const relationActions: string[];
 export declare type AbleAction = 'enable' | 'disable';
 export declare type AbleState = 'enabled' | 'disabled';
 export declare const makeAbleActionDef: (initialState?: AbleState) => ActionDef<AbleAction, AbleState>;

package/lib/actions/action.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAbleActionDef = exports.genericActions = exports.exludeRemoveActions = exports.excludeUpdateActions = exports.appendOnlyActions = exports.readOnlyActions = void 0;
+exports.makeAbleActionDef = exports.relationActions = exports.genericActions = exports.exludeRemoveActions = exports.excludeUpdateActions = exports.appendOnlyActions = exports.readOnlyActions = void 0;
 exports.readOnlyActions = ['count', 'stat', 'download', 'select'];
 exports.appendOnlyActions = exports.readOnlyActions.concat('create');
 exports.excludeUpdateActions = exports.appendOnlyActions.concat('remove');
 exports.exludeRemoveActions = exports.appendOnlyActions.concat('update');
 exports.genericActions = exports.excludeUpdateActions.concat('update');
+exports.relationActions = ['grant', 'revoke'];
 var makeAbleActionDef = function (initialState) { return ({
     stm: {
         enable: ['disabled', 'enabled'],

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

@@ -141,7 +141,7 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
     modiEntitys$modi?: OakOperation<"create", Omit<ModiEntity.CreateOperationData, "modi" | "modiId">[]> | Array<OakOperation<"create", Omit<ModiEntity.CreateOperationData, "modi" | "modiId">>>;
     operEntitys$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;
 };
-export declare type UpdateOperation = OakOperation<ParticularAction | "update" | string, UpdateOperationData, Filter, Sorter>;
+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;

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

@@ -3,7 +3,7 @@ import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey }
 import { OneOf } from "../../types/Polyfill";
 import * as SubQuery from "../_SubQuery";
 import { FormCreateData, FormUpdateData, Operation as OakOperation, MakeAction as OakMakeAction } from "../../types/Entity";
-import { GenericAction } from "../../actions/action";
+import { GenericAction, RelationAction } from "../../actions/action";
 import * as Oper from "../Oper/Schema";
 import * as OperEntity from "../OperEntity/Schema";
 import * as ModiEntity from "../ModiEntity/Schema";
@@ -118,7 +118,7 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
     operEntitys$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;
     modiEntitys$entity?: OakOperation<"create", Omit<ModiEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<ModiEntity.CreateOperationData, "entity" | "entityId">>>;
 };
-export declare type UpdateOperation = OakOperation<"update" | string, UpdateOperationData, Filter, Sorter>;
+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;
@@ -128,7 +128,7 @@ export declare type FullAttr = NativeAttr | `opers$${number}.${Oper.NativeAttr}`
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;
-    Action: OakMakeAction<GenericAction> | string;
+    Action: OakMakeAction<GenericAction | RelationAction> | string;
     Selection: Selection;
     Operation: Operation;
     Create: CreateOperation;

package/lib/base-app-domain/User/Storage.js

@@ -21,5 +21,5 @@ exports.desc = {
         }
     },
     actionType: "crud",
-    actions: action_1.genericActions
+    actions: action_1.genericActions.concat(action_1.relationActions)
 };

package/lib/compiler/schemalBuilder.js

@@ -24,6 +24,7 @@ var ActionImportStatements = function () { return [
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ReadOnlyAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeUpdateAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeRemoveAction")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
     ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined)
 ]; };
 var ActionAsts = {};
@@ -201,7 +202,7 @@ function getStringTextFromUnionStringLiterals(moduleName, filename, node, progra
         return [action];
     }
 }
-var RESERVED_ACTION_NAMES = ['GenericAction', 'ParticularAction', 'ExcludeRemoveAction', 'ExcludeUpdateAction', 'ReadOnlyAction', 'AppendOnlyAction'];
+var RESERVED_ACTION_NAMES = ['GenericAction', 'ParticularAction', 'ExcludeRemoveAction', 'ExcludeUpdateAction', 'ReadOnlyAction', 'AppendOnlyAction', 'RelationAction'];
 var action_1 = require("../actions/action");
 var DataType_1 = require("../types/DataType");
 var Entity_1 = require("../types/Entity");
@@ -212,8 +213,11 @@ var OriginActionDict = {
     'appendOnly': 'AppendOnlyAction',
     'readOnly': 'ReadOnlyAction',
 };
-function dealWithActions(moduleName, filename, node, program, sourceFile) {
+function dealWithActions(moduleName, filename, node, program, sourceFile, hasRelationDef) {
     var actionTexts = action_1.genericActions.map(function (ele) { return ele; });
+    if (hasRelationDef) {
+        actionTexts.push.apply(actionTexts, tslib_1.__spreadArray([], tslib_1.__read(action_1.relationActions), false));
+    }
     if (ts.isUnionTypeNode(node)) {
         var actionNames = node.types.map(function (ele) {
             if (ts.isTypeReferenceNode(ele) && ts.isIdentifier(ele.typeName)) {
@@ -494,13 +498,18 @@ function analyzeEntity(filename, path, program) {
                 hasActionDef = true;
                 var modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)];
                 pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, node.decorators, modifiers, factory.createIdentifier('ParticularAction'), node.typeParameters, node.type), sourceFile);
-                pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode([
+                var actionDefNodes = [
                     factory.createTypeReferenceNode(OriginActionDict[actionType], undefined),
                     factory.createTypeReferenceNode('ParticularAction', undefined)
-                ])), sourceFile);
-                dealWithActions(moduleName, filename, node.type, program, sourceFile);
+                ];
+                if (hasRelationDef || moduleName === 'User') {
+                    actionDefNodes.push(factory.createTypeReferenceNode('RelationAction', undefined));
+                }
+                pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode(actionDefNodes)), sourceFile);
+                dealWithActions(moduleName, filename, node.type, program, sourceFile, hasRelationDef || moduleName === 'User');
             }
             else if (node.name.text === 'Relation') {
+                (0, assert_1.default)(!hasActionDef, "\u3010".concat(filename, "\u3011action\u5B9A\u4E49\u987B\u5728Relation\u4E4B\u540E"));
                 (0, assert_1.default)(!localeDef, "\u3010".concat(filename, "\u3011locale\u5B9A\u4E49\u987B\u5728Relation\u4E4B\u540E"));
                 // 增加userXXX对象的描述
                 if (ts.isLiteralTypeNode(node.type)) {
@@ -783,6 +792,7 @@ function analyzeEntity(filename, path, program) {
         toModi: toModi,
         actionType: actionType,
         static: _static,
+        hasRelationDef: hasRelationDef,
     };
     if (hasFulltextIndex) {
         (0, lodash_1.assign)(schema, {
@@ -2244,12 +2254,13 @@ function constructActions(statements, entity) {
     }
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("UpdateOperationData"), undefined, factory.createIntersectionTypeNode(adNodes)));
     // UpdateOperation
-    var actionTypeNodes = ActionAsts[entity] ? [
-        factory.createTypeReferenceNode('ParticularAction'),
-        factory.createLiteralTypeNode(factory.createStringLiteral("update"))
-    ] : [
-        factory.createLiteralTypeNode(factory.createStringLiteral("update"))
-    ];
+    var actionTypeNodes = [factory.createLiteralTypeNode(factory.createStringLiteral("update"))];
+    if (ActionAsts[entity]) {
+        actionTypeNodes.push(factory.createTypeReferenceNode('ParticularAction'));
+    }
+    if (Schema[entity].hasRelationDef || entity === 'User') {
+        actionTypeNodes.push(factory.createTypeReferenceNode('RelationAction'));
+    }
     if (process.env.COMPLING_AS_LIB) {
         actionTypeNodes.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
     }
@@ -2603,7 +2614,9 @@ function outputSchema(outputDir, printer) {
                     ])), moduleSpecifier, undefined));
                 }
             }
-            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(localActions.map(function (ele) { return factory.createImportSpecifier(false, undefined, factory.createIdentifier(ele)); }))), factory.createStringLiteral('./Action'), undefined));
+            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(localActions.map(function (ele) { return factory.createImportSpecifier(false, undefined, factory.createIdentifier(ele)); }))), factory.createStringLiteral('./Action'), undefined), factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
+            ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
         }
         else {
             statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
@@ -2612,6 +2625,7 @@ function outputSchema(outputDir, printer) {
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ReadOnlyAction")),
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeUpdateAction")),
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeRemoveAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
             ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
         }
         constructSchema(statements, entity);
@@ -2621,9 +2635,17 @@ function outputSchema(outputDir, printer) {
         constructActions(statements, entity);
         constructQuery(statements, entity);
         constructFullAttrs(statements, entity);
-        var actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), [
-            ActionAsts[entity] ? factory.createTypeReferenceNode('Action') : factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType])
-        ]);
+        var makeActionArguments = [];
+        if (ActionAsts[entity]) {
+            makeActionArguments.push(factory.createTypeReferenceNode('Action'));
+        }
+        else {
+            makeActionArguments.push(factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType]));
+        }
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            makeActionArguments.push(factory.createTypeReferenceNode('RelationAction'));
+        }
+        var actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), makeActionArguments.length === 1 ? makeActionArguments : [factory.createUnionTypeNode(makeActionArguments)]);
         var EntityDefAttrs = [
             factory.createPropertySignature(undefined, factory.createIdentifier("Schema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined)),
             factory.createPropertySignature(undefined, factory.createIdentifier("OpSchema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)),
@@ -2906,17 +2928,18 @@ function outputStorage(outputDir, printer) {
             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([factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))])), factory.createStringLiteral("./Schema"), undefined)
         ];
+        var needImportActions = [];
         switch (actionType) {
             case 'readOnly': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("readOnlyActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("readOnlyActions"), factory.createIdentifier("actions")));
                 break;
             }
             case 'appendOnly': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("appendOnlyActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("appendOnlyActions"), factory.createIdentifier("actions")));
                 break;
             }
             case 'excludeUpdate': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("excludeUpdateActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("excludeUpdateActions"), factory.createIdentifier("actions")));
                 break;
             }
             default: {
@@ -2924,10 +2947,16 @@ function outputStorage(outputDir, printer) {
                     statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("actions"))])), factory.createStringLiteral("./Action"), undefined));
                 }
                 else {
-                    statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("genericActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                    needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("genericActions"), factory.createIdentifier("actions")));
                 }
             }
         }
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            needImportActions.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier("relationActions")));
+        }
+        if (needImportActions.length > 0) {
+            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(needImportActions)), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+        }
         var propertyAssignments = [];
         var attributes = constructAttributes(entity);
         propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("attributes"), factory.createObjectLiteralExpression(attributes, true)));
@@ -2943,7 +2972,13 @@ function outputStorage(outputDir, printer) {
         if (_static || actionType === 'readOnly') {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("static"), factory.createTrue()));
         }
-        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actionType"), factory.createStringLiteral(actionType)), factory.createShorthandPropertyAssignment(factory.createIdentifier("actions"), undefined));
+        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actionType"), factory.createStringLiteral(actionType)));
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actions"), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("actions"), factory.createIdentifier("concat")), undefined, [factory.createIdentifier("relationActions")])));
+        }
+        else {
+            propertyAssignments.push(factory.createShorthandPropertyAssignment(factory.createIdentifier("actions"), undefined));
+        }
         if (indexExpressions.length > 0) {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("indexes"), factory.createArrayLiteralExpression(indexExpressions, true)));
         }

package/lib/types/Connector.d.ts

@@ -10,11 +10,11 @@ export declare abstract class Connector<ED extends EntityDict, Cxt extends Conte
         opRecords: OpRecord<ED>[];
     }>;
     abstract getRouter(): string;
-    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): {
+    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): Promise<{
         name: string;
         params: any;
         context: Cxt;
-    };
+    }>;
     abstract serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any>;

package/lib/utils/SimpleConnector.d.ts

@@ -7,17 +7,17 @@ export declare class SimpleConnector<ED extends EntityDict, Cxt extends Universa
     private serverUrl;
     private makeException;
     private contextBuilder;
-    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException, contextBuilder: (str: string | undefined) => (store: RowStore<ED, Cxt>) => Cxt);
+    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException, contextBuilder: (str: string | undefined) => (store: RowStore<ED, Cxt>) => Promise<Cxt>);
     callAspect(name: string, params: any, context: Cxt): Promise<{
         result: any;
         opRecords: OpRecord<ED>[];
     }>;
     getRouter(): string;
-    parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): {
+    parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): Promise<{
         name: string;
         params: any;
         context: Cxt;
-    };
+    }>;
     serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any> | undefined;

package/lib/utils/SimpleConnector.js

@@ -61,15 +61,25 @@ var SimpleConnector = /** @class */ (function (_super) {
         return SimpleConnector.ROUTER;
     };
     SimpleConnector.prototype.parseRequest = function (headers, body, store) {
-        var oakCxtStr = headers["oak-cxt"], aspectName = headers["oak-aspect"];
-        (0, assert_1.default)(typeof oakCxtStr === 'string' || oakCxtStr === undefined);
-        (0, assert_1.default)(typeof aspectName === 'string');
-        var context = this.contextBuilder(oakCxtStr)(store);
-        return {
-            name: aspectName,
-            params: body,
-            context: context,
-        };
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var oakCxtStr, aspectName, context;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        oakCxtStr = headers["oak-cxt"], aspectName = headers["oak-aspect"];
+                        (0, assert_1.default)(typeof oakCxtStr === 'string' || oakCxtStr === undefined);
+                        (0, assert_1.default)(typeof aspectName === 'string');
+                        return [4 /*yield*/, this.contextBuilder(oakCxtStr)(store)];
+                    case 1:
+                        context = _a.sent();
+                        return [2 /*return*/, {
+                                name: aspectName,
+                                params: body,
+                                context: context,
+                            }];
+                }
+            });
+        });
     };
     SimpleConnector.prototype.serializeResult = function (result, context, headers, body) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "1.1.6",
+    "version": "1.1.8",
     "author": {
         "name": "XuChang"
     },