oak-domain 1.0.0

package/lib/types/Exception.js

@@ -0,0 +1,178 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeException = exports.OakCongruentRowExists = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakException = void 0;
+var OakException = /** @class */ (function (_super) {
+    __extends(OakException, _super);
+    function OakException(message) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = _newTarget.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(_this, _newTarget);
+        }
+        if (typeof Object.setPrototypeOf === 'function') {
+            Object.setPrototypeOf(_this, _newTarget.prototype);
+        }
+        else {
+            _this.__proto__ = _newTarget.prototype;
+        }
+        return _this;
+    }
+    OakException.prototype.toString = function () {
+        return JSON.stringify({
+            name: this.constructor.name,
+            message: this.message,
+        });
+    };
+    return OakException;
+}(Error));
+exports.OakException = OakException;
+var OakExternalException = /** @class */ (function (_super) {
+    __extends(OakExternalException, _super);
+    function OakExternalException() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return OakExternalException;
+}(Error));
+exports.OakExternalException = OakExternalException;
+var OakUserException = /** @class */ (function (_super) {
+    __extends(OakUserException, _super);
+    function OakUserException() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return OakUserException;
+}(OakException));
+exports.OakUserException = OakUserException;
+;
+// 在系统更新数据时，以下三个异常应按规范依次抛出。
+/**
+ * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
+ *
+ */
+var OakRowInconsistencyException = /** @class */ (function (_super) {
+    __extends(OakRowInconsistencyException, _super);
+    function OakRowInconsistencyException(data, message) {
+        var _this = _super.call(this, message) || this;
+        _this.data = data;
+        return _this;
+    }
+    OakRowInconsistencyException.prototype.getData = function () {
+        return this.data;
+    };
+    OakRowInconsistencyException.prototype.toString = function () {
+        return JSON.stringify({
+            name: this.constructor.name,
+            message: this.message,
+            data: this.data,
+        });
+    };
+    return OakRowInconsistencyException;
+}(OakUserException));
+exports.OakRowInconsistencyException = OakRowInconsistencyException;
+;
+/**
+ * 当输入的数据非法时抛此异常，attributes表示非法的属性
+ */
+var OakInputIllegalException = /** @class */ (function (_super) {
+    __extends(OakInputIllegalException, _super);
+    function OakInputIllegalException(attributes, message) {
+        var _this = _super.call(this, message) || this;
+        _this.attributes = attributes;
+        return _this;
+    }
+    OakInputIllegalException.prototype.getAttributes = function () {
+        return this.attributes;
+    };
+    OakInputIllegalException.prototype.addAttributesPrefix = function (prefix) {
+        this.attributes = this.attributes.map(function (ele) { return "".concat(prefix, ".").concat(ele); });
+    };
+    OakInputIllegalException.prototype.toString = function () {
+        return JSON.stringify({
+            name: this.constructor.name,
+            message: this.message,
+            attributes: this.attributes,
+        });
+    };
+    return OakInputIllegalException;
+}(OakUserException));
+exports.OakInputIllegalException = OakInputIllegalException;
+;
+/**
+ * 用户权限不够时抛的异常
+ */
+var OakUserUnpermittedException = /** @class */ (function (_super) {
+    __extends(OakUserUnpermittedException, _super);
+    function OakUserUnpermittedException() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return OakUserUnpermittedException;
+}(OakUserException));
+exports.OakUserUnpermittedException = OakUserUnpermittedException;
+;
+/**
+ * 要插入行时，发现已经有相同的行数据
+ */
+var OakCongruentRowExists = /** @class */ (function (_super) {
+    __extends(OakCongruentRowExists, _super);
+    function OakCongruentRowExists(data, message) {
+        var _this = _super.call(this, message) || this;
+        _this.data = data;
+        return _this;
+    }
+    OakCongruentRowExists.prototype.getData = function () {
+        return this.data;
+    };
+    OakCongruentRowExists.prototype.toString = function () {
+        return JSON.stringify({
+            name: this.constructor.name,
+            message: this.message,
+            data: this.data,
+        });
+    };
+    return OakCongruentRowExists;
+}(OakUserException));
+exports.OakCongruentRowExists = OakCongruentRowExists;
+function makeException(data) {
+    var name = data.name;
+    switch (name) {
+        case OakException.name: {
+            return new OakException(data.message);
+        }
+        case OakUserException.name: {
+            return new OakUserException(data.message);
+        }
+        case OakExternalException.name: {
+            return new OakExternalException(data.message);
+        }
+        case OakRowInconsistencyException.name: {
+            return new OakRowInconsistencyException(data.data, data.message);
+        }
+        case OakInputIllegalException.name: {
+            return new OakInputIllegalException(data.attributes, data.message);
+        }
+        case OakUserUnpermittedException.name: {
+            return new OakUserUnpermittedException(data.message);
+        }
+        case OakCongruentRowExists.name: {
+            return new OakCongruentRowExists(data.data, data.message);
+        }
+        default:
+            return;
+    }
+}
+exports.makeException = makeException;

