@lcap/nasl 3.8.0-beta.3 → 3.8.0-beta.5

package/out/server/naslServer.js

@@ -269,6 +269,20 @@ let NaslServer = NaslServer_1 = class NaslServer {
          } = optinos;
         Object.assign(allComponent, components);
         const { code, elementsLogic } = await (0, createUiTs_1.default)(allComponent);
+        // 处理一堆api.ts的类型
+        const convertTsCode = (code) => {
+            code = code.replace(/nasl.core.Integer/g, 'nasl.core.Long');
+            // 匹配union类型的正则
+            const unionReg = /\s*['"].*['"](\s*\|\s*['"].*['"])+/g;
+            code = code.replace(unionReg, 'nasl.core.String');
+            const extendsBooleanReg = /extends\s+(true|false)/g;
+            code = code.replace(extendsBooleanReg, ($0, $1) => {
+                return $1 === 'true' ? 'extends nasl.core.BooleanTrue' : 'extends nasl.core.BooleanFalse';
+            });
+            const extendsStringReg = /extends\s+(['"](.*)['"])/g;
+            code = code.replace(extendsStringReg, ($0, $1, $2) => `extends nasl.core.StringLiteral<\`${$2}\`>`);
+            return code;
+        };
         ///  process.env.BUILD_TARGET !== 'node'
         if (!utils.isNode) {
             await this.addFile({
@@ -279,9 +293,10 @@ let NaslServer = NaslServer_1 = class NaslServer {
         }
         /// #endif
         if (utils.isNode) {
+            let content = await fs.readFile(path.join(__dirname, '../../sandbox/stdlib/nasl.ui.definition.ts'), 'utf-8');
             await this.addFile({
                 file: 'nasl.ui.definition.ts',
-                fileContent: await fs.readFile(path.join(__dirname, '../../sandbox/stdlib/nasl.ui.definition.ts'), 'utf-8'),
+                fileContent: content,
             }, { cache: true });
         }
         // 放入生產的uits文件
@@ -294,12 +309,13 @@ let NaslServer = NaslServer_1 = class NaslServer {
         // 基础组件
         await this.addFile({
             file: 'nasl.ui.component.ts',
-            fileContent: optinos.basicUITsCode,
+            // FIXME 临时解决方式将union类型转换为string类型
+            fileContent: convertTsCode(optinos.basicUITsCode),
         }, { cache: true });
         // 带有类型的依赖库组件
         await this.addFile({
             file: 'extension.component.ts',
-            fileContent: optinos.withTypeLibraryTsCode,
+            fileContent: convertTsCode(optinos.withTypeLibraryTsCode),
         }, { cache: true });
         // 内置标准库类型
         Object.keys(naslStdlibMap_1.default).forEach(async (libFileName) => {
@@ -328,7 +344,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 self.file2NodeMap.set(result.filePath, node);
             }
             catch (err) {
-                if (process.env.NODE_ENV === 'development') {
+                if (utils.isDebugMode) {
                     self.logger.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
                 }
             }
@@ -539,7 +555,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 await Promise.all(openFiles.map(async (file) => fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)));
             }
             catch (e) {
-                this.logger.error(e);
+                if (utils.isDebugMode) {
+                    this.logger.error(e);
+                }
             }
         }
         /// #endif
@@ -654,6 +672,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
             let typeStr = types && types[1];
             // 从 {entity1:Entity1(defaultDS);},unknown,unknown,unknown 取出{entity1:Entity1(defaultDS);}
             typeStr = typeStr?.split(',')[0];
+            // 将Long转换为Integer
+            typeStr = typeStr?.replace('Long', 'Integer');
             if (flag) {
                 // 自定义结构的展示
                 if (typeStr.includes('__name: "AStructure_')) {
@@ -905,6 +925,25 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             return null;
                         }
                     }
+                    // 组件部分属性错误降级
+                    if (concepts_1.asserts.isBindAttribute(currentNode) && concepts_1.asserts.isViewElement(currentNode.parentNode)) {
+                        const element = currentNode.parentNode;
+                        const tags = {
+                            'u-number-input': ['value', 'min', 'max'],
+                            'u-input': ['value'],
+                            'van-fieldinput': ['value'],
+                            'van-stepper-new': ['value', 'min', 'max'],
+                        };
+                        if (tags[element.tag] && tags[element.tag].includes(currentNode.name)) {
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                    }
                     while (currentNode && currentNode?.parentNode?.concept !== 'App') {
                         if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
                             // 草稿区降级
@@ -1541,7 +1580,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                     jsCode = nodeIn.toJS();
                                 }
                                 catch (err) {
-                                    self.logger.error(err);
+                                    if (utils.isDebugMode) {
+                                        self.logger.error(err);
+                                    }
                                 }
                                 if (!jsCode.startsWith(`${node.name} = `))
                                     return;
@@ -1913,6 +1954,19 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                                 typeAnnotationErrorDetail.errorPos.scale = errorMsg;
                                             }
                                         }
+                                        if (property.defaultValue?.expression?.concept === 'NumericLiteral') {
+                                            const numeric = property.defaultValue.expression;
+                                            const value = numeric.value;
+                                            const decimalPlaces = value?.split('.')[1]?.length || 0;
+                                            if (decimalPlaces > +scale) {
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'error',
+                                                    message: `实体字段${property.name}默认值的小数位数不能大于设置的小数位数${scale}`,
+                                                };
+                                                diagnostics.push(diag);
+                                            }
+                                        }
                                         break;
                                     }
                                 }
@@ -2089,6 +2143,13 @@ let NaslServer = NaslServer_1 = class NaslServer {
                                 if (jsCode.startsWith(`${node.name} = `)) {
                                     used = true;
                                     if (!nodeIn.tsErrorDetail) {
+                                        // 如果要加报错的时候，当前赋值或者批量复制，属于子逻辑的
+                                        // 但是没有类型的参数 或者返回值，不是 属于他的
+                                        // 就不加了，只有是子逻辑，而且是自己的参数没类型才加
+                                        const isSubLogic = nodeIn?.getAncestor('SubLogic');
+                                        if (isSubLogic && isSubLogic !== node.parentNode) {
+                                            return;
+                                        }
                                         const diagnostic = {
                                             node: nodeIn,
                                             severity: 'error',
@@ -2151,6 +2212,50 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        else if (fileNode instanceof concepts_1.ProcessV2) {
+            yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* wrapIterator([node, value]) {
+                if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
+                    const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        let used = false;
+                        fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
+                            if (!used && nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    self.logger.error(err);
+                                }
+                                if (jsCode.startsWith(`${node.name} = `)) {
+                                    used = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        const diagnostic = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic;
+                                        diagnostics.push(diagnostic);
+                                    }
+                                }
+                            }
+                        });
+                        const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `${nodeTypeName} ${node.name} ${msg}`,
+                        };
+                        node.__aStructureError = diagnostic;
+                        diagnostics.push(diagnostic);
+                    }
+                    else {
+                        node.__aStructureError = null;
+                    }
+                }
+            });
+        }
         else if (fileNode instanceof concepts_1.Connection) {
             const connectorPropertyNames = NaslServer_1.getPropertyNames(fileNode);
             const connectionPropertyNames = NaslServer_1.getPropertyNames(fileNode?.connector);
@@ -2232,6 +2337,70 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             });
         }
