@lcap/nasl 4.3.0-creator.4 → 4.3.0-creator.5

package/out/natural/transforms/transform2LogicItem.js

@@ -24,7 +24,7 @@ class TransformManager {
     apply(node, options) {
         if (node.type === 'CallExpression') {
             if (node.callee.type === 'CallExpression')
-                return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
+                return (0, utils_1.throwError)(options, '不支持连续调用！', node.callee);
             const callee = flatMemberExpression(node.callee);
             if (callee[0]
                 && callee[0].type === 'CallExpression'
@@ -37,7 +37,7 @@ class TransformManager {
             else {
                 for (const calleeItem of callee) {
                     if (calleeItem.type !== 'Identifier' && !(calleeItem.type === 'FunctionExpression' && calleeItem.id?.name === 'match')) {
-                        return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
+                        return (0, utils_1.throwError)(options, '不支持连续调用！', node.callee);
                     }
                 }
             }
@@ -47,7 +47,7 @@ class TransformManager {
                     return transform(node, calleeName, callee, options);
                 }
             }
-            return (0, utils_1.throwError)(options?.parsingId, `不支持的节点类型 ${callee.map((item) => item.name).join('.')}`, node.type, node);
+            return (0, utils_1.throwError)(options, `不支持的节点类型 ${callee.map((item) => item.name).join('.')}`, node.type, node);
         }
         else {
             for (const [type, transform] of this.transforms) {
@@ -55,7 +55,7 @@ class TransformManager {
                     return transform(node, options);
                 }
             }
-            return (0, utils_1.throwError)(options?.parsingId, '不支持的节点类型', node.type, node);
+            return (0, utils_1.throwError)(options, '不支持的节点类型', node.type, node);
         }
     }
 }
@@ -126,7 +126,7 @@ function transformTSCode2SubLogic(node, options) {
 }
 function assertAssignmentRightIsNotAnonymousFunction(expression, options) {
     if (expression?.concept === 'AnonymousFunction')
-        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function is not allowed in assignment');
+        return (0, utils_1.throwError)(options, 'Anonymous function is not allowed in assignment');
     return expression;
 }
 function fixExpression(arg, options, supportSubLogic = false) {
@@ -284,7 +284,7 @@ function transform2Param(node, options) {
             name,
             typeAnnotation,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -298,7 +298,7 @@ function transform2Param(node, options) {
             name,
             typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -313,7 +313,7 @@ function transform2Param(node, options) {
             required: !node.optional,
             typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -336,12 +336,12 @@ function transform2Param(node, options) {
             name,
             typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '在输入参数中不支持节点类型', node);
+        return (0, utils_1.throwError)(options, '在输入参数中不支持节点类型', node);
     }
 }
 exports.transform2Param = transform2Param;
@@ -362,7 +362,7 @@ function transformCallExpressionToBinaryExpression(node, calleeName, callee, opt
     };
     const limitMap = ['STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN', 'IS_NULL'];
     if (limitMap.includes(calleeName) && options.transformType === 'logic' && !options.inCallQueryComponentField) {
-        return (0, utils_1.throwError)(options?.parsingId, `${calleeName} 仅支持在数据查询中使用`, node);
+        return (0, utils_1.throwError)(options, `${calleeName} 仅支持在数据查询中使用`, node);
     }
     if (calleeName === 'IS_NULL') {
         return new utils_1.naslTypes.UnaryExpression({
@@ -449,7 +449,7 @@ function transform2BinaryExpression(node, options) {
             right: transformNodeFunction(node.right, options),
         });
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在二元表达式中不支持节点类型', node.type, node);
+    return (0, utils_1.throwError)(options, '在二元表达式中不支持节点类型', node.type, node);
 }
 exports.transform2BinaryExpression = transform2BinaryExpression;
 function transformDefaultExpression(node, options) {
@@ -462,7 +462,7 @@ function transformConditionalExpression(node, options) {
         const expr = (0, utils_1.generate)(node.test)?.code;
         const then_expr = (0, utils_1.generate)(node.consequent)?.code;
         const else_expr = (0, utils_1.generate)(node.alternate)?.code;
-        return (0, utils_1.throwError)(options?.parsingId, `数据查询中不支持条件表达式！${(0, utils_1.generate)(node)?.code}, 请使用 SQL函数 IF(${expr} == null, ${then_expr}, ${else_expr})`);
+        return (0, utils_1.throwError)(options, `数据查询中不支持条件表达式！${(0, utils_1.generate)(node)?.code}, 请使用 SQL函数 IF(${expr} == null, ${then_expr}, ${else_expr})`);
     }
     const test = transformNodeFunction(node.test, options);
     const consequent = transformNodeFunction(node.consequent, options);
@@ -515,7 +515,7 @@ function transform2NewAnonymousStructure(node, options) {
                 item.naslType = currentType.typeAnnotation;
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '匿名数据结构的属性中, 不允许出现没有类型的 null 值，请使用 as 关键字来指定类型，如 { price: null as Decimal }', node);
+                return (0, utils_1.throwError)(options, '匿名数据结构的属性中, 不允许出现没有类型的 null 值，请使用 as 关键字来指定类型，如 { price: null as Decimal }', node);
             }
         }
         else if (itemValue.type === 'TSAsExpression') {
@@ -556,7 +556,7 @@ function transform2NewExpression(calleeName, node, options) {
             });
         }
         if (node?.arguments && node?.arguments?.[0]?.type !== 'ArrayExpression') {
-            return (0, utils_1.throwError)(options?.parsingId, 'NewList 中不允许出现非数组表达式', node);
+            return (0, utils_1.throwError)(options, 'NewList 中不允许出现非数组表达式', node);
         }
         return new utils_1.naslTypes.NewList({
             typeAnnotation: node?.typeParameters ? typeAnnotation : undefined,
@@ -589,13 +589,13 @@ function transform2NewExpression(calleeName, node, options) {
         const typeParam = node.typeParameters?.params[0];
         const typeNamespaceAndName = typeParam ? (0, utils_1.generate)(typeParam).code : '';
         if (!typeNamespaceAndName)
-            return (0, utils_1.throwError)(options?.parsingId, 'NewEntity 中必须指定类型', node);
+            return (0, utils_1.throwError)(options, 'NewEntity 中必须指定类型', node);
         return transform2NewStructure(typeNamespaceAndName, node.arguments[0], options);
     }
     if (calleeName === 'NewAnonymousStructure') {
         return transform2NewAnonymousStructure(node.arguments[0], options);
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
+    return (0, utils_1.throwError)(options, '在新建表达式中不支持节点类型', node.type, node);
 }
 function pushElseIf(ifNode, switchStatement, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -622,7 +622,7 @@ function transformBlockBody(body, options) {
     return body.flatMap((item) => {
         const logicItem = transformNodeFunction(item, options);
         if (!logicItem) {
-            console.log('item in block:', item);
+            console.log('item in block:', (0, utils_1.generate)(item).code);
             return [];
         }
         return item?.type === 'ReturnStatement' && item?.argument && logicItem.concept !== 'End' ? [logicItem, new utils_1.naslTypes.End()] : [logicItem];
@@ -825,7 +825,7 @@ function transformIdentifier(node, options) {
             propertyName: '',
         });
     }
-    const placeholderMap = ['__IDENTIFIER__', '__LEFT__', '__RIGHT__', '__RIGHT', '__LEFT', '__IDENTIFIER', 'undefined'];
+    const placeholderMap = ['__IDENTIFIER__', '__LEFT__', '__RIGHT__', '__RIGHT', '__LEFT', '__IDENTIFIER'];
     if (placeholderMap.includes(node.name)) {
         return new utils_1.naslTypes.Identifier({});
     }
@@ -839,6 +839,9 @@ function transformIdentifier(node, options) {
             }),
         });
     }
+    else if (node.name === 'undefined') {
+        return new utils_1.naslTypes.NullLiteral();
+    }
     return new utils_1.naslTypes.Identifier({
         name: node.name,
     });
@@ -850,7 +853,7 @@ function transform2SelectQueryFieldExpression(node, options) {
     if (expression.type === 'Identifier') {
         const isSameName = (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name;
         if (!isSameName) {
-            return (0, utils_1.throwError)(options?.parsingId, `字段名需为 ${(0, utils_2.firstLowerCase)(expression.name)}, 目前为: ${asNameNode.name}, 相关代码如下`, node);
+            return (0, utils_1.throwError)(options, `字段名需为 ${(0, utils_2.firstLowerCase)(expression.name)}, 目前为: ${asNameNode.name}, 相关代码如下`, node);
         }
         return new utils_1.naslTypes.QueryFieldExpression({
             isDotStar: true,
@@ -871,7 +874,7 @@ function transform2SelectQueryFieldExpression(node, options) {
         // @TODO
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '在 QueryFieldExpression 不支持表达式类型', expression.type, expression);
+        return (0, utils_1.throwError)(options, '在 QueryFieldExpression 不支持表达式类型', expression.type, expression);
     }
 }
 function transform2QueryAggregateExpression(node, options) {
@@ -880,10 +883,10 @@ function transform2QueryAggregateExpression(node, options) {
     const arg = callExpression.arguments[0];
     if (arg.type !== 'MemberExpression') {
         const code = (0, utils_1.generate)(arg).code;
-        return (0, utils_1.throwError)(options?.parsingId, `聚合函数的输入只能是表字段(实体.属性)，但${callExpression.callee.name}(${code})中的${code}不是表字段`, node);
+        return (0, utils_1.throwError)(options, `聚合函数的输入只能是表字段(实体.属性)，但${callExpression.callee.name}(${code})中的${code}不是表字段`, node);
     }
     if (callExpression.arguments?.length > 1) {
-        return (0, utils_1.throwError)(options?.parsingId, `聚合函数${callExpression.callee.name}只支持一个参数`);
+        return (0, utils_1.throwError)(options, `聚合函数${callExpression.callee.name}只支持一个参数`);
     }
     return new utils_1.naslTypes.QueryAggregateExpression({
         asName: asNameNode.name,
@@ -893,7 +896,7 @@ function transform2QueryAggregateExpression(node, options) {
 }
 function transform2AnonymousFunction(node, options) {
     if (node.body.type === 'BlockStatement')
-        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function with block statement is not supported', node);
+        return (0, utils_1.throwError)(options, 'Anonymous function with block statement is not supported', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.AnonymousFunction({
         params: node.params.map((param) => transform2Param(param, options)).filter(Boolean),
@@ -1178,7 +1181,7 @@ function transformNewExpression(node, options) {
     else if (calleeName.includes('.entities.') || calleeName.includes('.structures.')) {
         return transform2NewStructure(calleeName, node.arguments[0], options);
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
+    return (0, utils_1.throwError)(options, '在新建表达式中不支持节点类型', node.type, node);
 }
 exports.transformNewExpression = transformNewExpression;
 function transformMemberExpression(node, options) {
@@ -1308,38 +1311,80 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
     const arg = node.arguments[0];
     const ifStatement = node.callee.body.body[0];
     if (ifStatement.type !== 'IfStatement') {
-        return (0, utils_1.throwError)(options?.parsingId, 'Match 函数体内必须是一个 if 语句', ifStatement);
+        return (0, utils_1.throwError)(options, 'Match 函数体内必须是一个 if 语句', ifStatement);
     }
     const flatedIfStatements = flatIfStatementForMatch(ifStatement);
+    let isExpression = options.transformType !== 'logic';
     const match = new utils_1.naslTypes.Match({
         expression: transformNodeFunction(arg, options),
-        isExpression: true,
-        cases: flatedIfStatements.map((_case) => {
+        isExpression,
+        cases: flatedIfStatements.map((_case, index) => {
             let argument;
             if (_case.consequent.type === 'BlockStatement') {
                 if (_case.consequent.body.length === 1 && _case.consequent.body[0].type === 'ReturnStatement') {
                     argument = _case.consequent.body[0].argument;
+                    // 有一个 Return, match 就按 expression 处理
+                    isExpression = true;
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                    const isLastCase = index === flatedIfStatements.length - 1;
+                    let allowEmptyBody = false;
+                    if (isExpression) {
+                        if (isLastCase) {
+                            // 检查前面所有case的test属性,对布尔或者枚举类型特殊处理
+                            allowEmptyBody = flatedIfStatements
+                                .slice(0, index)
+                                .every((prevCase) => {
+                                if (!prevCase.test || prevCase.test.type !== 'BinaryExpression')
+                                    return false;
+                                const testNode = prevCase.test;
+                                const right = testNode.right;
+                                // 检查right是否为BooleanLiteral
+                                if (right?.type === 'BooleanLiteral')
+                                    return true;
+                                // 检查right是否为MemberExpression且包含app.enums
+                                if (right?.type === 'MemberExpression') {
+                                    const rightCode = (0, utils_1.generate)(right).code;
+                                    return rightCode.includes('app.enums');
+                                }
+                                return false;
+                            });
+                        }
+                        if (!allowEmptyBody) {
+                            return (0, utils_1.throwError)(options, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                        }
+                    }
+                    else {
+                        allowEmptyBody = true;
+                    }
                 }
             }
             else {
                 if (_case.consequent.type === 'ReturnStatement') {
                     argument = _case.consequent.argument;
+                    isExpression = true;
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                    return (0, utils_1.throwError)(options, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
                 }
             }
-            const bodyNode = transformNodeFunction(argument, options);
+            let bodyNode = transformNodeFunction(argument, options);
+            let body = [];
+            if (bodyNode) {
+                body = [bodyNode];
+            }
+            if (!isExpression && _case.consequent.type === 'BlockStatement') {
+                body = transformBlockBody(_case.consequent.body.filter((item) => item.type !== 'BreakStatement'), options);
+            }
             return new utils_1.naslTypes.MatchCase({
                 isMatchedTypeEnumable: false,
                 patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNodeFunction(_case.test, options)),
-                body: bodyNode ? [bodyNode] : [],
+                body,
             });
         }).filter(Boolean),
     });
+    // 根据 toNaturalTS，有Return语句的默认为 expression
+    match.isExpression = isExpression;
     if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
         match.cases.push(new utils_1.naslTypes.MatchCase({
             isMatchedTypeEnumable: false,
@@ -1349,7 +1394,7 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
     }
     match.cases.forEach((case_) => {
         if (case_.patterns.length) {
-            if (case_.patterns[0].concept === 'BooleanLiteral' || case_.patterns[0].concept === 'StringLiteral') {
+            if (case_.patterns[0].concept === 'BooleanLiteral') {
                 case_.isMatchedTypeEnumable = true;
             }
             if (case_.patterns[0].concept === 'MemberExpression') {
@@ -1357,13 +1402,13 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
                 case_.patterns[0] = new utils_1.naslTypes.MemberExpression({
                     object: {
                         concept: 'Identifier',
-                        name: case_.patterns[0].object.property.name,
+                        name: case_.patterns[0].object.name,
                         folded: false,
                         namespace: 'app.enums'
                     },
                     property: {
                         concept: 'Identifier',
-                        name: case_.patterns[0].property.value,
+                        name: case_.patterns[0].property.name,
                         folded: false,
                     },
                 });
@@ -1375,7 +1420,7 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
 exports.transformCallFunctionExpression2Match = transformCallFunctionExpression2Match;
 function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (calleeName?.includes('getPropValue') || calleeName?.includes('setPropValue')) {
         const componentName = callee?.[1]?.name;
         const propertyName = node?.arguments?.[0]?.value;
@@ -1411,7 +1456,7 @@ function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
 exports.transformCall2CallViewElementLogic = transformCall2CallViewElementLogic;
 function transformCall2CallEntityLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     const entityName = callee[0].name.replace(/Entity$/, '');
     // console.log('callee', callee);
     return new utils_1.naslTypes.CallLogic({
@@ -1425,7 +1470,7 @@ function transformCall2CallEntityLogic(node, calleeName, callee, options) {
 exports.transformCall2CallEntityLogic = transformCall2CallEntityLogic;
 function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (calleeName?.includes('.entities.')) {
         const calleeNamespace = (0, utils_1.generate)(node?.callee?.object?.object)?.code;
         const entityName = node?.callee?.object?.property?.name?.replace(/Entity$/, '');
@@ -1485,9 +1530,9 @@ function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
 exports.transformCall2CallDataSourceLogic = transformCall2CallDataSourceLogic;
 function transformCall2OQLQuery(node, calleeName, callee, options) {
     if (options?.isInFrontend)
-        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在前端使用', node);
+        return (0, utils_1.throwError)(options, 'OQL组件不支持在前端使用', node);
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, 'OQL组件不支持在组件或默认值表达式中使用', node);
     if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
         // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
         //   typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
@@ -1503,7 +1548,7 @@ function transformCall2OQLQuery(node, calleeName, callee, options) {
 }
 function transformCall2ConsoleLog(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.logging',
         calleeName: 'INFO',
@@ -1516,7 +1561,7 @@ function transformCall2ConsoleLog(node, calleeName, callee, options) {
 exports.transformCall2ConsoleLog = transformCall2ConsoleLog;
 function transformCall2Logging(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     const newArguments = node.arguments.map((arg) => new utils_1.naslTypes.Argument({
         expression: arg?.name === "undefined" ?
             new utils_1.naslTypes.StringLiteral()
@@ -1642,7 +1687,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
             const content = np?.toNaturalTS();
             const noContent = np?.toNaturalTS()?.includes('__IDENTIFIER__');
             if (!np && !p?.defaultExpression) {
-                return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用`, content);
+                return (0, utils_1.throwError)(options, `函数${calleeName}生成不符合标准的函数调用`, content);
             }
             if (np && calleeName === 'ListDistinctBy') {
                 if (idx === 1) {
@@ -1675,7 +1720,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         });
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}不存在`, node.callee, node);
+        return (0, utils_1.throwError)(options, `函数${calleeName}不存在`, node.callee, node);
     }
     if (!func.params?.length) {
         const needDefaultParam = ['CurrDate', 'CurrTime', 'CurrDateTime'];
@@ -1697,7 +1742,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // 这两个参数比较特殊，可以无限加参数，不再判断参数数量
         const excludes = ['HasValue', 'ListSort'];
         if (func.params?.length !== newArguments?.length && !excludes.includes(calleeName)) {
-            return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`, node.callee, node);
+            return (0, utils_1.throwError)(options, `函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`, node.callee, node);
         }
         else {
             newArguments?.forEach((arg, idx) => {
@@ -1715,17 +1760,20 @@ function transform2CallFunction(node, calleeName, argument, options) {
     });
     if (calleeName === 'ListSort') {
         const handledNode = (0, utils_1.handleListSort)(nodeElement?.toJSON(), options);
+        if (handledNode === null) {
+            return (0, utils_1.throwError)(options, 'ListSort 函数使用错误，ListSort 定义如下：export function ListSort<T>(list: List<T>, ...fns: ((item: T) => { asc: Boolean, by: Boolean | Long | Decimal | String | Date | Time | DateTime; })[]): List<T>;', node);
+        }
         return handledNode && new utils_1.naslTypes.CallFunction(handledNode);
     }
     if (options.transformType === 'logic' && options?.inCallQueryComponentField) {
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持使用内置函数', nodeElement.calleeName, node);
+        return (0, utils_1.throwError)(options, '数据查询中不支持使用内置函数', nodeElement.calleeName, node);
     }
     return nodeElement;
 }
 exports.transform2CallFunction = transform2CallFunction;
 function transform2SqlFunction(node, calleeName, argument, options) {
     if (options.inCallQueryComponentField && !['WHERE', 'HAVING', 'ORDER_BY'].includes(options.inCallQueryComponentField)) {
-        return (0, utils_1.throwError)(options?.parsingId, `数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`, node.callee, node);
+        return (0, utils_1.throwError)(options, `数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`, node.callee, node);
     }
     const specFunList = ['COUNT', 'COUNTD', 'SUM', 'AVG', 'MAX', 'MIN'];
     // TODO: 先写死了 mysql，后续需要传入: 参考 requestSqlFunctions
@@ -1826,10 +1874,10 @@ function transform2UIFunction(node, calleeName, callee, options) {
         });
     }
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
-    if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
-        return transformCall2ConsoleLog(node, calleeName, callee, options);
-    }
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+    // if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
+    //   return transformCall2ConsoleLog(node, calleeName, callee, options);
+    // }
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: callee[2].name,
@@ -1950,7 +1998,7 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
 exports.transformForEach2ForEachStatement = transformForEach2ForEachStatement;
 function transformAlert2ShowMessage(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
         return transformCall2ConsoleLog(node, calleeName, callee, options);
     }
@@ -1966,7 +2014,7 @@ function transformAlert2ShowMessage(node, calleeName, callee, options) {
 exports.transformAlert2ShowMessage = transformAlert2ShowMessage;
 function transformCall2Interface(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用接口不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '调用接口不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallInterface({
         calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
         calleeName: callee[callee.length - 1].name,
@@ -1979,14 +2027,14 @@ function transformCall2Interface(node, calleeName, callee, options) {
 exports.transformCall2Interface = transformCall2Interface;
 function transformCall2Connector(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用连接器不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '调用连接器不支持在组件或默认值表达式中使用', node);
     let calleeConnectionName = undefined;
     let calleeNamespace = undefined;
     let calleeNamespacePrefix = `connector.${callee[1].name}`;
     if (callee.length === 5) {
         const connectArg = callee[2].arguments[0];
         if (!connectArg || connectArg.type !== 'StringLiteral') {
-            return (0, utils_1.throwError)(options?.parsingId, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
+            return (0, utils_1.throwError)(options, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
         }
         calleeConnectionName = connectArg.value;
         const noNamespace = callee[3].name === 'logics';
@@ -2001,7 +2049,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
         calleeNamespace = calleeNamespacePrefix;
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
+        return (0, utils_1.throwError)(options, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
     }
     return new utils_1.naslTypes.CallConnector({
         calleeConnectionName,
@@ -2015,7 +2063,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
 exports.transformCall2Connector = transformCall2Connector;
 function transformCall2Extension(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用扩展逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '调用扩展逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
         calleeName: callee?.[callee?.length - 1]?.name,
@@ -2032,19 +2080,19 @@ function transformTSAsExpression(node, options) {
     else if (node.expression.type === 'ArrayExpression') {
         const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined;
         if (typeAnnotation.typeName !== 'List' && typeAnnotation.typeNamespace !== 'nasl.collection')
-            return (0, utils_1.throwError)(options?.parsingId, `列表 as 必须为 List 类型`, node);
+            return (0, utils_1.throwError)(options, `列表 as 必须为 List 类型`, node);
         return transformArrayExpression(node.expression, { ...options, typeAnnotation });
     }
     else if (node.expression.type === 'NullLiteral') {
         return transform2NullLiteral(node.expression, options);
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '表达式不支持使用 as 关键字', node.expression.type, node.expression);
+        return (0, utils_1.throwError)(options, '表达式不支持使用 as 关键字', node.expression.type, node.expression);
     }
 }
 function transformCall2CallViewLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用页面逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '调用页面逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: '',
         calleeName: calleeName.slice('viewLogic_'.length),
@@ -2056,7 +2104,7 @@ function transformCall2CallViewLogic(node, calleeName, callee, options) {
 exports.transformCall2CallViewLogic = transformCall2CallViewLogic;
 function transformCall2Logic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (utils_1.callFunctionMap.includes(calleeName)) {
         // 未带前缀，补一下
         return transform2CallFunction(node, calleeName, node?.arguments || [], options);
@@ -2082,7 +2130,7 @@ function transformCall2Logic(node, calleeName, callee, options) {
 exports.transformCall2Logic = transformCall2Logic;
 function transformCall2LogicWithAuth(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+        return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: `nasl.auth`,
         calleeName: callee[callee.length - 1].name,
@@ -2107,10 +2155,10 @@ function flatCallQueryComponentChainNode(node, options) {
         const calleeName = node.callee.name;
         if (['FROM', 'INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(calleeName)) {
             if (node.arguments[1].type !== 'ArrowFunctionExpression')
-                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1], node);
+                return (0, utils_1.throwError)(options, 'FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1], node);
             const arrowFunctionExpression = node.arguments[1];
             if (arrowFunctionExpression.body.type !== 'CallExpression')
-                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body, node);
+                return (0, utils_1.throwError)(options, 'FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body, node);
             const body = arrowFunctionExpression.body;
             const callExpressions = flatChainCallExpression(body);
             const joinNode = callExpressions?.filter((item) => item?.callee?.name.includes('_JOIN'));
@@ -2120,13 +2168,13 @@ function flatCallQueryComponentChainNode(node, options) {
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id)).SELECT(...)); // 错误用法, ${name}的回调函数必须是完整的QueryChain
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); // 正确用法, 后续查询都在${name}的回调函数中进行
 `;
-                return (0, utils_1.throwError)(options?.parsingId, error, node);
+                return (0, utils_1.throwError)(options, error, node);
             }
             const joinCode = (0, utils_1.generate)(joinNode[0])?.code || '';
             const count = joinCode.match(/_JOIN/g)?.length || 0;
             const errorOrder = count >= 1 && !callExpressions?.[callExpressions?.length - 1]?.callee?.name?.includes('_JOIN');
             if (errorOrder) {
-                return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
+                return (0, utils_1.throwError)(options, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
             }
             const result = [{
                     calleeName: calleeName,
@@ -2176,26 +2224,26 @@ function transformMemberExpression2Entity(node, node2, options) {
     const entityNamespace = entityPath.slice(0, -1).map(n => n.name).join('.');
     const entityName = entityPath[entityPath.length - 1].name.replace(/Entity$/, '');
     if (!entityNamespace?.includes('.entities')) {
-        return (0, utils_1.throwError)(options?.parsingId, `${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`, node);
+        return (0, utils_1.throwError)(options, `${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`, node);
     }
     const asName = node2.name === entityName ? undefined : node2.name;
     if (asName) {
-        return (0, utils_1.throwError)(options?.parsingId, `FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
+        return (0, utils_1.throwError)(options, `FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
     }
     return { entityNamespace, entityName, asName };
 }
 function transformCall2DataQuery(node, calleeName, callee, options) {
     if (options?.isInFrontend)
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在前端使用', node);
+        return (0, utils_1.throwError)(options, '数据查询组件不支持在前端使用', node);
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '数据查询组件不支持在组件或默认值表达式中使用', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const code = (0, utils_1.generate)(node)?.code || '';
     if (code?.includes('nasl.util')) {
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
+        return (0, utils_1.throwError)(options, '数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
     }
     if (!code?.includes('.SELECT(') && !code?.includes('.AGGR_SELECT(')) {
-        return (0, utils_1.throwError)(options?.parsingId, '缺少 SELECT 或 AGGR_SELECT 语句', code);
+        return (0, utils_1.throwError)(options, '缺少 SELECT 或 AGGR_SELECT 语句', code);
     }
     const flatted = flatCallQueryComponentChainNode(node, options);
     if (!flatted)
@@ -2203,7 +2251,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     const calleeNames = flatted && flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
     const isOrderCorrect = (0, utils_1.checkOQLCalleeNameOrder)(calleeNames);
     if (!isOrderCorrect) {
-        return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
+        return (0, utils_1.throwError)(options, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
     }
     let from;
     let where;
@@ -2242,7 +2290,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 const joinType = rawJoinType === 'OUTER' ? 'FULL' : rawJoinType;
                 const onExpressions = flatOnExpressions(item.arguments[2]);
                 if (!from)
-                    return; // throwError(options?.parsingId, 'FROM 不存在或异常，无法添加 JOIN 子句', node);
+                    return; // throwError(options, 'FROM 不存在或异常，无法添加 JOIN 子句', node);
                 from.addJoinPart(new utils_1.naslTypes.QueryJoinExpression({
                     ...entity,
                     joinType,
@@ -2258,8 +2306,8 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 }));
                 break;
             case 'AGGR_SELECT':
-                if (groupBy?.length) {
-                    return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT', node);
+                if (groupBy.length) {
+                    return (0, utils_1.throwError)(options, '存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT', node);
                 }
                 select = new utils_1.naslTypes.QuerySelectExpression({
                     distinct: false,
@@ -2280,7 +2328,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             }
                         }
                         else {
-                            return (0, utils_1.throwError)(options?.parsingId, `Unsupported expression type for QueryAggregateExpression`, arg?.value.type, arg?.value);
+                            return (0, utils_1.throwError)(options, `Unsupported expression type for QueryAggregateExpression`, arg?.value.type, arg?.value);
                         }
                     });
                 }
@@ -2301,37 +2349,41 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
+                    return (0, utils_1.throwError)(options, 'Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
                 }
                 break;
             case 'SELECT':
                 select = new utils_1.naslTypes.QuerySelectExpression({
                     distinct: false,
                     star: true,
-                    selectElements: groupBy?.length ? [new utils_1.naslTypes.QueryFieldExpression({
+                    selectElements: groupBy.length ? [new utils_1.naslTypes.QueryFieldExpression({
                             isDotStar: true,
                             entityAsName: from?.entityName,
                             propertyName: '',
                         })] : [],
                 });
+                if (item.arguments[0].type !== 'ObjectExpression') {
+                    select = undefined;
+                    return (0, utils_1.throwError)(options, 'SELECT 参数应为 ObjectExpression，标准示例：.SELECT({ ... })', node);
+                }
                 item.arguments[0].properties?.forEach((arg) => {
                     let selectElements = [];
                     if (arg.value.type === 'CallExpression') {
                         selectElements = [transform2QueryAggregateExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName })];
                     }
                     else if (arg.value.type === 'ObjectExpression') {
-                        if (groupBy?.length) {
-                            return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列', node);
+                        if (groupBy.length) {
+                            return (0, utils_1.throwError)(options, '存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列', node);
                         }
                         const originName = arg.key?.name || '';
                         if (originName && originName.charAt(0) === originName.charAt(0).toUpperCase()) {
                             const needName = (0, utils_2.firstLowerCase)(originName);
-                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`, node);
+                            return (0, utils_1.throwError)(options, `SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`, node);
                         }
                         const entityName = (0, utils_2.firstUpperCase)(originName);
                         const needNameList = entityAsNames.map(item => (0, utils_2.firstLowerCase)(item))?.join('或');
                         if (!entityAsNames.includes(entityName)) {
-                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
+                            return (0, utils_1.throwError)(options, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
                         }
                         selectElements = arg.value.properties?.map((property) => {
                             const columnAsName = property.key?.name;
@@ -2339,7 +2391,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             const selectElement = transform2SelectQueryFieldExpression(property, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
                             if (columnAsName !== columnPropertyName) {
                                 // eg: comment: Topic_Comment.comment_stu
-                                return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`, node);
+                                return (0, utils_1.throwError)(options, `SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`, node);
                             }
                             selectElement.isDotStar = false;
                             return selectElement;
@@ -2350,7 +2402,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             hasErrorTSScopeColumn = true;
                         }
                         if (arg.type === 'ObjectProperty' && select?.selectElements?.find(item => item?.concept === 'QueryFieldExpression' && item.entityAsName === arg.value?.name)) {
-                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 禁止在一次查询中对同一实体设置多个别名，请修改`, node);
+                            return (0, utils_1.throwError)(options, `SELECT 禁止在一次查询中对同一实体设置多个别名，请修改`, node);
                         }
                         selectElements = [transform2SelectQueryFieldExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName })];
                     }
@@ -2377,35 +2429,43 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'HAVING 不符合规范，请使用箭头函数', havingNode, node);
+                    return (0, utils_1.throwError)(options, 'HAVING 不符合规范，请使用箭头函数', havingNode, node);
                 }
                 having = transformNodeFunction(havingNode, { ...options, ...restParams });
                 break;
             case 'ORDER_BY':
+                const ORDER_BY_ERROR_MESSAGE = `ORDER_BY 不符合规范，请使用箭头函数，并返回 Array<[字段值, "ASC" | "DESC"]> 的形式，示例：
+- .ORDER_BY((resultItem) => [[resultItem[sort], order]])
+- .ORDER_BY((resultItem) => [[Student.age, 'ASC'], [Student.name, 'DESC']])`;
                 let orderNode = item.arguments;
                 let restOptionParams = { entityAsNames };
-                if (orderNode?.length === 1 && orderNode?.[0]?.type === 'ArrowFunctionExpression') {
-                    const params = orderNode?.[0]?.params;
-                    if (orderNode?.[0]?.body?.type !== 'ArrayExpression') {
-                        return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数，并返回数组', orderNode, node);
+                if (orderNode.length === 1 && orderNode[0].type === 'ArrowFunctionExpression') {
+                    const params = orderNode[0].params;
+                    if (orderNode[0].body.type !== 'ArrayExpression') {
+                        return (0, utils_1.throwError)(options, ORDER_BY_ERROR_MESSAGE, orderNode, node);
                     }
-                    orderNode = orderNode?.[0]?.body?.elements;
-                    if (params?.length && params?.[0]?.name) {
-                        restOptionParams = { inOqlIdentifierNamespace: params?.[0]?.name, entityAsNames };
+                    orderNode = orderNode[0].body.elements;
+                    if (params.length && params[0].name) {
+                        restOptionParams = { inOqlIdentifierNamespace: params[0].name, entityAsNames };
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数，并返回数组', orderNode, node);
+                    return (0, utils_1.throwError)(options, ORDER_BY_ERROR_MESSAGE, orderNode, node);
                 }
                 orderBy = orderNode.map((arg) => {
-                    let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
-                    if (!useResultItem) {
-                        useResultItem = orderElementCode.includes('resultItem.');
+                    if (arg.type === 'ArrayExpression') {
+                        let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
+                        if (!useResultItem) {
+                            useResultItem = orderElementCode.includes('resultItem.');
+                        }
+                        return new utils_1.naslTypes.QueryOrderByExpression({
+                            orderElement: transformNodeFunction(arg.elements[0], { ...options, ...restOptionParams, inCallQueryComponentField: item.calleeName }),
+                            order: transformNodeFunction(arg.elements[1], { ...options, ...restOptionParams, inCallQueryComponentField: item.calleeName })
+                        });
+                    }
+                    else {
+                        (0, utils_1.throwError)(options, ORDER_BY_ERROR_MESSAGE, arg, node);
                     }
-                    return new utils_1.naslTypes.QueryOrderByExpression({
-                        orderElement: transformNodeFunction(arg.elements[0], { ...options, ...restOptionParams, inCallQueryComponentField: item.calleeName }),
-                        order: transformNodeFunction(arg.elements[1], { ...options, ...restOptionParams, inCallQueryComponentField: item.calleeName })
-                    });
                 });
                 break;
         }
@@ -2420,27 +2480,30 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         orderBy,
         ideVersion: '2.22',
     });
-    if (hasErrorTSScopeColumn && !groupBy?.length && !having) {
-        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 局部列不符合规范，需要按两层对象返回', node);
+    if (!select) {
+        return (0, utils_1.throwError)(options, 'SELECT 不符合规范', node);
+    }
+    if (hasErrorTSScopeColumn && !groupBy.length && !having) {
+        return (0, utils_1.throwError)(options, 'SELECT 局部列不符合规范，需要按两层对象返回', node);
     }
-    const hasScopeColumn = select?.selectElements?.find((selectElement) => selectElement?.concept === 'QueryFieldExpression' && !selectElement?.isDotStar);
-    if (hasScopeColumn && (groupBy?.length || having)) {
-        return (0, utils_1.throwError)(options?.parsingId, '分组聚合与表字段局部列不允许同时出现', node);
+    const hasScopeColumn = select.selectElements.find((selectElement) => selectElement.concept === 'QueryFieldExpression' && !selectElement.isDotStar);
+    if (hasScopeColumn && (groupBy.length || having)) {
+        return (0, utils_1.throwError)(options, '分组聚合与表字段局部列不允许同时出现', node);
     }
     if (hasScopeColumn && useResultItem) {
-        return (0, utils_1.throwError)(options?.parsingId, "对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])", node);
+        return (0, utils_1.throwError)(options, "对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])", node);
     }
-    const isOnlyAggr = select?.selectElements?.find((selectElement) => selectElement?.concept !== 'QueryAggregateExpression');
+    const onlyAggr = select.selectElements.length && select.selectElements.every((selectElement) => selectElement.concept === 'QueryAggregateExpression');
     // 如果 select 中只有聚合属性时，并且没有用 AGGR_SELECT 来指定列
-    if (!isOnlyAggr && !calleeNames?.includes('AGGR_SELECT')) {
-        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 不符合规范，请使用 AGGR_SELECT', node);
+    if (onlyAggr && !calleeNames.includes('AGGR_SELECT')) {
+        return (0, utils_1.throwError)(options, 'SELECT 不符合规范，请使用 AGGR_SELECT', node);
     }
     // callQueryComponent.typeAnnotation = callQueryComponent.computeStructure();
     return callQueryComponent;
 }
 function transformCall2LaunchProcess(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用流程逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options, '调用流程逻辑不支持在组件或默认值表达式中使用', node);
     const args = node.arguments;
     const dataArg = args?.[0];
     const procDefKeyArg = args?.[1];
@@ -2556,9 +2619,19 @@ function transform2LogicItem(node, options) {
     transformManager.registerCallExpression('PAGINATE', transformCall2Paginate);
     transformManager.registerCallExpression('FROM', transformCall2DataQuery);
     transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && !['ArrowFunctionExpression', 'FunctionExpression'].includes(callee[0].type), transformCall2Logic);
-    let result = transformManager.apply(node, options);
-    delete options.typeAnnotation;
-    return result || undefined;
+    try {
+        let result = transformManager.apply(node, options);
+        return result || undefined;
+    }
+    catch (err) {
+        if (err.name === 'ParseNaturalTSError')
+            throw err;
+        (0, utils_1.throwError)(options, `解析逻辑发生异常：${err?.message}\n相关代码如下`, node);
+        return undefined;
+    }
+    finally {
+        delete options.typeAnnotation;
+    }
 }
 exports.transform2LogicItem = transform2LogicItem;
 //# sourceMappingURL=transform2LogicItem.js.map