oak-domain 5.1.8 → 5.1.10

package/lib/compiler/dependencyBuilder.js

@@ -461,7 +461,7 @@ function outputIntializeDev(cwd, dependencies, briefNames, sourceFile, printer,
             }
         });
         // startRoutine
-        if ((0, fs_1.existsSync)(join(destDir, 'routines', 'start'))) {
+        if ((0, fs_1.existsSync)(join(destDir, 'routines', 'start.js'))) {
             const variableName = `${briefNames[idx]}StartRoutines`;
             importStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, factory.createIdentifier(variableName), undefined), factory.createStringLiteral(join(dep, destDirName, 'routines/start')), undefined));
             if (objectDict.startRoutines) {
@@ -583,11 +583,30 @@ function outputFeatureIndex(dependencies, briefNames, sourceFile, printer, filen
     if (dependencies.length > 0) {
         const importStatements = [];
         const fdNames = [];
+        const adNames = [];
         dependencies.forEach((dep, idx) => {
             const fdName = `${(0, string_1.firstLetterUpperCase)(briefNames[idx])}FeatureDict`;
-            importStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("FeatureDict"), factory.createIdentifier(fdName))])), factory.createStringLiteral(dep), undefined));
+            const adName = `${(0, string_1.firstLetterUpperCase)(briefNames[idx])}AspectDict`;
+            // 导入FeatureDict和AspectDict
+            importStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, factory.createIdentifier("FeatureDict"), factory.createIdentifier(fdName)),
+                factory.createImportSpecifier(false, factory.createIdentifier("AspectDict"), factory.createIdentifier(adName))
+            ])), factory.createStringLiteral(dep), undefined));
             fdNames.push(fdName);
+            adNames.push(adName);
         });
+        // 导入自己的AspectDict：import { AspectDict } from '../aspects/AspectDict';
+        importStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("AspectDict"), factory.createIdentifier("ProjectAspectDict"))])), factory.createStringLiteral("../aspects/AspectDict"), undefined), 
+        // import { createService } from 'oak-frontend-base/es/aspects/AspectService';
+        factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("createService"))])), factory.createStringLiteral("oak-frontend-base/es/aspects/AspectService"), undefined));
+        // 创建一个这样的type: type MergeAspectDict = ProjectAspectDict & GenernalAspectDict<EntityDict>;
+        // 除了ProjectAspectDict，还有其他的AspectDict，需要<EntityDict>参数
+        const adTypeDeclaration = factory.createTypeAliasDeclaration(undefined, factory.createIdentifier("MergeAspectDict"), undefined, factory.createIntersectionTypeNode([
+            factory.createTypeReferenceNode(factory.createIdentifier("ProjectAspectDict"), undefined),
+            ...adNames.map(ad => {
+                return factory.createTypeReferenceNode(factory.createIdentifier(ad), [factory.createTypeReferenceNode(factory.createIdentifier("EntityDict"), undefined)]);
+            })
+        ]));
         let i = 0;
         while (true) {
             const stmt = statements[i];
@@ -599,7 +618,7 @@ function outputFeatureIndex(dependencies, briefNames, sourceFile, printer, filen
         const stmt3 = statements[i - 1], stmt4 = statements[i];
         (0, assert_1.default)(ts.isImportDeclaration(stmt3) && ts.isFunctionDeclaration(stmt4));
         const { name, parameters } = stmt4;
-        (0, assert_1.default)(ts.isIdentifier(name) && name.text === 'create' && parameters.length === 1);
+        (0, assert_1.default)(name && ts.isIdentifier(name) && name.text === 'create' && parameters.length === 1);
         const [param] = parameters;
         const { name: paramName, type } = param;
         (0, assert_1.default)(ts.isIdentifier(paramName) && paramName.text === 'features' && ts.isTypeReferenceNode(type));
@@ -611,9 +630,43 @@ function outputFeatureIndex(dependencies, briefNames, sourceFile, printer, filen
                 ]))
             ])
         });