+        // TODO need reset when process support hoc & spread param & type annotation
+        const isInProcess = fileNode instanceof concepts_1.Process ||
+            fileNode instanceof concepts_1.ProcessV2 ||
+            !!fileNode?.getAncestor('Process') ||
+            !!fileNode?.getAncestor('ProcessV2');
+        if (isInProcess) {
+            // 查找计算过 subLogic 的节点。（目前只有 Logic、ProcessElement、ProcessElementV2）
+            let targetNode = fileNode;
+            if ((0, asserts_1.isProcess)(fileNode) ||
+                (0, asserts_1.isProcessV2)(fileNode)) {
+                targetNode = fileNode;
+            }
+            else {
+                targetNode = fileNode.getAncestor('Process') || fileNode.getAncestor('ProcessV2');
+            }
+            if (targetNode?.subLogics?.length) {
+                const diagnostic = {
+                    node: fileNode,
+                    severity: 'error',
+                    message: `流程暂不支持子逻辑`,
+                    // 保留原来的内容方便查询一些问题
+                    originalDiagnostic: {
+                        fileName: '',
+                        start: null,
+                        end: null,
+                        category: 'error',
+                        text: `process not support subLogic`,
+                    },
+                };
+                diagnostics.push(diagnostic);
+            }
+            if (targetNode.includeSpreadCallLogic) {
+                const diagnostic = {
+                    node: fileNode,
+                    severity: 'error',
+                    message: `流程暂不支持可变参数`,
+                    // 保留原来的内容方便查询一些问题
+                    originalDiagnostic: {
+                        fileName: '',
+                        start: null,
+                        end: null,
+                        category: 'error',
+                        text: `process not support spread call`,
+                    },
+                };
+                diagnostics.push(diagnostic);
+            }
+            if (targetNode.includeTypeArgs) {
+                const diagnostic = {
+                    node: fileNode,
+                    severity: 'error',
+                    message: `流程暂不支持范型参数`,
+                    // 保留原来的内容方便查询一些问题
+                    originalDiagnostic: {
+                        fileName: '',
+                        start: null,
+                        end: null,
+                        category: 'error',
+                        text: `process not support type args`,
+                    },
+                };
+                diagnostics.push(diagnostic);
+            }
+        }
         return diagnostics;
     }
     *_treeMetadataType2CoreType(type, app) {
@@ -2527,11 +2696,26 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
         }
