@lcap/nasl 2.18.0-beta.7 → 2.19.0-beta.1

package/src/server/entity2LogicNamespace.ts

@@ -1,4 +1,4 @@
-import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Function, Return } from '..';
+import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Function, Return, AnonymousFunction, NewList } from '..';
 
 export function entity2LogicNamespace(entity: Entity) {
     const properties = entity.properties;
@@ -86,6 +86,26 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({
@@ -135,15 +155,6 @@ export function entity2LogicNamespace(entity: Entity) {
                 name: 'updateBy',
                 description: '根据条件，将body除id外所有属性更新到数据记录',
                 params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
                     new Param({
                         name: 'filter',
                         defaultExpression: new Function({
@@ -167,6 +178,35 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'body',
+                        typeAnnotation: new TypeAnnotation({
+                            typeKind: 'reference',
+                            typeNamespace: entity.getNamespace(),
+                            typeName: entity.name,
+                        }),
+                        required: true,
+                    }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({
@@ -257,6 +297,26 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({

package/src/server/extendBaseNode.ts

@@ -230,7 +230,11 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                             return null;
                         const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
-                            if (minRange.node instanceof CallLogic || minRange.node instanceof Destination) {
+                            /**
+                             * 调用方是 调用逻辑或者跳转页面， 去删除对应位置的内容
+                             * 如果是跳转页面，因为流程下的特殊翻译，需要过滤下 非页面下的参数修改，查找到页面跳转
+                             */
+                            if (minRange.node instanceof CallLogic || (node.parentNode instanceof View && minRange.node instanceof Destination)) {
                                 minRange.node.deleteCalleeArg(Index);
                             }
                         }
@@ -339,14 +343,14 @@ BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd =
 /**
  * 在原型上增加方法来调用
  */
-BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation() {
+BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation(outTime? :number) {
     try {
         /**
          * 查找这个节点是不是有依赖
          */
         const app = this.getAncestor('App');
         const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.getCurrentTypeAnnotation(this);
+        return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
     } catch (err) {
         console.log(err);
     }

package/src/server/formatTsUtils.ts

@@ -513,6 +513,8 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 item.expression = memberExpression;
                 item.variableParent = parent;
                 item.typeKey = typeKey;
+                // 标记实体属性是否是符合类型
+                item.isComplexType = item.typeAnnotation?.isComplexType();
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             if (typeKey && !isNoChildType(typeKey)) {
@@ -532,6 +534,10 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
             // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             item.concept = 'CompletionProperty';
             const completionProperty = new CompletionProperty(item);
+            // 标记实体属性是否是符合类型
+            if (typeof item.isComplexType === 'boolean') {
+                Object.assign(completionProperty, { isComplexType: item.isComplexType });
+            }
             if (!parent) {
                 // 变量 param return 在这里添加图标
                 completionProperty.icon = getNodeiconFromLogic(completionProperty, node);

package/src/server/getLogics.ts

@@ -1,3 +1,4 @@
+import { Identifier } from './../concepts/Identifier__';
 import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement, stdlibNamespace, EnumItem } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
 import { moduleToLogicNamesapce } from './getExtensionModules';
@@ -56,7 +57,7 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
 function toHump(name: string): string {
     return name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase());
 }
-export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boolean = true) {
+export async function getLogics(node: CallLogic | BindEvent| Identifier, needAllLogic: boolean = true) {
     const app = node.rootNode as App;
     if (node.concept === 'CallLogic' || node.concept === 'BindEvent') {
         const result = [];
@@ -264,6 +265,17 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             result.push(systemTree);
         }
         return result;
+    } else if (node.concept === 'Identifier') {
+        const extensions = app.dependencies.map(moduleToLogicNamesapce).filter((item) => item.logics && item.logics.length);
+        const tree = new Namespace({
+            name: 'category`',
+            path: `${app.getNamespace()}.logics`,
+            title: '全局逻辑',
+            logics: app.logics,
+            children: [...extensions],
+        });
+
+        return [tree];
     }
 }
 

package/src/server/getMemberIdentifier.ts

@@ -191,7 +191,7 @@ export async function getMemberIdentifier(node: BaseNode) {
 
         // 这个可能需要自己算一下
         const result = [
-            { name: '字面量', children: literals, expanded: true, icon: 'category' },
+            { name: '常量', children: literals, expanded: true, icon: 'category' },
             { name: '枚举', children: newEnums, expanded: false, icon: 'category' },
             { name: '变量', children: completionData, expanded: true, icon: 'category' },
             { name: '公共变量', children: globalVariable, expanded: false, icon: 'category' },

package/src/server/naslServer.ts

@@ -202,7 +202,34 @@ export class NaslServer {
             // 收集到一个行为集合
             const eventValue = $event.value;
             eventValue.forEach(async (item: EventPayload) => {
-                this.changeStackList.push(item.originEvent);
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    if (changeNode !== fileNode || !changeEvent.field) {
+                        const findIndex = this.changeStackList.findIndex((changeStackItem: EventPayload) => {
+                            const target = changeStackItem.target;
+                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                            return targetFileNode === fileNode;
+                        });
+                        if (findIndex === this.changeStackList.length - 1) {
+                            this.changeStackList.pop();
+                        }
+                    }
+                    this.changeStackList.push(item.originEvent);
+                } catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
             });
 
             // 如果有长度开始执行状态机
@@ -615,7 +642,8 @@ export class NaslServer {
         return '';
     }
     async getDataSchemaStructureOrTypeAnnotation(node: ViewElement) {
-        if (!(node instanceof ViewElement)) return;
+        if (!(node instanceof ViewElement))
+            return;
 
         const { currentSource, fileNode } = this.getCurrentSource(node);
         const quickInfo = await this._getTypeQuickinfo({
@@ -626,16 +654,18 @@ export class NaslServer {
         if (quickInfo.responseRequired) {
             const displayString = quickInfo?.response?.displayString || '';
             const flag = displayString.includes('<') && displayString.includes('>');
-            if(!flag) return;
+            if (!flag)
+                return;
 
             const types = /\<([^()]+)\>/g.exec(displayString);
-            let typeStr = types && types[1];
+            const typeStr = types && types[1];
             const app = node.app;
             if (typeStr.includes('__name: "AStructure_')) {
                 const properties: StructureProperty[] = [];
                 typeStr
                     .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
-                        if(name === '__name') return;
+                        if (name === '__name')
+                            return;
 
                         typeKey = `app.${typeKey}`;
                         const keys = typeKey.split('.');
@@ -647,12 +677,12 @@ export class NaslServer {
                                 typeKind: 'reference',
                                 typeName,
                                 typeNamespace,
-                            })
-                        }))
+                            }),
+                        }));
                         return '';
                     });
                 return TypeAnnotation.createTypeAnonymousStructure(properties);
-            } else if(typeStr.startsWith('structures'))
+            } else if (typeStr.startsWith('structures'))
                 return app.findNodeByCompleteName(`app.${typeStr}`);
         }
     }
@@ -814,7 +844,8 @@ export class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`
+                    , `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
 
@@ -847,7 +878,7 @@ export class NaslServer {
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof Match) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap: any = {};
@@ -857,7 +888,7 @@ export class NaslServer {
                         count: 0,
                     };
                     if (Array.isArray(cases)) {
-                        cases.forEach(async (caseItem, index) => {
+                        cases.forEach((caseItem, index) => {
                             let isDisabled = false;
                             // 是最后一项
                             if (index === cases.length - 1) {
@@ -997,7 +1028,7 @@ export class NaslServer {
             if (removed)
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
@@ -1111,6 +1142,40 @@ export class NaslServer {
                                 },
                             };
                             diagnostics.push(diagnostic);
+                        } else if (propertyValue.value) {
+                            const dataSource: any = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                } else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            } else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                } else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'error',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: <any>null,
+                                        end: <any>null,
+                                        category: 'error',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
                         }
                     });
                 }
@@ -1121,17 +1186,18 @@ export class NaslServer {
             if (fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
+                //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-                if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
-                    const diagnostic = {
-                        node,
-                        severity: 'error',
-                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
-                    };
-                    node.tsErrorDetail = diagnostic;
-                    diagnostics.push(diagnostic);
-                }
+                // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
+                //     const diagnostic = {
+                //         node,
+                //         severity: 'error',
+                //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                //     };
+                //     node.tsErrorDetail = diagnostic;
+                //     diagnostics.push(diagnostic);
+                // }
                 if (node instanceof Return || node instanceof Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
@@ -1167,6 +1233,11 @@ export class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        if (fileNode instanceof Process) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                this.checkNodeError(node, diagnostics);
+            });
+        }
         return diagnostics;
     }
 
@@ -1226,6 +1297,16 @@ export class NaslServer {
                 }
             });
         }