+        const functionBlock = stmt4.body;
+        (0, assert_1.default)(functionBlock && ts.isBlock(functionBlock));
+        let returnI = 0;
+        while (true) {
+            const stmt = functionBlock.statements[returnI];
+            if (ts.isReturnStatement(stmt)) {
+                break;
+            }
+            returnI++;
+        }
+        // 在return之前，插入const aspect = createService<EntityDict, MergeAspectDict>(cache);
+        const aspectDeclaration = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("aspect"), undefined, undefined, factory.createCallExpression(factory.createIdentifier("createService"), [
+                factory.createTypeReferenceNode(factory.createIdentifier("EntityDict"), undefined),
+                factory.createTypeReferenceNode(factory.createIdentifier("MergeAspectDict"), undefined)
+            ], [factory.createIdentifier("cache")]))], ts.NodeFlags.Const));
+        const returnStmt = functionBlock.statements[returnI];
+        (0, assert_1.default)(returnStmt.expression && ts.isObjectLiteralExpression(returnStmt.expression));
+        // 在里面添加aspect
+        const { properties } = returnStmt.expression;
+        Object.assign(returnStmt.expression, {
+            properties: [
+                ...properties,
+                factory.createShorthandPropertyAssignment(factory.createIdentifier("aspect"))
+            ]
+        });
+        // 把aspectDeclaration 插入到return之前
+        const newFunctionStatements = [
+            ...functionBlock.statements.slice(0, returnI),
+            aspectDeclaration,
+            ...functionBlock.statements.slice(returnI)
+        ];
+        const newBlock = factory.createBlock(newFunctionStatements);
+        Object.assign(functionBlock, newBlock);
         statements2 = [
             ...statements.slice(0, i),
             ...importStatements,
+            adTypeDeclaration,
             ...statements.slice(i)
         ];
         if (isModule) {

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;
@@ -189,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;
     }
@@ -210,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],
         });
@@ -226,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
@@ -282,7 +282,7 @@ function tryGetStringLiteralValues(moduleName, filename, obj, node, program) {
         if (['state', 'action'].includes(obj)) {
             (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);
         }
     }
@@ -307,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, './');
         }
@@ -340,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 {
@@ -355,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 {
@@ -383,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);
     }
@@ -419,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);
@@ -433,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,6 +566,38 @@ function analyzeImportDeclaration(node, referencedSchemas, additionalImports, fi
         } */
     }
 }
+/**
+ * 处理模块的导入，得到导入文件的sourcefile
+ */
+function dealImportedFile(path, fileSpecifierPath, filename, program) {
+    let importedFilepath = '';
+    const getExistedFileName = () => {
+        if ((0, fs_1.existsSync)(`${importedFilepath}.ts`)) {
+            return `${importedFilepath}.ts`;
+        }
+        else if ((0, fs_1.existsSync)(`${importedFilepath}.d.ts`)) {
+            return `${importedFilepath}.d.ts`;
+        }
+        return '';
+    };
+    if (fileSpecifierPath.startsWith('.')) {
+        importedFilepath = path_1.default.join(path, fileSpecifierPath);
+        const importedFilename = getExistedFileName();
+        (0, assert_1.default)(importedFilename, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+        const sourceFile = program.getSourceFile(importedFilename);
+        (0, assert_1.default)(sourceFile, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
+        return [sourceFile, importedFilename];
+    }
+    // 创建编译器主机
+    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:的依赖声明
@@ -594,7 +627,7 @@ function analyzeImportDeclaration(node, referencedSchemas, additionalImports, fi
 //         const cwd = process.cwd();
 //         const fileSpecifierPaths = fileSpecifierPath.split('/');
 //         const moduleName = fileSpecifierPaths[0] || fileSpecifierPaths[1];
-//         assert(moduleName);
+//         assert(moduleName, '「${filename}」中import路径不合法');
 //         // 从path向外找package.json -> node_modules直至找到fileSpecifier
 //         const paths = path.split('/');
 //         for (let iter = paths.length; iter >= 0; iter--) {
@@ -628,37 +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 compilerHost = ts.createCompilerHost(program.getCompilerOptions());
-        // 解析模块
-        const resolvedModule = ts.resolveModuleName(from, filename, program.getCompilerOptions(), compilerHost);
-        (0, assert_1.default)(resolvedModule.resolvedModule, "找不到module定义");
-        const resolvedFileName = resolvedModule.resolvedModule.resolvedFileName;
-        const sourceFile = program.getSourceFile(resolvedFileName);
-        // const importedFilename = getImportedFilePath(path, from, filename);
-        // const sourceFile = program.getSourceFile(importedFilename);
-        (0, assert_1.default)(sourceFile, `「${filename}」找不到相应的sourceFile：${resolvedFileName}`);
-        const relativeFilename = path_1.default.relative(process.cwd(), resolvedFileName);
+        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);
@@ -738,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;
@@ -833,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];
@@ -926,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 {
@@ -946,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);
                         }
                     });