+        // 加上信用卡验证规则的静态检查
+        if (node instanceof concepts_1.ValidationRule && node.calleeName === 'creditCard') {
+            const typesArg = node.arguments?.find((arg) => {
+                return arg?.keyword === 'types';
+            });
+            if (typesArg?.expression?.concept !== 'NewList' || !(typesArg?.expression?.items?.length)) {
+                const diagnostic = {
+                    node: typesArg?.expression,
+                    severity: 'error',
+                    message: '至少选择1项验证信用卡',
+                };
+                typesArg.expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
         if (node instanceof concepts_1.CallLogic) {
             // 处理依赖库高阶函数，函数签名和函数调用参数要完全一一对应
             if (node.calleeNamespace?.startsWith('extensions.')) {
                 const logicNode = node.getCallNode();
-                const params = logicNode?.params?.slice();
+                const params = logicNode?.params?.slice() || [];
                 const findFunction = params.find(param => param?.typeAnnotation?.typeKind === 'function');
                 if (findFunction) {
                     node.arguments?.forEach((argument, index) => {
@@ -2958,7 +3142,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         }
                     }
                     catch (e) {
-                        this.logger.error('naslServer实体引用', e);
+                        if (utils.isDebugMode) {
+                            this.logger.error('naslServer实体引用', e);
+                        }
                     }
                 }
             }
@@ -3267,8 +3453,12 @@ let NaslServer = NaslServer_1 = class NaslServer {
                     //     return null;
                     // }
                 }
-                // 如果节点是Identifier表达式
+                // 如果匹配到的节点是Identifier表达式
                 if (minRange.node instanceof concepts_1.Identifier) {
+                    // 如果参数修改影响了Identifier, 就说明是上一级逻辑的引用，所以就直接过滤掉就好了
+                    if (node instanceof concepts_1.Param && minRange.node?.namespace?.endsWith('logics')) {
+                        return null;
+                    }
                     // 匹配到的内容，当前这一行的内容；
                     // 因为要用下面的点位信息
                     const { name } = minRange.node;
@@ -3378,7 +3568,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             }
                         }
                         catch (error) {
-                            console.error(error);
+                            if (utils.isDebugMode) {
+                                this.logger.error(error);
+                            }
                         }
                     }
                     else if (minRange.node instanceof concepts_1.Identifier) {
@@ -3765,7 +3957,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
         }
         catch (err) {
-            this.logger.error(err);
+            if (utils.isDebugMode) {
+                this.logger.error(err);
+            }
         }
         return result;
     }
@@ -3790,7 +3984,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
             });
         }
         catch (err) {
-            this.logger.error(err);
+            if (utils.isDebugMode) {
+                this.logger.error(err);
+            }
         }
         return [...result];
     }
