@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/src/server/naslServer.ts

@@ -214,6 +214,9 @@ export class NaslServer {
                 if (data && data.event === 'publishDiagnostics') {
                     const records = await this._resolveDiagnosticRecords(data.records);
                     this.diagnosticManager.pushAll(records);
+                    try {
+                        invokeCommand('naslServer:nodeChange');
+                    } catch (e) { console.log('no "naslServer:nodeChange" event received'); }
                 }
             },
         });
@@ -492,8 +495,7 @@ export class NaslServer {
         await this.openApp(app);
         // 重新check一遍所有内容
         await this.getDiagnosticRecordsAndPushAll();
-        // 重新补一遍标注
-        await this.createdNaslAnnotatedJSON(app);
+        // check内容后，会自动走增量类型标注完善全部类型
     }
 
     /**
@@ -898,6 +900,25 @@ export class NaslServer {
                 });
             }
             record.semanticDiagnostics = record.semanticDiagnostics
+                /**
+                 * reduce 为去除重复的 'Duplicate identifier xxxx' 报错
+                 * 原属于 TS@4.x 的 bug，在 TS@5.0-dev 后修复，详见：https://github.com/microsoft/TypeScript/issues/51437
+                 * 触发场景：
+                 *   OQL查询中写入SQL语句：'select * from Entity1 ee, Entity1 ee, Entity1 ee, Entity1 ee'
+                 *   翻译出的TS代码中，ee 被成功检查为重复变量，但 ee 报错的数量超过 ee 实际的出现数量，需对同一 token 的报错进行去重
+                 */
+                .reduce((res, item: any) => {
+                    const hit = item.text.startsWith('Duplicate identifier') && res.some((r: any) => (r.text === item.text
+                        && r.start.line === item.start.line
+                        && r.start.offset === item.start.offset
+                        && r.end.line === item.end.line
+                        && r.end.offset === item.end.offset));
+
+                    if (!hit) {
+                        res.push(item);
+                    }
+                    return res;
+                }, [])
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
             record.semanticDiagnostics.push(...this._attachDiagnostics(node));
@@ -908,6 +929,25 @@ export class NaslServer {
                     // 错误降级如果属于草稿态的就降级
                     if (diagnostic?.node) {
                         let currentNode = diagnostic.node;
+
+                        // 数据源警告类型降级
+                        if (currentNode.concept === 'DataSource') {
+                            diagnostic.severity = 'warning';
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        } else if (currentNode.concept === 'OqlQueryComponent') {
+                            // OQL别名错误降级为警告
+                            if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                                // 重置 图标和错误等级
+                                diagnostic.severity = 'warning';
+                                if (diagnostic.node?.tsErrorDetail) {
+                                    // 重置组件节点上的错误信息
+                                    diagnostic.node.tsErrorDetail.severity = 'warning';
+                                }
+                                record.suggestionDiagnostics.push(diagnostic);
+                                return null;
+                            }
+                        }
                         while (currentNode?.parentNode?.concept !== 'App') {
                             if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
                                 // 草稿区降级
@@ -919,18 +959,6 @@ export class NaslServer {
                                 }
                                 record.suggestionDiagnostics.push(diagnostic);
                                 return null;
-                            } else if (currentNode.concept === 'OqlQueryComponent') {
-                                // OQL别名错误降级为警告
-                                if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
-                                    // 重置 图标和错误等级
-                                    diagnostic.severity = 'warning';
-                                    if (diagnostic.node?.tsErrorDetail) {
-                                        // 重置组件节点上的错误信息
-                                        diagnostic.node.tsErrorDetail.severity = 'warning';
-                                    }
-                                    record.suggestionDiagnostics.push(diagnostic);
-                                    return null;
-                                }
                             }
                             currentNode = currentNode.parentNode;
                         }