+        if (node instanceof MatchCase && (node.getAncestor('Match') as Match)?.isExpression && node.body.length === 0 && !node.isDisabled) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: '匹配分支：表达式不能为空',
+                titleTip: '表达式不能为空',
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
         // 如果节点是match的patterns 里的
         if (node?.parentKey === 'patterns' && node.parentNode instanceof MatchCase) {
             const matchNode = node.getAncestor('Match');
@@ -1244,9 +1325,30 @@ export class NaslServer {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            } else if (node instanceof TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            } else if (!(node instanceof TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
             if (node.tsErrorDetail) {
-                if (matchExpressionType?.typeNamespace?.includes('enums')) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof MemberExpression)) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 } else if (!node.tsErrorDetail.titleTip) {
                     node.tsErrorDetail.titleTip = '该值已被删除';
@@ -1263,6 +1365,25 @@ export class NaslServer {
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， calllogic 和 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);
+        }
     }
 
     /* 接口导入查找 */
@@ -2289,7 +2410,7 @@ export class NaslServer {
      * @returns 不需要去查就可以返回类型的节点
      */
     getCurrentNodeKnownTypeAnnotation(node: BaseNode) {
-        if (node.concept === 'StringLiteral' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
+        if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
             let type = 'String';
             switch (node.concept) {
                 case 'NullLiteral':
@@ -2306,7 +2427,7 @@ export class NaslServer {
             return TypeAnnotation.createPrimitive('Boolean');
         }
         // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
+        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
@@ -2396,6 +2517,9 @@ export class NaslServer {
                 'Return',
                 'Variable',
                 'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2442,12 +2566,18 @@ export class NaslServer {
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
+            } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+                fileDetail.line = item.range.end.line;
+                const indexOf = item.code.indexOf('return __newComposite');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
             }
             args.push(fileDetail);
         });
-        console.time('请求')
+        console.time('请求');
         const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
-        console.timeEnd('请求')
+        console.timeEnd('请求');
 
         // console.log(resultMap);
 
@@ -2499,6 +2629,9 @@ export class NaslServer {
                     } else if (value.typeAnnotation) {
                         node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
                     }
+                } else {
+                    // 清空原来已经赋值上去的类型，可能原来有现在没有了
+                    node.__TypeAnnotation = null;
                 }
             } catch (err) {
                 if (globalThis.window) {
@@ -2773,7 +2906,7 @@ export class NaslServer {
         };
     }
 
-    async getCurrentTypeAnnotation(node: BaseNode) {
+    async getCurrentTypeAnnotation(node: BaseNode, outTime: number = 600) {
         if (node.__TypeAnnotation) {
             return node.__TypeAnnotation;
         }
@@ -2787,7 +2920,7 @@ export class NaslServer {
                 } else {
                     resolve(null);
                 }
-            }, 600);
+            }, outTime);
             const mySetInterval = setInterval(() => {
                 if (node.__isCorrectTypeAnnotation) {
                     resolve(node.__TypeAnnotation);

package/src/server/process2LogicNamespace.ts

@@ -89,6 +89,10 @@ export function processToTreeFragment(process: Process) {
                 k.getNamespace = function () {
                     return path;
                 };
+                const api = `/api/${process.name}/${e.name}/${k.name}`;
+                k.getPath = function () {
+                    return api;
+                };
             });
 
             fragment.elements.push({
@@ -107,6 +111,10 @@ export function processToTreeFragment(process: Process) {
     launchLogic.getNamespace = function () {
         return path;
     };
+    const api = `/api/${process.name}/${launchLogic.name}`;
+    launchLogic.getPath = function () {
+        return api;
+    };
 
     fragment.logics.push(launchLogic);
     launchLogic.parentKey = 'readonly';