oak-domain 4.0.1 → 4.0.3

package/lib/store/actionAuth.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict } from '../types/Entity';
-import { Trigger } from '../types';
-import { AsyncContext } from './AsyncRowStore';
-export declare const triggers: Trigger<EntityDict, 'actionAuth', AsyncContext<EntityDict>>[];
+import { EntityDict } from '../types/Entity';
+import { Trigger } from '../types';
+import { AsyncContext } from './AsyncRowStore';
+export declare const triggers: Trigger<EntityDict, 'actionAuth', AsyncContext<EntityDict>>[];

package/lib/store/actionAuth.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.triggers = void 0;
-const uuid_1 = require("../utils/uuid");
-exports.triggers = [
-    {
-        name: '当actionAuth的deActions被置空后，删除此条数据',
-        entity: 'actionAuth',
-        action: 'update',
-        fn: async ({ operation }, context, option) => {
-            const { data, filter } = operation;
-            if (data.deActions && data.deActions.length === 0) {
-                await context.operate('actionAuth', {
-                    id: await (0, uuid_1.generateNewIdAsync)(),
-                    action: 'remove',
-                    data: {},
-                    filter,
-                }, option);
-                return 1;
-            }
-            return 0;
-        },
-        when: 'after',
-    }
-];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggers = void 0;
+const uuid_1 = require("../utils/uuid");
+exports.triggers = [
+    {
+        name: '当actionAuth的deActions被置空后，删除此条数据',
+        entity: 'actionAuth',
+        action: 'update',
+        fn: async ({ operation }, context, option) => {
+            const { data, filter } = operation;
+            if (data.deActions && data.deActions.length === 0) {
+                await context.operate('actionAuth', {
+                    id: await (0, uuid_1.generateNewIdAsync)(),
+                    action: 'remove',
+                    data: {},
+                    filter,
+                }, option);
+                return 1;
+            }
+            return 0;
+        },
+        when: 'after',
+    }
+];

package/lib/store/actionDef.d.ts

@@ -1,10 +1,10 @@
-import { ActionDictOfEntityDict, BBWatcher, Checker, EntityDict, StorageSchema, Trigger } from "../types";
-import { SyncContext } from "./SyncRowStore";
-import { AsyncContext } from "./AsyncRowStore";
-import { EntityDict as BaseEntityDict } from '../base-app-domain/EntityDict';
-export declare function getFullProjection<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>): ED[T]["Selection"]["data"];
-export declare function makeIntrinsicCTWs<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>>(schema: StorageSchema<ED>, actionDefDict: ActionDictOfEntityDict<ED>): {
-    triggers: Trigger<ED, keyof ED, Cxt>[];
-    checkers: Checker<ED, keyof ED, Cxt | FrontCxt>[];
-    watchers: BBWatcher<ED, keyof ED>[];
-};
+import { ActionDictOfEntityDict, BBWatcher, Checker, EntityDict, StorageSchema, Trigger } from "../types";
+import { SyncContext } from "./SyncRowStore";
+import { AsyncContext } from "./AsyncRowStore";
+import { EntityDict as BaseEntityDict } from '../base-app-domain/EntityDict';
+export declare function getFullProjection<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>): ED[T]["Selection"]["data"];
+export declare function makeIntrinsicCTWs<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>>(schema: StorageSchema<ED>, actionDefDict: ActionDictOfEntityDict<ED>): {
+    triggers: Trigger<ED, keyof ED, Cxt>[];
+    checkers: Checker<ED, keyof ED, Cxt | FrontCxt>[];
+    watchers: BBWatcher<ED, keyof ED>[];
+};

package/lib/store/actionDef.js