@@ -1484,14 +1512,14 @@ export class NaslServer {
                         if (!propertyValue.value && fileNode.name !== 'defaultDS') {
                             const diagnostic = {
                                 node: fileNode,
-                                severity: 'error',
+                                severity: 'warning',
                                 message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
                                 // 保留原来的内容方便查询一些问题
                                 originalDiagnostic: {
                                     fileName: '',
                                     start: <any>null,
                                     end: <any>null,
-                                    category: 'error',
+                                    category: 'warning',
                                     text: `Data Source is not config`,
                                 },
                             };
@@ -1517,14 +1545,14 @@ export class NaslServer {
                             if (envText) {
                                 const diagnostic = {
                                     node: fileNode,
-                                    severity: 'error',
+                                    severity: 'warning',
                                     message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
                                     // 保留原来的内容方便查询一些问题
                                     originalDiagnostic: {
                                         fileName: '',
                                         start: <any>null,
                                         end: <any>null,
-                                        category: 'error',
+                                        category: 'warning',
                                         text: `DataSource connection error`,
                                     },
                                 };
@@ -1746,22 +1774,38 @@ export class NaslServer {
         }
         /**
          * 如果节点是内置函数
-         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
          * && 他在父级中，不在body
          * && 也不再 if的线上
          * && 也不再 switch的线上consequent
          * && 也不再草稿区域
          * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
          * && 而且也没有类型，就说明在槽位里，就需要报错
+         *
+         * 如果是内置函数而且也不在线上
+         * 只有下面自己实现的函数才会报错
          */
-        if (node instanceof CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
-            const diagnostic = {
-                node,
-                severity: 'error',
-                message: `类型不匹配，传入类型：void`,
-            };
-            node.tsErrorDetail = diagnostic;
-            diagnostics.push(diagnostic);
+        if (node instanceof CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            let showErr = false;
+            if (node.parentNode?.parentNode?.concept === 'CallLogic') {
+                // calllogic 中别的类型会强校验，但是内置函数，不会强制校验，下面这几个其实是走的内置函数的实现，所以需要手动增加一下校验
+                const { calleeNamespace, calleeName } = (node.parentNode.parentNode as CallLogic);
+                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') && (calleeName === 'showMessage' || calleeName === 'consoleLog' || calleeName === 'jsonSerialize' || calleeName === 'jsonDeserialize')) {
+                    showErr = true;
+                }
+            } else {
+                showErr = true;
+            }
+
+            if (showErr) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `类型不匹配，传入类型：void`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
         }
         // newMap key或者value没填都要有报错
         if (node instanceof NewMap) {
@@ -1787,16 +1831,18 @@ export class NaslServer {
                 if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
                     const excludeList = [
                         'nasl.collection.List<nasl.core.String>',
-                        'nasl.collection.List<nasl.core.Text>',
                         'nasl.collection.List<nasl.core.Email>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.String>',
-                        'nasl.collection.Map<nasl.core.String, nasl.core.Text>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
                     ];
+                    const excludeList2 = [
+                        'nasl.collection.List<>',
+                        'nasl.collection.List<T>',
+                    ];
                     // 先特殊处理等 类型合并后就可以去掉了
                     if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
                         return null;
-                    } else if (['nasl.collection.List<>'].includes(leftType.sortedTypeKey) || ['nasl.collection.List<>'].includes(rightType.sortedTypeKey)) {
+                    } else if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
                         return null;
                     }
                     const diagnostic = {
@@ -2663,6 +2709,31 @@ export class NaslServer {
         return result;
     }
 
+    // 通过当前节点，查找被引用的节点
+    async nodeFindRefNodes(node: BaseNode) {
+        let refsList = await this._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) =>
+            // 自己引用自己的过滤掉
+            // 删除的时候过滤一把组件删除提示
+            // 展示组件自己屏蔽掉
+            !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
+        // 最后返回的结果
+        const result = new Set<BaseNode>();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode as FileNode);
+                result.add(minRange.node);
+            });
+        } catch (err) {
+            console.log(err);
+        }
+        return [...result];
+    }
+
     // 获取节点的上层渲染
     _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: Map<BaseNode, Array<Array<QuoteNode>>>, nodeMap: Map<BaseNode, QuoteNode>) {
         const minRangeNode = minRange.node;
@@ -2936,7 +3007,7 @@ export class NaslServer {
         if (node instanceof Param) {
             // index在nasl foreach上有脏数据
             if (node.parentKey === 'index' && node.parentNode instanceof ForEachStatement) {
-                return TypeAnnotation.createPrimitive('Integer');
+                return TypeAnnotation.createPrimitive('Long');
             }
         }
 
@@ -3093,7 +3164,7 @@ export class NaslServer {
             // console.log('原始：', displayString);
             // console.log('方案2：', item?.[0]?.nodeType);
             const nodeTypeAnnotation = type2TypeAnnotation(item?.[0]?.nodeType);
-            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
+            console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
             (newQuickInfoNodes[index].node as any).__nodeType = Object.freeze(item?.[0]?.nodeType);
 
@@ -3150,7 +3221,7 @@ export class NaslServer {
                 }
             } catch (err) {
                 if (globalThis.window) {
-                    console.log(err);
+                    // console.log(err);
                 }
             }
         });
