@lcap/nasl 1.0.0-alpha.9 → 1.0.2

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) => {
@@ -9,14 +14,20 @@ export function process2LogicNamespace(process: Process) {
             const ns = new Namespace({
                 name: e.name,
                 logics: [l],
+                originConcept: 'UserTask',
             });
             // 与process 中 toEmbededTS 所设置的 namespace 相关
             const path = `app.processes.${process.name}.elements.${e.name}.logics`;
             l.getNamespace = function() {
                 return path;
             }
+            const api = `/api/${process.name}/${e.name}/${l.name}`;
+            l.getPath = function() {
+                return api;
+            }
             children.push(ns);
-            ns.path = `app.processes.${process.name}.elements.${e.name}.logics`
+            ns.path = `app.processes.${process.name}.elements.${e.name}`;
+            ns.expanded = true;
         }
     });
     const launchLogic = genLaunchProcess(process);
@@ -26,6 +37,13 @@ export function process2LogicNamespace(process: Process) {
         children,
     });
     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;
+    }
     return ns;
 }
 
@@ -41,7 +59,11 @@ interface processTreeFragment {
         logics: Array<Logic>,
     }>
 }
-
+/**
+ * 给侧边栏树形用
+ * @param process 
+ * @returns 
+ */
 export function processToTreeFragment(process: Process) {
     const fragment: processTreeFragment = {
         level: 'processTreeFragment',
@@ -54,6 +76,10 @@ export function processToTreeFragment(process: Process) {
         if (e.type === 'UserTask') {
             const l = genUserTaskLogic(e);
             l.parentKey = 'readonly'
+            l.params.forEach(p => {
+                p.readonly = true;
+            })
+            l.parentNode = process;
             fragment.elements.push({
                 level: 'processTreeElementFragment',
                 id: e.id,
@@ -64,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,8 +1,60 @@
-import naslServer from "./naslServer";
-export function transformType(tsType: string): string {
+import naslServer from './naslServer';
+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,
+    ProcessOutcome,
+} 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' || tsType === 'Integer')
+    else if (tsType === 'number')
+        return '数字';
+    else if (tsType === 'Integer')
         return '整数';
     else if (tsType === 'Double')
         return '小数';
@@ -11,11 +63,27 @@ export function transformType(tsType: string): string {
     else if (tsType === 'DateTime')
         return '日期时间';
     else if (tsType === 'Date')
-        return '时间';
-    else if (tsType === 'Time')
         return '日期';
+    else if (tsType === 'Time')
+        return '时间';
     else if (tsType === 'boolean' || tsType === 'Boolean')
         return '布尔值';
+    else if (tsType === 'unknown')
+        return '未知类型';
+    else if (tsType === 'Enums')
+        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('}'))
+        return '当前节点';
     else if (tsType.endsWith('[]')) {
         return `List<${transformType(tsType.slice(0, -2))}>`;
     } else if (tsType.startsWith('<T extends ') && tsType.endsWith('>() => T')) {
@@ -25,144 +93,244 @@ 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: /Object literal may only specify known properties, and '(.+?)' does not exist in type/,
+        result: '当前参数$1，不可用',
+        transforms: [outOriginalvalue],
+    },
+    {
+        re: /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/,
+        result: '参数类型不一致！传入类型：$1，接收类型：$2。',
+        transforms: [transformType, transformType],
+    },
+    {
+        re: /Type '(.+?)' is not assignable to type '(.+?)'/,
+        result: '左右参数类型不一致！左边类型：$2，右边类型：$1。',
+        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: 'ForEach：循环列表：参数类型不匹配！所需类型：数组、集合等，提供类型：$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: '类型不匹配！左边类型：$1，右边类型：$2。',
-                transforms: [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: '所选择的内容未定义',
-            },
-        ];
-
-    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]));
@@ -170,3 +338,132 @@ 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;
+            if (node) {
+                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 = 'ForEach：结束值：不能为空！所需类型：基础类型>整数';
+        } 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 ProcessOutcome) {
+            tsErrorDetail.message = (node as any).constructor.nodeTitle + '：不能为空！';
+        } else if (node instanceof Argument || node instanceof TypeAnnotation) {
+            let str = tsErrorDetail.message;
+            str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+            tsErrorDetail.message = str;
+        } 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,
+    };
+}

package/src/service/config/index.js

@@ -1,4 +1,4 @@
-import { createService } from '../create';
+import { createService } from '../creator';
 import api from './api';
 
 const service = createService(api);