oak-domain 3.0.3 → 3.0.4

package/lib/types/Expression.d.ts

@@ -1,8 +1,8 @@
 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;
+export type RefOrExpression<A> = RefAttr<A> | Expression<A>;
+type MathType<A> = RefOrExpression<A> | number;
+type StringType<A> = RefOrExpression<A> | string;
 interface Add<A> {
     $add: (MathType<A>)[];
 }
@@ -30,8 +30,8 @@ interface Ceil<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;
+type MathExpression<A> = Add<A> | Subtract<A> | Multiply<A> | Divide<A> | Abs<A> | Round<A> | Floor<A> | Ceil<A> | Pow<A>;
+type CmpType<A> = RefOrExpression<A> | string | number;
 interface Gt<A> {
     $gt: [CmpType<A>, CmpType<A>];
 }
@@ -59,14 +59,14 @@ interface EndsWith<A> {
 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>;
+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>;
+type BoolExpression<A> = BoolTrue<A> | BoolFalse<A>;
 interface LogicAnd<A> {
     $and: Expression<A>[];
 }
@@ -76,7 +76,7 @@ interface LogicOr<A> {
 interface LogicNot<A> {
     $not: Expression<A>;
 }
-declare type LogicExpression<A> = LogicAnd<A> | LogicOr<A> | LogicNot<A>;
+type LogicExpression<A> = LogicAnd<A> | LogicOr<A> | LogicNot<A>;
 interface DateYear<A> {
     $year: RefOrExpression<A> | Date | number;
 }
@@ -110,18 +110,18 @@ interface DateCeiling<A> {
 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>;
+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 StringConcat<A> {
     $concat: StringType<A>[];
 }
-declare type StringExpression<A> = StringConcat<A>;
+type StringExpression<A> = StringConcat<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>;
+type GeoExpression<A> = GeoContains<A> | GeoDistance<A>;
 interface AggrCountExpression<A> {
     $$count: RefOrExpression<A>;
 }
@@ -137,9 +137,9 @@ interface AggrMinExpression<A> {
 interface AggrAvgExpression<A> {
     $$avg: RefOrExpression<A>;
 }
-export declare type AggrExpression<A> = AggrAvgExpression<A> | AggrCountExpression<A> | AggrSumExpression<A> | AggrMaxExpression<A> | AggrMinExpression<A>;
-export declare type Expression<A> = GeoExpression<A> | DateExpression<A> | LogicExpression<A> | BoolExpression<A> | CompareExpression<A> | MathExpression<A> | StringExpression<A> | AggrExpression<A>;
-export declare type ExpressionConstant = Geo | number | Date | string | boolean;
+export type AggrExpression<A> = AggrAvgExpression<A> | AggrCountExpression<A> | AggrSumExpression<A> | AggrMaxExpression<A> | AggrMinExpression<A>;
+export type Expression<A> = GeoExpression<A> | DateExpression<A> | LogicExpression<A> | BoolExpression<A> | CompareExpression<A> | MathExpression<A> | StringExpression<A>;
+export 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>;

package/lib/types/Expression.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAttrRefInExpression = exports.execOp = exports.opMultipleParams = exports.isExpression = exports.isAggrExpression = exports.isStringExpression = exports.isMathExpression = exports.isCompareExpression = exports.isBoolExpression = exports.isLogicExpression = exports.isDateExpression = exports.isGeoExpression = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var dayjs_1 = tslib_1.__importDefault(require("dayjs"));
-var weekOfYear_1 = tslib_1.__importDefault(require("dayjs/plugin/weekOfYear"));
-var dayOfYear_1 = tslib_1.__importDefault(require("dayjs/plugin/dayOfYear"));
-var geo_1 = require("../utils/geo");
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const weekOfYear_1 = tslib_1.__importDefault(require("dayjs/plugin/weekOfYear"));
+const dayOfYear_1 = tslib_1.__importDefault(require("dayjs/plugin/dayOfYear"));
+const geo_1 = require("../utils/geo");
 dayjs_1.default.extend(weekOfYear_1.default);
 dayjs_1.default.extend(dayOfYear_1.default);
 ;
@@ -45,7 +45,7 @@ dayjs_1.default.extend(dayOfYear_1.default);
 ;
 function isGeoExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$contains', '$distance'].includes(op)) {
             return true;
         }
@@ -55,7 +55,7 @@ function isGeoExpression(expression) {
 exports.isGeoExpression = isGeoExpression;
 function isDateExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$year', '$month', '$weekday', '$weekOfYear', '$day', '$dayOfMonth',
             '$dayOfWeek', '$dayOfYear', '$dateDiff', '$dateCeil', '$dateFloor'].includes(op)) {
             return true;
@@ -66,7 +66,7 @@ function isDateExpression(expression) {
 exports.isDateExpression = isDateExpression;
 function isLogicExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$and', '$or', '$not'].includes(op)) {
             return true;
         }
@@ -76,7 +76,7 @@ function isLogicExpression(expression) {
 exports.isLogicExpression = isLogicExpression;
 function isBoolExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$true', '$false'].includes(op)) {
             return true;
         }
@@ -86,7 +86,7 @@ function isBoolExpression(expression) {
 exports.isBoolExpression = isBoolExpression;
 function isCompareExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$gt', '$lt', '$gte', '$lte', '$eq', '$ne',
             '$startsWith', '$endsWith', '$includes'].includes(op)) {
             return true;
@@ -97,7 +97,7 @@ function isCompareExpression(expression) {
 exports.isCompareExpression = isCompareExpression;
 function isMathExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$add', '$subtract', '$multiply', '$divide', '$abs', '$pow',
             '$round', '$floor', '$ceil'].includes(op)) {
             return true;
@@ -108,7 +108,7 @@ function isMathExpression(expression) {
 exports.isMathExpression = isMathExpression;
 function isStringExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$concat'].includes(op)) {
             return true;
         }
@@ -118,7 +118,7 @@ function isStringExpression(expression) {
 exports.isStringExpression = isStringExpression;
 function isAggrExpression(expression) {
     if (Object.keys(expression).length == 1) {
-        var op = Object.keys(expression)[0];
+        const op = Object.keys(expression)[0];
         if (['$$max', '$$min', '$$sum', '$$avg', '$$count'].includes(op)) {
             return true;
         }
@@ -137,7 +137,6 @@ function opMultipleParams(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;
     }
@@ -171,23 +170,23 @@ function execOp(op, params, obscure) {
         }
         case '$add': {
             if (typeof params[0] === 'number') {
-                var result_1 = 0;
-                params.forEach(function (ele) { return result_1 += ele; });
-                return result_1;
+                let result = 0;
+                params.forEach((ele) => result += ele);
+                return result;
             }
             else {
-                var result_2 = '';
-                params.forEach(function (ele) { return result_2 += ele; });
-                return result_2;
+                let result = '';
+                params.forEach((ele) => result += ele);
+                return result;
             }
         }
         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;
+            let result = 1;
+            params.forEach((ele) => result = result * ele);
+            return result;
         }
         case '$divide': {
             return params[0] / params[1];
@@ -218,73 +217,53 @@ function execOp(op, params, obscure) {
             return !params;
         }
         case '$and': {
-            try {
-                for (var params_1 = tslib_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;
-                    }
+            for (const p of params) {
+                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 = tslib_1.__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);
+            for (const p of params) {
+                if (!!p) {
+                    return true;
                 }
-                finally { if (e_2) throw e_2.error; }
             }
             return false;
         }
         case '$year': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.year();
         }
         case '$month': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.month();
         }
         case '$weekday': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.day(); // 0~6
         }
         case '$weekOfYear': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.week();
         }
         case '$day':
         case '$dayOfMonth': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.date();
         }
         case '$dayOfWeek': {
-            var value = (0, dayjs_1.default)(params);
+            const value = (0, dayjs_1.default)(params);
             return value.day(); // 0~6
         }
         case '$dayOfYear': {
-            var value = (0, dayjs_1.default)(params);
+            const 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]);
+            const value1 = (0, dayjs_1.default)(params[0]);
+            const value2 = (0, dayjs_1.default)(params[1]);
             switch (params[2]) {
                 case 'y':
                 case 'M':
@@ -300,7 +279,7 @@ function execOp(op, params, obscure) {
             }
         }
         case '$dateCeil': {
-            var value = (0, dayjs_1.default)(params[0]);
+            const value = (0, dayjs_1.default)(params[0]);
             switch (params[1]) {
                 case 'y': {
                     return value.startOf('year').millisecond();
@@ -326,7 +305,7 @@ function execOp(op, params, obscure) {
             }
         }
         case '$dateFloor': {
-            var value = (0, dayjs_1.default)(params[0]);
+            const value = (0, dayjs_1.default)(params[0]);
             switch (params[1]) {
                 case 'y': {
                     return value.endOf('year').millisecond();
@@ -352,9 +331,9 @@ function execOp(op, params, obscure) {
             }
         }
         case '$distance': {
-            var _c = tslib_1.__read(params, 2), geo1 = _c[0], geo2 = _c[1];
-            var type1 = geo1.type, coordinate1 = geo1.coordinate;
-            var type2 = geo2.type, coordinate2 = geo2.coordinate;
+            const [geo1, geo2] = params;
+            const { type: type1, coordinate: coordinate1 } = geo1;
+            const { type: type2, coordinate: coordinate2 } = geo2;
             if (type1 !== 'point' || type2 !== 'point') {
                 throw new Error('目前只支持point类型的距离运算');
             }
@@ -367,7 +346,7 @@ function execOp(op, params, obscure) {
             return params.join('');
         }
         default: {
-            (0, assert_1.default)(false, "\u4E0D\u80FD\u8BC6\u522B\u7684expression\u8FD0\u7B97\u7B26\uFF1A".concat(op));
+            (0, assert_1.default)(false, `不能识别的expression运算符：${op}`);
         }
     }
 }
@@ -381,12 +360,10 @@ exports.execOp = execOp;
  * }
  */
 function getAttrRefInExpression(expression) {
-    var _a;
-    var result = (_a = {},
-        _a['#current'] = [],
-        _a);
-    var check = function (node) {
-        var _a, e_3, _b;
+    const result = {
+        ['#current']: [],
+    };
+    const check = (node) => {
         if (node['#attr']) {
             result['#current'].push(node['#attr']);
         }
@@ -395,28 +372,18 @@ function getAttrRefInExpression(expression) {
                 result[node['#refId']].push(node['#refAttr']);
             }
             else {
-                Object.assign(result, (_a = {},
-                    _a[node['#refId']] = [node['#refAttr']],
-                    _a));
+                Object.assign(result, {
+                    [node['#refId']]: [node['#refAttr']],
+                });
             }
         }
         else if (node instanceof Array) {
-            try {
-                for (var node_1 = tslib_1.__values(node), node_1_1 = node_1.next(); !node_1_1.done; node_1_1 = node_1.next()) {
-                    var subNode = node_1_1.value;
-                    check(subNode);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (node_1_1 && !node_1_1.done && (_b = node_1.return)) _b.call(node_1);
-                }
-                finally { if (e_3) throw e_3.error; }
+            for (const subNode of node) {
+                check(subNode);
             }
         }
         else if (typeof node === 'object') {
-            for (var attr in node) {
+            for (const attr in node) {
                 check(node[attr]);
             }
         }

package/lib/types/Geo.d.ts

@@ -1,8 +1,8 @@
-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 = {
+export type Point = [number, number];
+export type Path = Array<Point>;
+export type Polygon = Array<Path>;
+export type Circle = [Point, number];
+export type SingleGeo = {
     type: 'point';
     coordinate: Point;
 } | {
@@ -15,4 +15,4 @@ export declare type SingleGeo = {
     type: 'circle';
     coordinate: Circle;
 };
-export declare type Geo = SingleGeo | SingleGeo[];
+export type Geo = SingleGeo | SingleGeo[];

package/lib/types/Locale.d.ts

@@ -1,17 +1,17 @@
 import { EntityShape } from "./Entity";
-declare type Language = 'zh_CN' | 'en_US';
-declare type LocaleOfSchema<S extends Record<string, any>> = {
+type Language = 'zh_CN' | 'en_US';
+type LocaleOfSchema<S extends Record<string, any>> = {
     [A in keyof Required<Omit<S, keyof EntityShape>>]: string;
 };
-declare type LocaleOfStringEnum<A extends string> = {
+type LocaleOfStringEnum<A extends string> = {
     [K in A]: string;
 };
-declare type LocaleOfValue<V extends Record<string, string>> = {
+type LocaleOfValue<V extends Record<string, string>> = {
     [K in keyof V]: {
         [K2 in V[K]]: string;
     };
 };
-export declare type LocaleDef<Sc extends Record<string, any>, Ac extends string, R extends string, V extends Record<string, string>> = {
+export type LocaleDef<Sc extends Record<string, any>, Ac extends string, R extends string, V extends Record<string, string>> = {
     [L in Language]?: {
         name: string;
         attr: LocaleOfSchema<Sc> & {

package/lib/types/Polyfill.d.ts

@@ -1,24 +1,24 @@
-export declare type OmitInferKey<T, R> = {
+export type OmitInferKey<T, R> = {
     [K in keyof T as T extends R ? never : K]: T[K];
 };
-export declare type OmitInferValue<T, R> = {
+export type OmitInferValue<T, R> = {
     [K in keyof T as T extends R ? never : K]: T[K];
 };
-export declare type ValueOf<Obj> = Obj[keyof Obj];
-export declare type OneOnly<Obj, Key extends keyof Obj> = {
+export type ValueOf<Obj> = Obj[keyof Obj];
+export type OneOnly<Obj, Key extends keyof Obj> = {
     [key in Exclude<keyof Obj, Key>]?: undefined;
 } & Pick<Obj, Key>;
-export declare type OneOfByKey<Obj> = {
+export type OneOfByKey<Obj> = {
     [key in keyof Obj]: OneOnly<Obj, key>;
 };
-export declare type OneOf<Obj> = ValueOf<OneOfByKey<Obj>>;
-declare type IsOptional<T, K extends keyof T> = {
+export type OneOf<Obj> = ValueOf<OneOfByKey<Obj>>;
+type IsOptional<T, K extends keyof T> = {
     [K1 in Exclude<keyof T, K>]: T[K1];
 } & {
     K?: T[K];
 } extends T ? K : never;
-export declare type OptionalKeys<T> = {
+export type OptionalKeys<T> = {
     [K in keyof T]: IsOptional<T, K>;
 }[keyof T];
-export declare type SyncOrAsync<T> = T | Promise<T>;
+export type SyncOrAsync<T> = T | Promise<T>;
 export {};

package/lib/types/Port.d.ts

@@ -1,18 +1,18 @@
 import { AsyncContext } from "../store/AsyncRowStore";
 import { EntityDict } from "./Entity";
-export declare type Exportation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+export type Exportation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
     name: string;
     id: string;
     entity: T;
     projection: ED[T]['Selection']['data'];
     headers?: K[];
     makeHeaders?: (dataList: Partial<ED[T]['Schema']>[]) => string[];
-    fn: (data: ED[T]['Schema'], context?: AsyncContext<ED>, properties?: Record<string, any>) => Promise<Partial<Record<string, string | number | boolean | null>>> | Partial<Record<string, string | number | boolean | null>>;
+    fn: (data: ED[T]['Schema'], context?: Cxt, properties?: Record<string, any>) => Promise<Partial<Record<string, string | number | boolean | null>>> | Partial<Record<string, string | number | boolean | null>>;
 };
-export declare type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+export type Importation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
     name: string;
     id: string;
     entity: T;
     headers: K[];
-    fn: (data: Partial<Record<K, string | number | boolean>>[], context: AsyncContext<ED>, option?: Record<string, any>) => Promise<ED[T]['CreateMulti']['data']>;
+    fn: (data: Partial<Record<K, string | number | boolean>>[], context: Cxt, option?: Record<string, any>) => Promise<ED[T]['CreateMulti']['data']>;
 };

package/lib/types/RowStore.d.ts

@@ -2,11 +2,11 @@ import { OperationResult, EntityDict } from './Entity';
 import { StorageSchema } from './Storage';
 import { AsyncContext } from '../store/AsyncRowStore';
 import { SyncContext } from '../store/SyncRowStore';
-export declare type TxnOption = {
+export type TxnOption = {
     isolationLevel: 'repeatable read' | 'serializable';
 };
-export declare type SelectionRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'], context: Cxt) => void | Promise<void>;
-export declare type OperationRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt) => void | Promise<void>;
+export type SelectionRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'], context: Cxt) => void | Promise<void>;
+export type OperationRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt) => void | Promise<void>;
 export declare abstract class RowStore<ED extends EntityDict> {
     protected storageSchema: StorageSchema<ED>;
     constructor(storageSchema: StorageSchema<ED>);

package/lib/types/RowStore.js

@@ -1,34 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowStore = void 0;
-var lodash_1 = require("../utils/lodash");
-var RowStore = /** @class */ (function () {
-    function RowStore(storageSchema) {
+const lodash_1 = require("../utils/lodash");
+class RowStore {
+    storageSchema;
+    constructor(storageSchema) {
         this.storageSchema = storageSchema;
     }
-    RowStore.prototype.getSchema = function () {
+    getSchema() {
         return this.storageSchema;
-    };
-    RowStore.prototype.mergeOperationResult = function (result, toBeMerged) {
-        for (var entity in toBeMerged) {
-            for (var action in toBeMerged[entity]) {
-                var value = (0, lodash_1.get)(result, "".concat(entity, ".").concat(action));
+    }
+    mergeOperationResult(result, toBeMerged) {
+        for (const entity in toBeMerged) {
+            for (const action in toBeMerged[entity]) {
+                const value = (0, lodash_1.get)(result, `${entity}.${action}`);
                 if (typeof value === 'number') {
-                    (0, lodash_1.set)(result, "".concat(entity, ".").concat(action), value + toBeMerged[entity][action]);
+                    (0, lodash_1.set)(result, `${entity}.${action}`, value + toBeMerged[entity][action]);
                 }
                 else {
-                    (0, lodash_1.set)(result, "".concat(entity, ".").concat(action), toBeMerged[entity][action]);
+                    (0, lodash_1.set)(result, `${entity}.${action}`, toBeMerged[entity][action]);
                 }
             }
         }
-    };
-    RowStore.prototype.mergeMultipleResults = function (toBeMerged) {
-        var _this = this;
-        var result = {};
-        toBeMerged.forEach(function (ele) { return _this.mergeOperationResult(result, ele); });
+    }
+    mergeMultipleResults(toBeMerged) {
+        const result = {};
+        toBeMerged.forEach(ele => this.mergeOperationResult(result, ele));
         return result;
-    };
-    return RowStore;
-}());
+    }
+}
 exports.RowStore = RowStore;
 ;

package/lib/types/Storage.d.ts

@@ -1,7 +1,7 @@
 import { ActionType } from '.';
 import { EntityDict, EntityShape, InstinctiveAttributes } from './Entity';
 import { DataType, DataTypeParams } from './schema/DataTypes';
-export declare type Ref = 'ref';
+export type Ref = 'ref';
 export interface Column<SH extends EntityShape> {
     name: keyof SH | `${string}State`;
     size?: number;
@@ -28,12 +28,12 @@ export interface Attribute {
     sequenceStart?: number;
     enumeration?: string[];
 }
-export declare type Attributes<SH extends EntityShape> = Omit<{
+export type Attributes<SH extends EntityShape> = Omit<{
     [attrName in keyof SH]: Attribute;
 }, InstinctiveAttributes>;
 export interface EntityConfig {
 }
-export declare type UniqConstraint<SH extends EntityShape> = {
+export type UniqConstraint<SH extends EntityShape> = {
     attributes: Array<keyof SH>;
     type?: string;
 };
@@ -51,7 +51,8 @@ export interface StorageDesc<SH extends EntityShape> {
     actionType: ActionType;
     relation?: string[];
     view?: true;
+    recursiveDepth?: number;
 }
-export declare type StorageSchema<ED extends EntityDict> = {
+export type StorageSchema<ED extends EntityDict> = {
     [K in keyof ED]: StorageDesc<ED[K]['OpSchema']>;
 };

package/lib/types/Style.d.ts

@@ -1,7 +1,7 @@
 import { EntityDict } from './Entity';
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
-declare type ThemeColor = 'default' | 'success' | 'warning' | 'error' | 'primary' | 'danger';
-export declare type ColorDict<ED extends BaseEntityDict & EntityDict> = {
+type ThemeColor = 'default' | 'success' | 'warning' | 'error' | 'primary' | 'danger';
+export type ColorDict<ED extends BaseEntityDict & EntityDict> = {
     [T in keyof ED]?: {
         [A in keyof ED[T]['OpSchema']]?: {
             [E in ED[T]['OpSchema'][A]]?: ThemeColor | `#${string}`;

package/lib/types/Timer.d.ts

@@ -1,12 +1,12 @@
 import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
 import { EntityDict } from './Entity';
 import { AsyncContext } from '../store/AsyncRowStore';
-declare type RoutineFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<string>;
-export declare type Routine<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+type RoutineFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<string>;
+export type Routine<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
     fn: RoutineFn<ED, Cxt>;
 };
-export declare type Timer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+export type Timer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
     cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
     fn: RoutineFn<ED, Cxt>;