oak-domain 1.0.0

package/lib/store/UniversalContext.js

@@ -0,0 +1,208 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalContext = void 0;
+var assert_1 = __importDefault(require("assert"));
+var concurrent_1 = require("../utils/concurrent");
+var UniversalContext = /** @class */ (function () {
+    function UniversalContext(store) {
+        this.rowStore = store;
+        this.opRecords = [];
+        this.rwLock = new concurrent_1.RWLock();
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+    }
+    UniversalContext.prototype.getScene = function () {
+        return this.scene;
+    };
+    UniversalContext.prototype.setScene = function (scene) {
+        this.scene = scene;
+    };
+    UniversalContext.prototype.resetEvents = function () {
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+    };
+    UniversalContext.prototype.on = function (event, callback) {
+        this.uuid && this.events[event].push(callback);
+    };
+    /**
+     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
+     * @param options
+     */
+    UniversalContext.prototype.begin = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.rwLock.acquire('X')];
+                    case 1:
+                        _b.sent();
+                        if (!!this.uuid) return [3 /*break*/, 3];
+                        _a = this;
+                        return [4 /*yield*/, this.rowStore.begin(options)];
+                    case 2:
+                        _a.uuid = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        (0, assert_1.default)(false);
+                        _b.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UniversalContext.prototype.commit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, e, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!this.uuid) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.rowStore.commit(this.uuid)];
+                    case 1:
+                        _d.sent();
+                        // console.log('commit', this.uuid);
+                        this.uuid = undefined;
+                        this.rwLock.release();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(this.events.commit), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        e = _b.value;
+                        return [4 /*yield*/, e()];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this.resetEvents();
+                        _d.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UniversalContext.prototype.rollback = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, e, e_2_1;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!this.uuid) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.rowStore.rollback(this.uuid)];
+                    case 1:
+                        _d.sent();
+                        // console.log('rollback', this.uuid);
+                        this.uuid = undefined;
+                        this.rwLock.release();
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(this.events.rollback), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        e = _b.value;
+                        return [4 /*yield*/, e()];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this.resetEvents();
+                        _d.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UniversalContext.prototype.getCurrentTxnId = function () {
+        return this.uuid;
+    };
+    return UniversalContext;
+}());
+exports.UniversalContext = UniversalContext;

package/lib/store/actionDef.d.ts

@@ -0,0 +1,8 @@
+import { ActionDictOfEntityDict, Checker, Context, DeduceFilter, EntityDict, StorageSchema, Trigger, Watcher } from "../types";
+export declare function getFullProjection<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>): ED[T]["Selection"]["data"];
+export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>>(entity: T, schema: StorageSchema<ED>, contained: DeduceFilter<ED[T]['Schema']>, context: Cxt, filter?: DeduceFilter<ED[T]['Schema']>): Promise<void>;
+export declare function analyzeActionDefDict<ED extends EntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>, actionDefDict: ActionDictOfEntityDict<ED>): {
+    triggers: Trigger<ED, keyof ED, Cxt>[];
+    checkers: Checker<ED, keyof ED, Cxt>[];
+    watchers: Watcher<ED, keyof ED, Context<ED>>[];
+};

package/lib/store/actionDef.js

