oak-domain 5.1.18 → 5.1.20

package/lib/compiler/dependencyBuilder.js

@@ -865,69 +865,150 @@ function buildDependency(rebuild) {
     ];
     const program = ts.createProgram(templateFileList, {});
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    let output = true;
     if (!isModule) {
         const initDevFile = join(cwd, 'src', 'initialize.frontend.ts');
-        if ((0, fs_1.existsSync)(initDevFile) && !rebuild) {
-            console.log(`[${initDevFile}]文件已经存在，无需构建启动文件`);
+        if ((0, fs_1.existsSync)(initDevFile)) {
+            let tips = `[${initDevFile}]文件已经存在`;
+            if (!rebuild) {
+                tips += '，忽略构建。';
+                output = false;
+            }
+            else {
+                tips += '，将重新构建';
+            }
+            console.log(tips);
         }
-        else {
+        if (output) {
             outputIntializeDev(cwd, dependencies, briefNames, program.getSourceFile(templateFileList[0]), printer, initDevFile);
         }
+        output = true;
         const initProdFile = join(cwd, 'src', 'initialize.server.ts');
         if ((0, fs_1.existsSync)(initProdFile) && !rebuild) {
-            console.log(`[${initProdFile}]文件已经存在，无需构建启动文件`);
+            let tips = `[${initProdFile}]文件已经存在`;
+            if (!rebuild) {
+                tips += '，忽略构建。';
+                output = false;
+            }
+            else {
+                tips += '，将重新构建';
+            }
+            console.log(tips);
         }
-        else {
+        if (output) {
             outputIntializeProd(cwd, dependencies, briefNames, program.getSourceFile(templateFileList[1]), printer, initProdFile);
         }
+        output = true;
         const initFeaturesFile = join(cwd, 'src', 'initializeFeatures.ts');
         if ((0, fs_1.existsSync)(initFeaturesFile) && !rebuild) {
-            console.log(`[${initFeaturesFile}]文件已经存在，无需构建启动文件`);
+            let tips = `[${initFeaturesFile}]文件已经存在`;
+            if (!rebuild) {
+                tips += '，忽略构建。';
+                output = false;
+            }
+            else {
+                tips += '，将重新构建，注意如果自定义过初始化过程，需要重新输入';
+            }
+            console.log(tips);
         }
-        else {
+        if (output) {
             outputIntializeFeatures(cwd, dependencies, briefNames, program.getSourceFile(templateFileList[2]), printer, initFeaturesFile);
         }
     }
+    output = true;
     const runtimeCxtFile = join(cwd, 'src', 'types', 'RuntimeCxt.ts');
     if ((0, fs_1.existsSync)(runtimeCxtFile) && !rebuild) {
-        console.log(`[${runtimeCxtFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${runtimeCxtFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建';
+        }
+        console.log(tips);
     }
-    else {
+    if (output) {
         outputRuntimeCxt(dependencies, briefNames, program.getSourceFile(templateFileList[3]), printer, runtimeCxtFile);
     }
+    output = true;
     const dependentExceptionsFile = join(cwd, 'src', 'types', 'DependentExceptions.ts');
     if ((0, fs_1.existsSync)(dependentExceptionsFile) && !rebuild) {
-        console.log(`[${dependentExceptionsFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${dependentExceptionsFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建';
+        }
+        console.log(tips);
     }
-    else {
+    if (output) {
         outputDependentExceptions(dependencies, briefNames, program.getSourceFile(templateFileList[4]), printer, dependentExceptionsFile);
     }
+    output = true;
     const polyfillDtsFile = join(cwd, 'typings', 'polyfill.d.ts');
     if ((0, fs_1.existsSync)(polyfillDtsFile) && !rebuild) {
-        console.log(`[${polyfillDtsFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${polyfillDtsFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建';
+        }
+        console.log(tips);
     }
-    else {
+    if (output) {
         outputPolyfillDts(dependencies, briefNames, program.getSourceFile(templateFileList[5]), printer, polyfillDtsFile);
     }
+    output = true;
     const featureIndexFile = join(cwd, 'src', 'features', 'index.ts');
     if ((0, fs_1.existsSync)(featureIndexFile) && !rebuild) {
-        console.log(`[${featureIndexFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${featureIndexFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建';
+        }
+        console.log(tips);
     }
     else {
         outputFeatureIndex(dependencies, briefNames, program.getSourceFile(templateFileList[6]), printer, featureIndexFile, isModule);
     }
+    output = true;
     let contextFile = join(cwd, 'src', 'context', 'BackendRuntimeContext.ts');
     if ((0, fs_1.existsSync)(contextFile) && !rebuild) {
-        console.log(`[${contextFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${contextFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建，注意如果自定义过上下文的其它方法或属性，需要重新输入';
+        }
+        console.log(tips);
     }
-    else {
+    if (output) {
         outputContext(depGraph, program.getSourceFile(templateFileList[7]), printer, contextFile);
     }
+    output = true;
     contextFile = join(cwd, 'src', 'context', 'FrontendRuntimeContext.ts');
     if ((0, fs_1.existsSync)(contextFile) && !rebuild) {
-        console.log(`[${contextFile}]文件已经存在，无需构建启动文件`);
+        let tips = `[${contextFile}]文件已经存在`;
+        if (!rebuild) {
+            tips += '，忽略构建。';
+            output = false;
+        }
+        else {
+            tips += '，将重新构建，注意如果自定义过上下文的其它方法或属性，需要重新输入';
+        }
+        console.log(tips);
     }
-    else {
+    if (output) {
         outputContext(depGraph, program.getSourceFile(templateFileList[8]), printer, contextFile);
     }
     // 把各个依赖项目的一些初始化的文件拷贝过去

package/lib/data/i18n.js

@@ -16,6 +16,11 @@ const i18ns = [
             "signatureFailed": "验签失败",
             "attributesNull": "属性[%{attributes}]不允许为空",
             "attributesCantUpdate": "属性[%{attributes}]不能更新",
+            "attributesFormatError": "属性[%{attributes}]格式不对，应当是[%{format}]",
+            "attributesTooLong": "属性[%{attributes}]长度过长，最长长度是[%{length}]",
+            "attributesOverMax": "属性[%{attributes}]超过最大值[%{threshold}]",
+            "attributesUnderMin": "属性[%{attributes}]低于最小值[%{threshold}]",
+            "attributesNotInEnumeration": "属性[%{attributes}]不在有效的枚举值当中",
             "operationUnpermitted": "用户操作权限不足",
             "dataInvisible": "用户查询权限不足",
             "unLoggedIn": "用户未登录",
@@ -25,6 +30,7 @@ const i18ns = [
             "preconditionUnset": "前置条件未满足",
             "externalException": "外部接口调用异常",
             "socketConnectException": "连接出现问题，请尝试刷新页面",
+            "applicationHasToUpgrade": "应用需要升级",
             "importedDataParseError": "import的数据存在异常"
         }
     }

package/lib/store/AsyncRowStore.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo, OakException } from "../types";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { IncomingHttpHeaders } from "http";
 /**
@@ -61,6 +61,7 @@ export declare abstract class AsyncContext<ED extends EntityDict & BaseEntityDic
     abstract initialize(data?: any, later?: boolean): Promise<void>;
     abstract allowUserUpdate(): boolean;
     abstract openRootMode(): () => void;
+    abstract tryDeduceException(err: Error): Promise<OakException<any> | void>;
 }
 export interface AsyncRowStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends RowStore<ED> {
     operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;

package/lib/store/CascadeStore.d.ts

@@ -4,6 +4,15 @@ import { OperationRewriter, RowStore, SelectionRewriter } from '../types/RowStor
 import { StorageSchema } from '../types/Storage';
 import { SyncContext } from "./SyncRowStore";
 import { AsyncContext } from "./AsyncRowStore";
+/**
+ * 补全一个不完整的Selection，会将需要的各种连接、过滤和排序的属性加到相应的projection上
+ * @param schema
+ * @param entity
+ * @param selection
+ * @param context
+ * @param option
+ */
+export declare function polishSelection<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends SelectOption>(schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'] | ED[keyof ED]['Aggregation'], context?: Cxt, option?: Op): void;
 /**这个用来处理级联的select和update，对不同能力的 */
 export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> extends RowStore<ED> {
     constructor(storageSchema: StorageSchema<ED>);
@@ -13,7 +22,6 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     private operationRewriters;
     private reinforceSelectionAsync;
     private reinforceSelectionSync;
-    private reinforceSelectionInner;
     private reinforceOperation;
     registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
     registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;

package/lib/store/CascadeStore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CascadeStore = void 0;
+exports.CascadeStore = exports.polishSelection = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const Entity_1 = require("../types/Entity");
@@ -14,314 +14,299 @@ const filter_2 = require("./filter");
 const uuid_1 = require("../utils/uuid");
 const entities_1 = require("../compiler/entities");
 const projection_1 = require("../utils/projection");
-/**这个用来处理级联的select和update，对不同能力的 */
-class CascadeStore extends RowStore_1.RowStore {
-    constructor(storageSchema) {
-        super(storageSchema);
-    }
-    selectionRewriters = [];
-    operationRewriters = [];
-    async reinforceSelectionAsync(entity, selection, context, option, isAggr) {
-        if (!isAggr && !selection.distinct) {
-            this.reinforceSelectionInner(entity, selection, context, option);
-        }
-        const rewriterPromises = this.selectionRewriters.map(ele => ele(this.getSchema(), entity, selection, context, option, isAggr));
-        if (rewriterPromises.length > 0) {
-            await Promise.all(rewriterPromises);
-        }
-    }
-    reinforceSelectionSync(entity, selection, context, option, isAggr) {
-        if (!isAggr && !selection.distinct) {
-            this.reinforceSelectionInner(entity, selection, context, option);
-        }
-        this.selectionRewriters.forEach(ele => {
-            const result = ele(this.getSchema(), entity, selection, context, option, isAggr);
-            (0, assert_1.default)(!(result instanceof Promise));
+/**
+ * 补全一个不完整的Selection，会将需要的各种连接、过滤和排序的属性加到相应的projection上
+ * @param schema
+ * @param entity
+ * @param selection
+ * @param context
+ * @param option
+ */
+function polishSelection(schema, entity, selection, context, option) {
+    const { filter, data, sorter } = selection;
+    const assignNecessaryProjectionAttrs = (projectionNode, attrs) => {
+        attrs.forEach((attr) => {
+            if (!projectionNode.hasOwnProperty(attr)) {
+                Object.assign(projectionNode, {
+                    [attr]: 1,
+                });
+            }
         });
-    }
-    reinforceSelectionInner(entity, selection, context, option) {
-        const { filter, data, sorter } = selection;
-        const assignNecessaryProjectionAttrs = (projectionNode, attrs) => {
-            attrs.forEach((attr) => {
-                if (!projectionNode.hasOwnProperty(attr)) {
-                    Object.assign(projectionNode, {
-                        [attr]: 1,
-                    });
-                }
-            });
-        };
-        const checkFilterNode = (entity2, filterNode, projectionNode, toBeAssignNode, filterNodeDict) => {
-            const necessaryAttrs = ['id'];
-            for (const attr in filterNode) {
-                if (attr === '#id') {
-                    (0, assert_1.default)(!filterNodeDict[filterNode[attr]], `projection中结点的id有重复, ${filterNode[attr]}`);
-                    Object.assign(filterNodeDict, {
-                        [filterNode[attr]]: projectionNode,
-                    });
-                    if (toBeAssignNode[filterNode[attr]]) {
-                        assignNecessaryProjectionAttrs(projectionNode, toBeAssignNode[filterNode[attr]]);
-                    }
-                }
-                else if (['$and', '$or'].includes(attr)) {
-                    for (const node of filterNode[attr]) {
-                        checkFilterNode(entity2, node, projectionNode, toBeAssignNode, filterNodeDict);
-                    }
-                }
-                else if (attr === '$not') {
-                    checkFilterNode(entity2, filterNode[attr], projectionNode, toBeAssignNode, filterNodeDict);
+    };
+    const checkFilterNode = (entity2, filterNode, projectionNode, toBeAssignNode, filterNodeDict) => {
+        const necessaryAttrs = ['id'];
+        for (const attr in filterNode) {
+            if (attr === '#id') {
+                (0, assert_1.default)(!filterNodeDict[filterNode[attr]], `projection中结点的id有重复, ${filterNode[attr]}`);
+                Object.assign(filterNodeDict, {
+                    [filterNode[attr]]: projectionNode,
+                });
+                if (toBeAssignNode[filterNode[attr]]) {
+                    assignNecessaryProjectionAttrs(projectionNode, toBeAssignNode[filterNode[attr]]);
                 }
-                else if (attr === '$text') {
-                    // 全文检索首先要有fulltext索引，其次要把fulltext的相关属性加到projection里
-                    const { indexes } = this.getSchema()[entity2];
-                    const fulltextIndex = indexes.find(ele => ele.config && ele.config.type === 'fulltext');
-                    const { attributes } = fulltextIndex;
-                    necessaryAttrs.push(...(attributes.map(ele => ele.name)));
+            }
+            else if (['$and', '$or'].includes(attr)) {
+                for (const node of filterNode[attr]) {
+                    checkFilterNode(entity2, node, projectionNode, toBeAssignNode, filterNodeDict);
                 }
-                else {
-                    if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
-                        const exprResult = (0, types_1.getAttrRefInExpression)(filterNode[attr]);
-                        for (const nodeName in exprResult) {
-                            if (nodeName === '#current') {
-                                assignNecessaryProjectionAttrs(projectionNode, exprResult[nodeName]);
-                            }
-                            else if (filterNodeDict[nodeName]) {
-                                assignNecessaryProjectionAttrs(filterNodeDict[nodeName], exprResult[nodeName]);
-                            }
-                            else {
-                                if (toBeAssignNode[nodeName]) {
-                                    toBeAssignNode[nodeName].push(...exprResult[nodeName]);
-                                }
-                                else {
-                                    Object.assign(toBeAssignNode, {
-                                        [nodeName]: exprResult[nodeName],
-                                    });
-                                }
-                            }
+            }
+            else if (attr === '$not') {
+                checkFilterNode(entity2, filterNode[attr], projectionNode, toBeAssignNode, filterNodeDict);
+            }
+            else if (attr === '$text') {
+                // 全文检索首先要有fulltext索引，其次要把fulltext的相关属性加到projection里
+                const { indexes } = schema[entity2];
+                const fulltextIndex = indexes.find(ele => ele.config && ele.config.type === 'fulltext');
+                const { attributes } = fulltextIndex;
+                necessaryAttrs.push(...(attributes.map(ele => ele.name)));
+            }
+            else {
+                if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+                    const exprResult = (0, types_1.getAttrRefInExpression)(filterNode[attr]);
+                    for (const nodeName in exprResult) {
+                        if (nodeName === '#current') {
+                            assignNecessaryProjectionAttrs(projectionNode, exprResult[nodeName]);
                         }
-                    }
-                    else {
-                        const rel = this.judgeRelation(entity2, attr);
-                        if (rel === 1) {
-                            necessaryAttrs.push(attr);
+                        else if (filterNodeDict[nodeName]) {
+                            assignNecessaryProjectionAttrs(filterNodeDict[nodeName], exprResult[nodeName]);
                         }
-                        else if (rel === 2) {
-                            // entity/entityId反指
-                            necessaryAttrs.push('entity', 'entityId');
-                            if (!projectionNode[attr]) {
-                                Object.assign(projectionNode, {
-                                    [attr]: {
-                                        id: 1,
-                                    }
-                                });
+                        else {
+                            if (toBeAssignNode[nodeName]) {
+                                toBeAssignNode[nodeName].push(...exprResult[nodeName]);
                             }
-                            checkFilterNode(attr, filterNode[attr], projectionNode[attr], toBeAssignNode, filterNodeDict);
-                        }
-                        else if (typeof rel === 'string') {
-                            necessaryAttrs.push(`${attr}Id`);
-                            if (!projectionNode[attr]) {
-                                Object.assign(projectionNode, {
-                                    [attr]: {
-                                        id: 1,
-                                    }
+                            else {
+                                Object.assign(toBeAssignNode, {
+                                    [nodeName]: exprResult[nodeName],
                                 });
                             }
-                            checkFilterNode(rel, filterNode[attr], projectionNode[attr], toBeAssignNode, filterNodeDict);
-                        }
-                        else if (rel instanceof Array) {
-                            // 子查询，暂时不处理
                         }
                     }
                 }
-                assignNecessaryProjectionAttrs(projectionNode, necessaryAttrs);
-            }
-        };
-        const checkSorterNode = (entity2, sorterNode, projectionNode) => {
-            const checkSortAttr = (e2, sortAttr, projNode) => {
-                const necessaryAttrs = [];
-                for (const attr in sortAttr) {
-                    const rel = this.judgeRelation(e2, attr);
-                    if (typeof rel === 'number' && [0, 1].includes(rel)) {
+                else {
+                    const rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
+                    if (rel === 1) {
                         necessaryAttrs.push(attr);
                     }
-                    else if (typeof rel === 'string') {
-                        if (!projNode[attr]) {
-                            Object.assign(projNode, {
-                                [attr]: {},
+                    else if (rel === 2) {
+                        // entity/entityId反指
+                        necessaryAttrs.push('entity', 'entityId');
+                        if (!projectionNode[attr]) {
+                            Object.assign(projectionNode, {
+                                [attr]: {
+                                    id: 1,
+                                }
                             });
                         }
-                        (0, assert_1.default)(typeof sortAttr[attr] === 'object');
-                        checkSortAttr(rel, sortAttr[attr], projNode[attr]);
+                        checkFilterNode(attr, filterNode[attr], projectionNode[attr], toBeAssignNode, filterNodeDict);
                     }
-                    else {
-                        (0, assert_1.default)(rel === 2);
-                        if (!projNode[attr]) {
-                            Object.assign(projNode, {
-                                [attr]: {},
+                    else if (typeof rel === 'string') {
+                        necessaryAttrs.push(`${attr}Id`);
+                        if (!projectionNode[attr]) {
+                            Object.assign(projectionNode, {
+                                [attr]: {
+                                    id: 1,
+                                }
                             });
                         }
-                        (0, assert_1.default)(typeof sortAttr[attr] === 'object');
-                        checkSortAttr(attr, sortAttr[attr], projNode[attr]);
+                        checkFilterNode(rel, filterNode[attr], projectionNode[attr], toBeAssignNode, filterNodeDict);
+                    }
+                    else if (rel instanceof Array) {
+                        // 子查询，暂时不处理
                     }
                 }
-                assignNecessaryProjectionAttrs(projNode, necessaryAttrs);
-            };
-            sorterNode.forEach((node) => {
-                const { $attr } = node;
-                checkSortAttr(entity2, $attr, projectionNode);
-            });
-        };
-        let relevantIds = [];
-        if (filter) {
-            const toBeAssignNode = {}; // 用来记录在表达式中涉及到的结点
-            // filter当中所关联到的属性必须在projection中
-            const filterNodeDict = {};
-            checkFilterNode(entity, filter, data, toBeAssignNode, filterNodeDict);
-            relevantIds = (0, filter_2.getRelevantIds)(filter);
-        }
-        // sorter也得取了，前端需要处理排序
-        if (sorter) {
-            checkSorterNode(entity, sorter, data);
+            }
+            assignNecessaryProjectionAttrs(projectionNode, necessaryAttrs);
         }
-        const toBeAssignNode2 = {}; // 用来记录在表达式中涉及到的结点
-        const projectionNodeDict = {};
-        const checkProjectionNode = (entity2, projectionNode) => {
-            const necessaryAttrs = ['id', '$$createAt$$', '$$updateAt$$']; // 有的页面依赖于其它页面取数据，有时两个页面的filter的差异会导致有一个加createAt，有一个不加，此时可能产生前台取数据不完整的异常。先统一加上
-            for (const attr in projectionNode) {
-                if (attr === '#id') {
-                    (0, assert_1.default)(!projectionNodeDict[projectionNode[attr]], `projection中结点的id有重复, ${projectionNode[attr]}`);
-                    Object.assign(projectionNodeDict, {
-                        [projectionNode[attr]]: projectionNode,
-                    });
-                    if (toBeAssignNode2[projectionNode[attr]]) {
-                        assignNecessaryProjectionAttrs(projectionNode, toBeAssignNode2[projectionNode[attr]]);
+    };
+    const checkSorterNode = (entity2, sorterNode, projectionNode) => {
+        const checkSortAttr = (e2, sortAttr, projNode) => {
+            const necessaryAttrs = [];
+            for (const attr in sortAttr) {
+                const rel = (0, relation_1.judgeRelation)(schema, e2, attr);
+                if (typeof rel === 'number' && [0, 1].includes(rel)) {
+                    necessaryAttrs.push(attr);
+                }
+                else if (typeof rel === 'string') {
+                    if (!projNode[attr]) {
+                        Object.assign(projNode, {
+                            [attr]: {},
+                        });
                     }
+                    (0, assert_1.default)(typeof sortAttr[attr] === 'object');
+                    checkSortAttr(rel, sortAttr[attr], projNode[attr]);
                 }
                 else {
-                    if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
-                        const exprResult = (0, types_1.getAttrRefInExpression)(projectionNode[attr]);
-                        for (const nodeName in exprResult) {
-                            if (nodeName === '#current') {
-                                assignNecessaryProjectionAttrs(projectionNode, exprResult[nodeName]);
-                            }
-                            else if (projectionNodeDict[nodeName]) {
-                                assignNecessaryProjectionAttrs(projectionNodeDict[nodeName], exprResult[nodeName]);
-                            }
-                            else {
-                                if (toBeAssignNode2[nodeName]) {
-                                    toBeAssignNode2[nodeName].push(...exprResult[nodeName]);
-                                }
-                                else {
-                                    Object.assign(toBeAssignNode2, {
-                                        [nodeName]: exprResult[nodeName],
-                                    });
-                                }
-                            }
-                        }
+                    (0, assert_1.default)(rel === 2);
+                    if (!projNode[attr]) {
+                        Object.assign(projNode, {
+                            [attr]: {},
+                        });
                     }
-                    else {
-                        const rel = (0, relation_1.judgeRelation)(this.getSchema(), entity2, attr);
-                        if (rel === 1) {
-                            necessaryAttrs.push(attr);
-                        }
-                        else if (rel === 2) {
-                            // entity/entityId反指
-                            necessaryAttrs.push('entity', 'entityId');
-                            checkProjectionNode(attr, projectionNode[attr]);
+                    (0, assert_1.default)(typeof sortAttr[attr] === 'object');
+                    checkSortAttr(attr, sortAttr[attr], projNode[attr]);
+                }
+            }
+            assignNecessaryProjectionAttrs(projNode, necessaryAttrs);
+        };
+        sorterNode.forEach((node) => {
+            const { $attr } = node;
+            checkSortAttr(entity2, $attr, projectionNode);
+        });
+    };
+    let relevantIds = [];
+    if (filter) {
+        const toBeAssignNode = {}; // 用来记录在表达式中涉及到的结点
+        // filter当中所关联到的属性必须在projection中
+        const filterNodeDict = {};
+        checkFilterNode(entity, filter, data, toBeAssignNode, filterNodeDict);
+        relevantIds = (0, filter_2.getRelevantIds)(filter);
+    }
+    // sorter也得取了，前端需要处理排序
+    if (sorter) {
+        checkSorterNode(entity, sorter, data);
+    }
+    const toBeAssignNode2 = {}; // 用来记录在表达式中涉及到的结点
+    const projectionNodeDict = {};
+    const checkProjectionNode = (entity2, projectionNode) => {
+        const necessaryAttrs = ['id', '$$createAt$$', '$$updateAt$$']; // 有的页面依赖于其它页面取数据，有时两个页面的filter的差异会导致有一个加createAt，有一个不加，此时可能产生前台取数据不完整的异常。先统一加上
+        for (const attr in projectionNode) {
+            if (attr === '#id') {
+                (0, assert_1.default)(!projectionNodeDict[projectionNode[attr]], `projection中结点的id有重复, ${projectionNode[attr]}`);
+                Object.assign(projectionNodeDict, {
+                    [projectionNode[attr]]: projectionNode,
+                });
+                if (toBeAssignNode2[projectionNode[attr]]) {
+                    assignNecessaryProjectionAttrs(projectionNode, toBeAssignNode2[projectionNode[attr]]);
+                }
+            }
+            else {
+                if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+                    const exprResult = (0, types_1.getAttrRefInExpression)(projectionNode[attr]);
+                    for (const nodeName in exprResult) {
+                        if (nodeName === '#current') {
+                            assignNecessaryProjectionAttrs(projectionNode, exprResult[nodeName]);
                         }
-                        else if (typeof rel === 'string') {
-                            necessaryAttrs.push(`${attr}Id`);
-                            checkProjectionNode(rel, projectionNode[attr]);
+                        else if (projectionNodeDict[nodeName]) {
+                            assignNecessaryProjectionAttrs(projectionNodeDict[nodeName], exprResult[nodeName]);
                         }
-                        else if (rel instanceof Array && !attr.endsWith('$$aggr')) {
-                            const { data, filter } = projectionNode[attr];
-                            if (rel[1]) {
-                                assignNecessaryProjectionAttrs(data, [rel[1]]);
+                        else {
+                            if (toBeAssignNode2[nodeName]) {
+                                toBeAssignNode2[nodeName].push(...exprResult[nodeName]);
                             }
                             else {
-                                assignNecessaryProjectionAttrs(data, ['entity', 'entityId']);
+                                Object.assign(toBeAssignNode2, {
+                                    [nodeName]: exprResult[nodeName],
+                                });
                             }
-                            this.reinforceSelectionInner(rel[0], projectionNode[attr], context, option);
                         }
                     }
                 }
-                assignNecessaryProjectionAttrs(projectionNode, necessaryAttrs);
-            }
-            // 如果对象中指向一对多的Modi，此时加上指向Modi的projection
-            // 此逻辑关闭，用户自己撰写去取modi     by Xc 20241207
-            /* if (this.getSchema()[entity2].toModi) {
-                Object.assign(projectionNode, {
-                    modi$entity: {
-                        $entity: 'modi',
-                        data: {
-                            id: 1,
-                            targetEntity: 1,
-                            entity: 1,
-                            entityId: 1,
-                            action: 1,
-                            iState: 1,
-                            data: 1,
-                            filter: 1,
-                            $$createAt$$: 1,
-                            $$updateAt$$: 1,
-                        },
-                        filter: {
-                            iState: 'active',
-                        },
+                else {
+                    const rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
+                    if (rel === 1) {
+                        necessaryAttrs.push(attr);
                     }
-                });
-            } */
-            // 如果对象上有relation关系，在此将本用户相关的relation和actionAuth全部取出
-            // 还要将actionAuth上没有relation关系但destEntity为本对象的行也全部取出，这些是指向userId的可能路径
-            // 放在这里有点怪异，暂先这样
-            if (context instanceof AsyncRowStore_1.AsyncContext && !option.dontCollect) {
-                const userId = context.getCurrentUserId(true);
-                if (userId && !entities_1.SYSTEM_RESERVE_ENTITIES.includes(entity2)) {
-                    if (this.getSchema()[entity2].relation && !projectionNode.userRelation$entity) {
-                        Object.assign(projectionNode, {
-                            userRelation$entity: {
-                                $entity: 'userRelation',
-                                data: {
+                    else if (rel === 2) {
+                        // entity/entityId反指
+                        necessaryAttrs.push('entity', 'entityId');
+                        checkProjectionNode(attr, projectionNode[attr]);
+                    }
+                    else if (typeof rel === 'string') {
+                        necessaryAttrs.push(`${attr}Id`);
+                        checkProjectionNode(rel, projectionNode[attr]);
+                    }
+                    else if (rel instanceof Array && !attr.endsWith('$$aggr')) {
+                        const { data, filter } = projectionNode[attr];
+                        if (rel[1]) {
+                            assignNecessaryProjectionAttrs(data, [rel[1]]);
+                        }
+                        else {
+                            assignNecessaryProjectionAttrs(data, ['entity', 'entityId']);
+                        }
+                        polishSelection(schema, rel[0], projectionNode[attr], context, option);
+                    }
+                }
+            }
+            assignNecessaryProjectionAttrs(projectionNode, necessaryAttrs);
+        }
+        // 如果对象上有relation关系，在此将本用户相关的relation和actionAuth全部取出
+        // 还要将actionAuth上没有relation关系但destEntity为本对象的行也全部取出，这些是指向userId的可能路径
+        // 放在这里有点怪异，暂先这样
+        if (context && !option?.dontCollect) {
+            const userId = context.getCurrentUserId(true);
+            if (userId && !entities_1.SYSTEM_RESERVE_ENTITIES.includes(entity2)) {
+                if (schema[entity2].relation && !projectionNode.userRelation$entity) {
+                    Object.assign(projectionNode, {
+                        userRelation$entity: {
+                            $entity: 'userRelation',
+                            data: {
+                                id: 1,
+                                entity: 1,
+                                entityId: 1,
+                                userId: 1,
+                                relationId: 1,
+                                relation: {
                                     id: 1,
-                                    entity: 1,
-                                    entityId: 1,
-                                    userId: 1,
-                                    relationId: 1,
-                                    relation: {
-                                        id: 1,
-                                        name: 1,
-                                        display: 1,
-                                        [Entity_1.CreateAtAttribute]: 1,
-                                        [Entity_1.UpdateAtAttribute]: 1,
-                                    },
+                                    name: 1,
+                                    display: 1,
                                     [Entity_1.CreateAtAttribute]: 1,
                                     [Entity_1.UpdateAtAttribute]: 1,
                                 },
-                                filter: {
-                                    userId,
-                                },
+                                [Entity_1.CreateAtAttribute]: 1,
+                                [Entity_1.UpdateAtAttribute]: 1,
                             },
-                        });
-                    }
+                            filter: {
+                                userId,
+                            },
+                        },
+                    });
                 }
             }
-        };
-        checkProjectionNode(entity, data);
-        if (!sorter && relevantIds.length === 0) {
-            // 如果没有sorter，就给予一个按createAt逆序的sorter
-            Object.assign(selection, {
-                sorter: [
-                    {
-                        $attr: {
-                            $$createAt$$: 1,
-                        },
-                        $direction: 'desc',
-                    }
-                ]
-            });
-            Object.assign(data, {
-                $$createAt$$: 1,
-            });
         }
+    };
+    checkProjectionNode(entity, data);
+    if (!sorter && relevantIds.length === 0) {
+        // 如果没有sorter，就给予一个按createAt逆序的sorter
+        Object.assign(selection, {
+            sorter: [
+                {
+                    $attr: {
+                        $$createAt$$: 1,
+                    },
+                    $direction: 'desc',
+                }
+            ]
+        });
+        Object.assign(data, {
+            $$createAt$$: 1,
+        });
+    }
+}
+exports.polishSelection = polishSelection;
+/**这个用来处理级联的select和update，对不同能力的 */
+class CascadeStore extends RowStore_1.RowStore {
+    constructor(storageSchema) {
+        super(storageSchema);
+    }
+    selectionRewriters = [];
+    operationRewriters = [];
+    async reinforceSelectionAsync(entity, selection, context, option, isAggr) {
+        if (!isAggr && !selection.distinct) {
+            polishSelection(this.getSchema(), entity, selection, context, option);
+        }
+        const rewriterPromises = this.selectionRewriters.map(ele => ele(this.getSchema(), entity, selection, context, option, isAggr));
+        if (rewriterPromises.length > 0) {
+            await Promise.all(rewriterPromises);
+        }
+    }
+    reinforceSelectionSync(entity, selection, context, option, isAggr) {
+        if (!isAggr && !selection.distinct) {
+            polishSelection(this.getSchema(), entity, selection);
+        }
+        this.selectionRewriters.forEach(ele => {
+            const result = ele(this.getSchema(), entity, selection, context, option, isAggr);
+            (0, assert_1.default)(!(result instanceof Promise));
+        });
     }
     async reinforceOperation(entity, operation, context, option) {
         await Promise.all(this.operationRewriters.map(ele => ele(this.getSchema(), entity, operation, context, option)));

package/lib/store/IntrinsicCheckers.js

@@ -273,6 +273,7 @@ function cascadelyCheckUpdateFilters(entity, schema, data, filter, matrix, restA
         if (!f) {
             return true;
         }
+        (0, assert_1.default)(typeof f !== 'function', '此处是原来写的时候的疏漏情况，跑出来再改。by Xc 20250214');
         // 此时看应用了success的attributes更新后，能否消除掉f中的部分条件
         const result = (0, filter_1.analyzeFilterRelation)(entity, schema, successAttrFilter, f, true);
         if (typeof result === 'boolean') {
@@ -325,7 +326,7 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                 const attrs = Object.keys(data);
                 const extras = (0, lodash_1.difference)(attrs, updateAttrs);
                 if (extras.length > 0) {
-                    throw new types_1.OakAttrCantUpdateException(entity, extras, '更新了不允许的属性');
+                    throw new types_1.OakAttrCantUpdateException(entity, extras);
                 }
                 const condition = attrs.map(ele => matrix[ele]);
                 const actions = condition.map(ele => ele?.actions).filter(ele => !!ele);
@@ -335,7 +336,7 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                     if (!a.includes(action)) {
                         // 找到不满足的那个attr
                         const attrsIllegal = attrs.filter((attr) => matrix[attr]?.actions && !matrix[attr]?.actions?.includes(action));
-                        throw new types_1.OakAttrCantUpdateException(entity, attrsIllegal, `${attrsIllegal.join(',')}不允许被${action}动作更新`);
+                        throw new types_1.OakAttrCantUpdateException(entity, attrsIllegal);
                     }
                 }
                 const filters = condition.map(ele => {
@@ -353,7 +354,7 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                                 if (attrs.length > 1) {
                                     return cascadelyCheckUpdateFilters(entity, schema, data, filter, matrix, attrs, context);
                                 }
-                                throw new types_1.OakAttrCantUpdateException(entity, attrs, '更新的行当前属性不满足约束，请仔细检查数据');
+                                throw new types_1.OakAttrCantUpdateException(entity, attrs);
                             }
                         });
                     }

package/lib/store/checker.js

@@ -352,11 +352,17 @@ function checkAttributeLegal(schema, entity, data) {
                 case 'char':
                 case 'varchar': {
                     if (typeof data[attr] !== 'string') {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is not a string`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesFormatError', 'oak-domain', {
+                            attribtues: attr,
+                            format: 'string',
+                        });
                     }
                     const { length } = params;
                     if (length && data[attr].length > length) {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is too long`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesTooLong', 'oak-domain', {
+                            attributes: attr,
+                            length,
+                        });
                     }
                     break;
                 }
@@ -367,21 +373,30 @@ function checkAttributeLegal(schema, entity, data) {
                 case 'decimal':
                 case 'money': {
                     if (typeof data[attr] !== 'number') {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is not a number`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesFormatError', 'oak-domain', {
+                            attribtues: attr,
+                            format: 'number',
+                        });
                     }
                     const { min, max } = params || {};
                     if (typeof min === 'number' && data[attr] < min) {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is too small`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesUnderMin', 'oak-domain', {
+                            attributes: attr,
+                            threshold: `${min}`,
+                        });
                     }
                     if (typeof max === 'number' && data[attr] > max) {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is too big`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesOverMax', 'oak-domain', {
+                            attributes: attr,
+                            threshold: `${max}`,
+                        });
                     }
                     break;
                 }
                 case 'enum': {
                     (0, assert_1.default)(enumeration);
                     if (!enumeration.includes(data[attr])) {
-                        throw new Exception_1.OakInputIllegalException(entity, [attr], `${entity}: ${attr}'s value "${data[attr]}" is not in enumeration`);
+                        throw new Exception_1.OakInputIllegalException(entity, [attr], 'error::attributesNotInEnumeration');
                     }
                     break;
                 }

package/lib/types/EntityDesc.d.ts

@@ -18,7 +18,7 @@ export type AttrUpdateMatrix<ED extends EntityDict> = {
     [T in keyof ED]?: {
         [A in keyof ED[T]['Update']['data']]?: {
             actions?: ED[T]['Action'][];
-            filter?: (NonNullable<ED[T]['Filter']>) | ((action: ED[T]['Action']) => NonNullable<ED[T]['Filter']>);
+            filter?: (NonNullable<ED[T]['Filter']>) | ((action: ED[T]['Action']) => ED[T]['Filter'] | undefined);
         };
     };
 };

package/lib/types/Exception.d.ts

@@ -186,6 +186,9 @@ export declare class OakExternalException<ED extends EntityDict & BaseEntityDict
 export declare class OakSocketConnectException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
     constructor(message?: string, _module?: string, params?: Record<string, any>);
 }
+export declare class OakApplicationHasToUpgrade<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
+    constructor(message?: string, _module?: string, params?: Record<string, any>);
+}
 export declare function makeException<ED extends EntityDict & BaseEntityDict>(data: {
     name: string;
     message?: string;

package/lib/types/Exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeException = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakDataInvisibleException = exports.OakOperationUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakSignatureVerificationException = exports.OakClockDriftException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakRequestTimeoutException = exports.OakException = void 0;
+exports.makeException = exports.OakApplicationHasToUpgrade = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakDataInvisibleException = exports.OakOperationUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakSignatureVerificationException = exports.OakClockDriftException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakRequestTimeoutException = exports.OakException = void 0;
 const relation_1 = require("../store/relation");
 const lodash_1 = require("../utils/lodash");
 class OakException extends Error {
@@ -225,7 +225,9 @@ class OakInputIllegalException extends OakUserException {
     attributes;
     entity;
     constructor(entity, attributes, message, _module, params) {
-        super(message, _module, params);
+        super(message, _module, params || {
+            attributes: attributes.join(','),
+        });
         this.entity = entity;
         this.attributes = attributes;
     }
@@ -423,6 +425,12 @@ class OakSocketConnectException extends OakUserException {
 }
 exports.OakSocketConnectException = OakSocketConnectException;
 ;
+class OakApplicationHasToUpgrade extends OakUserException {
+    constructor(message, _module, params) {
+        super(message || 'error::applicationHasToUpgrade', _module || 'oak-domain', params);
+    }
+}
+exports.OakApplicationHasToUpgrade = OakApplicationHasToUpgrade;
 function makeException(data) {
     const { name, message, _module, params } = data;
     let e = undefined;
@@ -531,6 +539,10 @@ function makeException(data) {
             e = new OakSignatureVerificationException(message, _module, params);
             break;
         }
+        case 'OakApplicationHasToUpgrade': {
+            e = new OakApplicationHasToUpgrade(message, _module, params);
+            break;
+        }
         default:
             return;
     }

package/lib/types/Trigger.d.ts

@@ -1,5 +1,5 @@
 import { SelectOption, CheckerType } from ".";
-import { GenericAction } from "../actions/action";
+import { ExcludeUpdateAction } from "../actions/action";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption } from "../types/Entity";
@@ -56,7 +56,7 @@ export type CreateTrigger<ED extends EntityDict & BaseEntityDict, T extends keyo
  * 只要有，就会触发trigger。要注意的是这个条件是exists而不是all
  */
 export interface UpdateTriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
-    action: Exclude<ED[T]['Action'], GenericAction> | 'update' | Array<Exclude<ED[T]['Action'], GenericAction> | 'update'>;
+    action: Exclude<ED[T]['Action'], ExcludeUpdateAction> | Array<Exclude<ED[T]['Action'], ExcludeUpdateAction>>;
     attributes?: keyof ED[T]['OpSchema'] | Array<keyof ED[T]['OpSchema']>;
     mt?: ModiTurn;
     check?: (operation: ED[T]['Update']) => boolean;

package/lib/utils/validator.js

@@ -119,7 +119,7 @@ function checkAttributesNotNull(entity, data, attributes, allowEmpty) {
         }
     });
     if (attrs.length > 0) {
-        throw new types_1.OakAttrNotNullException(entity, attrs, '属性不能为空');
+        throw new types_1.OakAttrNotNullException(entity, attrs, 'error::attributesNull');
     }
 }
 exports.checkAttributesNotNull = checkAttributesNotNull;
@@ -127,7 +127,7 @@ exports.checkAttributesNotNull = checkAttributesNotNull;
 function checkAttributesScope(entity, data, attributes) {
     const attrs = attributes.filter(attr => !data.hasOwnProperty(attr));
     if (attrs.length > 0) {
-        throw new types_1.OakInputIllegalException(entity, attrs, '多余的属性');
+        throw new types_1.OakInputIllegalException(entity, attrs, 'error::attributesCantUpdate');
     }
 }
 exports.checkAttributesScope = checkAttributesScope;

package/lib/utils/version.d.ts

@@ -4,4 +4,10 @@
  * @param reqVersion 比较版本
  * @returns
  */
-export declare const compareVersion: (curVersion: string, reqVersion: string) => number;
+export declare function compareVersion(curVersion: string, reqVersion: string): number;
+/**
+ * 是不是一个有效的版本号
+ * @param version
+ * @returns
+ */
+export declare function isVersion(version: string): boolean;

package/lib/utils/version.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareVersion = void 0;
+exports.isVersion = exports.compareVersion = void 0;
 /**
  * 版本比较
  * @param curVersion 当前版本
  * @param reqVersion 比较版本
  * @returns
  */
-const compareVersion = (curVersion, reqVersion) => {
+function compareVersion(curVersion, reqVersion) {
     const v1 = curVersion.split('.');
     const v2 = reqVersion.split('.');
     for (let i = 0; i < Math.max(v1.length, v2.length); i++) {
@@ -17,5 +17,15 @@ const compareVersion = (curVersion, reqVersion) => {
             return num1 - num2;
     }
     return 0;
-};
+}
 exports.compareVersion = compareVersion;
+;
+/**
+ * 是不是一个有效的版本号
+ * @param version
+ * @returns
+ */
+function isVersion(version) {
+    return /([1-9][0-9]*|[0-9])\.([1-9][0-9]*|[0-9])*\.([1-9][0-9]*|[0-9])*(\-[0-9A-Za-z-](\.[0-9A-Za-z-])*)*/g.test(version);
+}
+exports.isVersion = isVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "5.1.18",
+    "version": "5.1.20",
     "author": {
         "name": "XuChang"
     },