@@ -998,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)
@@ -1015,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);
@@ -1037,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}」`);
@@ -1057,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') {
@@ -1179,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);
                     }
                 }
@@ -1224,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);
@@ -1268,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 {
@@ -1617,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
             ])));
@@ -3118,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);
@@ -3247,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]) {
@@ -3259,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]) {
@@ -3271,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]) {
@@ -3413,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)));
@@ -3434,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))
@@ -3459,7 +3483,7 @@ 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)

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;
         }

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/types/Configuration.d.ts

@@ -29,11 +29,14 @@ export type ServerConfiguration = {
         socketPath: string;
     };
     cors?: {
-        origin: string;
+        origin: string | string[];
         headers?: string[];
         methods?: string[];
     };
     internalExceptionMask?: string;
+    koaBody?: {
+        maxFileSize?: number;
+    };
 };
 /**
  * 前后台访问配置
@@ -42,16 +45,17 @@ export type AccessConfiguration = {
     routerPrefixes?: {
         aspect?: string;
         endpoint?: string;
-        subscribe?: string;
         getSubscribePoint?: string;
         bridge?: string;
     };
+    socketPath?: string;
     http: {
         hostname: string;
         port?: number;
         ssl?: boolean;
         path?: string;
     };
+    timeout?: 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;

package/lib/types/Exception.d.ts

@@ -19,6 +19,9 @@ export declare class OakException<ED extends EntityDict & BaseEntityDict> extend
     tag2?: boolean;
     tag3?: any;
 }
+export declare class OakRequestTimeoutException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
+    constructor(message?: string);
+}
 export declare class OakMakeSureByMySelfException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
 }
 export declare class OakPartialSuccess<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {

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.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;
+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.OakRequestTimeoutException = exports.OakException = void 0;
 const relation_1 = require("../store/relation");
 const lodash_1 = require("../utils/lodash");
 class OakException extends Error {
@@ -90,6 +90,13 @@ class OakException extends Error {
     tag3;
 }
 exports.OakException = OakException;
+// 请求超时
+class OakRequestTimeoutException extends OakException {
+    constructor(message) {
+        super(message || '请求超时');
+    }
+}
+exports.OakRequestTimeoutException = OakRequestTimeoutException;
 // 这个异常表示模块自己处理跨事务一致性，框架pass（在分布式数据传递时会用到）（backend-base老版本有使用先保留）
 class OakMakeSureByMySelfException extends OakException {
 }
@@ -495,6 +502,14 @@ function makeException(data) {
             e = new OakSocketConnectException(data.message);
             break;
         }
+        case 'OakPartialSuccess': {
+            e = new OakPartialSuccess(data.message);
+            break;
+        }
+        case 'OakRequestTimeoutException': {
+            e = new OakRequestTimeoutException(data.message);
+            break;
+        }
         default:
             return;
     }

package/lib/types/Sync.d.ts

@@ -76,6 +76,7 @@ export interface SyncRemoteConfig<ED extends EntityDict & BaseEntityDict, Cxt ex
         }[];
         reason: Error;
     }, context: Cxt) => Promise<void>;
+    timeout?: number;
 }
 export interface SyncSelfConfigBase<ED extends EntityDict & BaseEntityDict> {
     endpoint?: string;

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;
@@ -16,6 +17,7 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
     private serverSubscribePointUrl;
     private configuration;
     private makeException;
+    private timeout;
     constructor(configuration: AccessConfiguration, makeException: (exceptionData: any) => OakException<ED>);
     getCorsHeader(): string[];
     protected makeHeadersAndBody(name: string, data: any, context?: FrontCxt): Promise<{
@@ -47,11 +49,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): {
@@ -80,4 +83,5 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
         headers?: Record<string, string> | undefined;
     };
     getFullData(): Promise<{}>;
+    private fetchWithTimeout;
 }

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;
@@ -17,9 +18,11 @@ class SimpleConnector {
     serverSubscribePointUrl;
     configuration;
     makeException;
+    timeout;
     constructor(configuration, makeException) {
         this.configuration = configuration;
-        const { routerPrefixes, http } = configuration;
+        const { routerPrefixes, http, timeout } = configuration;
+        this.timeout = timeout || 5000;
         const { ssl, hostname, port, path } = http;
         const protocol = ssl ? 'https:' : 'http:';
         let serverUrl = `${protocol}//${hostname}`;