@@ -3207,8 +3278,9 @@ export class NaslServer {
 
     // 全量标注并且返回json
     async getNaslAnnotatedJSON(app: App, releaseFlag: boolean) {
-        console.time('全量标注');
-
+        if (this.changeStackList?.length) {
+            throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作，请稍后再试！或刷新后重试！`);
+        }
         const nodes: QuickInfoNodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
             // 先不排除view，传递给后端的时候，去除views下的标注
@@ -3237,25 +3309,6 @@ export class NaslServer {
         return json;
     }
 
-    // 加载全量nasl节点标注
-    async createdNaslAnnotatedJSON(app: App) {
-        // 全量标注
-        const nodes: QuickInfoNodes = [];
-        this.file2NodeMap.forEach((fileNode, filePath) => {
-            // 先不排除view，传递给后端的时候，去除views下的标注
-            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
-                fileNode.sourceMap.forEach((item, node) => {
-                    nodes.push({
-                        filePath,
-                        node,
-                        item,
-                    });
-                });
-            }
-        });
-        await this.getQuickInfoNodesTypeMap(nodes, true);
-    }
-
     // 增量标注
     async IncrementalAnnotationJSON(records: DiagnosticRecord[]) {
         console.time('增量标注');
@@ -3335,7 +3388,7 @@ export class NaslServer {
                             concept: 'TypeAnnotation',
                             typeKind: 'primitive',
                             typeNamespace: 'nasl.core',
-                            typeName: 'Integer',
+                            typeName: 'Long',
                             typeArguments: null,
                             inferred: null,
                         },
@@ -3349,7 +3402,7 @@ export class NaslServer {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof ForEachStatement) {
                     const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-                    jsonNode.typeAnnotation = TypeAnnotation.createPrimitive('Integer').toJSON();
+                    jsonNode.typeAnnotation = TypeAnnotation.createPrimitive('Long').toJSON();
                 }
             }
             if (node instanceof Match) {

package/src/server/translator.ts

@@ -68,7 +68,7 @@ function transformType(tsType: string): string {
     else if (tsType === 'Double')
         return '小数';
     else if (tsType === 'Decimal')
-        return '精确小数';
+        return '小数';
     else if (tsType === 'Long')
         return '长整数';
     else if (tsType === 'DateTime')

package/src/service/creator/add.configs.js

@@ -22,6 +22,9 @@ function httpCode(response, params, requestInfo) {
 }
 
 function shortResponse(response, params, requestInfo) {
+    if(params === false)
+        return response;
+
     if (response.data && response.data.result !== undefined) {
         return response.data.result;
     } else {

package/src/service/creator/index.js

@@ -48,6 +48,9 @@ const requester = function (requestInfo) {
         withCredentials: !baseURL,
     };
 
+    if(config.timeout)
+        requestOptions.timeout = config.timeout;
+        
     if (aslConfig.debugRequestAll || (aslConfig.debugRequest && requestOptions.method !== 'GET')) {
         console.debug('[Request Debug]', requestOptions);
     }

package/src/service/storage/api.js

@@ -11,4 +11,16 @@ export default {
             path: '/proxy/nasl-storage/api/storage/batchAction',
         },
     },
+    batchInstruct: {
+        url: {
+            method: 'post',
+            path: '/proxy/nasl-storage/api/storage/batchInstruct',
+        },
+    },
+    saveFrontendNasl: {
+        url: {
+            method: 'post',
+            path: '/proxy/nasl-storage/api/storage/saveFrontendNasl',
+        },        
+    },
 };