package/lib/types/Expression.d.ts

@@ -0,0 +1,132 @@
+import { RefAttr } from "./Demand";
+import { Geo } from "./Geo";
+export declare type RefOrExpression<A> = RefAttr<A> | Expression<A>;
+declare type MathType<A> = RefOrExpression<A> | number;
+declare type StringType<A> = RefOrExpression<A> | string;
+interface Add<A> {
+    $add: (MathType<A> | StringType<A>)[];
+}
+interface Subtract<A> {
+    $subtract: [MathType<A>, MathType<A>];
+}
+interface Multiply<A> {
+    $multiply: (MathType<A>)[];
+}
+interface Divide<A> {
+    $divide: [MathType<A>, MathType<A>];
+}
+interface Abs<A> {
+    $abs: MathType<A>;
+}
+interface Round<A> {
+    $round: [MathType<A>, MathType<A>];
+}
+interface Floor<A> {
+    $floor: MathType<A>;
+}
+interface Ceil<A> {
+    $ceil: MathType<A>;
+}
+interface Pow<A> {
+    $pow: [MathType<A>, MathType<A>];
+}
+declare type MathExpression<A> = Add<A> | Subtract<A> | Multiply<A> | Divide<A> | Abs<A> | Round<A> | Floor<A> | Ceil<A> | Pow<A>;
+declare type CmpType<A> = RefOrExpression<A> | string | number;
+interface Gt<A> {
+    $gt: [CmpType<A>, CmpType<A>];
+}
+interface Lt<A> {
+    $lt: [CmpType<A>, CmpType<A>];
+}
+interface Eq<A> {
+    $eq: [CmpType<A>, CmpType<A>];
+}
+interface Gte<A> {
+    $gte: [CmpType<A>, CmpType<A>];
+}
+interface Lte<A> {
+    $lte: [CmpType<A>, CmpType<A>];
+}
+interface Ne<A> {
+    $ne: [CmpType<A>, CmpType<A>];
+}
+interface StartsWith<A> {
+    $startsWith: [RefOrExpression<A> | string, RefOrExpression<A> | string];
+}
+interface EndsWith<A> {
+    $endsWith: [RefOrExpression<A> | string, RefOrExpression<A> | string];
+}
+interface Includes<A> {
+    $includes: [RefOrExpression<A> | string, RefOrExpression<A> | string];
+}
+declare type CompareExpression<A> = Lt<A> | Gt<A> | Lte<A> | Gte<A> | Eq<A> | Ne<A> | StartsWith<A> | EndsWith<A> | Includes<A>;
+interface BoolTrue<A> {
+    $true: Expression<A>;
+}
+interface BoolFalse<A> {
+    $false: Expression<A>;
+}
+declare type BoolExpression<A> = BoolTrue<A> | BoolFalse<A>;
+interface LogicAnd<A> {
+    $and: Expression<A>[];
+}
+interface LogicOr<A> {
+    $or: Expression<A>[];
+}
+interface LogicNot<A> {
+    $not: Expression<A>;
+}
+declare type LogicExpression<A> = LogicAnd<A> | LogicOr<A> | LogicNot<A>;
+interface DateYear<A> {
+    $year: RefOrExpression<A> | Date | number;
+}
+interface DateMonth<A> {
+    $month: RefOrExpression<A> | Date | number;
+}
+interface DateWeekday<A> {
+    $weekday: RefOrExpression<A> | Date | number;
+}
+interface DateWeekOfYear<A> {
+    $weekOfYear: RefOrExpression<A> | Date | number;
+}
+interface DateDay<A> {
+    $day: RefOrExpression<A> | Date | number;
+}
+interface DateDayOfMonth<A> {
+    $dayOfMonth: RefOrExpression<A> | Date | number;
+}
+interface DateDayOfWeek<A> {
+    $dayOfWeek: RefOrExpression<A> | Date | number;
+}
+interface DateDayOfYear<A> {
+    $dayOfYear: RefOrExpression<A> | Date | number;
+}
+interface DateDiff<A> {
+    $dateDiff: [RefOrExpression<A> | Date | number, RefOrExpression<A> | Date | number, 'y' | 'M' | 'd' | 'h' | 'm' | 's'];
+}
+interface DateCeiling<A> {
+    $dateCeil: [RefOrExpression<A> | Date | number, 'y' | 'M' | 'd' | 'h' | 'm' | 's'];
+}
+interface DateFloor<A> {
+    $dateFloor: [RefOrExpression<A> | Date | number, 'y' | 'M' | 'd' | 'h' | 'm' | 's'];
+}
+declare type DateExpression<A> = DateYear<A> | DateMonth<A> | DateWeekday<A> | DateWeekOfYear<A> | DateDay<A> | DateDayOfYear<A> | DateDayOfMonth<A> | DateDayOfWeek<A> | DateDiff<A> | DateCeiling<A> | DateFloor<A>;
+interface GeoContains<A> {
+    $contains: [RefOrExpression<A> | Geo, RefOrExpression<A> | Geo];
+}
+interface GeoDistance<A> {
+    $distance: [RefOrExpression<A> | Geo, RefOrExpression<A> | Geo];
+}
+declare type GeoExpression<A> = GeoContains<A> | GeoDistance<A>;
+export declare type Expression<A> = GeoExpression<A> | DateExpression<A> | LogicExpression<A> | BoolExpression<A> | CompareExpression<A> | MathExpression<A>;
+export declare type ExpressionConstant = Geo | number | Date | string | boolean;
+export declare function isGeoExpression<A>(expression: any): expression is GeoExpression<A>;
+export declare function isDateExpression<A>(expression: any): expression is DateExpression<A>;
+export declare function isLogicExpression<A>(expression: any): expression is LogicExpression<A>;
+export declare function isBoolExpression<A>(expression: any): expression is BoolExpression<A>;
+export declare function isCompareExpression<A>(expression: any): expression is CompareExpression<A>;
+export declare function isMathExpression<A>(expression: any): expression is MathExpression<A>;
+export declare function isExpression<A>(expression: any): expression is Expression<A>;
+export declare function opMultipleParams(op: string): boolean;
+export declare function execOp(op: string, params: any, obscure?: boolean): ExpressionConstant;
+export {};