@@ -0,0 +1,241 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeActionDefDict = exports.checkFilterContains = exports.getFullProjection = void 0;
+var filter_1 = require("./filter");
+var types_1 = require("../types");
+function getFullProjection(entity, schema) {
+    var attributes = schema[entity].attributes;
+    var projection = {
+        id: 1,
+        $$createAt$$: 1,
+        $$updateAt$$: 1,
+        $$deleteAt$$: 1,
+    };
+    Object.keys(attributes).forEach(function (k) {
+        var _a;
+        return Object.assign(projection, (_a = {},
+            _a[k] = 1,
+            _a));
+    });
+    return projection;
+}
+exports.getFullProjection = getFullProjection;
+function checkFilterContains(entity, schema, contained, context, filter) {
+    return __awaiter(this, void 0, void 0, function () {
+        var rowStore, filter2, result, data_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!filter) {
+                        throw new types_1.OakRowInconsistencyException();
+                    }
+                    // 优先判断两个条件是否相容
+                    if ((0, filter_1.contains)(entity, schema, filter, contained)) {
+                        return [2 /*return*/];
+                    }
+                    rowStore = context.rowStore;
+                    filter2 = (0, filter_1.combineFilters)([filter, {
+                            $not: contained,
+                        }]);
+                    return [4 /*yield*/, rowStore.select(entity, {
+                            data: getFullProjection(entity, schema),
+                            filter: filter2,
+                            indexFrom: 0,
+                            count: 10,
+                        }, context)];
+                case 1:
+                    result = (_b.sent()).result;
+                    if (result.length > 0) {
+                        data_1 = {};
+                        result.forEach(function (ele) {
+                            var _a;
+                            return Object.assign(data_1, (_a = {},
+                                _a[ele.id] = ele,
+                                _a));
+                        });
+                        throw new types_1.OakRowInconsistencyException({
+                            a: 's',
+                            d: (_a = {},
+                                _a[entity] = data_1,
+                                _a)
+                        });
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.checkFilterContains = checkFilterContains;
+function makeIntrinsicWatchers(schema) {
+    var _this = this;
+    var watchers = [];
+    var _loop_1 = function (entity) {
+        var attributes = schema[entity].attributes;
+        var now = Date.now();
+        var expiresAt = attributes.expiresAt, expired = attributes.expired;
+        if (expiresAt && expiresAt.type === 'datetime' && expired && expired.type === 'boolean') {
+            // 如果有定义expiresAt和expired，则自动生成一个检查的watcher
+            watchers.push({
+                entity: entity,
+                name: "\u5BF9\u8C61".concat(entity, "\u4E0A\u7684\u8FC7\u671F\u81EA\u52A8watcher"),
+                filter: function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, {
+                                expired: false,
+                                expiresAt: {
+                                    $lte: now,
+                                },
+                            }];
+                    });
+                }); },
+                action: 'update',
+                actionData: {
+                    expired: true,
+                },
+            });
+        }
+    };
+    for (var entity in schema) {
+        _loop_1(entity);
+    }
+    return watchers;
+}
+function analyzeActionDefDict(schema, actionDefDict) {
+    var _this = this;
+    var checkers = [];
+    var triggers = [];
+    var _loop_2 = function (entity) {
+        var _loop_3 = function (attr) {
+            var def = actionDefDict[entity][attr];
+            var _a = def, stm = _a.stm, is = _a.is;
+            var _loop_4 = function (action) {
+                var actionStm = stm[action];
+                checkers.push({
+                    action: action,
+                    type: 'row',
+                    entity: entity,
+                    checker: function (_a, context) {
+                        var operation = _a.operation;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var filter, conditionalFilter;
+                            var _b, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        filter = operation.filter;
+                                        conditionalFilter = typeof actionStm[0] === 'string' ? (_b = {},
+                                            _b[attr] = actionStm[0],
+                                            _b) : (_c = {},
+                                            _c[attr] = {
+                                                $in: actionStm[0],
+                                            },
+                                            _c);
+                                        return [4 /*yield*/, checkFilterContains(entity, schema, conditionalFilter, context, filter)];
+                                    case 1:
+                                        _d.sent();
+                                        return [2 /*return*/, 0];
+                                }
+                            });
+                        });
+                    }
+                });
+                triggers.push({
+                    name: "set next state of ".concat(attr, " for ").concat(entity, " on action ").concat(action),
+                    action: action,
+                    entity: entity,
+                    when: 'before',
+                    fn: function (_a) {
+                        var operation = _a.operation;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var _b, data;
+                            var _c;
+                            return __generator(this, function (_d) {
+                                _b = operation.data, data = _b === void 0 ? {} : _b;
+                                Object.assign(operation, {
+                                    data: Object.assign(data, (_c = {},
+                                        _c[attr] = stm[action][1],
+                                        _c)),
+                                });
+                                return [2 /*return*/, 1];
+                            });
+                        });
+                    }
+                });
+            };
+            for (var action in stm) {
+                _loop_4(action);
+            }
+            if (is) {
+                triggers.push({
+                    name: "set initial state of ".concat(attr, " for ").concat(entity, " on create"),
+                    action: 'create',
+                    entity: entity,
+                    when: 'before',
+                    fn: function (_a) {
+                        var operation = _a.operation;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var data;
+                            var _b;
+                            return __generator(this, function (_c) {
+                                data = operation.data;
+                                Object.assign(data, (_b = {},
+                                    _b[attr] = is,
+                                    _b));
+                                return [2 /*return*/, 1];
+                            });
+                        });
+                    }
+                });
+            }
+        };
+        for (var attr in actionDefDict[entity]) {
+            _loop_3(attr);
+        }
+    };
+    for (var entity in actionDefDict) {
+        _loop_2(entity);
+    }
+    return {
+        triggers: triggers,
+        checkers: checkers,
+        watchers: makeIntrinsicWatchers(schema),
+    };
+}
+exports.analyzeActionDefDict = analyzeActionDefDict;

