oak-domain 5.1.7 → 5.1.9

package/lib/compiler/schemalBuilder.js

@@ -160,7 +160,7 @@ function pushStatementIntoSchemaAst(moduleName, statement, sourceFile) {
  */
 function checkActionDefNameConsistent(filename, actionDefNode) {
     const { name, type } = actionDefNode;
-    (0, assert_1.default)(ts.isTypeReferenceNode(type));
+    (0, assert_1.default)(ts.isTypeReferenceNode(type), "ActionDef应该是一个类型引用");
     const { typeArguments } = type;
     (0, assert_1.default)(typeArguments.length === 2);
     const [actionNode, stateNode] = typeArguments;
@@ -173,7 +173,8 @@ function checkActionDefNameConsistent(filename, actionDefNode) {
     const adfName = name.text.slice(0, name.text.length - 9);
     const aName = actionNode.typeName.text.slice(0, actionNode.typeName.text.length - 6);
     const sName = stateNode.typeName.text.slice(0, stateNode.typeName.text.length - 5);
-    (0, assert_1.default)(adfName === aName && aName === sName, `文件${filename}中的ActionDef${name.text}中ActionDef, Action和State的命名规则不一致`);
+    (0, assert_1.default)(adfName === aName && aName === sName, `文件${filename}中的ActionDef${name.text}中ActionDef, Action和State的命名规则不一致， 需要
+        ${adfName}ActionDef, ${adfName}Action, ${adfName}State`);
 }
 function checkStringLiteralLegal(filename, obj, text, ele) {
     (0, assert_1.default)(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `${filename}中引用的${obj} ${text}中存在不是stringliteral的类型`);
@@ -188,13 +189,13 @@ function addImportedFrom(moduleName, name, node) {
     let propertyName;
     if (typeof node === 'object') {
         const { moduleSpecifier, importClause } = node;
-        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier));
-        (0, assert_1.default)(importClause);
+        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier), `${moduleName}中的${name}未引用正确的moduleSpecifier`);
+        (0, assert_1.default)(importClause, `${moduleName}中的${name}未引用正确的importClause`);
         const { namedBindings } = importClause;
-        (0, assert_1.default)(namedBindings);
+        (0, assert_1.default)(namedBindings, `${moduleName}中的${name}未引用正确的namedBindings`);
         (0, assert_1.default)(ts.isNamedImports(namedBindings));
         const importSpecifier = namedBindings.elements.find((ele) => ele.name.text === name);
-        (0, assert_1.default)(importSpecifier);
+        (0, assert_1.default)(importSpecifier, `${moduleName}中的${name}未引用正确的importSpecifier`);
         propertyName = importSpecifier.propertyName && importSpecifier.propertyName.text;
         importFrom = moduleSpecifier.text;
     }
@@ -209,7 +210,7 @@ function addImportedFrom(moduleName, name, node) {
         });
     }
     else {
-        (0, assert_1.default)(name.endsWith("State"));
+        (0, assert_1.default)(name.endsWith("State"), `${moduleName}中的${name}未以State结尾`);
         (0, lodash_1.assign)(ast.importStateFrom, {
             [name]: [importFrom, propertyName],
         });
@@ -225,15 +226,15 @@ function analyzeExternalAttrImport(node, program, importAttrFrom, relativePath)
     if (ts.isImportSpecifier(declaration)) {
         const name = declaration.name.text;
         const importDeclartion = declaration.parent.parent.parent;
-        (0, assert_1.default)(ts.isImportDeclaration(importDeclartion));
+        (0, assert_1.default)(ts.isImportDeclaration(importDeclartion), `未找到${name}的importDeclaration`);
         const { moduleSpecifier, importClause } = importDeclartion;
-        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier));
-        (0, assert_1.default)(importClause);
+        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier), `未找到${name}的moduleSpecifier`);
+        (0, assert_1.default)(importClause, `未找到${name}的importClause`);
         const { namedBindings } = importClause;
-        (0, assert_1.default)(namedBindings);
-        (0, assert_1.default)(ts.isNamedImports(namedBindings));
+        (0, assert_1.default)(namedBindings, `未找到${name}的namedBindings`);
+        (0, assert_1.default)(ts.isNamedImports(namedBindings), `未找到${name}的namedImports`);
         const importSpecifier = namedBindings.elements.find((ele) => ele.name.text === name);
-        (0, assert_1.default)(importSpecifier);
+        (0, assert_1.default)(importSpecifier, `未找到${name}的importSpecifier`);
         const propertyName = importSpecifier.propertyName && importSpecifier.propertyName.text;
         const importFrom = moduleSpecifier.text;
         const importFromRelatively = importFrom.startsWith('.') ? (relativePath
@@ -279,9 +280,9 @@ function tryGetStringLiteralValues(moduleName, filename, obj, node, program) {
             }).filter(ele => !!ele));
         }
         if (['state', 'action'].includes(obj)) {
-            (0, assert_1.default)(values.length > 0);
+            (0, assert_1.default)(values.length > 0, `${filename}中的${obj} ${node.typeName.getText()}未定义`);
             const importDeclartion = declaration.parent.parent.parent;
-            (0, assert_1.default)(ts.isImportDeclaration(importDeclartion));
+            (0, assert_1.default)(ts.isImportDeclaration(importDeclartion), '未找到importDeclaration');
             addImportedFrom(moduleName, declaration.name.text, importDeclartion);
         }
     }
@@ -306,7 +307,7 @@ function tryGetStringLiteralValues(moduleName, filename, obj, node, program) {
             values.push(action);
         }
         if (['state', 'action'].includes(obj)) {
-            (0, assert_1.default)(values.length > 0);
+            (0, assert_1.default)(values.length > 0, `${filename}中的${obj} ${node.typeName.getText()}未定义`);
             const ast = ActionAsts[moduleName];
             addImportedFrom(moduleName, declaration.name.text, './');
         }
