oak-domain 2.5.1 → 2.6.1

package/lib/store/checker.js

@@ -5,10 +5,12 @@ 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 types_1 = require("../types");
 var actionDef_1 = require("./actionDef");
 var string_1 = require("../utils/string");
 var lodash_1 = require("../utils/lodash");
 var relation_1 = require("./relation");
+var uuid_1 = require("../utils/uuid");
 function translateCheckerInAsyncContext(checker) {
     var _this = this;
     var entity = checker.entity, type = checker.type, action = checker.action;
@@ -42,20 +44,19 @@ function translateCheckerInAsyncContext(checker) {
             var fn = (function (_a, context, option) {
                 var operation = _a.operation;
                 return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var operationFilter, action, filter2, _b, entity2, selection2, rows2, data_1, rows2, data_2;
-                    var _c, _d;
-                    return tslib_1.__generator(this, function (_e) {
-                        switch (_e.label) {
+                    var operationFilter, action, filter2, _b, entity2, selection2, rows2, e, rows2, e;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.label) {
                             case 0:
                                 operationFilter = operation.filter, action = operation.action;
                                 if (!(typeof filter_2 === 'function')) return [3 /*break*/, 2];
                                 return [4 /*yield*/, filter_2(operation, context, option)];
                             case 1:
-                                _b = _e.sent();
+                                _b = _c.sent();
                                 return [3 /*break*/, 3];
                             case 2:
                                 _b = filter_2;
-                                _e.label = 3;
+                                _c.label = 3;
                             case 3:
                                 filter2 = _b;
                                 if (!['select', 'count', 'stat'].includes(action)) return [3 /*break*/, 4];
@@ -63,7 +64,7 @@ function translateCheckerInAsyncContext(checker) {
                                 return [2 /*return*/, 0];
                             case 4: return [4 /*yield*/, (0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter || {}, true)];
                             case 5:
-                                if (_e.sent()) {
+                                if (_c.sent()) {
                                     return [2 /*return*/, 0];
                                 }
                                 if (!inconsistentRows_1) return [3 /*break*/, 7];
@@ -73,20 +74,10 @@ function translateCheckerInAsyncContext(checker) {
                                         blockTrigger: true,
                                     })];
                             case 6:
-                                rows2 = _e.sent();
-                                data_1 = {};
-                                rows2.forEach(function (ele) {
-                                    var _a;
-                                    return Object.assign(data_1, (_a = {},
-                                        _a[ele.id] = ele,
-                                        _a));
-                                });
-                                throw new Exception_1.OakRowInconsistencyException({
-                                    a: 's',
-                                    d: (_c = {},
-                                        _c[entity2] = data_1,
-                                        _c)
-                                }, errMsg_1);
+                                rows2 = _c.sent();
+                                e = new Exception_1.OakRowInconsistencyException(undefined, errMsg_1);
+                                e.addData(entity2, rows2);
+                                throw e;
                             case 7: return [4 /*yield*/, context.select(entity, {
                                     data: (0, actionDef_1.getFullProjection)(entity, context.getSchema()),
                                     filter: Object.assign({}, operationFilter, {
@@ -97,20 +88,10 @@ function translateCheckerInAsyncContext(checker) {
                                     blockTrigger: true,
                                 })];
                             case 8:
-                                rows2 = _e.sent();
-                                data_2 = {};
-                                rows2.forEach(function (ele) {
-                                    var _a;
-                                    return Object.assign(data_2, (_a = {},
-                                        _a[ele.id] = ele,
-                                        _a));
-                                });
-                                throw new Exception_1.OakRowInconsistencyException({
-                                    a: 's',
-                                    d: (_d = {},
-                                        _d[entity] = data_2,
-                                        _d)
-                                }, errMsg_1);
+                                rows2 = _c.sent();
+                                e = new Exception_1.OakRowInconsistencyException(undefined, errMsg_1);
+                                e.addData(entity, rows2);
+                                throw e;
                         }
                     });
                 });
@@ -226,7 +207,8 @@ function translateCheckerInSyncContext(checker) {
                     if ((0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter, true)) {
                         return;
                     }
-                    throw new Exception_1.OakRowInconsistencyException(undefined, errMsg_3);
+                    var e = new Exception_1.OakRowInconsistencyException(undefined, errMsg_3);
+                    throw e;
                 }
             };
             return {
@@ -406,12 +388,12 @@ function createAuthCheckers(schema, authDict) {
             var _b = authDict[entity], relationAuth = _b.relationAuth, actionAuth = _b.actionAuth;
             if (relationAuth) {
                 var raFilterMakerDict_1 = {};
+                var userEntityName_1 = "user".concat((0, string_1.firstLetterUpperCase)(entity));
                 for (var r in relationAuth) {
                     Object.assign(raFilterMakerDict_1, (_a = {},
                         _a[r] = translateActionAuthFilterMaker(schema, relationAuth[r], entity),
                         _a));
                 }
-                var userEntityName_1 = "user".concat((0, string_1.firstLetterUpperCase)(entity));
                 var entityIdAttr_1 = "".concat(entity, "Id");
                 checkers.push({
                     entity: userEntityName_1,
@@ -508,7 +490,7 @@ exports.createAuthCheckers = createAuthCheckers;
  * @returns
  * 如果有的对象允许删除，需要使用trigger来处理其相关联的外键对象，这些trigger写作before，则会在checker之前执行，仍然可以删除成功
  */
-function createRemoveCheckers(schema) {
+function createRemoveCheckers(schema, authDict) {
     var e_1, _a;
     var checkers = [];
     // 先建立所有的一对多的关系
@@ -575,9 +557,9 @@ function createRemoveCheckers(schema) {
                 var e_3, _a, e_4, _b;
                 var promises = [];
                 if (OneToManyMatrix[entity]) {
-                    var _loop_4 = function (otm) {
-                        var _g, _h, _j, _k;
-                        var _l = tslib_1.__read(otm, 2), e = _l[0], attr = _l[1];
+                    var _loop_5 = function (otm) {
+                        var _g, _h;
+                        var _j = tslib_1.__read(otm, 2), e = _j[0], attr = _j[1];
                         var proj = (_g = {
                                 id: 1
                             },
@@ -594,40 +576,27 @@ function createRemoveCheckers(schema) {
                         }, { dontCollect: true });
                         if (result instanceof Promise) {
                             promises.push(result.then(function (_a) {
-                                var _b, _c;
-                                var _d = tslib_1.__read(_a, 1), row = _d[0];
+                                var _b = tslib_1.__read(_a, 1), row = _b[0];
                                 if (row) {
-                                    var record = {
-                                        a: 's',
-                                        d: (_b = {},
-                                            _b[e] = (_c = {},
-                                                _c[row.id] = row,
-                                                _c),
-                                            _b)
-                                    };
-                                    throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                                    var err = new Exception_1.OakRowInconsistencyException(undefined, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                                    err.addData(e, [row]);
+                                    throw err;
                                 }
                             }));
                         }
                         else {
-                            var _m = tslib_1.__read(result, 1), row = _m[0];
+                            var _k = tslib_1.__read(result, 1), row = _k[0];
                             if (row) {
-                                var record = {
-                                    a: 's',
-                                    d: (_j = {},
-                                        _j[e] = (_k = {},
-                                            _k[row.id] = row,
-                                            _k),
-                                        _j)
-                                };
-                                throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                                var err = new Exception_1.OakRowInconsistencyException(undefined, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                                err.addData(e, [row]);
+                                throw err;
                             }
                         }
                     };
                     try {
                         for (var _c = (e_3 = void 0, tslib_1.__values(OneToManyMatrix[entity])), _d = _c.next(); !_d.done; _d = _c.next()) {
                             var otm = _d.value;
-                            _loop_4(otm);
+                            _loop_5(otm);
                         }
                     }
                     catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -639,16 +608,16 @@ function createRemoveCheckers(schema) {
                     }
                 }
                 if (OneToManyOnEntityMatrix[entity]) {
-                    var _loop_5 = function (otm) {
-                        var _o, _p, _q;
+                    var _loop_6 = function (otm) {
+                        var _l, _m, _o;
                         var proj = {
                             id: 1,
                             entity: 1,
                             entityId: 1,
                         };
-                        var filter = operation.filter && (_o = {},
-                            _o[entity] = operation.filter,
-                            _o);
+                        var filter = operation.filter && (_l = {},
+                            _l[entity] = operation.filter,
+                            _l);
                         var result = context.select(otm, {
                             data: proj,
                             filter: filter,
@@ -657,40 +626,35 @@ function createRemoveCheckers(schema) {
                         }, { dontCollect: true });
                         if (result instanceof Promise) {
                             promises.push(result.then(function (_a) {
-                                var _b, _c;
-                                var _d = tslib_1.__read(_a, 1), row = _d[0];
+                                var _b = tslib_1.__read(_a, 1), row = _b[0];
                                 if (row) {
-                                    var record = {
-                                        a: 's',
-                                        d: (_b = {},
-                                            _b[otm] = (_c = {},
-                                                _c[row.id] = row,
-                                                _c),
-                                            _b)
-                                    };
-                                    throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                                    var e = new Exception_1.OakRowInconsistencyException(undefined, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                                    e.addData(otm, [row]);
+                                    throw e;
                                 }
                             }));
                         }
                         else {
-                            var _r = tslib_1.__read(result, 1), row = _r[0];
+                            var _p = tslib_1.__read(result, 1), row = _p[0];
                             if (row) {
                                 var record = {
                                     a: 's',
-                                    d: (_p = {},
-                                        _p[otm] = (_q = {},
-                                            _q[row.id] = row,
-                                            _q),
-                                        _p)
+                                    d: (_m = {},
+                                        _m[otm] = (_o = {},
+                                            _o[row.id] = row,
+                                            _o),
+                                        _m)
                                 };
-                                throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                                var e = new Exception_1.OakRowInconsistencyException(undefined, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                                e.addData(otm, [row]);
+                                throw e;
                             }
                         }
                     };
                     try {
                         for (var _e = (e_4 = void 0, tslib_1.__values(OneToManyOnEntityMatrix[entity])), _f = _e.next(); !_f.done; _f = _e.next()) {
                             var otm = _f.value;
-                            _loop_5(otm);
+                            _loop_6(otm);
                         }
                     }
                     catch (e_4_1) { e_4 = { error: e_4_1 }; }
@@ -720,6 +684,146 @@ function createRemoveCheckers(schema) {
         }
         finally { if (e_1) throw e_1.error; }
     }
+    var _loop_4 = function (entity) {
+        var e_5, _b;
+        var cascadeRemove = authDict[entity].cascadeRemove;
+        if (cascadeRemove) {
+            var entitiesOnEntityAttr = [];
+            var hasAllEntity = false;
+            var _loop_7 = function (attr) {
+                if (attr === '@entity') {
+                    hasAllEntity = true;
+                    return "continue";
+                }
+                var rel = (0, relation_1.judgeRelation)(schema, entity, attr);
+                if (rel === 2) {
+                    entitiesOnEntityAttr.push(attr);
+                    checkers.push({
+                        entity: attr,
+                        action: 'remove',
+                        type: 'logical',
+                        priority: types_1.REMOVE_CASCADE_PRIORITY,
+                        checker: function (operation, context) {
+                            var _a, _b;
+                            var filter = operation.filter;
+                            if (cascadeRemove[attr] === 'remove') {
+                                return context.operate(entity, {
+                                    id: (0, uuid_1.generateNewId)(),
+                                    action: 'remove',
+                                    data: {},
+                                    filter: filter ? (_a = {},
+                                        _a[attr] = filter,
+                                        _a) : undefined,
+                                }, { dontCollect: true });
+                            }
+                            return context.operate(entity, {
+                                id: (0, uuid_1.generateNewId)(),
+                                action: 'update',
+                                data: {
+                                    entity: null,
+                                    entityId: null,
+                                },
+                                filter: filter ? (_b = {},
+                                    _b[attr] = filter,
+                                    _b) : undefined,
+                            }, { dontCollect: true });
+                        }
+                    });
+                }
+                else {
+                    (0, assert_1.default)(typeof rel === 'string');
+                    checkers.push({
+                        entity: rel,
+                        action: 'remove',
+                        type: 'logical',
+                        priority: types_1.REMOVE_CASCADE_PRIORITY,
+                        checker: function (operation, context) {
+                            var _a, _b, _c;
+                            var filter = operation.filter;
+                            if (cascadeRemove[attr] === 'remove') {
+                                return context.operate(entity, {
+                                    id: (0, uuid_1.generateNewId)(),
+                                    action: 'remove',
+                                    data: {},
+                                    filter: filter ? (_a = {},
+                                        _a[attr] = filter,
+                                        _a) : undefined,
+                                }, { dontCollect: true });
+                            }
+                            return context.operate(entity, {
+                                id: (0, uuid_1.generateNewId)(),
+                                action: 'update',
+                                data: (_b = {},
+                                    _b["".concat(attr, "Id")] = null,
+                                    _b),
+                                filter: filter ? (_c = {},
+                                    _c[attr] = filter,
+                                    _c) : undefined,
+                            }, { dontCollect: true });
+                        }
+                    });
+                }
+            };
+            for (var attr in cascadeRemove) {
+                _loop_7(attr);
+            }
+            if (hasAllEntity) {
+                var attributes = schema[entity].attributes;
+                var ref = attributes.entity.ref;
+                var restEntities = (0, lodash_1.difference)(ref, entitiesOnEntityAttr);
+                var _loop_8 = function (e) {
+                    checkers.push({
+                        entity: e,
+                        action: 'remove',
+                        type: 'logical',
+                        priority: types_1.REMOVE_CASCADE_PRIORITY,
+                        checker: function (operation, context) {
+                            var _a, _b;
+                            var filter = operation.filter;
+                            if (cascadeRemove['@entity'] === 'remove') {
+                                return context.operate(entity, {
+                                    id: (0, uuid_1.generateNewId)(),
+                                    action: 'remove',
+                                    data: {},
+                                    filter: filter ? (_a = {},
+                                        _a[e] = filter,
+                                        _a) : undefined,
+                                }, { dontCollect: true });
+                            }
+                            return context.operate(entity, {
+                                id: (0, uuid_1.generateNewId)(),
+                                action: 'update',
+                                data: {
+                                    entity: null,
+                                    entityId: null,
+                                },
+                                filter: filter ? (_b = {},
+                                    _b[e] = filter,
+                                    _b) : undefined,
+                            }, { dontCollect: true });
+                        }
+                    });
+                };
+                try {
+                    for (var restEntities_1 = (e_5 = void 0, tslib_1.__values(restEntities)), restEntities_1_1 = restEntities_1.next(); !restEntities_1_1.done; restEntities_1_1 = restEntities_1.next()) {
+                        var e = restEntities_1_1.value;
+                        _loop_8(e);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (restEntities_1_1 && !restEntities_1_1.done && (_b = restEntities_1.return)) _b.call(restEntities_1);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            }
+        }
+    };
+    // 注入声明的cascade删除时的外键处理动作
+    for (var entity in authDict) {
+        _loop_4(entity);
+    }
     return checkers;
 }
 exports.createRemoveCheckers = createRemoveCheckers;

package/lib/store/selection.d.ts

@@ -1,7 +1,19 @@
 import { StorageSchema } from '../types';
 import { EntityDict } from '../types/Entity';
+declare type SelectionRewriter<ED extends EntityDict> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection']) => void;
+export declare function registerSelectionRewriter<ED extends EntityDict>(rewriter: SelectionRewriter<ED>): void;
+declare type OperationRewriter<ED extends EntityDict> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation']) => void;
+export declare function registerOperationRewriter<ED extends EntityDict>(rewriter: OperationRewriter<ED>): void;
 /**
  * 对selection进行一些完善，避免编程人员的疏漏
  * @param selection
  */
 export declare function reinforceSelection<ED extends EntityDict>(schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection']): void;
+/**
+ * 对operation进行一些完善，作为operation算子的注入点
+ * @param schema
+ * @param entity
+ * @param selection
+ */
+export declare function reinforceOperation<ED extends EntityDict>(schema: StorageSchema<ED>, entity: keyof ED, operation: ED[keyof ED]['Operation']): void;
+export {};

package/lib/store/selection.js

@@ -1,18 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reinforceSelection = void 0;
+exports.reinforceOperation = exports.reinforceSelection = exports.registerOperationRewriter = exports.registerSelectionRewriter = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var types_1 = require("../types");
 var Demand_1 = require("../types/Demand");
 var filter_1 = require("./filter");
 var relation_1 = require("./relation");
+var SelectionRewriters = [];
+function registerSelectionRewriter(rewriter) {
+    SelectionRewriters.push(rewriter);
+}
+exports.registerSelectionRewriter = registerSelectionRewriter;
+function getSelectionRewriters() {
+    return SelectionRewriters;
+}
+var OperationRewriters = [];
+function registerOperationRewriter(rewriter) {
+    OperationRewriters.push(rewriter);
+}
+exports.registerOperationRewriter = registerOperationRewriter;
+function getOperationRewriters() {
+    return OperationRewriters;
+}
 /**
  * 对selection进行一些完善，避免编程人员的疏漏
  * @param selection
  */
 function reinforceSelection(schema, entity, selection) {
     var filter = selection.filter, data = selection.data, sorter = selection.sorter;
+    Object.assign(data, {
+        '$$createAt$$': 1,
+    }); // 有的页面依赖于其它页面取数据，有时两个页面的filter的差异会导致有一个加createAt，有一个不加，此时可能产生前台取数据不完整的异常。先统一加上
     var checkNode = function (projectionNode, attrs) {
         attrs.forEach(function (attr) {
             var _a;
@@ -234,5 +253,16 @@ function reinforceSelection(schema, entity, selection) {
             $$createAt$$: 1,
         });
     }
+    SelectionRewriters.forEach(function (ele) { return ele(schema, entity, selection); });
 }
 exports.reinforceSelection = reinforceSelection;
+/**
+ * 对operation进行一些完善，作为operation算子的注入点
+ * @param schema
+ * @param entity
+ * @param selection
+ */
+function reinforceOperation(schema, entity, operation) {
+    OperationRewriters.forEach(function (ele) { return ele(schema, entity, operation); });
+}
+exports.reinforceOperation = reinforceOperation;

package/lib/types/Action.d.ts

@@ -13,6 +13,8 @@ export declare type ActionDictOfEntityDict<E extends EntityDict> = {
         [A in keyof E[T]['OpSchema']]?: ActionDef<string, string>;
     };
 };
+export declare type CascadeActionItem = CascadeRelationItem;
 export declare type CascadeActionAuth<A extends Action = ''> = {
-    [K in A | GenericAction]?: CascadeRelationItem | (CascadeRelationItem | CascadeRelationItem[])[];
+    [K in A | GenericAction]?: CascadeActionItem | (CascadeActionItem | CascadeActionItem[])[];
 };
+export declare type ActionOnRemove = 'setNull' | 'remove';

package/lib/types/Auth.d.ts

@@ -1,4 +1,4 @@
-import { CascadeActionAuth, CascadeRelationAuth } from ".";
+import { CascadeActionAuth, CascadeRelationAuth, ActionOnRemove } from ".";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
@@ -60,6 +60,9 @@ export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt exten
 export declare type AuthDef<ED extends EntityDict, T extends keyof ED> = {
     relationAuth?: CascadeRelationAuth<NonNullable<ED[T]['Relation']>>;
     actionAuth?: CascadeActionAuth<ED[T]['Action']>;
+    cascadeRemove?: {
+        [E in (keyof ED | '@entity')]?: ActionOnRemove;
+    };
 };
 export declare type AuthDefDict<ED extends EntityDict> = {
     [K in keyof ED]?: AuthDef<ED, K>;

package/lib/types/Connector.d.ts

@@ -19,7 +19,7 @@ export declare abstract class Connector<ED extends EntityDict, BackCxt extends A
         body: any;
         headers?: Record<string, any>;
     };
-    abstract serializeException(exception: OakException, headers: IncomingHttpHeaders, body: any): {
+    abstract serializeException(exception: OakException<ED>, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any>;
     };

package/lib/types/Entity.d.ts

@@ -165,7 +165,7 @@ export declare type SelectOpResult<ED extends EntityDict> = {
     a: 's';
     d: {
         [T in keyof ED]?: {
-            [ID: string]: ED[T]['OpSchema'];
+            [ID: string]: Partial<ED[T]['OpSchema']>;
         };
     };
 };

package/lib/types/Exception.d.ts

@@ -1,11 +1,14 @@
-import { EntityDict, OpRecord } from "./Entity";
-export declare class OakException extends Error {
+import { EntityDict, OpRecord, SelectOpResult } from "./Entity";
+export declare class OakException<ED extends EntityDict> extends Error {
+    opRecord: SelectOpResult<ED>;
     constructor(message?: string);
+    addData<T extends keyof ED>(entity: T, rows: Partial<ED[T]['OpSchema']>[]): void;
+    setOpRecords(opRecord: SelectOpResult<ED>): void;
     toString(): string;
 }
-export declare class OakDataException extends OakException {
+export declare class OakDataException<ED extends EntityDict> extends OakException<ED> {
 }
-export declare class OakUniqueViolationException extends OakException {
+export declare class OakUniqueViolationException<ED extends EntityDict> extends OakException<ED> {
     rows: Array<{
         id?: string;
         attrs: string[];
@@ -15,14 +18,14 @@ export declare class OakUniqueViolationException extends OakException {
         attrs: string[];
     }>, message?: string);
 }
-export declare class OakImportDataParseException extends OakException {
+export declare class OakImportDataParseException<ED extends EntityDict> extends OakException<ED> {
     line: number;
     header?: string;
     constructor(message: string, line: number, header?: string);
 }
-export declare class OakOperExistedException extends OakDataException {
+export declare class OakOperExistedException<ED extends EntityDict> extends OakDataException<ED> {
 }
-export declare class OakRowUnexistedException extends OakDataException {
+export declare class OakRowUnexistedException<ED extends EntityDict> extends OakDataException<ED> {
     private rows;
     constructor(rows: Array<{
         entity: any;
@@ -36,22 +39,20 @@ export declare class OakRowUnexistedException extends OakDataException {
 }
 export declare class OakExternalException extends Error {
 }
-export declare class OakUserException extends OakException {
+export declare class OakUserException<ED extends EntityDict> extends OakException<ED> {
 }
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
  *
  */
-export declare class OakRowInconsistencyException<ED extends EntityDict> extends OakUserException {
-    private data?;
+export declare class OakRowInconsistencyException<ED extends EntityDict> extends OakUserException<ED> {
     constructor(data?: OpRecord<ED>, message?: string);
-    getData(): OpRecord<ED> | undefined;
     toString(): string;
 }
 /**
  * 当输入的数据非法时抛此异常，attributes表示非法的属性
  */
-export declare class OakInputIllegalException extends OakUserException {
+export declare class OakInputIllegalException<ED extends EntityDict> extends OakUserException<ED> {
     private attributes;
     private entity;
     constructor(entity: string, attributes: string[], message?: string);
@@ -63,24 +64,24 @@ export declare class OakInputIllegalException extends OakUserException {
 /**
  * 用户权限不够时抛的异常
  */
-export declare class OakUserUnpermittedException extends OakUserException {
+export declare class OakUserUnpermittedException<ED extends EntityDict> extends OakUserException<ED> {
 }
 /**
  * 用户未登录抛的异常
  */
-export declare class OakUnloggedInException extends OakUserException {
+export declare class OakUnloggedInException<ED extends EntityDict> extends OakUserException<ED> {
     constructor(message?: string);
 }
 /**
  * 用户未登录抛的异常
  */
-export declare class OakRowLockedException extends OakUserException {
+export declare class OakRowLockedException<ED extends EntityDict> extends OakUserException<ED> {
     constructor(message?: string);
 }
 /**
  * 要插入行时，发现已经有相同的行数据
  */
-export declare class OakCongruentRowExists<ED extends EntityDict, T extends keyof ED> extends OakUserException {
+export declare class OakCongruentRowExists<ED extends EntityDict, T extends keyof ED> extends OakUserException<ED> {
     private data;
     private entity;
     constructor(entity: T, data: ED[T]['OpSchema'], message?: string);
@@ -88,11 +89,12 @@ export declare class OakCongruentRowExists<ED extends EntityDict, T extends keyo
     getEntity(): T;
     toString(): string;
 }
-export declare class OakDeadlock extends OakUserException {
+export declare class OakDeadlock<ED extends EntityDict> extends OakUserException<ED> {
     constructor(message?: string | undefined);
 }
-export declare function makeException(data: {
+export declare function makeException<ED extends EntityDict>(data: {
     name: string;
     message?: string;
+    opRecords: SelectOpResult<ED>;
     [A: string]: any;
-}): OakException | OakExternalException | undefined;
+}): OakException<EntityDict> | undefined;