package/lib/types/Expression.js

@@ -0,0 +1,378 @@
+"use strict";
+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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execOp = exports.opMultipleParams = exports.isExpression = exports.isMathExpression = exports.isCompareExpression = exports.isBoolExpression = exports.isLogicExpression = exports.isDateExpression = exports.isGeoExpression = void 0;
+var assert_1 = __importDefault(require("assert"));
+var dayjs_1 = __importDefault(require("dayjs"));
+var weekOfYear_1 = __importDefault(require("dayjs/plugin/weekOfYear"));
+var dayOfYear_1 = __importDefault(require("dayjs/plugin/dayOfYear"));
+var geo_1 = require("../utils/geo");
+dayjs_1.default.extend(weekOfYear_1.default);
+dayjs_1.default.extend(dayOfYear_1.default);
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+function isGeoExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$contains', '$distance'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isGeoExpression = isGeoExpression;
+function isDateExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$year', '$month', '$weekday', '$weekOfYear', '$day', '$dayOfMonth',
+            '$dayOfWeek', '$dayOfYear', '$dateDiff', '$dateCeil', '$dateFloor'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isDateExpression = isDateExpression;
+function isLogicExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$and', '$or', '$not'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isLogicExpression = isLogicExpression;
+function isBoolExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$true', '$false'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isBoolExpression = isBoolExpression;
+function isCompareExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$gt', '$lt', '$gte', '$lte', '$eq', '$ne',
+            '$startsWith', '$endsWith', '$includes'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isCompareExpression = isCompareExpression;
+function isMathExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$add', '$subtract', '$multiply', '$divide', '$abs', '$pow',
+            '$round', '$floor', '$ceil'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isMathExpression = isMathExpression;
+function isExpression(expression) {
+    return typeof expression === 'object' && Object.keys(expression).length === 1 && Object.keys(expression)[0].startsWith('$');
+}
+exports.isExpression = isExpression;
+function opMultipleParams(op) {
+    return !['$year', '$month', '$weekday', '$weekOfYear', '$day', '$dayOfMonth',
+        '$dayOfWeek', '$dayOfYear', '$not', '$true', '$false', '$abs', '$round', '$floor', '$ceil'].includes(op);
+}
+exports.opMultipleParams = opMultipleParams;
+function execOp(op, params, obscure) {
+    var e_1, _a, e_2, _b;
+    if (obscure && (params === undefined || params.includes(undefined))) {
+        return true;
+    }
+    switch (op) {
+        case '$gt': {
+            return params[0] > params[1];
+        }
+        case '$lt': {
+            return params[0] < params[1];
+        }
+        case '$gte': {
+            return params[0] >= params[1];
+        }
+        case '$lte': {
+            return params[0] <= params[1];
+        }
+        case '$eq': {
+            return params[0] === params[1];
+        }
+        case '$ne': {
+            return params[0] !== params[1];
+        }
+        case '$startsWith': {
+            return params[0].startsWith(params[1]);
+        }
+        case '$endsWith': {
+            return params[0].endsWith(params[1]);
+        }
+        case '$includes': {
+            return params[0].includes(params[1]);
+        }
+        case '$add': {
+            if (typeof params[0] === 'number') {
+                var result_1 = 0;
+                params.forEach(function (ele) { return result_1 += ele; });
+                return result_1;
+            }
+            else {
+                var result_2 = '';
+                params.forEach(function (ele) { return result_2 += ele; });
+                return result_2;
+            }
+        }
+        case '$subtract': {
+            return params[0] - params[1];
+        }
+        case '$multiply': {
+            var result_3 = 1;
+            params.forEach(function (ele) { return result_3 = result_3 * ele; });
+            return result_3;
+        }
+        case '$divide': {
+            return params[0] / params[1];
+        }
+        case '$abs': {
+            return Math.abs(params);
+        }
+        case '$round': {
+            return Math.round(params);
+        }
+        case '$ceil': {
+            return Math.ceil(params);
+        }
+        case '$floor': {
+            return Math.floor(params);
+        }
+        case '$round': {
+            return Math.round(params);
+        }
+        case '$pow': {
+            return Math.pow(params[0], params[1]);
+        }
+        case '$true': {
+            return !!params;
+        }
+        case '$false':
+        case '$not': {
+            return !params;
+        }
+        case '$and': {
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var p = params_1_1.value;
+                    if (!p) {
+                        return false;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return true;
+        }
+        case '$or': {
+            try {
+                for (var params_2 = __values(params), params_2_1 = params_2.next(); !params_2_1.done; params_2_1 = params_2.next()) {
+                    var p = params_2_1.value;
+                    if (!!p) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_2_1 && !params_2_1.done && (_b = params_2.return)) _b.call(params_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return false;
+        }
+        case '$year': {
+            var value = (0, dayjs_1.default)(params);
+            return value.year();
+        }
+        case '$month': {
+            var value = (0, dayjs_1.default)(params);
+            return value.month();
+        }
+        case '$weekday': {
+            var value = (0, dayjs_1.default)(params);
+            return value.day(); // 0~6
+        }
+        case '$weekOfYear': {
+            var value = (0, dayjs_1.default)(params);
+            return value.week();
+        }
+        case '$day':
+        case '$dayOfMonth': {
+            var value = (0, dayjs_1.default)(params);
+            return value.date();
+        }
+        case '$dayOfWeek': {
+            var value = (0, dayjs_1.default)(params);
+            return value.day(); // 0~6
+        }
+        case '$dayOfYear': {
+            var value = (0, dayjs_1.default)(params);
+            return value.dayOfYear(); // 0~6
+        }
+        case '$dateDiff': {
+            var value1 = (0, dayjs_1.default)(params[0]);
+            var value2 = (0, dayjs_1.default)(params[1]);
+            switch (params[2]) {
+                case 'y':
+                case 'M':
+                case 'd':
+                case 'h':
+                case 'm':
+                case 's': {
+                    return value1.diff(value2, params[2]);
+                }
+                default: {
+                    (0, assert_1.default)(false);
+                }
+            }
+        }
+        case '$dateCeil': {
+            var value = (0, dayjs_1.default)(params[0]);
+            switch (params[1]) {
+                case 'y': {
+                    return value.startOf('year').millisecond();
+                }
+                case 'M': {
+                    return value.startOf('month').millisecond();
+                }
+                case 'd': {
+                    return value.startOf('day').millisecond();
+                }
+                case 'h': {
+                    return value.startOf('hour').millisecond();
+                }
+                case 'm': {
+                    return value.startOf('minute').millisecond();
+                }
+                case 's': {
+                    return value.startOf('second').millisecond();
+                }
+                default: {
+                    (0, assert_1.default)(false);
+                }
+            }
+        }
+        case '$dateFloor': {
+            var value = (0, dayjs_1.default)(params[0]);
+            switch (params[1]) {
+                case 'y': {
+                    return value.endOf('year').millisecond();
+                }
+                case 'M': {
+                    return value.endOf('month').millisecond();
+                }
+                case 'd': {
+                    return value.endOf('day').millisecond();
+                }
+                case 'h': {
+                    return value.endOf('hour').millisecond();
+                }
+                case 'm': {
+                    return value.endOf('minute').millisecond();
+                }
+                case 's': {
+                    return value.endOf('second').millisecond();
+                }
+                default: {
+                    (0, assert_1.default)(false);
+                }
+            }
+        }
+        case '$distance': {
+            var _c = __read(params, 2), geo1 = _c[0], geo2 = _c[1];
+            var type1 = geo1.type, coordinate1 = geo1.coordinate;
+            var type2 = geo2.type, coordinate2 = geo2.coordinate;
+            if (type1 !== 'point' || type2 !== 'point') {
+                throw new Error('目前只支持point类型的距离运算');
+            }
+            return (0, geo_1.getDistanceBetweenPoints)(coordinate1[1], coordinate1[0], coordinate2[1], coordinate2[0]);
+        }
+        case '$contains': {
+            throw new Error('$contains类型未实现');
+        }
+        default: {
+            (0, assert_1.default)(false, "\u4E0D\u80FD\u8BC6\u522B\u7684expression\u8FD0\u7B97\u7B26\uFF1A".concat(op));
+        }
+    }
+}
+exports.execOp = execOp;

package/lib/types/Geo.d.ts

@@ -0,0 +1,18 @@
+export declare type Point = [number, number];
+export declare type Path = Array<Point>;
+export declare type Polygon = Array<Path>;
+export declare type Circle = [Point, number];
+export declare type SingleGeo = {
+    type: 'point';
+    coordinate: Point;
+} | {
+    type: 'path';
+    coordinate: Path;
+} | {
+    type: 'polygon';
+    coordinate: Polygon;
+} | {
+    type: 'circle';
+    coordinate: Circle;
+};
+export declare type Geo = SingleGeo | SingleGeo[];