@lcap/nasl 1.0.0-alpha.13 → 1.0.0-alpha.16

package/src/server/process2LogicNamespace.ts

@@ -1,6 +1,11 @@
 import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ProcessElement } from '..';
 import { genLaunchProcess, genUserTaskLogic } from './getProcesses';
 
+/**
+ * 给调用逻辑用
+ * @param process 
+ * @returns 
+ */
 export function process2LogicNamespace(process: Process) {
     const children: Array<Namespace> = [];
     process.elements.forEach((e) => {
@@ -22,6 +27,7 @@ export function process2LogicNamespace(process: Process) {
             }
             children.push(ns);
             ns.path = `app.processes.${process.name}.elements.${e.name}`;
+            ns.expanded = true;
         }
     });
     const launchLogic = genLaunchProcess(process);
@@ -32,6 +38,9 @@ export function process2LogicNamespace(process: Process) {
     });
     ns.path = `app.processes.${process.name}.logics`;
     const api = `/api/${process.name}/${launchLogic.name}`;
+    launchLogic.getNamespace = function() {
+        return ns.path;
+    }
     launchLogic.getPath = function() {
         return api;
     }
@@ -50,7 +59,11 @@ interface processTreeFragment {
         logics: Array<Logic>,
     }>
 }
-
+/**
+ * 给侧边栏树形用
+ * @param process 
+ * @returns 
+ */
 export function processToTreeFragment(process: Process) {
     const fragment: processTreeFragment = {
         level: 'processTreeFragment',
@@ -66,6 +79,7 @@ export function processToTreeFragment(process: Process) {
             l.params.forEach(p => {
                 p.readonly = true;
             })
+            l.parentNode = process;
             fragment.elements.push({
                 level: 'processTreeElementFragment',
                 id: e.id,
@@ -76,6 +90,8 @@ export function processToTreeFragment(process: Process) {
     });
 
     const launchLogic = genLaunchProcess(process);
+    launchLogic.parentNode = process;
+    
     fragment.logics.push(launchLogic);
     launchLogic.parentKey = 'readonly'
     return fragment;

package/src/server/translator.ts

@@ -1,5 +1,54 @@
 import naslServer from './naslServer';
-export function transformType(tsType: string): string {
+import {
+    Module,
+    BaseNode,
+    App,
+    Structure,
+    Logic,
+    Entity,
+    TypeAnnotation,
+    MemberExpression,
+    EntityProperty,
+    EntityIndex,
+    View,
+    Destination,
+    Enum,
+    BindEvent,
+    QueryFromExpression,
+    QueryJoinExpression,
+    QueryFieldExpression,
+    Identifier,
+    CallLogic,
+    EnumItem,
+    Param,
+    Process,
+    Interface,
+    Argument,
+    ViewElement,
+    BindAttribute,
+    Assignment,
+    CallQueryComponent,
+    Role,
+    Configuration,
+    CallInterface,
+    Return,
+    ProcessElement,
+    NullLiteral,
+    SwitchCase,
+    WhileStatement,
+    IfStatement,
+    UnaryExpression,
+    ForEachStatement,
+    CallFunction,
+} from '../concepts';
+import { SourceMapItem } from '../translator';
+import { Diagnostic } from '../manager/diagnostic';
+export interface MinRange {
+    node: BaseNode;
+    item: SourceMapItem;
+}
+
+function transformType(tsType: string): string {
     if (tsType === 'string' || tsType === 'String')
         return '字符串';
     else if (tsType === 'number')
@@ -24,8 +73,12 @@ export function transformType(tsType: string): string {
         return '枚举';
     else if (tsType === 'views')
         return '页面';
+    else if (tsType === 'void')
+        return '无返回值';
     else if (tsType === '__elements')
         return '页面元素';
+    else if (tsType === 'extensions')
+        return '拓展模块';
     else if (tsType === 'Promise<void>')
         return '未知类型';
     else if (tsType.startsWith('{') && tsType.endsWith('}'))
@@ -39,154 +92,239 @@ export function transformType(tsType: string): string {
             tsStr += index === 0 ? transformType(item) : ' | ' + transformType(item);
         });
         return tsStr;
+    } else if (tsType.includes(' & ')) {
+        const types = tsType.split(' & ');
+        let tsStr = '';
+        types.forEach((item, index) => {
+            tsStr += index === 0 ? transformType(item) : ' | ' + transformType(item);
+        });
+        return tsStr;
+    } else if (tsType.includes(' | ')) {
+        const types = tsType.split(' | ');
+        let tsStr = '';
+        types.forEach((item, index) => {
+            tsStr += index === 0 ? transformType(item) : ' | ' + transformType(item);
+        });
+        return tsStr;
     } else {
         return tsType;
     }
 }
 
-export function transformNamespace(tsNamespace: string): string {
-    if (tsNamespace.endsWith('.structures'))
-        return '数据结构';
-    else if (tsNamespace.endsWith('.logics'))
-        return '逻辑';
-    else
-        return tsNamespace;
+const NAMESPACE_CONCEPT_MAP: Record<string, string> = {
+    entities: '实体',
+    structures: '数据结构',
+    enums: '枚举',
+    logics: '逻辑',
+    interfaces: '接口',
+    views: '页面',
+    elements: '元素',
+    processes: '流程',
+    roles: '角色',
+    extensions: '扩展模块',
+    apis: '接口应用',
+    components: '扩展组件',
+};
+
+function transformNamespace(tsNamespace: string): string {
+    for (const key in NAMESPACE_CONCEPT_MAP) {
+        const value = NAMESPACE_CONCEPT_MAP[key];
+        if (tsNamespace.endsWith(key))
+            return value;
+    }
+    return tsNamespace;
 }
 
-export function transformMethod(tsMethod: string): string {
+function transformMethod(tsMethod: string): string {
     if (tsMethod === 'forEach')
         return 'ForEach';
-    return tsMethod;
+    else
+        return tsMethod;
 }
+
+function transformIdentifier(identifier: string): string {
+    if (NAMESPACE_CONCEPT_MAP[identifier])
+        return NAMESPACE_CONCEPT_MAP[identifier];
+    else
+        return ` ${transformType(identifier)} 上的`;
+}
+
 export function outOriginalvalue(value: string) {
     return value;
 }
 
+const TS_RULES: Array<{
+    re: RegExp;
+    result: string;
+    transforms?: Array<(str: string) => string>;
+}> = [
+    {
+        re: /Type '(.+?)' is not assignable to type '(.+?)'/,
+        result: '左右参数类型不一致！左边类型：$2，右边类型：$1。',
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/,
+        result: '参数类型不一致！传入类型：$1，接收类型：$2。',
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /Type '(.+?)' does not satisfy the constraint '(.+?)'/,
+        result: '参数类型不一致！传入类型：$1，接收类型：$2。',
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /This condition will always return '(.+?)' since the types '(.+?)' and '(.+?)' have no overlap/,
+        result: '左右参数类型不一致！左边类型：$2，右边类型：$3。',
+        transforms: [transformType, transformType, transformType],
+    },
+    {
+        re: /Type '(.+?)' is missing the following properties from type '(.+?)'/,
+        result: '类型不一致！左边类型：$2，右边类型：$1。',
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'/,
+        result: '类型不一致！左边类型：$3，右边类型：$2。',
+        transforms: [outOriginalvalue, transformType, transformType],
+    },
+    {
+        re: /Expression expected/,
+        result: '表达式不能为空。',
+    },
+    {
+        re: /Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'/,
+        result: '表达式不能为空。',
+    },
+    {
+        re: /Cannot find name '__(?:QueryFieldExpression)__'/,
+        result: '数据查询：实体字段不能为空。',
+    },
+    {
+        re: /Cannot find name '__(?:WHERE_MULTIPLE_CONDITION)__'/,
+        result: '数据查询：筛选条件不能有多个表达式。',
+    },
+    {
+        re: /Cannot find name '__(?:HAVING_MULTIPLE_CONDITION)__'/,
+        result: '数据查询：聚合属性过滤不能有多个表达式。',
+    },
+    {
+        re: /Cannot find name '__(?:EMPTY_AGGREGATE_NAME)__'/,
+        result: '数据查询：聚合函数名称不能为空。',
+    },
+    {
+        re: /Cannot find name '__(?:EMPTY_AGGREGATE_ALIAS)__'/,
+        result: '数据查询：聚合函数别名不能为空。',
+    },
+    {
+        re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
+        result: '用户任务未关联页面',
+    },
+    {
+        re: /'(.+?)' is declared but its value is never read/,
+        result: "已添加'$1'，但从来没有使用过。",
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /'(.+?)' has no exported member(?: named)? '(.+?)'/,
+        result: '找不到$1 $2。',
+        transforms: [transformNamespace, transformType],
+    },
+    {
+        re: /Unreachable code detected\./,
+        result: '逻辑中有未使用的。',
+    },
+    {
+        re: /Property '__slice' does not exist on type '(.+?)'/,
+        result: 'For Each：循环列表：参数类型不匹配！所需类型：数组、集合等，提供类型：$1',
+        transforms: [transformType],
+    },
+    {
+        re: /Property '(.+?)' does not exist on type 'typeof (.+?)'/,
+        result: '找不到$2 $1。',
+        transforms: [transformMethod, transformIdentifier],
+    },
+    {
+        re: /Property '(.+?)' does not exist on type '(.+?)'/,
+        result: '找不到$2 $1。',
+        transforms: [transformMethod, transformIdentifier],
+    },
+    {
+        re: /Cannot find name '(.+?)'. Did you mean '(.+?)'\?/,
+        result: '找不到 $1。',
+        transforms: [outOriginalvalue, outOriginalvalue],
+    },
+    {
+        re: /Expected (.+?) type arguments, but got (.+?)/,
+        result: '预期 $1 个类型参数，但传入了 $2 个。',
+        transforms: [outOriginalvalue, outOriginalvalue],
+    },
+    {
+        re: /Expected (.+?) arguments, but got (.+?)./,
+        result: '预期 $1 个参数，但传入了 $2 个。',
+        transforms: [outOriginalvalue, outOriginalvalue],
+    },
+    {
+        re: /The (.+?)-hand side of an arithmetic operation must be of type (.+?). type./,
+        result: '表达式错误！',
+        transforms: [outOriginalvalue, outOriginalvalue],
+    },
+    {
+        re: /Operator '(.+?)' cannot be applied to types '(.+?)' and '(.+?)'./,
+        result: '符号：$1 参数类型不匹配！所需类型：基础类型>$2，提供类型：$3。',
+        transforms: [outOriginalvalue, transformType, transformType],
+    },
+    {
+        re: /Object is possibly 'undefined'./,
+        result: '所选择的内容未定义。',
+    },
+    {
+        re: /Cannot find name '(.+?)'./,
+        result: '所选择的内容 $1 未定义。',
+        transforms: [outOriginalvalue],
+    },
+    {
+        re: /Duplicate identifier '(.+?)'./,
+        result: '当前内容中有重复的 $1，可能会影响使用。',
+        transforms: [outOriginalvalue],
+    },
+];
+
+const POST_RULES: Array<{
+    re: RegExp;
+    result: string;
+    transforms?: Array<(str: string) => string>;
+}> = [
+    {
+        re: /__IDENTIFIER__/g,
+        result: 'undefined',
+    },
+    {
+        re: /Integer|"Integer"/g,
+        result: '整数',
+    },
+    {
+        re: /Long|"Long"/g,
+        result: '长整数',
+    },
+    {
+        re: /Double|"Double"/g,
+        result: '小数',
+    },
+    {
+        re: /never/g,
+        result: '不接受任何类型',
+    },
+];
+Object.keys(NAMESPACE_CONCEPT_MAP).forEach((key) => {
+    POST_RULES.push({
+        re: new RegExp(key, 'g'),
+        result: NAMESPACE_CONCEPT_MAP[key],
+    });
+});
+
 export function translateDiagnosticMessage(message: string) {
-    const translateRules: Array<{
-        re: RegExp;
-        result: string;
-        transforms?: Array<(str: string) => string>;
-    }> = [
-        {
-            re: /^Type '(.+?)' is not assignable to type '(.+?)'\./,
-            result: '左右参数类型不一致！左边类型：$2，右边类型：$1。',
-            transforms: [transformType, transformType],
-        },
-        {
-            re: /^Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'\./,
-            result: '参数类型不一致！传入类型：$1，接收类型：$2。',
-            transforms: [transformType, transformType],
-        },
-        {
-            re: /^This condition will always return 'false' since the types '(.+?)' and '(.+?)' have no overlap\.$/,
-            result: '类型不一致！左边类型：$1，右边类型：$2。',
-            transforms: [transformType, transformType],
-        },
-        {
-            re: /^Type '(.+?)' is missing the following properties from type '(.+?)'/,
-            result: '类型不一致！左边类型：$2，右边类型：$1。',
-            transforms: [transformType, transformType],
-        },
-        {
-            re: /^Property '(.+?)' is missing in type '(.+?)' but required in type '(.+?)'./,
-            result: '类型不一致！左边类型：$3，右边类型：$2。',
-            transforms: [outOriginalvalue, transformType, transformType],
-        },
-        {
-            re: /^Expression expected\.$/,
-            result: '表达式不能为空。',
-        },
-        {
-            re: /^Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'\.$/,
-            result: '表达式不能为空。',
-        },
-        {
-            re: /^Cannot find name '__(?:QueryFieldExpression)__'\.$/,
-            result: '实体字段不能为空。',
-        },
-        {
-            re: /^Cannot find name '__(?:WHERE_MULTIPLE_CONDITION)__'\.$/,
-            result: '筛选条件不能有多个表达式。',
-        },
-        {
-            re: /^Cannot find name '__(?:HAVING_MULTIPLE_CONDITION)__'\.$/,
-            result: '聚合属性过滤不能有多个表达式。',
-        },
-        {
-            re: /^Cannot find name '__(?:EMPTY_AGGREGATE_NAME)__'\.$/,
-            result: '聚合函数名称不能为空。',
-        },
-        {
-            re: /^Cannot find name '__(?:EMPTY_AGGREGATE_ALIAS)__'\.$/,
-            result: '聚合函数别名不能为空。',
-        },
-        {
-            re: /^'(.+?)' is declared but its value is never read\.$/,
-            result: "已添加'$1'，但从来没有使用过。",
-            transforms: [transformType, transformType],
-        },
-        {
-            re: /'(.+?)' has no exported member(?: named)? '(.+?)'/,
-            result: "找不到数据结构 '$2'。",
-            transforms: [transformType, transformNamespace],
-        },
-        {
-            re: /^Unreachable code detected\.$/,
-            result: '逻辑中有未使用的。',
-        },
-        {
-            re: /Property '__slice' does not exist on type '(.+?)'./,
-            result: 'For Each：循环列表：参数类型不匹配！所需类型：基础类型>字符串、数组、集合等，提供类型：$1',
-            transforms: [transformType],
-        },
-        {
-            re: /Property '(.+?)' does not exist on type 'typeof logics'./,
-            result: '逻辑上找不到 $1 未找到。',
-            transforms: [outOriginalvalue],
-        },
-        {
-            re: /Property '(.+?)' does not exist on type 'typeof (.+?)'./,
-            result: '$2 上找不到 $1。',
-            transforms: [transformMethod, transformType],
-        },
-        {
-            re: /Property '(.+?)' does not exist on type '(.+?)'./,
-            result: '$2 上找不到 $1。',
-            transforms: [transformMethod, transformType],
-        },
-        {
-            re: /Cannot find name '(.+?)'. Did you mean '(.+?)'\?/,
-            result: '找不到 $1，您是想要 $2 吗？',
-            transforms: [outOriginalvalue, outOriginalvalue],
-        },
-        {
-            re: /Expected (.+?) arguments, but got (.+?)./,
-            result: '预期 $1 个参数，但传入了 $2 个。',
-            transforms: [outOriginalvalue, outOriginalvalue],
-        },
-        {
-            re: /The (.+?)-hand side of an arithmetic operation must be of type (.+?). type./,
-            result: '表达式错误！',
-            transforms: [outOriginalvalue, outOriginalvalue],
-        },
-        {
-            re: /Operator '(.+?)' cannot be applied to types '(.+?)' and '(.+?)'./,
-            result: '符号 $1 左右类型不匹配！左侧 $2，右侧 $3。',
-            transforms: [outOriginalvalue, transformType, transformType],
-        },
-        {
-            re: /Object is possibly 'undefined'./,
-            result: '所选择的内容未定义。',
-        },
-        {
-            re: /Cannot find name '(.+?)'./,
-            result: '所选择的内容 $1 未定义。',
-            transforms: [outOriginalvalue],
-        },
-    ];
-
-    for (const rule of translateRules) {
+    for (const rule of TS_RULES) {
         const cap = rule.re.exec(message);
         if (cap) {
             return rule.result.replace(/\$(\d+)/g, (m, index) => rule.transforms[index - 1](cap[index]));
@@ -194,3 +332,123 @@ export function translateDiagnosticMessage(message: string) {
     }
     return message;
 }
+/**
+ * 节点和ts 报错结合，转成更精准的ts报错
+ * @param minRange
+ * @param tsErrorDetail 报错具体信息
+ * @returns
+ */
+export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diagnostic) {
+    const text = tsErrorDetail.originalDiagnostic.text;
+    let node = minRange.node;
+    // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
+    if (node instanceof View || node instanceof ViewElement) {
+        if (text.startsWith(`'nasl.ui' has no exported member named `)) {
+            return null;
+        } else if (text.startsWith(`Property '`) && text.includes(`does not exist on type 'typeof ui'.`)) {
+            return null;
+        } else if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
+            return null;
+        }
+    }
+    // 处理bindevent参数没传递的报错
+    if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
+        // bindevent本身现在就不传参数
+        if (node instanceof BindEvent) {
+            return null;
+        }
+    }
+
+    // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
+    // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
+    if (/Expected (.+?) arguments, but got (.+?)./.exec(text) && node.getAncestor('CallLogic')) {
+        node = node.getAncestor('CallLogic');
+    }
+
+    if (node instanceof Argument) {
+        // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {
+        // }
+        // Argument在callInterface上的报错放到内部
+        if (node.expression) {
+            node = node.expression;
+        }
+    }
+
+    // 处理一些复制过来的内容 Identifier或者MemberExpression内容缺失，错误要像上冒
+    if (node instanceof Identifier || node instanceof MemberExpression) {
+        if (node.parentNode instanceof MemberExpression) {
+            let parentNode: BaseNode = node;
+            while (parentNode && parentNode.parentNode instanceof MemberExpression) {
+                parentNode = parentNode.parentNode;
+            }
+            node = parentNode || node;
+
+            let str = tsErrorDetail.message;
+            str = (node as any).constructor.nodeTitle + '：' + str;
+            tsErrorDetail.message = str;
+        }
+    }
+
+    // 类型报错的，需要放到上一级
+    if (/'(.+?)' has no exported member(?: named)? '(.+?)'/.exec(text) || /Property '(.+?)' does not exist on type '(.+?)'./.exec(text)) {
+        if (node instanceof TypeAnnotation) {
+            // 变量type的报错放到内部
+            node = node.parentNode;
+            let str = tsErrorDetail.message;
+            str = (node as any).constructor.nodeTitle + '：' + str;
+            tsErrorDetail.message = str;
+        }
+    }
+
+    /**
+     * 所有问题的报错处理具体信息
+     */
+    if (/^Cannot find name '__(?:IDENTIFIER|LEFT|RIGHT)__'\.$/.exec(text)) {
+        if (node instanceof IfStatement || node instanceof SwitchCase || node instanceof WhileStatement) {
+            tsErrorDetail.message = (node as any).constructor.nodeTitle + '：参数不能为空！所需类型：基础类型>布尔值';
+        } else if (node instanceof ForEachStatement) {
+            tsErrorDetail.message = 'For Each：结束值：不能为空！所需类型：基础类型>整数';
+        } else if (node instanceof UnaryExpression) {
+            tsErrorDetail.message = '!：参数不能为空！';
+        } else if (node instanceof Assignment) {
+            tsErrorDetail.message = '赋值：参数不能为空！';
+        } else if ((node instanceof Argument && node.parentNode instanceof CallInterface) || node instanceof CallInterface) {
+            tsErrorDetail.message = '调用接口：逻辑不能为空！';
+        } else if ((node instanceof Argument && node.parentNode instanceof CallFunction) || node instanceof CallFunction) {
+            tsErrorDetail.message = '调用函数：逻辑不能为空！';
+        } else if ((node instanceof Argument && node.parentNode instanceof CallLogic) || node instanceof CallLogic) {
+            tsErrorDetail.message = '调用逻辑：逻辑不能为空！';
+        } else if (node instanceof Identifier) {
+            // 根据父级内容推断当前缺少啥
+            const identifierToString = (node: Identifier) => {
+                let str = tsErrorDetail.message;
+                if (node.parentNode instanceof Assignment) {
+                    str = '赋值：参数不能为空！';
+                } else if (node.parentNode instanceof Argument && node.parentNode.parentNode instanceof CallLogic) {
+                    str = '调用逻辑：逻辑不能为空！';
+                } else {
+                    str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+                    tsErrorDetail.message = str;
+                }
+                return str;
+            };
+            tsErrorDetail.message = identifierToString(node);
+        }
+    }
+    // 左右类型不一致的，把上级信息带上
+    if (/^Type '(.+?)' is not assignable to type '(.+?)'\./.exec(text) || /^This condition will always return '(.+?)' since the types '(.+?)' and '(.+?)' have no overlap./.exec(text)) {
+        let str = tsErrorDetail.message;
+        str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+        tsErrorDetail.message = str;
+    }
+
+    for (const rule of POST_RULES) {
+        if (rule.re.test(tsErrorDetail.message))
+            tsErrorDetail.message = tsErrorDetail.message.replace(rule.re, rule.result);
+    }
+    node.tsErrorDetail = tsErrorDetail;
+    return {
+        node,
+        ...tsErrorDetail,
+    };
+}