@@ -38,7 +41,7 @@ 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() {
@@ -107,11 +110,11 @@ class SimpleConnector {
         const { headers, body } = await this.makeHeadersAndBody(name, params, context);
         let response;
         try {
-            response = await global.fetch(this.serverAspectUrl, {
+            response = await this.fetchWithTimeout(this.serverAspectUrl, {
                 method: 'POST',
                 headers,
                 body,
-            });
+            }, this.timeout);
         }
         catch (err) {
             // fetch返回异常一定是网络异常
@@ -122,16 +125,19 @@ 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);
+            response = await this.fetchWithTimeout(this.serverSubscribePointUrl, {}, this.timeout);
         }
         catch (err) {
             throw new types_1.OakNetworkException();
@@ -144,10 +150,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 {
@@ -226,5 +233,29 @@ class SimpleConnector {
         console.error('前后台模式下暂时不支持此操作，请到数据库查看数据');
         return {};
     }
+    async fetchWithTimeout(url, options, timeout = 5000) {
+        if (typeof AbortController === 'undefined') {
+            return global.fetch(url, options);
+        }
+        const controller = new AbortController();
+        const signal = controller.signal;
+        // 设置超时
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+        }, timeout);
+        // 发起 fetch 请求并传递 signal
+        return global.fetch(url, Object.assign({}, options, { signal }))
+            .then(response => {
+            clearTimeout(timeoutId); // 如果请求成功，清除超时
+            return response;
+        })
+            .catch(error => {
+            clearTimeout(timeoutId); // 如果请求失败，清除超时
+            if (error.name === 'AbortError') {
+                throw new types_1.OakRequestTimeoutException();
+            }
+            throw error; // 其他错误
+        });
+    }
 }
 exports.default = SimpleConnector;

package/lib/utils/geo.d.ts