@@ -339,8 +340,9 @@ function dealWithActionTypeNode(moduleName, filename, actionTypeNode, program, s
         (0, assert_1.default)((0, lodash_1.intersection)(actionNames, RESERVED_ACTION_NAMES).length === 0, `${filename}中的Action命名不能是「${RESERVED_ACTION_NAMES.join(',')}」之一`);
         actionTypeNode.types.forEach(ele => {
             if (ts.isTypeReferenceNode(ele)) {
+                // 这里递归了类型定义，去查找所有的action字符串
                 const actionStrings = tryGetStringLiteralValues(moduleName, filename, 'action', ele, program);
-                (0, assert_1.default)(actionStrings.length > 0);
+                (0, assert_1.default)(actionStrings.length > 0, `${filename}中的Action所引用的Type定义为空`);
                 actionTexts.push(...actionStrings);
             }
             else {
@@ -354,7 +356,7 @@ function dealWithActionTypeNode(moduleName, filename, actionTypeNode, program, s
             (0, assert_1.default)(!RESERVED_ACTION_NAMES.includes(actionTypeNode.typeName.text), `${filename}中的Action命名不能是「${RESERVED_ACTION_NAMES.join(',')}」之一`);
         }
         const actionStrings = tryGetStringLiteralValues(moduleName, filename, 'action', actionTypeNode, program);
-        (0, assert_1.default)(actionStrings.length > 0);
+        (0, assert_1.default)(actionStrings.length > 0, `${filename}中的Action定义为空`);
         actionTexts.push(...actionStrings);
     }
     else {
@@ -382,10 +384,10 @@ function dealWithActionDefInitializer(moduleName, initializer, program) {
         // 是从别处的引用，注入到mportActionDefFrom
         const checker = program.getTypeChecker();
         const identifier = ts.isIdentifier(initializer) ? initializer : initializer.expression;
-        (0, assert_1.default)(ts.isIdentifier(identifier));
+        (0, assert_1.default)(ts.isIdentifier(identifier), "ActionDef的initializer不是一个Identifier");
         const symbol = checker.getSymbolAtLocation(identifier);
         const declaration = symbol?.getDeclarations()[0];
-        (0, assert_1.default)(ts.isImportSpecifier(declaration));
+        (0, assert_1.default)(ts.isImportSpecifier(declaration), "ActionDef的initializer不是一个ImportSpecifier");
         const importDeclartion = declaration.parent.parent.parent;
         addImportedFrom(moduleName, identifier.text, importDeclartion);
     }
@@ -418,7 +420,7 @@ function getEntityImported(declaration) {
 function checkLocaleEnumAttrs(node, attrs, filename) {
     const { members } = node;
     const memberKeys = members.map((ele) => {
-        (0, assert_1.default)(ts.isPropertySignature(ele) && ts.isIdentifier(ele.name));
+        (0, assert_1.default)(ts.isPropertySignature(ele) && ts.isIdentifier(ele.name), 'locale定义中的属性必须是identifier');
         return ele.name.text;
     });
     const lack = (0, lodash_1.difference)(attrs, memberKeys);
@@ -432,7 +434,7 @@ function checkLocaleExpressionPropertyExists(root, attr, exists, filename) {
         (0, assert_1.default)(ts.isPropertyAssignment(ele) && (ts.isIdentifier(ele.name) || ts.isStringLiteral(ele.name)) && ts.isObjectLiteralExpression(ele.initializer));
         const { properties: p2 } = ele.initializer;
         const pp = p2.find((ele2) => {
-            (0, assert_1.default)(ts.isPropertyAssignment(ele2) && ts.isIdentifier(ele2.name));
+            (0, assert_1.default)(ts.isPropertyAssignment(ele2) && ts.isIdentifier(ele2.name), 'locale定义中的属性必须是identifier');
             return ele2.name.text === attr;
         });
         if (exists && !pp) {
@@ -565,14 +567,9 @@ function analyzeImportDeclaration(node, referencedSchemas, additionalImports, fi
     }
 }
 /**
- * 在path下的filename文件中import了fileSpecifierPath，要找到其对应的引用路径
- * 这里关键是要处理形如file:的依赖声明
- * @param path
- * @param fileSpecifierPath
- * @param filename
- * @returns
+ * 处理模块的导入，得到导入文件的sourcefile
  */
-function getImportedFilePath(path, fileSpecifierPath, filename) {
+function dealImportedFile(path, fileSpecifierPath, filename, program) {
     let importedFilepath = '';
     const getExistedFileName = () => {
         if ((0, fs_1.existsSync)(`${importedFilepath}.ts`)) {
@@ -587,39 +584,76 @@ function getImportedFilePath(path, fileSpecifierPath, filename) {
         importedFilepath = path_1.default.join(path, fileSpecifierPath);
         const importedFilename = getExistedFileName();
         (0, assert_1.default)(importedFilename, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
-        return importedFilename;
-    }
-    else {
-        const cwd = process.cwd();
-        const fileSpecifierPaths = fileSpecifierPath.split('/');
-        const moduleName = fileSpecifierPaths[0] || fileSpecifierPaths[1];
-        (0, assert_1.default)(moduleName);
-        // 从path向外找package.json -> node_modules直至找到fileSpecifier
-        const paths = path.split('/');
-        for (let iter = paths.length; iter >= 0; iter--) {
-            const paths2 = paths.slice(0, iter);
-            const pkgJsonPath = path_1.default.join(cwd, ...paths2, 'package.json');
-            if ((0, fs_1.existsSync)(pkgJsonPath)) {
-                const pkgJson = require(pkgJsonPath);
-                if (pkgJson.dependencies?.hasOwnProperty(moduleName)) {
-                    const dependentPath = pkgJson.dependencies[moduleName];
-                    if (dependentPath.trimStart().startsWith('file:')) {
-                        const dependentFilePath = dependentPath.trimStart().slice(5);
-                        importedFilepath = path_1.default.join(pkgJsonPath, '..', dependentFilePath, ...(fileSpecifierPaths[0] ? fileSpecifierPaths.slice(1) : (fileSpecifierPaths.slice(2))));
-                    }
-                    else {
-                        importedFilepath = path_1.default.join(pkgJsonPath, '..', 'node_modules', fileSpecifierPath);
-                    }
-                    const importedFilename = getExistedFileName();
-                    if (importedFilename) {
-                        return importedFilename;
-                    }
-                }
-            }
-        }
+        const sourceFile = program.getSourceFile(importedFilename);
+        (0, assert_1.default)(sourceFile, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+        return [sourceFile, importedFilename];
     }
-    (0, assert_1.default)(false, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+    // 创建编译器主机
+    const compilerHost = ts.createCompilerHost(program.getCompilerOptions());
+    // 解析模块
+    const resolvedModule = ts.resolveModuleName(fileSpecifierPath, filename, program.getCompilerOptions(), compilerHost);
+    (0, assert_1.default)(resolvedModule.resolvedModule, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+    const pathName = resolvedModule.resolvedModule.resolvedFileName;
+    const sourceFile = program.getSourceFile(pathName);
+    (0, assert_1.default)(sourceFile, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+    return [sourceFile, pathName];
 }
+/**
+ * 在path下的filename文件中import了fileSpecifierPath，要找到其对应的引用路径
+ * 这里关键是要处理形如file:的依赖声明
+ * @param path
+ * @param fileSpecifierPath
+ * @param filename
+ * @returns
+ */
+// function getImportedFilePath(path: string, fileSpecifierPath: string, filename: string) {
+//     let importedFilepath = '';
+//     const getExistedFileName = () => {
+//         if (existsSync(`${importedFilepath}.ts`)) {
+//             return `${importedFilepath}.ts`;
+//         }
+//         else if (existsSync(`${importedFilepath}.d.ts`)) {
+//             return `${importedFilepath}.d.ts`;
+//         }
+//         return '';
+//     };
+//     if (fileSpecifierPath.startsWith('.')) {
+//         importedFilepath = PathLib.join(path, fileSpecifierPath);
+//         const importedFilename = getExistedFileName();
+//         assert(importedFilename, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+//         return importedFilename;
+//     }
+//     else {
+//         const cwd = process.cwd();
+//         const fileSpecifierPaths = fileSpecifierPath.split('/');
+//         const moduleName = fileSpecifierPaths[0] || fileSpecifierPaths[1];
+//         assert(moduleName, '「${filename}」中import路径不合法');
+//         // 从path向外找package.json -> node_modules直至找到fileSpecifier
+//         const paths = path.split('/');
+//         for (let iter = paths.length; iter >= 0; iter--) {
+//             const paths2 = paths.slice(0, iter);
+//             const pkgJsonPath = PathLib.join(cwd, ...paths2, 'package.json');
+//             if (existsSync(pkgJsonPath)) {
+//                 const pkgJson = require(pkgJsonPath);
+//                 if (pkgJson.dependencies?.hasOwnProperty(moduleName)) {
+//                     const dependentPath = pkgJson.dependencies[moduleName] as string;
+//                     if (dependentPath.trimStart().startsWith('file:')) {
+//                         const dependentFilePath = dependentPath.trimStart().slice(5);
+//                         importedFilepath = PathLib.join(pkgJsonPath, '..', dependentFilePath, ...(fileSpecifierPaths[0] ? fileSpecifierPaths.slice(1) : (fileSpecifierPaths.slice(2))));
+//                     }
+//                     else {
+//                         importedFilepath = PathLib.join(pkgJsonPath, '..', 'node_modules', fileSpecifierPath);
+//                     }
+//                     const importedFilename = getExistedFileName();
+//                     if (importedFilename) {
+//                         return importedFilename;
+//                     }
+//                 }
+//             }
+//         }
+//     }
+//     assert(false, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+// }
 function analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, relativePath) {
     let hasEntityAttr = false;
     let hasEntityIdAttr = false;
@@ -627,30 +661,28 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
     let toLog = false;
     const extendsFrom = [];
     const { members, heritageClauses } = node;
-    (0, assert_1.default)(heritageClauses);
+    (0, assert_1.default)(heritageClauses, `「${filename}」中的Schema定义需要继承EntityShape或者其他Entity`);
     const heritagedResult = heritageClauses.map((clause) => {
         const { expression } = clause.types[0];
-        (0, assert_1.default)(ts.isIdentifier(expression));
+        (0, assert_1.default)(ts.isIdentifier(expression), `${expression}不是一个合法的继承类型`);
         if (expression.text === 'EntityShape') {
             // import { EntityShape }  from 'oak-domain/lib/types/Entities; 所有schema的公共祖先类型，不用处理
             return;
         }
         // 从其它文件的Schema类继承，这里需要将所继承的对象的属性进行访问并展开
-        (0, assert_1.default)(referencedSchemas.includes(expression.text));
+        (0, assert_1.default)(referencedSchemas.includes(expression.text), `「${filename}」中的Schema继承了未定义的实体「${expression.text}」`);
         const checker = program.getTypeChecker();
         const symbol = checker.getSymbolAtLocation(expression);
         let declaration = symbol?.getDeclarations()[0];
-        (0, assert_1.default)(ts.isImportSpecifier(declaration));
+        (0, assert_1.default)(ts.isImportSpecifier(declaration), `${declaration.getText()}应该是导入的类型`);
         const importDeclaration = declaration.parent.parent.parent;
-        (0, assert_1.default)(ts.isImportDeclaration(importDeclaration));
+        (0, assert_1.default)(ts.isImportDeclaration(importDeclaration), `${declaration.getText()}应该是导入的类型`);
         const { moduleSpecifier } = importDeclaration;
-        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier));
+        (0, assert_1.default)(ts.isStringLiteral(moduleSpecifier), `${declaration.getText()}应该是导入的类型`);
         const { text: from } = moduleSpecifier;
         extendsFrom.push(from);
-        const importedFilename = getImportedFilePath(path, from, filename);
-        const sourceFile = program.getSourceFile(importedFilename);
-        (0, assert_1.default)(sourceFile, `「${filename}」找不到相应的sourceFile：${importedFilename}`);
-        const relativeFilename = path_1.default.relative(process.cwd(), importedFilename);
+        const [sourceFile, pathName] = dealImportedFile(path, from, filename, program);
+        const relativeFilename = path_1.default.relative(process.cwd(), pathName);
         const result = analyzeReferenceSchemaFile(moduleName, path_1.default.basename(relativeFilename), path_1.default.dirname(relativeFilename), sourceFile, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, path_1.default.join(from, '..'));
         return result;
     }).filter(ele => !!ele);
@@ -730,7 +762,7 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
         else {
             schemaAttrs.push(attrNode);
             if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) && ts.isStringLiteral(type.types[0].literal)) {
-                (0, assert_1.default)(ts.isIdentifier(name));
+                (0, assert_1.default)(ts.isIdentifier(name), `「${filename}」中的属性定义不是String类型`);
                 const { types } = type;
                 const enumValues = types.map((ele) => checkStringLiteralLegal(filename, '属性', name.text, ele));
                 enumAttributes[name.text] = enumValues;
@@ -825,13 +857,13 @@ function analyzeReferenceSchemaFile(moduleName, filename, path, sourceFile, prog
             }
         }
     });
-    (0, assert_1.default)(result);
+    (0, assert_1.default)(result, `「${filename}」中没有找到Schema定义`);
     return result;
 }
 function analyzeEntity(filename, path, program, relativePath) {
     const fullPath = `${path}/${filename}`;
     const sourceFile = program.getSourceFile(fullPath);
-    (0, assert_1.default)(sourceFile);
+    (0, assert_1.default)(sourceFile, `「${filename}」文件不存在`);
     const moduleName = filename.split('.')[0];
     if (Schema.hasOwnProperty(moduleName)) {
         delete ActionAsts[moduleName];
@@ -918,13 +950,13 @@ function analyzeEntity(filename, path, program, relativePath) {
                 (0, assert_1.default)(!localeDef, `【${filename}】locale定义须在Relation之后`);
                 const relationValues = [];
                 if (ts.isLiteralTypeNode(node.type)) {
-                    (0, assert_1.default)(ts.isStringLiteral(node.type.literal));
+                    (0, assert_1.default)(ts.isStringLiteral(node.type.literal), `${filename}中的Relation的定义只能是string类型`);
                     (0, assert_1.default)(node.type.literal.text.length < env_1.STRING_LITERAL_MAX_LENGTH, `Relation定义的字符串长度不长于${env_1.STRING_LITERAL_MAX_LENGTH}（${filename}，${node.type.literal.text}）`);
                     relationValues.push(node.type.literal.text);
                 }
                 else if (ts.isTypeReferenceNode(node.type)) {
                     const relationStrings = tryGetStringLiteralValues(moduleName, filename, 'relation', node.type, program);
-                    (0, assert_1.default)(relationStrings.length > 0);
+                    (0, assert_1.default)(relationStrings.length > 0, `文件${filename}中的relation${node.type.typeName.text}定义未找到字符串类型`);
                     relationValues.push(...relationStrings);
                 }
                 else {
@@ -938,7 +970,7 @@ function analyzeEntity(filename, path, program, relativePath) {
                         else {
                             (0, assert_1.default)(ts.isTypeReferenceNode(ele), `Relation的定义只能是string类型，或者string union类型，或者两者的union（${filename}）`);
                             const relationStrings = tryGetStringLiteralValues(moduleName, filename, 'relation', ele, program);
-                            (0, assert_1.default)(relationStrings.length > 0);
+                            (0, assert_1.default)(relationStrings.length > 0, `文件${filename}中的relation${ele.typeName.text}定义未找到字符串类型`);
                             relationValues.push(...relationStrings);
                         }
                     });
@@ -990,7 +1022,7 @@ function analyzeEntity(filename, path, program, relativePath) {
                     ]) : type), sourceFile);
                 }
                 else {
-                    (0, assert_1.default)(ts.isLiteralTypeNode(type) || ts.isTypeReferenceNode(type), `${moduleName} - ${node.name}`);
+                    (0, assert_1.default)(ts.isLiteralTypeNode(type) || ts.isTypeReferenceNode(type), `文件${filename}中的${type.getText()}应该是字面量或引用类型`);
                     pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, node.typeParameters, process.env.COMPLING_AS_LIB ? factory.createUnionTypeNode([
                         type,
                         factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
@@ -1007,12 +1039,12 @@ function analyzeEntity(filename, path, program, relativePath) {
             const dealWithActionDef = (declaration) => {
                 checkActionDefNameConsistent(filename, declaration);
                 const { typeArguments } = declaration.type;
-                (0, assert_1.default)(typeArguments.length === 2);
+                (0, assert_1.default)(typeArguments.length === 2, `文件${filename}中的action定义不是两个泛型参数`);
                 const [actionNode, stateNode] = typeArguments;
-                (0, assert_1.default)(ts.isTypeReferenceNode(actionNode));
+                (0, assert_1.default)(ts.isTypeReferenceNode(actionNode), `文件${filename}中的action定义不是TypeReferenceNode`);
                 // 这里有可能引用的Action不是本文件的定义，要调用这个函数加到importFrom中
                 tryGetStringLiteralValues(moduleName, filename, 'action', actionNode, program);
-                (0, assert_1.default)(ts.isTypeReferenceNode(stateNode));
+                (0, assert_1.default)(ts.isTypeReferenceNode(stateNode), `文件${filename}中的action定义不是TypeReferenceNode`);
                 const enumStateValues = tryGetStringLiteralValues(moduleName, filename, 'state', stateNode, program);
                 (0, assert_1.default)(enumStateValues.length > 0, `文件${filename}中的state${stateNode.typeName.text}定义不是字符串类型`);
                 pushStatementIntoActionAst(moduleName, node, sourceFile);
@@ -1029,18 +1061,18 @@ function analyzeEntity(filename, path, program, relativePath) {
                 const { elements } = declaration;
                 elements.forEach((ele) => {
                     let isFulltextIndex = false;
-                    (0, assert_1.default)(ts.isObjectLiteralExpression(ele));
+                    (0, assert_1.default)(ts.isObjectLiteralExpression(ele), `「${filename}」中索引定义应该是对象字面量`);
                     const { properties } = ele;
                     const attrProperty = properties.find((ele2) => {
-                        (0, assert_1.default)(ts.isPropertyAssignment(ele2));
+                        (0, assert_1.default)(ts.isPropertyAssignment(ele2), `「${filename}」中索引的属性不为PropertyAssignment`);
                         return ele2.name.getText() === 'attributes';
                     });
-                    (0, assert_1.default)(ts.isArrayLiteralExpression(attrProperty.initializer));
+                    (0, assert_1.default)(ts.isArrayLiteralExpression(attrProperty.initializer), `「${filename}」中索引的attributes属性应该是数组字面量`);
                     const nameProperty = properties.find((ele2) => {
                         (0, assert_1.default)(ts.isPropertyAssignment(ele2));
                         return ele2.name.getText() === 'name';
                     });
-                    (0, assert_1.default)(ts.isStringLiteral(nameProperty.initializer));
+                    (0, assert_1.default)(ts.isStringLiteral(nameProperty.initializer), '「${filename}」中索引的name属性应该是字符串字面量');
                     const nameText = nameProperty.initializer.text;
                     if (indexNameDict[nameText]) {
                         throw new Error(`「${filename}」索引定义重名「${nameText}」`);
@@ -1049,14 +1081,14 @@ function analyzeEntity(filename, path, program, relativePath) {
                         [nameText]: true,
                     });
                     const configProperty = properties.find((ele2) => {
-                        (0, assert_1.default)(ts.isPropertyAssignment(ele2));
+                        (0, assert_1.default)(ts.isPropertyAssignment(ele2), `「${filename}」中索引的属性不为PropertyAssignment`);
                         return ele2.name.getText() === 'config';
                     });
                     if (configProperty) {
-                        (0, assert_1.default)(ts.isObjectLiteralExpression(configProperty.initializer));
+                        (0, assert_1.default)(ts.isObjectLiteralExpression(configProperty.initializer), `「${filename}」中索引的config属性应该是对象字面量`);
                         const { properties: properties2 } = configProperty.initializer;
                         const typeProperty = properties2.find((ele2) => {
-                            (0, assert_1.default)(ts.isPropertyAssignment(ele2));
+                            (0, assert_1.default)(ts.isPropertyAssignment(ele2), `「${filename}」中索引的属性不为PropertyAssignment`);
                             return ele2.name.getText() === 'type';
                         });
                         if (typeProperty && typeProperty.initializer.text === 'fulltext') {
@@ -1171,21 +1203,21 @@ function analyzeEntity(filename, path, program, relativePath) {
                 if (ts.isObjectLiteralExpression(declaration)) {
                     const { properties } = declaration;
                     const localesProperty = properties.find(ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'locales');
-                    (0, assert_1.default)(ts.isPropertyAssignment(localesProperty));
+                    (0, assert_1.default)(ts.isPropertyAssignment(localesProperty), `「${filename}」中entityDesc的locales应该是属性声明`);
                     dealWithLocales(localesProperty.initializer);
                     const indexesProperty = properties.find(ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'indexes');
                     if (indexesProperty) {
-                        (0, assert_1.default)(ts.isPropertyAssignment(indexesProperty));
+                        (0, assert_1.default)(ts.isPropertyAssignment(indexesProperty), `「${filename}」中entityDesc的indexes应该是属性声明`);
                         dealWithIndexes(indexesProperty.initializer);
                     }
                     const configurationProperty = properties.find(ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'configuration');
                     if (configurationProperty) {
-                        (0, assert_1.default)(ts.isPropertyAssignment(configurationProperty));
+                        (0, assert_1.default)(ts.isPropertyAssignment(configurationProperty), `「${filename}」中entityDesc的configuration应该是属性声明`);
                         dealWithConfiguration(configurationProperty.initializer);
                     }
                     const styleDescProperty = properties.find(ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'style');
                     if (styleDescProperty) {
-                        (0, assert_1.default)(ts.isPropertyAssignment(styleDescProperty));
+                        (0, assert_1.default)(ts.isPropertyAssignment(styleDescProperty), `「${filename}」中entityDesc的style应该是属性声明`);
                         dealWithStyleDesc(styleDescProperty.initializer);
                     }
                 }
@@ -1216,14 +1248,14 @@ function analyzeEntity(filename, path, program, relativePath) {
                         && declaration.type.typeArguments[0].typeName.text === 'Index')) {
                     // 对索引Index的定义
                     console.log(`「${filename}」直接定义indexes的写法已经过时，请定义在entityDesc中`);
-                    (0, assert_1.default)(ts.isArrayLiteralExpression(declaration.initializer));
+                    (0, assert_1.default)(ts.isArrayLiteralExpression(declaration.initializer), `「${filename}」中索引定义应该是数组字面量`);
                     dealWithIndexes(declaration.initializer);
                 }
                 else if (declaration.type && ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'LocaleDef') {
                     // locale定义
                     console.log(`「${filename}」直接定义locales的写法已经过时，请定义在entityDesc中`);
                     const { type, initializer } = declaration;
-                    (0, assert_1.default)(ts.isObjectLiteralExpression(initializer));
+                    (0, assert_1.default)(ts.isObjectLiteralExpression(initializer), `「${filename}」中locale定义应该是对象字面量`);
                     const { properties } = initializer;
                     (0, assert_1.default)(properties.length > 0, `${filename}至少需要有一种locale定义`);
                     const allEnumStringAttrs = Object.keys(enumAttributes);
@@ -1260,12 +1292,12 @@ function analyzeEntity(filename, path, program, relativePath) {
                 }
                 else if (declaration.type && ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'Configuration') {
                     console.log(`「${filename}」直接定义configuration的写法已经过时，请定义在entityDesc中`);
-                    (0, assert_1.default)(ts.isObjectLiteralExpression(declaration.initializer));
+                    (0, assert_1.default)(ts.isObjectLiteralExpression(declaration.initializer), `「${filename}」中configuration定义应该是对象字面量`);
                     dealWithConfiguration(declaration.initializer);
                 }
                 else if (declaration.type && ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'EntityDesc') {
                     const { initializer } = declaration;
-                    (0, assert_1.default)(initializer);
+                    (0, assert_1.default)(initializer, `「${filename}」中entityDesc的定义不应该为空`);
                     dealWithEntityDesc(initializer);
                 }
                 else {
@@ -1609,7 +1641,7 @@ function constructFilter(statements, entity) {
         }
         else {
             // 此时应当是引用本地定义的shape
-            (0, assert_1.default)(type);
+            (0, assert_1.default)(type, `${entity}中的属性${name.toString()}有非法的属性类型定义`);
             members.push(factory.createPropertySignature(undefined, name, undefined, factory.createTypeReferenceNode(factory.createIdentifier('JsonFilter'), [
                 type
             ])));
@@ -3110,7 +3142,7 @@ function outputSchema(outputDir, printer) {
             const fromLocalActionSpecifiers = ['Action', 'ParticularAction'];
             const fromExtenalStates = {};
             for (const state in importStateFrom) {
-                (0, assert_1.default)(state.endsWith('State'));
+                (0, assert_1.default)(state.endsWith('State'), `${state} should end with State`);
                 if (importStateFrom[state][0] === './') {
                     // 本地定义的State从 ./Action 中获取
                     fromLocalActionSpecifiers.push(state);
@@ -3239,7 +3271,7 @@ function outputAction(outputDir, printer) {
         const importStatements = [];
         const fromExternalImports = {};
         for (const state in importStateFrom) {
-            (0, assert_1.default)(state.endsWith('State'));
+            (0, assert_1.default)(state.endsWith('State'), `${state} should end with State`);
             const [from, propertyName] = importStateFrom[state];
             if (from !== './') {
                 if (fromExternalImports[from]) {
@@ -3251,7 +3283,7 @@ function outputAction(outputDir, printer) {
             }
         }
         for (const action in importActionFrom) {
-            (0, assert_1.default)(action.endsWith('Action'));
+            (0, assert_1.default)(action.endsWith('Action'), `${action} should end with Action`);
             const [from, propertyName] = importActionFrom[action];
             if (from !== './') {
                 if (fromExternalImports[from]) {
@@ -3263,7 +3295,7 @@ function outputAction(outputDir, printer) {
             }
         }
         for (const def in importActionDefFrom) {
-            (0, assert_1.default)(def.endsWith('ActionDef'));
+            (0, assert_1.default)(def.endsWith('ActionDef'), `${def} should end with ActionDef`);
             const [from, propertyName] = importActionDefFrom[def];
             if (from !== './') {
                 if (fromExternalImports[from]) {
@@ -3405,11 +3437,11 @@ function constructAttributes(entity) {
             if (ts.isUnionTypeNode(type)) {
                 if (ts.isLiteralTypeNode(type.types[0])) {
                     if (ts.isStringLiteral(type.types[0].literal)) {
-                        (0, assert_1.default)(enumAttributes && enumAttributes[name.text]);
+                        (0, assert_1.default)(enumAttributes && enumAttributes[name.text], `${entity}对象中的${name.text}属性没有定义enumAttributes`);
                         attrAssignments.push(factory.createPropertyAssignment('type', factory.createStringLiteral("enum")), factory.createPropertyAssignment('enumeration', factory.createArrayLiteralExpression(enumAttributes[name.text].map(ele => factory.createStringLiteral(ele)))));
                     }
                     else {
-                        (0, assert_1.default)(ts.isNumericLiteral(type.types[0].literal));
+                        (0, assert_1.default)(ts.isNumericLiteral(type.types[0].literal), `${entity}对象中的${type.types[0].literal.getText()}属性不是数字`);
                         attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("int")), factory.createPropertyAssignment(factory.createIdentifier("params"), factory.createObjectLiteralExpression([
                             factory.createPropertyAssignment(factory.createIdentifier("width"), factory.createNumericLiteral(env_1.INT_LITERL_DEFAULT_WIDTH))
                         ], true)));
@@ -3426,7 +3458,7 @@ function constructAttributes(entity) {
                         attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("varchar")), factory.createPropertyAssignment(factory.createIdentifier("params"), factory.createObjectLiteralExpression([factory.createPropertyAssignment(factory.createIdentifier("length"), factory.createNumericLiteral(env_1.STRING_LITERAL_MAX_LENGTH))], true)));
                     }
                     else {
-                        (0, assert_1.default)(ts.isNumericLiteral(type.literal));
+                        (0, assert_1.default)(ts.isNumericLiteral(type.literal), `${entity}对象中的${name.text}属性不是数字`);
                         attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("precision")), factory.createPropertyAssignment(factory.createIdentifier("params"), factory.createObjectLiteralExpression([
                             factory.createPropertyAssignment(factory.createIdentifier("precision"), factory.createNumericLiteral(env_1.NUMERICAL_LITERL_DEFAULT_PRECISION)),
                             factory.createPropertyAssignment(factory.createIdentifier("scale"), factory.createNumericLiteral(env_1.NUMERICAL_LITERL_DEFAULT_SCALE))
@@ -3451,14 +3483,14 @@ function outputLocale(outputDir, printer) {
         if (locale) {
             const { properties } = locale;
             properties.forEach((ele) => {
-                (0, assert_1.default)(ts.isPropertyAssignment(ele) && (ts.isIdentifier(ele.name) || ts.isStringLiteral(ele.name)) && ts.isObjectLiteralExpression(ele.initializer));
+                (0, assert_1.default)(ts.isPropertyAssignment(ele) && (ts.isIdentifier(ele.name) || ts.isStringLiteral(ele.name)) && ts.isObjectLiteralExpression(ele.initializer), `${entity}对象中的locale属性定义不正确`);
                 const lng = ele.name.text;
                 const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray([
                     factory.createReturnStatement(ele.initializer)
                 ]), sourceFile);
                 const data = Function(result)();
                 const filename = path_1.default.join(outputDir, entity, 'locales', `${lng}.json`);
-                (0, fs_1.writeFileSync)(filename, JSON.stringify(data), { flag: 'w' });
+                (0, fs_1.writeFileSync)(filename, JSON.stringify(data, null, 2), { flag: 'w' });
                 if (locales[lng]) {
                     locales[lng].push(entity);
                 }

package/lib/entities/I18n.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const entityDesc = {
     locales: {
         zh_CN: {
-            name: '用户授权',
+            name: 'i18n',
             attr: {
                 module: '模块',
                 position: '文件位置',

package/lib/store/IntrinsicCheckers.js

@@ -269,7 +269,7 @@ function cascadelyCheckUpdateFilters(entity, schema, data, filter, matrix, restA
      * 先找到能直接更新成功的属性
      */
     const legalAttrResult = restAttrs.map((attr) => {
-        const { filter: f } = matrix[attr];
+        const { filter: f } = matrix[attr] || {};
         if (!f) {
             return true;
         }
@@ -331,6 +331,7 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                 const actions = condition.map(ele => ele?.actions).filter(ele => !!ele);
                 const a = actions.length > 0 && (0, lodash_1.intersection)(actions.flat());
                 if (a) {
+                    (0, assert_1.default)(action);
                     if (!a.includes(action)) {
                         // 找到不满足的那个attr
                         const attrsIllegal = attrs.filter((attr) => matrix[attr]?.actions && !matrix[attr]?.actions?.includes(action));

package/lib/store/TriggerExecutor.js

@@ -253,10 +253,13 @@ class TriggerExecutor {
                     cxtStr2 = data.$$triggerData$$?.cxtStr;
                 }
                 const record = opRecords.find(ele => ele.id === operation.id);
-                // 目前框架在operation时，一定会将ids记录在operation当中（见CascadeStore中的doUpdateSingleRowAsync函数
-                (0, assert_1.default)(record && record.a !== 'c');
-                const { f } = record;
-                ids = f.id.$in;
+                if (record) {
+                    // 目前框架在operation时，一定会将ids记录在operation当中（见CascadeStore中的doUpdateSingleRowAsync函数
+                    // 但也有一种可能，此operation没有更新任何一行。by Xc 20241022
+                    (0, assert_1.default)(record.a !== 'c');
+                    const { f } = record;
+                    ids = f.id.$in;
+                }
             }
             // 此时项目的上下文，和执行此trigger时的上下文可能不一致（rootMode），采用当时的上下文cxtStr来执行
             this.onVolatileTrigger(entity, trigger, ids, cxtStr2, option);
@@ -348,12 +351,12 @@ class TriggerExecutor {
     async execVolatileTrigger(entity, name, ids, context, option) {
         const trigger = this.triggerNameMap[name];
         (0, assert_1.default)(trigger && trigger.when === 'commit');
-        (0, assert_1.default)(ids.length > 0);
+        // assert(ids.length > 0);
         const { fn } = trigger;
         const closeRoot = trigger.asRoot && context.openRootMode();
         try {
             const callback = await fn({ ids }, context, option);
-            if (trigger.strict === 'makeSure') {
+            if (trigger.strict === 'makeSure' && ids.length) {
                 // 这里开root模式，否则还可能有权限问题
                 const closeRoot2 = context.openRootMode();
                 try {

package/lib/store/filter.js

@@ -1621,7 +1621,7 @@ function checkDeduceFilters(dfc, context) {
  * @returns
  */
 function checkFilterContains(entity, context, contained, filter, dataCompare, warningOnDataCompare) {
-    (0, assert_1.default)(filter);
+    (0, assert_1.default)(filter, `对${entity}的访问必须有filter`);
     const schema = context.getSchema();
     const result = contains(entity, schema, filter, contained);
     if (typeof result === 'boolean') {

package/lib/store/triggers.js

@@ -362,41 +362,25 @@ exports.logTriggers = [
             return (result.oper?.remove || 0) + (result2.log?.remove || 0);
         }
     },
-    // 在删除log时，解除与此log关联的oper
+    // 在删除log时，删除与此log关联的oper
     {
-        name: '当删除log时，解除与此log关联的oper',
+        name: '当删除log时，删除与此log关联的oper',
         entity: 'log',
         action: 'remove',
         when: 'before',
         fn: async ({ operation }, context) => {
             const { filter } = operation;
             (0, assert_1.default)(filter);
-            // 查询这次删除操作涉及到的所有log 
-            const logs = await context.select('log', {
-                data: {
-                    id: 1,
-                    oper$log: {
-                        $entity: 'oper',
-                        data: {
-                            id: 1,
-                        },
-                    },
-                },
-                filter,
+            // 查询这次删除操作涉及到的所有log
+            const result = await context.operate('oper', {
+                id: "dummy",
+                action: 'remove',
+                data: {},
+                filter: {
+                    log: filter,
+                }
             }, {});
-            const operIds = logs.flatMap(log => log.oper$log.map(oper => oper.id));
-            let result = 0;
-            for (const operId of operIds) {
-                const result2 = await context.operate('oper', {
-                    id: operId,
-                    action: 'update',
-                    data: {
-                        logId: null,
-                    },
-                }, {});
-                result += result2.oper?.update || 0;
-            }
-            return result;
+            return result.oper?.remove || 0;
         }
     },
 ];

package/lib/types/Configuration.d.ts

@@ -29,7 +29,7 @@ export type ServerConfiguration = {
         socketPath: string;
     };
     cors?: {
-        origin: string;
+        origin: string | string[];
         headers?: string[];
         methods?: string[];
     };
@@ -42,10 +42,10 @@ export type AccessConfiguration = {
     routerPrefixes?: {
         aspect?: string;
         endpoint?: string;
-        subscribe?: string;
         getSubscribePoint?: string;
         bridge?: string;
     };
+    socketPath?: string;
     http: {
         hostname: string;
         port?: number;

package/lib/types/Connector.d.ts

@@ -26,10 +26,11 @@ export interface Connector<ED extends EntityDict & BaseEntityDict, FrontCxt exte
         };
         headers?: Record<string, any>;
     };
-    getSubscribeRouter: () => string;
-    getSubscribePointRouter: () => string;
-    getSubscribePoint: () => Promise<{
-        url: string;
+    getSocketPath: () => string;
+    getSocketPointRouter: () => string;
+    getSocketPoint: () => Promise<{
+        socketUrl: string;
+        subscribeUrl: string;
         path: string;
     }>;
     getBridgeRouter: () => string;
@@ -42,4 +43,5 @@ export interface Connector<ED extends EntityDict & BaseEntityDict, FrontCxt exte
     getFullData: (keys?: (keyof ED)[]) => Promise<{
         [T in keyof ED]?: ED[T]['OpSchema'][];
     }>;
+    getCorsHeader: () => string[];
 }

package/lib/types/Exception.d.ts

@@ -72,6 +72,8 @@ export declare class OakNetworkException<ED extends EntityDict & BaseEntityDict>
 }
 export declare class OakServerProxyException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
 }
+export declare class OakClockDriftException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
+}
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
  *
@@ -128,7 +130,7 @@ export declare class OakUnloggedInException<ED extends EntityDict & BaseEntityDi
     constructor(message?: string);
 }
 /**
- * 用户未登录抛的异常
+ * 行数据被锁抛的异常
  */
 export declare class OakRowLockedException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
     constructor(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.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakException = void 0;
+exports.makeException = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = 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.OakException = void 0;
 const relation_1 = require("../store/relation");
 const lodash_1 = require("../utils/lodash");
 class OakException extends Error {
@@ -173,10 +173,14 @@ exports.OakImportDataParseException = OakImportDataParseException;
 class OakNetworkException extends OakException {
 }
 exports.OakNetworkException = OakNetworkException;
-// 
+// 请求未到达应用服务程序
 class OakServerProxyException extends OakException {
 }
 exports.OakServerProxyException = OakServerProxyException;
+// 时钟漂移过久（重放攻击）
+class OakClockDriftException extends OakException {
+}
+exports.OakClockDriftException = OakClockDriftException;
 // 在系统更新数据时，以下三个异常应按规范依次抛出。
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
@@ -294,7 +298,7 @@ class OakUnloggedInException extends OakUserException {
 exports.OakUnloggedInException = OakUnloggedInException;
 ;
 /**
- * 用户未登录抛的异常
+ * 行数据被锁抛的异常
  */
 class OakRowLockedException extends OakUserException {
     constructor(message) {
@@ -479,6 +483,10 @@ function makeException(data) {
             e = new OakNetworkException(data.message);
             break;
         }
+        case 'OakClockDriftException': {
+            e = new OakClockDriftException(data.message);
+            break;
+        }
         case 'OakServerProxyException': {
             e = new OakServerProxyException(data.message);
             break;

package/lib/types/Timer.d.ts

@@ -1,18 +1,21 @@
 import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
-import { EntityDict } from './Entity';
+import { EntityDict, OperationResult } from './Entity';
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { AsyncContext } from '../store/AsyncRowStore';
 import { Watcher } from './Watcher';
-import { OperationResult } from '.';
-type FreeOperateFn<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
+import { Namespace } from 'socket.io';
+type FreeRoutineFn<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt, env: {
+    socket: Namespace;
+}) => Promise<OperationResult<ED>>;
+type FreeTimerFn<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
 export type FreeRoutine<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
-    routine: FreeOperateFn<ED, Cxt>;
+    routine: FreeRoutineFn<ED, Cxt>;
 };
 export type FreeTimer<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
     cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
-    timer: FreeOperateFn<ED, Cxt>;
+    timer: FreeTimerFn<ED, Cxt>;
     singleton?: true;
 };
 export type Routine<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeRoutine<ED, Cxt> | Watcher<ED, T, Cxt>;

package/lib/types/Watcher.d.ts

@@ -17,6 +17,7 @@ export interface WBWatcher<ED extends EntityDict & BaseEntityDict, T extends key
     filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
     projection: ED[T]['Selection']['data'] | (() => Promise<ED[T]['Selection']['data']>);
     fn: (context: Cxt, data: Partial<ED[T]['Schema']>[]) => Promise<OperationResult<ED>>;
+    forUpdate?: true;
     singleton?: true;
 }
 export type Watcher<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;

package/lib/utils/SimpleConnector.d.ts

@@ -7,8 +7,9 @@ import { AccessConfiguration } from '../types/Configuration';
 export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, FrontCxt extends SyncContext<ED>> implements Connector<ED, FrontCxt> {
     static ASPECT_ROUTER: string;
     static BRIDGE_ROUTER: string;
-    static SUBSCRIBE_ROUTER: string;
-    static SUBSCRIBE_POINT_ROUTER: string;
+    static SUBSCRIBE_PATH: string;
+    static SOCKET_PATH: string;
+    static SOCKET_POINT_ROUTER: string;
     static ENDPOINT_ROUTER: string;
     private serverUrl;
     private serverAspectUrl;
@@ -17,11 +18,15 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
     private configuration;
     private makeException;
     constructor(configuration: AccessConfiguration, makeException: (exceptionData: any) => OakException<ED>);
+    getCorsHeader(): string[];
     protected makeHeadersAndBody(name: string, data: any, context?: FrontCxt): Promise<{
-        headers: Record<string, string>;
+        headers: {
+            'oak-cxt': string;
+            'oak-aspect': string;
+        };
         body: FormData;
     } | {
-        headers: HeadersInit;
+        headers: Record<string, string>;
         body: string;
     }>;
     protected parseAspectResult(response: Response): Promise<{
@@ -43,11 +48,12 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
         opRecords?: undefined;
     }>;
     getRouter(): string;
-    getSubscribeRouter(): string;
-    getSubscribePointRouter(): string;
-    getSubscribePoint(): Promise<{
-        url: any;
+    getSocketPath(): string;
+    getSocketPointRouter(): string;
+    getSocketPoint(): Promise<{
         path: any;
+        subscribeUrl: any;
+        socketUrl: any;
     }>;
     getEndpointRouter(): string;
     parseRequest(headers: IncomingHttpHeaders, body?: any, files?: any): {

package/lib/utils/SimpleConnector.js

@@ -8,8 +8,9 @@ const types_1 = require("../types");
 class SimpleConnector {
     static ASPECT_ROUTER = '/aspect';
     static BRIDGE_ROUTER = '/bridge';
-    static SUBSCRIBE_ROUTER = process.env.OAK_SUBSCRIBE_ROUTER || '/subscribe';
-    static SUBSCRIBE_POINT_ROUTER = '/subscribePoint';
+    static SUBSCRIBE_PATH = process.env.OAK_SUBSCRIBE_PATH || '/subscribe';
+    static SOCKET_PATH = process.env.OAK_SOCKET_PATH || '/socket';
+    static SOCKET_POINT_ROUTER = '/socketPoint';
     static ENDPOINT_ROUTER = '/endpoint';
     serverUrl;
     serverAspectUrl;
@@ -38,9 +39,15 @@ class SimpleConnector {
         this.serverAspectUrl = `${serverUrl}${routerPrefixes?.aspect || SimpleConnector.ASPECT_ROUTER}`;
         this.serverBridgeUrl = `${serverUrl}${routerPrefixes?.bridge || SimpleConnector.BRIDGE_ROUTER}`;
         this.serverSubscribePointUrl = `${serverUrl}${routerPrefixes?.getSubscribePoint ||
-            SimpleConnector.SUBSCRIBE_POINT_ROUTER}`;
+            SimpleConnector.SOCKET_POINT_ROUTER}`;
         this.makeException = makeException;
     }
+    getCorsHeader() {
+        return [
+            'oak-cxt',
+            'oak-aspect'
+        ];
+    }
     async makeHeadersAndBody(name, data, context) {
         const cxtStr = context ? await context.toString() : '{}';
         const headers = {
@@ -48,6 +55,7 @@ class SimpleConnector {
             'oak-aspect': name,
         };
         if (process.env.OAK_PLATFORM !== 'wechatMp') {
+            // 小程序环境下没有FormData，跑到这里会挂
             if (data instanceof FormData) {
                 return {
                     headers,
@@ -115,13 +123,16 @@ class SimpleConnector {
     getRouter() {
         return this.configuration.routerPrefixes?.aspect || SimpleConnector.ASPECT_ROUTER;
     }
-    getSubscribeRouter() {
-        return this.configuration.routerPrefixes?.subscribe || SimpleConnector.SUBSCRIBE_ROUTER;
+    /*  getSubscribePath(): string {
+         return this.configuration.socketPath?.subscribe || SimpleConnector.SUBSCRIBE_PATH;
+     } */
+    getSocketPath() {
+        return this.configuration.socketPath || SimpleConnector.SOCKET_PATH;
     }
-    getSubscribePointRouter() {
-        return this.configuration.routerPrefixes?.getSubscribePoint || SimpleConnector.SUBSCRIBE_POINT_ROUTER;
+    getSocketPointRouter() {
+        return this.configuration.routerPrefixes?.getSubscribePoint || SimpleConnector.SOCKET_POINT_ROUTER;
     }
-    async getSubscribePoint() {
+    async getSocketPoint() {
         let response;
         try {
             response = await global.fetch(this.serverSubscribePointUrl);
@@ -137,10 +148,11 @@ class SimpleConnector {
         const responseType = response.headers.get('Content-Type') ||
             response.headers.get('content-type');
         if (responseType?.toLocaleLowerCase().match(/application\/json/i)) {
-            const { url, path } = await response.json();
+            const { socketUrl, subscribeUrl, path } = await response.json();
             return {
-                url,
                 path,
+                subscribeUrl,
+                socketUrl,
             };
         }
         else {

package/lib/utils/row.js

@@ -6,8 +6,8 @@ const lodash_1 = require("./lodash");
 const relation_1 = require("../store/relation");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 function compareRow(schema, entity, row1, row2) {
-    const attrs1 = Object.keys(row1).filter(ele => !ele.startsWith('$$'));
-    const attrs2 = Object.keys(row2).filter(ele => !ele.startsWith('$$'));
+    const attrs1 = Object.keys(row1 || {}).filter(ele => !ele.startsWith('$$'));
+    const attrs2 = Object.keys(row2 || {}).filter(ele => !ele.startsWith('$$'));
     if ((0, lodash_1.difference)(attrs1, attrs2).length > 0) {
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "5.1.7",
+    "version": "5.1.9",
     "author": {
         "name": "XuChang"
     },
@@ -29,6 +29,7 @@
         "@types/node": "^20.6.1",
         "@types/node-schedule": "^2.1.0",
         "@types/react": "^17.0.2",
+        "@types/socket.io": "^3.0.2",
         "@types/uuid": "^8.3.0",
         "@types/wechat-miniprogram": "^3.4.1",
         "assert": "^2.0.0",
@@ -45,6 +46,7 @@
     "dependencies": {
         "dayjs": "^1.11.9",
         "node-schedule": "^2.1.1",
+        "socket.io": "^4.7.2",
         "uuid": "^9.0.0",
         "webidl-conversions": "^5.0.0"
     }

package/src/entities/I18n.ts

@@ -13,7 +13,7 @@ export interface Schema extends EntityShape {
 const entityDesc: EntityDesc<Schema> = {
     locales: {
         zh_CN: {
-            name: '用户授权',
+            name: 'i18n',
             attr: {
                 module: '模块',
                 position: '文件位置',