oak-domain 2.6.6 → 2.6.8

package/lib/store/SyncRowStore.d.ts

@@ -1,6 +1,6 @@
 import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, TxnOption, Context, AggregationResult } from "../types";
 export declare abstract class SyncContext<ED extends EntityDict> implements Context {
-    private rowStore;
+    rowStore: SyncRowStore<ED, this>;
     private uuid?;
     constructor(rowStore: SyncRowStore<ED, SyncContext<ED>>);
     abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;

package/lib/store/TriggerExecutor.js

@@ -33,7 +33,7 @@ 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 _a = (0, checker_1.translateCheckerInAsyncContext)(checker, true), fn = _a.fn, when = _a.when;
+        var _a = (0, checker_1.translateCheckerInAsyncContext)(checker), fn = _a.fn, when = _a.when;
         var priority = type === 'data' ? Trigger_1.DATA_CHECKER_DEFAULT_PRIORITY : Trigger_1.CHECKER_DEFAULT_PRIORITY; // checker的默认优先级最低（前面的trigger可能会赋上一些相应的值）
         var trigger = {
             checkerType: type,

package/lib/store/checker.d.ts

@@ -8,7 +8,7 @@ import { SyncContext } from './SyncRowStore';
  * @param silent 如果silent，则row和relation类型的checker只会把限制条件加到查询上，而不报错（除掉create动作）
  * @returns
  */
-export declare function translateCheckerInAsyncContext<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>>(checker: Checker<ED, T, Cxt>, silent?: boolean): {
+export declare function translateCheckerInAsyncContext<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>>(checker: Checker<ED, T, Cxt>): {
     fn: Trigger<ED, T, Cxt>['fn'];
     when: 'before' | 'after';
 };
@@ -30,3 +30,4 @@ export declare function createAuthCheckers<ED extends EntityDict & BaseEntityDic
  * 如果有的对象允许删除，需要使用trigger来处理其相关联的外键对象，这些trigger写作before，则会在checker之前执行，仍然可以删除成功
  */
 export declare function createRemoveCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>, authDict?: AuthDefDict<ED>): Checker<ED, keyof ED, Cxt>[];
+export declare function createCreateCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];

package/lib/store/checker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRemoveCheckers = exports.createAuthCheckers = exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
+exports.createCreateCheckers = exports.createRemoveCheckers = exports.createAuthCheckers = exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var filter_1 = require("../store/filter");
@@ -11,13 +11,14 @@ var string_1 = require("../utils/string");
 var lodash_1 = require("../utils/lodash");
 var relation_1 = require("./relation");
 var uuid_1 = require("../utils/uuid");
+var action_1 = require("../actions/action");
 /**
  *
  * @param checker 要翻译的checker
  * @param silent 如果silent，则row和relation类型的checker只会把限制条件加到查询上，而不报错（除掉create动作）
  * @returns
  */
-function translateCheckerInAsyncContext(checker, silent) {
+function translateCheckerInAsyncContext(checker) {
     var _this = this;
     var entity = checker.entity, type = checker.type;
     var when = 'before'; // 现在create的relation改成提前的expression检查了，原先是先插入再后检查，性能不行，而且select也需要实现前检查
@@ -65,7 +66,7 @@ function translateCheckerInAsyncContext(checker, silent) {
                                 _c.label = 3;
                             case 3:
                                 filter2 = _b;
-                                if (!silent) return [3 /*break*/, 4];
+                                if (!['select', 'count', 'stat'].includes(action)) return [3 /*break*/, 4];
                                 operation.filter = (0, filter_1.addFilterSegment)(operationFilter || {}, filter2);
                                 return [2 /*return*/, 0];
                             case 4: return [4 /*yield*/, (0, filter_1.checkFilterContains)(entity, context, filter2, operationFilter || {}, true)];
@@ -135,7 +136,7 @@ function translateCheckerInAsyncContext(checker, silent) {
                                     console.warn("".concat(entity, "\u5BF9\u8C61\u7684create\u7C7B\u578B\u7684checker\u4E2D\uFF0C\u5B58\u5728\u65E0\u6CD5\u8F6C\u6362\u4E3A\u8868\u8FBE\u5F0F\u5F62\u5F0F\u7684\u60C5\u51B5\uFF0C\u8BF7\u5C3D\u91CF\u4F7F\u7528authDef\u683C\u5F0F\u5B9A\u4E49\u8FD9\u7C7Bchecker"));
                                     return [2 /*return*/, 0];
                                 }
-                                if (silent) {
+                                if (['select', 'count', 'stat'].includes(action)) {
                                     operation.filter = (0, filter_1.addFilterSegment)(filter || {}, result);
                                     return [2 /*return*/, 0];
                                 }
@@ -409,7 +410,7 @@ function translateCascadeRelationFilterMaker(schema, lch, entity2, pathPrefix) {
                 counters.push.apply(counters, tslib_1.__spreadArray([], tslib_1.__read(ca2), false));
             }
             if (filter.$or) {
-                var countersOr = filter.$and.map(function (ele) { return translateCreateFilterMaker(entity, ele, userId); });
+                var countersOr = filter.$or.map(function (ele) { return translateCreateFilterMaker(entity, ele, userId); });
                 // or也只要有一个满足就行（不能否定）
                 var co2 = countersOr.filter(function (ele) { return !(ele instanceof Exception_1.OakUserUnpermittedException); });
                 counters.push.apply(counters, tslib_1.__spreadArray([], tslib_1.__read(co2), false));
@@ -1216,3 +1217,155 @@ function createRemoveCheckers(schema, authDict) {
     return checkers;
 }
 exports.createRemoveCheckers = createRemoveCheckers;
+function checkAttributeLegal(schema, entity, data) {
+    var _a;
+    var attributes = schema[entity].attributes;
+    for (var attr in data) {
+        if (attributes[attr]) {
+            var _b = attributes[attr], type = _b.type, params = _b.params, defaultValue = _b.default, enumeration = _b.enumeration, notNull = _b.notNull;
+            if (data[attr] === null || data[attr] === undefined) {
+                if (notNull && defaultValue === undefined) {
+                    throw new Exception_1.OakAttrNotNullException(entity, [attr]);
+                }
+                if (defaultValue !== undefined) {
+                    Object.assign(data, (_a = {},
+                        _a[attr] = defaultValue,
+                        _a));
+                }
+                continue;
+            }
+            switch (type) {
+                case 'char':
+                case 'varchar': {
+                    if (typeof data[attr] !== 'string') {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'not a string');
+                    }
+                    var length_1 = params.length;
+                    if (length_1 && data[attr].length > length_1) {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'too long');
+                    }
+                    break;
+                }
+                case 'int':
+                case 'smallint':
+                case 'tinyint':
+                case 'bigint':
+                case 'decimal':
+                case 'money': {
+                    if (typeof data[attr] !== 'number') {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'not a number');
+                    }
+                    var _c = params || {}, min = _c.min, max = _c.max;
+                    if (typeof min === 'number' && data[attr] < min) {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'too small');
+                    }
+                    if (typeof max === 'number' && data[attr] > max) {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'too big');
+                    }
+                    break;
+                }
+                case 'enum': {
+                    (0, assert_1.default)(enumeration);
+                    if (!enumeration.includes(data[attr])) {
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'not in enumberation');
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            // 这里似乎还有一种update中带cascade remove的case，等遇到再说（貌似cascadeUpdate没有处理完整这种情况） by Xc
+            if (typeof data[attr] === 'object' && data[attr].action === 'remove') {
+                console.warn('cascade remove可能是未处理的边界，请注意');
+            }
+        }
+    }
+}
+function createCreateCheckers(schema) {
+    var checkers = [];
+    var _loop_9 = function (entity) {
+        var _a = schema[entity], attributes = _a.attributes, actions = _a.actions;
+        var notNullAttrs = Object.keys(attributes).filter(function (ele) { return attributes[ele].notNull; });
+        var updateActions = (0, lodash_1.difference)(actions, action_1.excludeUpdateActions);
+        checkers.push({
+            entity: entity,
+            type: 'data',
+            action: 'create',
+            checker: function (data) {
+                var checkData = function (data2) {
+                    var e_9, _a, e_10, _b;
+                    var illegalNullAttrs = (0, lodash_1.difference)(notNullAttrs, Object.keys(data2));
+                    if (illegalNullAttrs.length > 0) {
+                        try {
+                            // 要处理多对一的cascade create
+                            for (var illegalNullAttrs_1 = (e_9 = void 0, tslib_1.__values(illegalNullAttrs)), illegalNullAttrs_1_1 = illegalNullAttrs_1.next(); !illegalNullAttrs_1_1.done; illegalNullAttrs_1_1 = illegalNullAttrs_1.next()) {
+                                var attr = illegalNullAttrs_1_1.value;
+                                if (attr === 'entityId') {
+                                    if (illegalNullAttrs.includes('entity')) {
+                                        continue;
+                                    }
+                                }
+                                else if (attr === 'entity' && attributes[attr].type === 'ref') {
+                                    var hasCascadeCreate = false;
+                                    try {
+                                        for (var _c = (e_10 = void 0, tslib_1.__values(attributes[attr].ref)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                            var ref = _d.value;
+                                            if (data2[ref] && data2[ref].action === 'create') {
+                                                hasCascadeCreate = true;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                                    finally {
+                                        try {
+                                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                                        }
+                                        finally { if (e_10) throw e_10.error; }
+                                    }
+                                    if (hasCascadeCreate) {
+                                        continue;
+                                    }
+                                }
+                                else if (attributes[attr].type === 'ref') {
+                                    var ref = attributes[attr].ref;
+                                    if (data2[ref] && data2[ref].action === 'create') {
+                                        continue;
+                                    }
+                                }
+                                // 到这里说明确实是有not null的属性没有赋值
+                                throw new Exception_1.OakAttrNotNullException(entity, illegalNullAttrs);
+                            }
+                        }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        finally {
+                            try {
+                                if (illegalNullAttrs_1_1 && !illegalNullAttrs_1_1.done && (_a = illegalNullAttrs_1.return)) _a.call(illegalNullAttrs_1);
+                            }
+                            finally { if (e_9) throw e_9.error; }
+                        }
+                    }
+                    checkAttributeLegal(schema, entity, data2);
+                };
+                if (data instanceof Array) {
+                    data.forEach(function (ele) { return checkData(ele); });
+                }
+                else {
+                    checkData(data);
+                }
+            }
+        }, {
+            entity: entity,
+            type: 'data',
+            action: updateActions,
+            checker: function (data) {
+                checkAttributeLegal(schema, entity, data);
+            }
+        });
+    };
+    for (var entity in schema) {
+        _loop_9(entity);
+    }
+    return checkers;
+}
+exports.createCreateCheckers = createCreateCheckers;

package/lib/store/modi.js

@@ -151,8 +151,8 @@ function createModiRelatedTriggers(schema) {
     var _this = this;
     var triggers = [];
     var _loop_2 = function (entity) {
-        var inModi = schema[entity].inModi;
-        if (inModi) {
+        var toModi = schema[entity].toModi;
+        if (toModi) {
             // 当关联modi的对象被删除时，对应的modi也删除。这里似乎只需要删除掉活跃对象？因为oper不能删除，所以oper和modi是必须要支持对deleted对象的容错？
             // 这里没有想清楚，by Xc 20230209
             triggers.push({

package/lib/store/relation.js

@@ -55,6 +55,7 @@ function judgeRelation(schema, entity, attr) {
     else if (attributes.hasOwnProperty('entity')
         && attributes.hasOwnProperty('entityId')
         && schema.hasOwnProperty(attr)) {
+        (0, assert_1.default)(attributes.entity.ref.includes(attr), '不应当出现的case');
         // 反向指针的外键
         return 2;
     }

package/lib/timers/oper.d.ts

@@ -0,0 +1,18 @@
+import { EntityDict } from '../types/Entity';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { AsyncContext } from '../store/AsyncRowStore';
+export declare type VaccumOperOption<ED extends EntityDict & BaseEntityDict> = {
+    aliveLine: number;
+    excludeOpers?: {
+        [T in keyof ED]?: ED[T]['Action'][];
+    };
+    backupDir?: string;
+    zip?: boolean;
+};
+/**
+ * 将一定日期之前的oper对象清空
+ * @param option
+ * @param context
+ * @returns
+ */
+export declare function vaccumOper<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(option: VaccumOperOption<ED>, context: Cxt): Promise<void>;

package/lib/timers/oper.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaccumOper = void 0;
+var tslib_1 = require("tslib");
+var vaccum_1 = require("./vaccum");
+var filter_1 = require("../store/filter");
+/**
+ * 将一定日期之前的oper对象清空
+ * @param option
+ * @param context
+ * @returns
+ */
+function vaccumOper(option, context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var aliveLine, excludeOpers, rest, operFilter, notFilters, key;
+        return tslib_1.__generator(this, function (_a) {
+            aliveLine = option.aliveLine, excludeOpers = option.excludeOpers, rest = tslib_1.__rest(option, ["aliveLine", "excludeOpers"]);
+            operFilter = {};
+            if (excludeOpers) {
+                notFilters = [];
+                for (key in excludeOpers) {
+                    if (excludeOpers[key].length > 0) {
+                        notFilters.push({
+                            targetEntity: key,
+                            action: {
+                                $in: excludeOpers[key],
+                            }
+                        });
+                    }
+                    else {
+                        notFilters.push({
+                            targetEntity: key,
+                        });
+                    }
+                }
+                if (notFilters.length > 0) {
+                    operFilter.$not = {
+                        $or: notFilters,
+                    };
+                }
+            }
+            return [2 /*return*/, (0, vaccum_1.vaccumEntities)(tslib_1.__assign({ entities: [{
+                            entity: 'operEntity',
+                            aliveLine: aliveLine + 10000,
+                            filter: {
+                                oper: (0, filter_1.combineFilters)([operFilter, {
+                                        $$createAt$$: {
+                                            $lt: aliveLine,
+                                        }
+                                    }]),
+                            },
+                        }, {
+                            entity: 'oper',
+                            aliveLine: aliveLine,
+                            filter: operFilter,
+                        }] }, rest), context)];
+        });
+    });
+}
+exports.vaccumOper = vaccumOper;

package/lib/timers/vaccum.d.ts

@@ -0,0 +1,20 @@
+import { EntityDict } from '../types/Entity';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { AsyncContext } from '../store/AsyncRowStore';
+declare type VaccumOptionEntity<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = {
+    entity: T;
+    filter?: ED[T]['Selection']['filter'];
+    aliveLine: number;
+};
+declare type VaccumOption<ED extends EntityDict & BaseEntityDict> = {
+    entities: Array<VaccumOptionEntity<ED, keyof ED>>;
+    backupDir?: string;
+    zip?: boolean;
+};
+/**
+ * 删除数据库中的部分数据，减少体积
+ * 一般只删除日志类数据
+ * @param option
+ */
+export declare function vaccumEntities<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(option: VaccumOption<ED>, context: Cxt): Promise<void>;
+export {};

package/lib/timers/vaccum.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaccumEntities = void 0;
+var tslib_1 = require("tslib");
+var dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+var fs_1 = require("fs");
+var filter_1 = require("../store/filter");
+var stream_1 = require("stream");
+var uuid_1 = require("../utils/uuid");
+/**
+ * 删除数据库中的部分数据，减少体积
+ * 一般只删除日志类数据
+ * @param option
+ */
+function vaccumEntities(option, context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var entities, backupDir, _loop_1, entities_1, entities_1_1, ele, e_1_1;
+        var e_1, _a;
+        var _this = this;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    entities = option.entities, backupDir = option.backupDir;
+                    _loop_1 = function (ele) {
+                        var entity, filter, aliveLine, filter2, zip, now, backFile, fd_1, attributes_1, projection_1, attr, count_1, appendData_1, createGzip, gzip_1, source_1, destination_1, _c, _d, _e;
+                        var _f, _g;
+                        return tslib_1.__generator(this, function (_h) {
+                            switch (_h.label) {
+                                case 0:
+                                    entity = ele.entity, filter = ele.filter, aliveLine = ele.aliveLine;
+                                    filter2 = {
+                                        $$createAt$$: {
+                                            $lt: aliveLine,
+                                        },
+                                    };
+                                    if (filter) {
+                                        filter2 = (0, filter_1.combineFilters)([filter2, filter]);
+                                    }
+                                    if (!(backupDir && process.env.OAK_PLATFORM === 'server')) return [3 /*break*/, 4];
+                                    zip = option.zip;
+                                    now = (0, dayjs_1.default)();
+                                    backFile = "".concat(backupDir, "/").concat(entity, "-").concat(now.format('YYYY-MM-DD HH:mm:ss'), ".csv");
+                                    if ((0, fs_1.existsSync)(backFile)) {
+                                        (0, fs_1.rmSync)(backFile);
+                                    }
+                                    fd_1 = (0, fs_1.openSync)(backFile, 'a');
+                                    attributes_1 = ['id', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$'];
+                                    projection_1 = {
+                                        id: 1,
+                                        $$createAt$$: 1,
+                                        $$updateAt$$: 1,
+                                        $$deleteAt$$: 1,
+                                    };
+                                    for (attr in context.getSchema()[entity].attributes) {
+                                        Object.assign(projection_1, (_f = {},
+                                            _f[attr] = 1,
+                                            _f));
+                                        attributes_1.push(attr);
+                                    }
+                                    (0, fs_1.appendFileSync)(fd_1, attributes_1.join(','));
+                                    (0, fs_1.appendFileSync)(fd_1, '\n');
+                                    count_1 = 0;
+                                    appendData_1 = function (minCreateAt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                        var filter3, rows, csvTxt, maxCreateAt;
+                                        return tslib_1.__generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    filter3 = (0, filter_1.combineFilters)([filter2, {
+                                                            $$createAt$$: {
+                                                                $gt: minCreateAt,
+                                                            },
+                                                        }]);
+                                                    return [4 /*yield*/, context.select(entity, {
+                                                            data: projection_1,
+                                                            filter: filter3,
+                                                            sorter: [{
+                                                                    $attr: {
+                                                                        $$createAt$$: 1,
+                                                                    },
+                                                                    $direction: 'asc'
+                                                                }],
+                                                            indexFrom: 0,
+                                                            count: 1000,
+                                                        }, { includedDeleted: true })];
+                                                case 1:
+                                                    rows = _a.sent();
+                                                    csvTxt = rows.map(function (row) { return attributes_1.map(function (attr) { return JSON.stringify(row[attr]); }).join(','); }).join('\n');
+                                                    (0, fs_1.appendFileSync)(fd_1, csvTxt);
+                                                    (0, fs_1.appendFileSync)(fd_1, '\n');
+                                                    count_1 += rows.length;
+                                                    if (rows.length === 1000) {
+                                                        maxCreateAt = rows[999].$$createAt$$;
+                                                        return [2 /*return*/, appendData_1(maxCreateAt)];
+                                                    }
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); };
+                                    return [4 /*yield*/, appendData_1(0)];
+                                case 1:
+                                    _h.sent();
+                                    (0, fs_1.closeSync)(fd_1);
+                                    console.log("\u5907\u4EFD".concat(entity, "\u5BF9\u8C61\u5B8C\u6BD5\uFF0C\u5171\u5907\u4EFD\u4E86").concat(count_1, "\u884C\u6570\u636E"));
+                                    if (!(count_1 === 0)) return [3 /*break*/, 2];
+                                    (0, fs_1.rmSync)(backFile);
+                                    return [3 /*break*/, 4];
+                                case 2:
+                                    if (!zip) return [3 /*break*/, 4];
+                                    createGzip = require('zlib').createGzip;
+                                    gzip_1 = createGzip();
+                                    source_1 = (0, fs_1.createReadStream)(backFile);
+                                    destination_1 = (0, fs_1.createWriteStream)("".concat(backFile, ".zip"));
+                                    return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                            (0, stream_1.pipeline)(source_1, gzip_1, destination_1, function (err) {
+                                                if (err) {
+                                                    reject(err);
+                                                }
+                                                else {
+                                                    resolve(undefined);
+                                                }
+                                            });
+                                        })];
+                                case 3:
+                                    _h.sent();
+                                    _h.label = 4;
+                                case 4:
+                                    _d = (_c = context).operate;
+                                    _e = [entity];
+                                    _g = {};
+                                    return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
+                                case 5: 
+                                // 将对应的数据删除
+                                return [4 /*yield*/, _d.apply(_c, _e.concat([(_g.id = _h.sent(),
+                                            _g.action = 'remove',
+                                            _g.data = {},
+                                            _g.filter = filter2,
+                                            _g), { deletePhysically: true }]))];
+                                case 6:
+                                    // 将对应的数据删除
+                                    _h.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!entities_1_1.done) return [3 /*break*/, 5];
+                    ele = entities_1_1.value;
+                    return [5 /*yield**/, _loop_1(ele)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    entities_1_1 = entities_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.vaccumEntities = vaccumEntities;

package/lib/types/Connector.d.ts

@@ -16,10 +16,10 @@ export declare abstract class Connector<ED extends EntityDict, BackCxt extends A
         params: any;
         context: BackCxt;
     }>;
-    abstract serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): {
+    abstract serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): Promise<{
         body: any;
         headers?: Record<string, any>;
-    };
+    }>;
     abstract serializeException(exception: OakException<ED>, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any>;

package/lib/types/Entity.d.ts

@@ -37,6 +37,7 @@ export declare type OperateOption = {
     allowExists?: boolean;
     modiParentId?: string;
     modiParentEntity?: string;
+    deletePhysically?: boolean;
     dummy?: 1;
 };
 export declare type FormUpdateData<SH extends GeneralEntityShape> = Partial<{
@@ -64,7 +65,7 @@ export interface EntityShape {
     $$updateAt$$: number | Date;
     $$deleteAt$$?: number | Date | null;
 }
-interface GeneralEntityShape extends EntityShape {
+export interface GeneralEntityShape extends EntityShape {
     [K: string]: any;
 }
 export declare type MakeAction<A extends string> = A;

package/lib/types/Exception.d.ts

@@ -55,12 +55,15 @@ export declare class OakRowInconsistencyException<ED extends EntityDict> extends
 export declare class OakInputIllegalException<ED extends EntityDict> extends OakUserException<ED> {
     private attributes;
     private entity;
-    constructor(entity: string, attributes: string[], message?: string);
-    getEntity(): string;
+    constructor(entity: keyof ED, attributes: string[], message?: string);
+    getEntity(): keyof ED;
     getAttributes(): string[];
     addAttributesPrefix(prefix: string): void;
     toString(): string;
 }
+export declare class OakAttrNotNullException<ED extends EntityDict> extends OakInputIllegalException<ED> {
+    constructor(entity: keyof ED, attributes: string[], message?: string);
+}
 /**
  * 用户权限不够时抛的异常
  */

package/lib/types/Exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakDataException = exports.OakException = void 0;
+exports.makeException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakDataException = exports.OakException = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var OakException = /** @class */ (function (_super) {
@@ -179,6 +179,15 @@ var OakInputIllegalException = /** @class */ (function (_super) {
 }(OakUserException));
 exports.OakInputIllegalException = OakInputIllegalException;
 ;
+// 属性为空
+var OakAttrNotNullException = /** @class */ (function (_super) {
+    tslib_1.__extends(OakAttrNotNullException, _super);
+    function OakAttrNotNullException(entity, attributes, message) {
+        return _super.call(this, entity, attributes, message || '属性不允许为空') || this;
+    }
+    return OakAttrNotNullException;
+}(OakInputIllegalException));
+exports.OakAttrNotNullException = OakAttrNotNullException;
 /**
  * 用户权限不够时抛的异常
  */
@@ -344,6 +353,11 @@ function makeException(data) {
             e.setOpRecords(data.opRecords);
             return e;
         }
+        case 'OakAttrNotNullException': {
+            var e = new OakAttrNotNullException(data.entity, data.attributes, data.message);
+            e.setOpRecords(data.opRecords);
+            return e;
+        }
         default:
             return;
     }

package/lib/types/RowStore.d.ts

@@ -3,9 +3,13 @@ import { StorageSchema } from './Storage';
 export declare type TxnOption = {
     isolationLevel: 'repeatable read' | 'serializable';
 };
+export declare type SelectionRewriter<ED extends EntityDict> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection']) => void;
+export declare type OperationRewriter<ED extends EntityDict> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation']) => void;
 export declare abstract class RowStore<ED extends EntityDict> {
     protected storageSchema: StorageSchema<ED>;
     constructor(storageSchema: StorageSchema<ED>);
+    abstract registerOperationRewriter(rewriter: OperationRewriter<ED>): void;
+    abstract registerSelectionRewriter(rewriter: SelectionRewriter<ED>): void;
     getSchema(): StorageSchema<ED>;
     mergeOperationResult(result: OperationResult<ED>, toBeMerged: OperationResult<ED>): void;
     mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;