@@ -2,3 +2,33 @@
  * 计算地球上两点之间的球面距离
  */
 export declare function getDistanceBetweenPoints(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/**
+ * 百度坐标系 (BD-09) 与 火星坐标系 (GCJ-02)的转换
+ * 即 百度 转 谷歌、高德
+ * @param bd_lon
+ * @param bd_lat
+ * @returns {*[]}
+ */
+export declare function bd09togcj02(coord: [number, number]): number[];
+/**
+ * 火星坐标系 (GCJ-02) 与百度坐标系 (BD-09) 的转换
+ * 即谷歌、高德 转 百度
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+export declare function gcj02tobd09(coord: [number, number]): number[];
+/**
+ * WGS84转GCj02
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+export declare function wgs84togcj02(coord: [number, number]): number[];
+/**
+ * GCJ02 转换为 WGS84
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+export declare function gcj02towgs84(coord: [number, number]): number[];

package/lib/utils/geo.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDistanceBetweenPoints = void 0;
+exports.gcj02towgs84 = exports.wgs84togcj02 = exports.gcj02tobd09 = exports.bd09togcj02 = exports.getDistanceBetweenPoints = void 0;
 /**
  * 计算地球上两点之间的球面距离
  */
@@ -22,3 +22,125 @@ function getDistanceBetweenPoints(lat1, lon1, lat2, lon2) {
     return d * 1000;
 }
 exports.getDistanceBetweenPoints = getDistanceBetweenPoints;
+//定义一些常量
+const x_PI = 3.14159265358979324 * 3000.0 / 180.0;
+const PI = 3.1415926535897932384626;
+const a = 6378245.0;
+const ee = 0.00669342162296594323;
+function transformlat(lng, lat) {
+    let ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng));
+    ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
+    ret += (20.0 * Math.sin(lat * PI) + 40.0 * Math.sin(lat / 3.0 * PI)) * 2.0 / 3.0;
+    ret += (160.0 * Math.sin(lat / 12.0 * PI) + 320 * Math.sin(lat * PI / 30.0)) * 2.0 / 3.0;
+    return ret;
+}
+;
+function transformlng(lng, lat) {
+    let ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng));
+    ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
+    ret += (20.0 * Math.sin(lng * PI) + 40.0 * Math.sin(lng / 3.0 * PI)) * 2.0 / 3.0;
+    ret += (150.0 * Math.sin(lng / 12.0 * PI) + 300.0 * Math.sin(lng / 30.0 * PI)) * 2.0 / 3.0;
+    return ret;
+}
+;
+/**
+ * 判断是否在国内，不在国内则不做偏移
+ * @param lng
+ * @param lat
+ * @returns {boolean}
+ */
+function out_of_china(lng, lat) {
+    // 纬度3.86~53.55,经度73.66~135.05 
+    return !(lng > 73.66 && lng < 135.05 && lat > 3.86 && lat < 53.55);
+}
+;
+/**
+ * 百度坐标系 (BD-09) 与 火星坐标系 (GCJ-02)的转换
+ * 即 百度 转 谷歌、高德
+ * @param bd_lon
+ * @param bd_lat
+ * @returns {*[]}
+ */
+function bd09togcj02(coord) {
+    const [bd_lon, bd_lat] = coord;
+    const x = bd_lon - 0.0065;
+    const y = bd_lat - 0.006;
+    const z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_PI);
+    const theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_PI);
+    const gg_lng = z * Math.cos(theta);
+    const gg_lat = z * Math.sin(theta);
+    return [gg_lng, gg_lat];
+}
+exports.bd09togcj02 = bd09togcj02;
+;
+/**
+ * 火星坐标系 (GCJ-02) 与百度坐标系 (BD-09) 的转换
+ * 即谷歌、高德 转 百度
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+function gcj02tobd09(coord) {
+    const [lng, lat] = coord;
+    const z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * x_PI);
+    const theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * x_PI);
+    const bd_lng = z * Math.cos(theta) + 0.0065;
+    const bd_lat = z * Math.sin(theta) + 0.006;
+    return [bd_lng, bd_lat];
+}
+exports.gcj02tobd09 = gcj02tobd09;
+;
+/**
+ * WGS84转GCj02
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+function wgs84togcj02(coord) {
+    const [lng, lat] = coord;
+    if (out_of_china(lng, lat)) {
+        return [lng, lat];
+    }
+    else {
+        let dlat = transformlat(lng - 105.0, lat - 35.0);
+        let dlng = transformlng(lng - 105.0, lat - 35.0);
+        const radlat = lat / 180.0 * PI;
+        let magic = Math.sin(radlat);
+        magic = 1 - ee * magic * magic;
+        const sqrtmagic = Math.sqrt(magic);
+        dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * PI);
+        dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * PI);
+        const mglat = lat + dlat;
+        const mglng = lng + dlng;
+        return [mglng, mglat];
+    }
+}
+exports.wgs84togcj02 = wgs84togcj02;
+;
+/**
+ * GCJ02 转换为 WGS84
+ * @param lng
+ * @param lat
+ * @returns {*[]}
+ */
+function gcj02towgs84(coord) {
+    const [lng, lat] = coord;
+    if (out_of_china(lng, lat)) {
+        return [lng, lat];
+    }
+    else {
+        let dlat = transformlat(lng - 105.0, lat - 35.0);
+        let dlng = transformlng(lng - 105.0, lat - 35.0);
+        const radlat = lat / 180.0 * PI;
+        let magic = Math.sin(radlat);
+        magic = 1 - ee * magic * magic;
+        const sqrtmagic = Math.sqrt(magic);
+        dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * PI);
+        dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * PI);
+        const mglat = lat + dlat;
+        const mglng = lng + dlng;
+        return [lng * 2 - mglng, lat * 2 - mglat];
+    }
+}
+exports.gcj02towgs84 = gcj02towgs84;
+;

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.8",
+    "version": "5.1.10",
     "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"
     }