@@ -1,278 +1,278 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeIntrinsicCTWs = exports.getFullProjection = void 0;
-const types_1 = require("../types");
-const lodash_1 = require("../utils/lodash");
-const filter_1 = require("./filter");
-const checkers_1 = require("../checkers");
-const triggers_1 = require("../triggers");
-const actionAuth_1 = require("./actionAuth");
-function getFullProjection(entity, schema) {
-    const { attributes } = schema[entity];
-    const projection = {
-        id: 1,
-        $$createAt$$: 1,
-        $$updateAt$$: 1,
-        $$deleteAt$$: 1,
-    };
-    Object.keys(attributes).forEach((k) => Object.assign(projection, {
-        [k]: 1,
-    }));
-    return projection;
-}
-exports.getFullProjection = getFullProjection;
-function makeIntrinsicWatchers(schema) {
-    const watchers = [];
-    for (const entity in schema) {
-        const { attributes } = schema[entity];
-        const { expiresAt, expired } = attributes;
-        if (expiresAt && expiresAt.type === 'datetime' && expired && expired.type === 'boolean') {
-            // 如果有定义expiresAt和expired，则自动生成一个检查的watcher
-            watchers.push({
-                entity,
-                name: `对象${entity}上的过期自动watcher`,
-                filter: () => {
-                    return {
-                        expired: false,
-                        expiresAt: {
-                            $lte: Date.now(),
-                        },
-                    };
-                },
-                action: 'update',
-                actionData: {
-                    expired: true,
-                },
-            });
-        }
-    }
-    return watchers;
-}
-function checkUniqueBetweenRows(rows, uniqAttrs) {
-    // 先检查这些行本身之间有无unique冲突
-    const dict = {};
-    for (const row of rows) {
-        let s = '';
-        for (const a of uniqAttrs) {
-            if (row[a] === null || row[a] === undefined) {
-                s + row.id;
-            }
-            else {
-                s + `-${row[a]}`;
-            }
-        }
-        if (dict[s]) {
-            throw new types_1.OakUniqueViolationException([{
-                    id: row.id,
-                    attrs: uniqAttrs,
-                }]);
-        }
-        else {
-            dict[s] = 1;
-        }
-    }
-}
-function checkCountLessThan(count, uniqAttrs, than = 0, id) {
-    if (count instanceof Promise) {
-        return count.then((count2) => {
-            if (count2 > than) {
-                throw new types_1.OakUniqueViolationException([{
-                        id,
-                        attrs: uniqAttrs,
-                    }]);
-            }
-        });
-    }
-    if (count > than) {
-        throw new types_1.OakUniqueViolationException([{
-                id,
-                attrs: uniqAttrs,
-            }]);
-    }
-}
-function checkUnique(entity, row, context, uniqAttrs, extraFilter) {
-    const filter = (0, lodash_1.pick)(row, uniqAttrs);
-    for (const a in filter) {
-        if (filter[a] === null || filter[a] === undefined) {
-            delete filter[a];
-        }
-    }
-    if (Object.keys(filter).length < uniqAttrs.length) {
-        // 说明有null值，不需要检查约束
-        return;
-    }
-    const filter2 = extraFilter ? (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, extraFilter]) : filter;
-    const count = context.count(entity, { filter: filter2 }, { dontCollect: true });
-    return checkCountLessThan(count, uniqAttrs, 0, row.id);
-}
-function makeIntrinsicCTWs(schema, actionDefDict) {
-    const checkers = (0, checkers_1.createDynamicCheckers)(schema);
-    const triggers = (0, triggers_1.createDynamicTriggers)(schema);
-    // action状态转换矩阵相应的checker
-    for (const entity in actionDefDict) {
-        for (const attr in actionDefDict[entity]) {
-            const def = actionDefDict[entity][attr];
-            const { stm, is } = def;
-            for (const action in stm) {
-                const actionStm = stm[action];
-                const conditionalFilter = typeof actionStm[0] === 'string' ? {
-                    [attr]: actionStm[0],
-                } : {
-                    [attr]: {
-                        $in: actionStm[0],
-                    },
-                };
-                checkers.push({
-                    action: action,
-                    type: 'row',
-                    entity,
-                    filter: conditionalFilter,
-                    errMsg: '',
-                });
-                // 这里用data类型的checker改数据了不太好，先这样
-                checkers.push({
-                    action: action,
-                    type: 'data',
-                    entity,
-                    checker: (data) => {
-                        Object.assign(data, {
-                            [attr]: stm[action][1],
-                        });
-                    }
-                });
-            }
-            if (is) {
-                checkers.push({
-                    action: 'create',
-                    type: 'data',
-                    entity,
-                    priority: 10,
-                    checker: (data) => {
-                        if (data instanceof Array) {
-                            data.forEach(ele => {
-                                if (!ele[attr]) {
-                                    Object.assign(ele, {
-                                        [attr]: is,
-                                    });
-                                }
-                            });
-                        }
-                        else {
-                            if (!data[attr]) {
-                                Object.assign(data, {
-                                    [attr]: is,
-                                });
-                            }
-                        }
-                    }
-                });
-            }
-        }
-    }
-    // unique索引相应的checker
-    for (const entity in schema) {
-        const { indexes } = schema[entity];
-        if (indexes) {
-            for (const index of indexes) {
-                if (index.config?.unique) {
-                    const { attributes } = index;
-                    const uniqAttrs = attributes.map(ele => ele.name);
-                    checkers.push({
-                        entity,
-                        action: 'create',
-                        type: 'logicalData',
-                        priority: types_1.CHECKER_MAX_PRIORITY,
-                        checker: (operation, context) => {
-                            const { data } = operation;
-                            if (data instanceof Array) {
-                                checkUniqueBetweenRows(data, uniqAttrs);
-                                const checkResult = data.map(ele => checkUnique(entity, ele, context, uniqAttrs));
-                                if (checkResult[0] instanceof Promise) {
-                                    return Promise.all(checkResult).then(() => undefined);
-                                }
-                            }
-                            else if (data) {
-                                return checkUnique(entity, data, context, uniqAttrs);
-                            }
-                        }
-                    }, {
-                        entity,
-                        action: 'update',
-                        type: 'logicalData',
-                        priority: types_1.CHECKER_MAX_PRIORITY,
-                        checker: (operation, context) => {
-                            const { data, filter: operationFilter } = operation;
-                            if (data) {
-                                const attrs = Object.keys(data);
-                                const refAttrs = (0, lodash_1.intersection)(attrs, uniqAttrs);
-                                if (refAttrs.length === 0) {
-                                    // 如果本次更新和unique约束的属性之间没有交集则直接返回
-                                    return;
-                                }
-                                for (const attr of refAttrs) {
-                                    // 如果有更新为null值，不用再检查约束
-                                    if (data[attr] === null || data[attr] === undefined) {
-                                        return;
-                                    }
-                                }
-                                if (refAttrs.length === uniqAttrs.length) {
-                                    // 如果更新了全部属性，直接检查
-                                    const filter = (0, lodash_1.pick)(data, refAttrs);
-                                    // 在这些行以外的行不和更新后的键值冲突
-                                    const count = context.count(entity, {
-                                        filter: (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, {
-                                                $not: operationFilter,
-                                            }]),
-                                    }, { dontCollect: true });
-                                    const checkCount = checkCountLessThan(count, uniqAttrs, 0, operationFilter?.id);
-                                    // 更新的行只能有一行
-                                    const rowCount = context.count(entity, {
-                                        filter: operationFilter,
-                                    }, { dontCollect: true });
-                                    const checkRowCount = checkCountLessThan(rowCount, uniqAttrs, 1, operationFilter?.id);
-                                    // 如果更新的行数为零似乎也可以，但这应该不可能出现吧，by Xc 20230131
-                                    if (checkRowCount instanceof Promise) {
-                                        return Promise.all([checkCount, checkRowCount]).then(() => undefined);
-                                    }
-                                }
-                                // 否则需要结合本行现有的属性来进行检查
-                                const projection = { id: 1 };
-                                for (const attr of uniqAttrs) {
-                                    Object.assign(projection, {
-                                        [attr]: 1,
-                                    });
-                                }
-                                const checkWithRows = (rows2) => {
-                                    const rows22 = rows2.map(ele => Object.assign(ele, data));
-                                    // 先检查这些行本身之间是否冲突
-                                    checkUniqueBetweenRows(rows22, uniqAttrs);
-                                    const checkResults = rows22.map((row) => checkUnique(entity, row, context, uniqAttrs, {
-                                        $not: operationFilter
-                                    }));
-                                    if (checkResults[0] instanceof Promise) {
-                                        return Promise.all(checkResults).then(() => undefined);
-                                    }
-                                };
-                                const currentRows = context.select(entity, {
-                                    data: projection,
-                                    filter: operationFilter,
-                                }, { dontCollect: true });
-                                if (currentRows instanceof Promise) {
-                                    return currentRows.then((row2) => checkWithRows(row2));
-                                }
-                                return checkWithRows(currentRows);
-                            }
-                        }
-                    });
-                }
-            }
-        }
-    }
-    triggers.push(...actionAuth_1.triggers);
-    return {
-        triggers,
-        checkers,
-        watchers: makeIntrinsicWatchers(schema),
-    };
-}
-exports.makeIntrinsicCTWs = makeIntrinsicCTWs;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIntrinsicCTWs = exports.getFullProjection = void 0;
+const types_1 = require("../types");
+const lodash_1 = require("../utils/lodash");
+const filter_1 = require("./filter");
+const checkers_1 = require("../checkers");
+const triggers_1 = require("../triggers");
+const actionAuth_1 = require("./actionAuth");
+function getFullProjection(entity, schema) {
+    const { attributes } = schema[entity];
+    const projection = {
+        id: 1,
+        $$createAt$$: 1,
+        $$updateAt$$: 1,
+        $$deleteAt$$: 1,
+    };
+    Object.keys(attributes).forEach((k) => Object.assign(projection, {
+        [k]: 1,
+    }));
+    return projection;
+}
+exports.getFullProjection = getFullProjection;
+function makeIntrinsicWatchers(schema) {
+    const watchers = [];
+    for (const entity in schema) {
+        const { attributes } = schema[entity];
+        const { expiresAt, expired } = attributes;
+        if (expiresAt && expiresAt.type === 'datetime' && expired && expired.type === 'boolean') {
+            // 如果有定义expiresAt和expired，则自动生成一个检查的watcher
+            watchers.push({
+                entity,
+                name: `对象${entity}上的过期自动watcher`,
+                filter: () => {
+                    return {
+                        expired: false,
+                        expiresAt: {
+                            $lte: Date.now(),
+                        },
+                    };
+                },
+                action: 'update',
+                actionData: {
+                    expired: true,
+                },
+            });
+        }
+    }
+    return watchers;
+}
+function checkUniqueBetweenRows(rows, uniqAttrs) {
+    // 先检查这些行本身之间有无unique冲突
+    const dict = {};
+    for (const row of rows) {
+        let s = '';
+        for (const a of uniqAttrs) {
+            if (row[a] === null || row[a] === undefined) {
+                s + row.id;
+            }
+            else {
+                s + `-${row[a]}`;
+            }
+        }
+        if (dict[s]) {
+            throw new types_1.OakUniqueViolationException([{
+                    id: row.id,
+                    attrs: uniqAttrs,
+                }]);
+        }
+        else {
+            dict[s] = 1;
+        }
+    }
+}
+function checkCountLessThan(count, uniqAttrs, than = 0, id) {
+    if (count instanceof Promise) {
+        return count.then((count2) => {
+            if (count2 > than) {
+                throw new types_1.OakUniqueViolationException([{
+                        id,
+                        attrs: uniqAttrs,
+                    }]);
+            }
+        });
+    }
+    if (count > than) {
+        throw new types_1.OakUniqueViolationException([{
+                id,
+                attrs: uniqAttrs,
+            }]);
+    }
+}
+function checkUnique(entity, row, context, uniqAttrs, extraFilter) {
+    const filter = (0, lodash_1.pick)(row, uniqAttrs);
+    for (const a in filter) {
+        if (filter[a] === null || filter[a] === undefined) {
+            delete filter[a];
+        }
+    }
+    if (Object.keys(filter).length < uniqAttrs.length) {
+        // 说明有null值，不需要检查约束
+        return;
+    }
+    const filter2 = extraFilter ? (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, extraFilter]) : filter;
+    const count = context.count(entity, { filter: filter2 }, { dontCollect: true });
+    return checkCountLessThan(count, uniqAttrs, 0, row.id);
+}
+function makeIntrinsicCTWs(schema, actionDefDict) {
+    const checkers = (0, checkers_1.createDynamicCheckers)(schema);
+    const triggers = (0, triggers_1.createDynamicTriggers)(schema);
+    // action状态转换矩阵相应的checker
+    for (const entity in actionDefDict) {
+        for (const attr in actionDefDict[entity]) {
+            const def = actionDefDict[entity][attr];
+            const { stm, is } = def;
+            for (const action in stm) {
+                const actionStm = stm[action];
+                const conditionalFilter = typeof actionStm[0] === 'string' ? {
+                    [attr]: actionStm[0],
+                } : {
+                    [attr]: {
+                        $in: actionStm[0],
+                    },
+                };
+                checkers.push({
+                    action: action,
+                    type: 'row',
+                    entity,
+                    filter: conditionalFilter,
+                    errMsg: '',
+                });
+                // 这里用data类型的checker改数据了不太好，先这样
+                checkers.push({
+                    action: action,
+                    type: 'data',
+                    entity,
+                    checker: (data) => {
+                        Object.assign(data, {
+                            [attr]: stm[action][1],
+                        });
+                    }
+                });
+            }
+            if (is) {
+                checkers.push({
+                    action: 'create',
+                    type: 'data',
+                    entity,
+                    priority: 10, // 优先级要高，先于真正的data检查进行
+                    checker: (data) => {
+                        if (data instanceof Array) {
+                            data.forEach(ele => {
+                                if (!ele[attr]) {
+                                    Object.assign(ele, {
+                                        [attr]: is,
+                                    });
+                                }
+                            });
+                        }
+                        else {
+                            if (!data[attr]) {
+                                Object.assign(data, {
+                                    [attr]: is,
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+        }
+    }
+    // unique索引相应的checker
+    for (const entity in schema) {
+        const { indexes } = schema[entity];
+        if (indexes) {
+            for (const index of indexes) {
+                if (index.config?.unique) {
+                    const { attributes } = index;
+                    const uniqAttrs = attributes.map(ele => ele.name);
+                    checkers.push({
+                        entity,
+                        action: 'create',
+                        type: 'logicalData',
+                        priority: types_1.CHECKER_MAX_PRIORITY, // 优先级要放在最低，所有前置的checker/trigger将数据完整之后再在这里检测
+                        checker: (operation, context) => {
+                            const { data } = operation;
+                            if (data instanceof Array) {
+                                checkUniqueBetweenRows(data, uniqAttrs);
+                                const checkResult = data.map(ele => checkUnique(entity, ele, context, uniqAttrs));
+                                if (checkResult[0] instanceof Promise) {
+                                    return Promise.all(checkResult).then(() => undefined);
+                                }
+                            }
+                            else if (data) {
+                                return checkUnique(entity, data, context, uniqAttrs);
+                            }
+                        }
+                    }, {
+                        entity,
+                        action: 'update', // 只检查update，其它状态转换的action应该不会涉及unique约束的属性
+                        type: 'logicalData',
+                        priority: types_1.CHECKER_MAX_PRIORITY, // 优先级要放在最低，所有前置的checker/trigger将数据完整之后再在这里检测
+                        checker: (operation, context) => {
+                            const { data, filter: operationFilter } = operation;
+                            if (data) {
+                                const attrs = Object.keys(data);
+                                const refAttrs = (0, lodash_1.intersection)(attrs, uniqAttrs);
+                                if (refAttrs.length === 0) {
+                                    // 如果本次更新和unique约束的属性之间没有交集则直接返回
+                                    return;
+                                }
+                                for (const attr of refAttrs) {
+                                    // 如果有更新为null值，不用再检查约束
+                                    if (data[attr] === null || data[attr] === undefined) {
+                                        return;
+                                    }
+                                }
+                                if (refAttrs.length === uniqAttrs.length) {
+                                    // 如果更新了全部属性，直接检查
+                                    const filter = (0, lodash_1.pick)(data, refAttrs);
+                                    // 在这些行以外的行不和更新后的键值冲突
+                                    const count = context.count(entity, {
+                                        filter: (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, {
+                                                $not: operationFilter,
+                                            }]),
+                                    }, { dontCollect: true });
+                                    const checkCount = checkCountLessThan(count, uniqAttrs, 0, operationFilter?.id);
+                                    // 更新的行只能有一行
+                                    const rowCount = context.count(entity, {
+                                        filter: operationFilter,
+                                    }, { dontCollect: true });
+                                    const checkRowCount = checkCountLessThan(rowCount, uniqAttrs, 1, operationFilter?.id);
+                                    // 如果更新的行数为零似乎也可以，但这应该不可能出现吧，by Xc 20230131
+                                    if (checkRowCount instanceof Promise) {
+                                        return Promise.all([checkCount, checkRowCount]).then(() => undefined);
+                                    }
+                                }
+                                // 否则需要结合本行现有的属性来进行检查
+                                const projection = { id: 1 };
+                                for (const attr of uniqAttrs) {
+                                    Object.assign(projection, {
+                                        [attr]: 1,
+                                    });
+                                }
+                                const checkWithRows = (rows2) => {
+                                    const rows22 = rows2.map(ele => Object.assign(ele, data));
+                                    // 先检查这些行本身之间是否冲突
+                                    checkUniqueBetweenRows(rows22, uniqAttrs);
+                                    const checkResults = rows22.map((row) => checkUnique(entity, row, context, uniqAttrs, {
+                                        $not: operationFilter
+                                    }));
+                                    if (checkResults[0] instanceof Promise) {
+                                        return Promise.all(checkResults).then(() => undefined);
+                                    }
+                                };
+                                const currentRows = context.select(entity, {
+                                    data: projection,
+                                    filter: operationFilter,
+                                }, { dontCollect: true });
+                                if (currentRows instanceof Promise) {
+                                    return currentRows.then((row2) => checkWithRows(row2));
+                                }
+                                return checkWithRows(currentRows);
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    }
+    triggers.push(...actionAuth_1.triggers);
+    return {
+        triggers,
+        checkers,
+        watchers: makeIntrinsicWatchers(schema),
+    };
+}
+exports.makeIntrinsicCTWs = makeIntrinsicCTWs;