oak-domain 4.0.1 → 4.0.2

package/lib/store/modi.d.ts

@@ -1,13 +1,13 @@
-import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { OpSchema as Modi } from '../base-app-domain/Modi/Schema';
-import { Operation, StorageSchema, RowChecker, EntityDict, OperateOption, Trigger } from '../types';
-import { AsyncContext } from './AsyncRowStore';
-import { SyncContext } from './SyncRowStore';
-export declare function createOperationsFromModies(modies: Modi[]): Array<{
-    operation: Operation<string, Object, Object>;
-    entity: string;
-}>;
-export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): RowChecker<ED, keyof ED, Cxt>[];
-export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { OpSchema as Modi } from '../base-app-domain/Modi/Schema';
+import { Operation, StorageSchema, RowChecker, EntityDict, OperateOption, Trigger } from '../types';
+import { AsyncContext } from './AsyncRowStore';
+import { SyncContext } from './SyncRowStore';
+export declare function createOperationsFromModies(modies: Modi[]): Array<{
+    operation: Operation<string, Object, Object>;
+    entity: string;
+}>;
+export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): RowChecker<ED, keyof ED, Cxt>[];
+export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];

package/lib/store/modi.js

@@ -1,254 +1,254 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModiRelatedTriggers = exports.createModiRelatedCheckers = exports.abandonModis = exports.applyModis = exports.createOperationsFromModies = void 0;
-const tslib_1 = require("tslib");
-const types_1 = require("../types");
-const action_1 = require("../actions/action");
-const lodash_1 = require("../utils/lodash");
-const uuid_1 = require("../utils/uuid");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-function createOperationsFromModies(modies) {
-    return modies.map((modi) => {
-        return {
-            entity: modi.targetEntity,
-            operation: {
-                id: modi.id,
-                action: modi.action,
-                data: modi.data,
-                filter: modi.filter,
-            }
-        };
-    });
-}
-exports.createOperationsFromModies = createOperationsFromModies;
-async function applyModis(filter, context, option) {
-    const closeMode = context.openRootMode();
-    const result = await context.operate('modi', {
-        id: await (0, uuid_1.generateNewIdAsync)(),
-        action: 'apply',
-        data: {},
-        filter,
-        /* sorter: [
-            {
-                $attr: {
-                    $$createAt$$: 1,
-                },
-                $direction: 'asc',
-            }
-        ] */
-    }, Object.assign({}, option, {
-        blockTrigger: false,
-    }));
-    closeMode();
-    return result;
-}
-exports.applyModis = applyModis;
-async function abandonModis(filter, context, option) {
-    const closeMode = context.openRootMode();
-    const result = context.operate('modi', {
-        id: await (0, uuid_1.generateNewIdAsync)(),
-        action: 'abandon',
-        data: {},
-        filter,
-        /* sorter: [
-            {
-                $attr: {
-                    $$createAt$$: 1,
-                },
-                $direction: 'asc',
-            }
-        ] */
-    }, Object.assign({}, option, {
-        blockTrigger: false,
-    }));
-    closeMode();
-    return result;
-}
-exports.abandonModis = abandonModis;
-function createModiRelatedCheckers(schema) {
-    const checkers = [];
-    for (const entity in schema) {
-        const { actionType, actions, inModi } = schema[entity];
-        if (!inModi || ['readOnly', 'appendOnly'].includes(actionType)) {
-            continue;
-        }
-        const restActions = (0, lodash_1.difference)(actions, action_1.appendOnlyActions);
-        checkers.push({
-            entity,
-            action: restActions,
-            type: 'row',
-            filter: (operation, context, option) => {
-                /**
-                 * 只有一种情况可以通过，即当前是在更新和active的modi所指向同一个父更新对象。
-                 * 比如：先申请了一个公司（company），再申请修改公司（companyApplyment），这时所有的active modi都指向此条companyApplyment
-                 *      这时：
-                 *          1）再申请一条新的修改公司（create companyApplyment），应被拒绝
-                 *          2）申请修改原来的companyApplyment(update companyApplyment)，可以通过
-                 *          3）在其它路径上对此company对象进行直接的更新，应被拒绝
-                 */
-                if (option.modiParentEntity) {
-                    const { modiParentEntity, modiParentId } = option;
-                    (0, assert_1.default)(modiParentEntity);
-                    (0, assert_1.default)(modiParentId);
-                    return {
-                        modiEntity$entity: {
-                            '#sqp': 'not in',
-                            entity,
-                            modi: {
-                                iState: 'active',
-                                $or: [
-                                    {
-                                        entity: {
-                                            $ne: modiParentEntity,
-                                        },
-                                    },
-                                    {
-                                        entityId: {
-                                            $ne: modiParentId,
-                                        },
-                                    }
-                                ],
-                            },
-                        },
-                        /* id: {
-                            $nin: {
-                                entity: 'modiEntity',
-                                data: {
-                                    entityId: 1,
-                                },
-                                filter: {
-                                    entity,
-                                    modi: {
-                                        iState: 'active',
-                                        $or: [
-                                            {
-                                                entity: {
-                                                    $ne: modiParentEntity,
-                                                },
-                                            },
-                                            {
-                                                entityId: {
-                                                    $ne: modiParentId,
-                                                },
-                                            }
-                                        ],
-                                    },
-                                },
-                            },
-                        } */
-                    };
-                }
-                return {
-                    modiEntity$entity: {
-                        '#sqp': 'not in',
-                        entity,
-                        modi: {
-                            iState: 'active',
-                        }
-                    },
-                    /* id: {
-                        $nin: {
-                            entity: 'modiEntity',
-                            data: {
-                                entityId: 1,
-                            },
-                            filter: {
-                                entity,
-                                modi: {
-                                    iState: 'active',
-                                }
-                            },
-                        },
-                    } */
-                };
-            },
-            errMsg: '您请求的更新对象上还有正在申请的更新，请等该更新结束后再试',
-        });
-    }
-    return checkers;
-}
-exports.createModiRelatedCheckers = createModiRelatedCheckers;
-function createModiRelatedTriggers(schema) {
-    const triggers = [];
-    for (const entity in schema) {
-        const { toModi } = schema[entity];
-        if (toModi) {
-            // 当关联modi的对象被删除时，对应的modi也删除。这里似乎只需要删除掉活跃对象？因为oper不能删除，所以oper和modi是必须要支持对deleted对象的容错？
-            // 这里没有想清楚，by Xc 20230209
-            triggers.push({
-                name: `当删除${entity}对象时，删除相关联的modi的modiEntity`,
-                action: 'remove',
-                entity,
-                when: 'before',
-                priority: types_1.TRIGGER_DEFAULT_PRIORITY,
-                fn: async ({ operation }, context, option) => {
-                    const { filter } = operation;
-                    await context.operate('modiEntity', {
-                        id: await (0, uuid_1.generateNewIdAsync)(),
-                        action: 'remove',
-                        data: {},
-                        filter: {
-                            modi: {
-                                [entity]: filter,
-                                iState: 'active',
-                            },
-                        }
-                    }, { dontCollect: true });
-                    await context.operate('modi', {
-                        id: await (0, uuid_1.generateNewIdAsync)(),
-                        action: 'remove',
-                        data: {},
-                        filter: {
-                            [entity]: filter,
-                            iState: 'active',
-                        }
-                    }, { dontCollect: true });
-                    return 0;
-                },
-            });
-        }
-    }
-    // modi被应用时的效用，搬到这里了
-    const applyTrigger = {
-        name: '当modi被应用时，将相应的operate完成',
-        entity: 'modi',
-        action: 'apply',
-        when: 'after',
-        fn: async ({ operation }, context, option) => {
-            const { filter } = operation;
-            const modies = await context.select('modi', {
-                data: {
-                    id: 1,
-                    action: 1,
-                    data: 1,
-                    filter: 1,
-                    targetEntity: 1,
-                },
-                filter,
-                sorter: [
-                    {
-                        $attr: {
-                            $$createAt$$: 1,
-                        },
-                        $direction: 'asc',
-                    },
-                ],
-            }, option);
-            for (const modi of modies) {
-                const { targetEntity, id, action, data, filter } = modi;
-                await context.operate(targetEntity, {
-                    id: id,
-                    action: action,
-                    data: data,
-                    filter: filter,
-                }, {
-                    ...option,
-                    applyingModi: true,
-                });
-            }
-            return modies.length;
-        }
-    };
-    return triggers.concat([applyTrigger]);
-}
-exports.createModiRelatedTriggers = createModiRelatedTriggers;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModiRelatedTriggers = exports.createModiRelatedCheckers = exports.abandonModis = exports.applyModis = exports.createOperationsFromModies = void 0;
+const tslib_1 = require("tslib");
+const types_1 = require("../types");
+const action_1 = require("../actions/action");
+const lodash_1 = require("../utils/lodash");
+const uuid_1 = require("../utils/uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+function createOperationsFromModies(modies) {
+    return modies.map((modi) => {
+        return {
+            entity: modi.targetEntity,
+            operation: {
+                id: modi.id,
+                action: modi.action,
+                data: modi.data,
+                filter: modi.filter,
+            }
+        };
+    });
+}
+exports.createOperationsFromModies = createOperationsFromModies;
+async function applyModis(filter, context, option) {
+    const closeMode = context.openRootMode();
+    const result = await context.operate('modi', {
+        id: await (0, uuid_1.generateNewIdAsync)(),
+        action: 'apply',
+        data: {},
+        filter,
+        /* sorter: [
+            {
+                $attr: {
+                    $$createAt$$: 1,
+                },
+                $direction: 'asc',
+            }
+        ] */
+    }, Object.assign({}, option, {
+        blockTrigger: false,
+    }));
+    closeMode();
+    return result;
+}
+exports.applyModis = applyModis;
+async function abandonModis(filter, context, option) {
+    const closeMode = context.openRootMode();
+    const result = context.operate('modi', {
+        id: await (0, uuid_1.generateNewIdAsync)(),
+        action: 'abandon',
+        data: {},
+        filter,
+        /* sorter: [
+            {
+                $attr: {
+                    $$createAt$$: 1,
+                },
+                $direction: 'asc',
+            }
+        ] */
+    }, Object.assign({}, option, {
+        blockTrigger: false,
+    }));
+    closeMode();
+    return result;
+}
+exports.abandonModis = abandonModis;
+function createModiRelatedCheckers(schema) {
+    const checkers = [];
+    for (const entity in schema) {
+        const { actionType, actions, inModi } = schema[entity];
+        if (!inModi || ['readOnly', 'appendOnly'].includes(actionType)) {
+            continue;
+        }
+        const restActions = (0, lodash_1.difference)(actions, action_1.appendOnlyActions);
+        checkers.push({
+            entity,
+            action: restActions,
+            type: 'row',
+            filter: (operation, context, option) => {
+                /**
+                 * 只有一种情况可以通过，即当前是在更新和active的modi所指向同一个父更新对象。
+                 * 比如：先申请了一个公司（company），再申请修改公司（companyApplyment），这时所有的active modi都指向此条companyApplyment
+                 *      这时：
+                 *          1）再申请一条新的修改公司（create companyApplyment），应被拒绝
+                 *          2）申请修改原来的companyApplyment(update companyApplyment)，可以通过
+                 *          3）在其它路径上对此company对象进行直接的更新，应被拒绝
+                 */
+                if (option.modiParentEntity) {
+                    const { modiParentEntity, modiParentId } = option;
+                    (0, assert_1.default)(modiParentEntity);
+                    (0, assert_1.default)(modiParentId);
+                    return {
+                        modiEntity$entity: {
+                            '#sqp': 'not in',
+                            entity,
+                            modi: {
+                                iState: 'active',
+                                $or: [
+                                    {
+                                        entity: {
+                                            $ne: modiParentEntity,
+                                        },
+                                    },
+                                    {
+                                        entityId: {
+                                            $ne: modiParentId,
+                                        },
+                                    }
+                                ],
+                            },
+                        },
+                        /* id: {
+                            $nin: {
+                                entity: 'modiEntity',
+                                data: {
+                                    entityId: 1,
+                                },
+                                filter: {
+                                    entity,
+                                    modi: {
+                                        iState: 'active',
+                                        $or: [
+                                            {
+                                                entity: {
+                                                    $ne: modiParentEntity,
+                                                },
+                                            },
+                                            {
+                                                entityId: {
+                                                    $ne: modiParentId,
+                                                },
+                                            }
+                                        ],
+                                    },
+                                },
+                            },
+                        } */
+                    };
+                }
+                return {
+                    modiEntity$entity: {
+                        '#sqp': 'not in',
+                        entity,
+                        modi: {
+                            iState: 'active',
+                        }
+                    },
+                    /* id: {
+                        $nin: {
+                            entity: 'modiEntity',
+                            data: {
+                                entityId: 1,
+                            },
+                            filter: {
+                                entity,
+                                modi: {
+                                    iState: 'active',
+                                }
+                            },
+                        },
+                    } */
+                };
+            },
+            errMsg: '您请求的更新对象上还有正在申请的更新，请等该更新结束后再试',
+        });
+    }
+    return checkers;
+}
+exports.createModiRelatedCheckers = createModiRelatedCheckers;
+function createModiRelatedTriggers(schema) {
+    const triggers = [];
+    for (const entity in schema) {
+        const { toModi } = schema[entity];
+        if (toModi) {
+            // 当关联modi的对象被删除时，对应的modi也删除。这里似乎只需要删除掉活跃对象？因为oper不能删除，所以oper和modi是必须要支持对deleted对象的容错？
+            // 这里没有想清楚，by Xc 20230209
+            triggers.push({
+                name: `当删除${entity}对象时，删除相关联的modi的modiEntity`,
+                action: 'remove',
+                entity,
+                when: 'before',
+                priority: types_1.TRIGGER_DEFAULT_PRIORITY,
+                fn: async ({ operation }, context, option) => {
+                    const { filter } = operation;
+                    await context.operate('modiEntity', {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'remove',
+                        data: {},
+                        filter: {
+                            modi: {
+                                [entity]: filter,
+                                iState: 'active',
+                            },
+                        }
+                    }, { dontCollect: true });
+                    await context.operate('modi', {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'remove',
+                        data: {},
+                        filter: {
+                            [entity]: filter,
+                            iState: 'active',
+                        }
+                    }, { dontCollect: true });
+                    return 0;
+                },
+            });
+        }
+    }
+    // modi被应用时的效用，搬到这里了
+    const applyTrigger = {
+        name: '当modi被应用时，将相应的operate完成',
+        entity: 'modi',
+        action: 'apply',
+        when: 'after',
+        fn: async ({ operation }, context, option) => {
+            const { filter } = operation;
+            const modies = await context.select('modi', {
+                data: {
+                    id: 1,
+                    action: 1,
+                    data: 1,
+                    filter: 1,
+                    targetEntity: 1,
+                },
+                filter,
+                sorter: [
+                    {
+                        $attr: {
+                            $$createAt$$: 1,
+                        },
+                        $direction: 'asc',
+                    },
+                ],
+            }, option);
+            for (const modi of modies) {
+                const { targetEntity, id, action, data, filter } = modi;
+                await context.operate(targetEntity, {
+                    id: id,
+                    action: action,
+                    data: data,
+                    filter: filter,
+                }, {
+                    ...option,
+                    applyingModi: true,
+                });
+            }
+            return modies.length;
+        }
+    };
+    return triggers.concat([applyTrigger]);
+}
+exports.createModiRelatedTriggers = createModiRelatedTriggers;

package/lib/store/relation.d.ts

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