package/lib/store/filter.d.ts

@@ -0,0 +1,36 @@
+import { StorageSchema } from '../types';
+import { EntityDict } from "../types/Entity";
+export declare function addFilterSegment<ED extends EntityDict, T extends keyof ED>(...filters: ED[T]['Selection']['filter'][]): ED[T]["Selection"]["filter"];
+export declare function combineFilters<ED extends EntityDict, T extends keyof ED>(filters: Array<ED[T]['Selection']['filter']>): ED[T]["Selection"]["filter"];
+/**
+ * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
+ * filter = {
+ *      a: 1
+ *      b: 2,
+ *      c: 3,
+ * },
+ * conditionalFilter = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ */
+export declare function contains<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Selection']['filter'], conditionalFilter: ED[T]['Selection']['filter']): boolean;
+/**
+ * 判断filter1和filter2是否相斥，即filter1和filter2查询的结果一定没有交集
+ * filter1 = {
+ *      a: 2
+ * },
+ * filter2 = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ */
+export declare function repel<ED extends EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;

package/lib/store/filter.js

@@ -0,0 +1,121 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repel = exports.contains = exports.combineFilters = exports.addFilterSegment = void 0;
+function addFilterSegment() {
+    var filters = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        filters[_i] = arguments[_i];
+    }
+    var filter = {};
+    filters.forEach(function (ele) {
+        var _a, _b, _c, _d;
+        if (ele) {
+            for (var k in ele) {
+                if (k === '$and') {
+                    if (filter.$and) {
+                        (_a = filter.$and).push.apply(_a, __spreadArray([], __read(ele[k]), false));
+                    }
+                    else {
+                        filter.$and = ele[k];
+                    }
+                }
+                else if (k === '$or') {
+                    if (filter.$or) {
+                        (_b = filter.$or).push.apply(_b, __spreadArray([], __read(ele[k]), false));
+                    }
+                    else {
+                        filter.$or = ele[k];
+                    }
+                }
+                else if (filter.hasOwnProperty(k)) {
+                    if (filter.$and) {
+                        filter.$and.push((_c = {},
+                            _c[k] = ele[k],
+                            _c));
+                    }
+                    else {
+                        filter.$and = [
+                            (_d = {},
+                                _d[k] = ele[k],
+                                _d)
+                        ];
+                    }
+                }
+                else {
+                    filter[k] = ele[k];
+                }
+            }
+        }
+    });
+    return filter;
+}
+exports.addFilterSegment = addFilterSegment;
+function combineFilters(filters) {
+    return addFilterSegment.apply(void 0, __spreadArray([], __read(filters), false));
+}
+exports.combineFilters = combineFilters;
+/**
+ * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
+ * filter = {
+ *      a: 1
+ *      b: 2,
+ *      c: 3,
+ * },
+ * conditionalFilter = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ */
+function contains(entity, schema, filter, conditionalFilter) {
+    // todo
+    return false;
+}
+exports.contains = contains;
+/**
+ * 判断filter1和filter2是否相斥，即filter1和filter2查询的结果一定没有交集
+ * filter1 = {
+ *      a: 2
+ * },
+ * filter2 = {
+ *      a: 1
+ * }
+ * 则包含
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ */
+function repel(entity, schema, filter1, filter2) {
+    // todo
+    return false;
+}
+exports.repel = repel;

package/lib/store/relation.d.ts

@@ -0,0 +1,13 @@
+import { EntityDef } from "../types/Entity";
+import { StorageSchema } from "../types/Storage";
+/**
+ * 判断对象和属性之间的关系
+ * @param schema
+ * @param entity
+ * @param attr
+ * @param row
+ * @returns
+ */
+export declare function judgeRelation<ED extends {
+    [E: string]: EntityDef;
+}>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | string[] | 1 | 0 | 2;