@@ -4277,26 +4473,23 @@ let NaslServer = NaslServer_1 = class NaslServer {
                     if (node instanceof concepts_1.CallLogic &&
                         node.completeTypeParams?.length &&
                         node?.__nodeType) {
-                        const logicNode = node.getCallNode();
                         const autoTypeArguments = node.__nodeType?.typeArguments || [];
                         const newAutoTypeArguments = [...autoTypeArguments];
-                        if (logicNode.returns?.length) {
-                            let returnType = newAutoTypeArguments.shift();
-                            if (node.handleError && returnType.typeName === 'Union') {
-                                const returnTypeArguments = returnType.typeArguments || [];
-                                const typeArguments = [...returnTypeArguments];
-                                const errorType = typeArguments.find((t) => t.typeName === 'Error');
-                                if (errorType) {
-                                    if (typeArguments.length === 2) {
-                                        returnType = typeArguments.filter((t) => t !== errorType)[0];
-                                    }
-                                    else {
-                                        returnType.typeArguments = typeArguments.filter((t) => t !== errorType);
-                                    }
+                        let returnType = newAutoTypeArguments.shift();
+                        if (node.handleError && returnType.typeName === 'Union') {
+                            const returnTypeArguments = returnType.typeArguments || [];
+                            const typeArguments = [...returnTypeArguments];
+                            const errorType = typeArguments.find((t) => t.typeName === 'Error');
+                            if (errorType) {
+                                if (typeArguments.length === 2) {
+                                    returnType = typeArguments.filter((t) => t !== errorType)[0];
+                                }
+                                else {
+                                    returnType.typeArguments = typeArguments.filter((t) => t !== errorType);
                                 }
                             }
-                            node.__TypeAnnotation = utils.runGeneratorSync((0, formatTsUtils_1.type2TypeAnnotation)(returnType));
                         }
+                        node.__TypeAnnotation = utils.runGeneratorSync((0, formatTsUtils_1.type2TypeAnnotation)(returnType));
                         const typeArgs = [];
                         const typeArguments = node.typeArguments;
                         node.completeTypeParams.forEach((typeArg, typeIndex) => {
@@ -4348,8 +4541,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
         const json = app.toJSON();
         this.logger.timeEnd('全量标注');
-        // 测试环境打印数据
-        if (utils.isTestBrowser) {
+        // 测试环境或者是调试模式打印数据
+        if (utils.isDebugMode || utils.isTestBrowser) {
             this.logger.info('全量标注数据', json);
         }
         if (releaseFlag) {
@@ -4498,8 +4691,66 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 */
                 if (node instanceof concepts_1.CallLogic && node.__TypeArguments?.length) {
                     const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-                    jsonNode.typeArguments = node.__TypeArguments;
-                    jsonNode.typeAnnotation = node.__TypeAnnotation;
+                    jsonNode.typeArguments = node.__TypeArguments.map((type) => type?.toJSON());
+                    jsonNode.typeAnnotation = node.__TypeAnnotation?.toJSON();
+                }
+                // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
+                // 对CallFunction节点，若其callee为部分List/Map内置函数，则修改其argument类型标注以让服务端据此插入显式的类型转换。规则如下：
+                // - 对argument.expression.typeAnnotation 无需做修改，保持为其实际类型
+                // - 对argument.typeAnnotation，为根据对应Collection的泛型参数的类型填写其类型
+                if (node instanceof concepts_1.CallFunction) {
+                    if (node.calleeNamespace === 'nasl.util') {
+                        const calleeName = node.calleeName;
+                        const listFunctionParamIndexMaps = new Map(Object.entries({
+                            Add: { collection: 0, item: 1 },
+                            Insert: { collection: 0, item: 2 },
+                            Remove: { collection: 0, item: 1 },
+                            Contains: { collection: 0, item: 1 },
+                        }));
+                        const mapFunctionParamIndexMaps = new Map(Object.entries({
+                            MapPut: { collection: 0, key: 1, value: 2 },
+                            MapGet: { collection: 0, key: 1, },
+                            MapRemove: { collection: 0, key: 1 },
+                            MapContains: { collection: 0, key: 1 },
+                        }));
+                        const listParamIndex = listFunctionParamIndexMaps.get(calleeName);
+                        if (listParamIndex) {
+                            const list = node.arguments[listParamIndex.collection];
+                            const item = node.arguments[listParamIndex.item];
+                            const itemExpression = item?.expression;
+                            if (itemExpression) {
+                                const listTypeArgument = list.__TypeAnnotation?.typeArguments?.[0]?.toJSON();
+                                if (listTypeArgument) {
+                                    const jsonNode = jsoner.queryNodeByPath(json, item.getNodePath(false));
+                                    jsonNode.typeAnnotation = listTypeArgument;
+                                }
+                            }
+                        }
+                        else {
+                            const mapParamIndex = mapFunctionParamIndexMaps.get(calleeName);
+                            if (mapParamIndex) {
+                                const map = node.arguments[mapParamIndex.collection];
+                                const key = node.arguments[mapParamIndex.key];
+                                const value = node.arguments[mapParamIndex.value];
+                                const keyExpression = key?.expression;
+                                const valueExpression = value?.expression;
+                                if (keyExpression) {
+                                    const mapKeyTypeArgument = map.__TypeAnnotation?.typeArguments?.[0]?.toJSON();
+                                    if (mapKeyTypeArgument) {
+                                        const jsonNode = jsoner.queryNodeByPath(json, key.getNodePath(false));
+                                        jsonNode.typeAnnotation = mapKeyTypeArgument;
+                                    }
+                                }
+                                if (valueExpression) {
+                                    const mapValueTypeArgument = map.__TypeAnnotation?.typeArguments?.[1]?.toJSON();
+                                    if (mapValueTypeArgument) {
+                                        const jsonNode = jsoner.queryNodeByPath(json, value.getNodePath(false));
+                                        jsonNode.typeAnnotation = mapValueTypeArgument;
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
             // 服务端需要默认值节点有类型来判断父节点是否是日期类型
@@ -4558,7 +4809,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
         }
         return new Promise((resolve, reject) => {
             const myTimer = setTimeout(() => {
-                this.logger.warn(node, '没有获取到类型');
+                if (utils.isDebugMode) {
+                    this.logger.warn(node, '没有获取到类型');
+                }
                 clearTimeout(myTimer);
                 clearInterval(mySetInterval);
                 if (node.__isCorrectTypeAnnotation) {