@lcap/nasl 4.4.0-beta.3 → 4.4.0-beta.30

package/out/natural/transforms/transform2LogicItem.js

@@ -3,12 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAlert2ShowMessage = exports.transformForEach2ForEachStatement = exports.transformForOf2ForEachStatement = exports.transform2ForEachStatement = exports.transformMap2ListTransform = exports.transform2UIFunction = exports.transformCall2CallFunction = exports.transform2CallFunction = exports.transform2CallOtherNASLLogic = exports.transform2CallEventLogic = exports.transformCall2JSONFunctions = exports.transformCall2Logging = exports.transformCall2ConsoleLog = exports.transformCall2CallDataSourceLogic = exports.transformCall2CallEntityLogic = exports.transformCall2CallViewElementLogic = exports.transformCallFunctionExpression2Match = exports.transformMemberExpression = exports.transformNewExpression = exports.transform2NewRegex = exports.transform2PartialNewComposite = exports.transform2Comment = exports.transform2StringInterpolation = exports.transformReturnStatement2AssignmentOrEnd = exports.transform2NullLiteral = exports.transform2NumericLiteral = exports.transform2DirectiveLiteral = exports.transform2StringLiteral = exports.transform2BooleanLiteral = exports.transformUpdateExpression2Assignment = exports.transform2Assignment = exports.transform2AnonymousFunction = exports.transformIdentifier = exports.transformSwitchStatement2Match = exports.transform2WhileStatement = exports.transform2Break = exports.transform2Continue = exports.transform2IfStatement = exports.transform2BinaryExpression = exports.transform2VariadicExpression = exports.transformCallExpressionToBinaryExpression = exports.transform2Param = exports.fixLogicNode = exports.flatIfStatementForMatch = exports.flatMatchPatternsExpression = exports.getSelectMembers = exports.unflatMemberExpression = exports.flatMemberExpression = exports.fixExpression = exports.TransformManager = void 0;
-exports.transform2LogicItem = exports.transformNode2Directory = exports.transformCall2Paginate = exports.transformCall2LogicWithAuth = exports.transformCall2Logic = exports.transformCall2CallViewLogic = exports.transformCall2Extension = exports.transformCall2Connector = exports.transformCall2Interface = void 0;
-const utils_1 = require("./utils");
+exports.transformCall2Interface = exports.transformAlert2ShowMessage = exports.transformForEach2ForEachStatement = exports.transformForOf2ForEachStatement = exports.transform2ForEachStatement = exports.transformMap2ListTransform = exports.transform2UIFunction = exports.transformCall2CallFunction = exports.transform2CallFunction = exports.transform2CallOtherNASLLogic = exports.transform2CallEventLogic = exports.transformCall2JSONFunctions = exports.transformCall2Logging = exports.transformCall2ConsoleLog = exports.transformCall2CallDataSourceLogic = exports.transformCall2CallEntityLogic = exports.transformCall2CallViewElementLogic = exports.transformCallFunctionExpression2Match = exports.transformMemberExpression = exports.transformNewExpression = exports.transform2NewRegex = exports.transform2PartialNewComposite = exports.transform2Comment = exports.transform2StringInterpolation = exports.transformReturnStatement2AssignmentOrEnd = exports.transform2NullLiteral = exports.transform2NumericLiteral = exports.transform2DirectiveLiteral = exports.transform2StringLiteral = exports.transform2BooleanLiteral = exports.transformUpdateExpression2Assignment = exports.transform2Assignment = exports.transform2AnonymousFunction = exports.transformIdentifier = exports.transformSwitchStatement2Match = exports.transform2WhileStatement = exports.transform2Break = exports.transform2Continue = exports.transform2IfStatement = exports.transform2BinaryExpression = exports.transform2VariadicExpression = exports.transformCallExpressionToBinaryExpression = exports.fixLogicNode = exports.flatIfStatementForMatch = exports.flatMatchPatternsExpression = exports.getSelectMembers = exports.unflatMemberExpression = exports.flatMemberExpression = exports.fixExpression = exports.TransformManager = void 0;
+exports.transform2LogicItem = exports.transform2DefaultValue = exports.transformNode2Directory = exports.transformCall2Paginate = exports.transformCall2LogicWithAuth = exports.transformCall2Logic = exports.transformCall2CallViewLogic = exports.transformCall2Extension = exports.transformCall2Connector = void 0;
+const utils_1 = require("../utils");
+const misc_1 = require("./utils/misc");
+const checkDataQueryCalleeNameOrder_1 = require("./checker/checkDataQueryCalleeNameOrder");
 const transform2TypeAnnotation_1 = require("./transform2TypeAnnotation");
-const utils_2 = require("../../utils");
+const transform2Param_1 = require("./transform2Param");
 const server_1 = __importDefault(require("../../server"));
+const parseDecorator_1 = require("./utils/parseDecorator");
 ;
 class TransformManager {
     constructor() {
@@ -63,7 +66,7 @@ exports.TransformManager = TransformManager;
 function transformTSCode2SubLogic(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const logic = new utils_1.naslTypes.SubLogic();
-    logic.name = options.transformType === 'logic' && options.logic?.getSubLogicUniqueName ? options.logic.getSubLogicUniqueName() : `subLogic_${(0, utils_2.uuidv4)().slice(0, 2)}`;
+    logic.name = options.transformType === 'logic' && options.logic?.getSubLogicUniqueName ? options.logic.getSubLogicUniqueName() : `subLogic_${(0, utils_1.uuidv4)().slice(0, 2)}`;
     logic.body = logic.body.slice(0, 1);
     let parameters = [];
     let statements = [];
@@ -77,7 +80,7 @@ function transformTSCode2SubLogic(node, options) {
         statements = [...node?.body?.directives, ...node?.body?.body];
     }
     parameters.forEach((node) => {
-        const param = transform2Param(node, options);
+        const param = (0, transform2Param_1.transform2Param)(node, options);
         if (param && !param?.typeAnnotation) {
             param.typeAnnotation = null;
         }
@@ -129,6 +132,15 @@ function assertAssignmentRightIsNotAnonymousFunction(expression, options) {
         return (0, utils_1.throwError)(options, 'Anonymous function is not allowed in assignment');
     return expression;
 }
+/**
+ * 处理赋值表达式右侧的判定逻辑
+ */
+function validateAssignmentRightExpression(right, options, node) {
+    if (right?.concept === 'CallLogic' && right.calleeName === 'delete' && right.calleeNamespace?.includes('app.dataSources')) {
+        return (0, utils_1.throwError)(options, 'delete 函数返回值为空，请移除赋值语句和相关判定操作。可默认 delete 函数执行成功，无需考虑失败情况处理。', node);
+    }
+    return right;
+}
 function fixExpression(arg, options, supportSubLogic = false) {
     let expression;
     if (options.transformType === 'logic' && supportSubLogic &&
@@ -146,11 +158,18 @@ function fixExpression(arg, options, supportSubLogic = false) {
         if (arg?.body?.type === 'ReturnStatement') {
             arg.body = arg?.body?.argument;
         }
-        const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
-        expression = transformNodeFunction(arg, options);
-        if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+        // app.logics.logic5("123", undefined);
+        // 这种情况 undefined 是一个参数，所以需要特殊处理
+        if (arg.type === 'Identifier' && arg.name === 'undefined') {
             expression = undefined;
         }
+        else {
+            const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
+            expression = transformNodeFunction(arg, options);
+            if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+                expression = undefined;
+            }
+        }
     }
     return expression;
 }
@@ -246,9 +265,12 @@ function flatMatchPatternsExpression(node) {
 }
 exports.flatMatchPatternsExpression = flatMatchPatternsExpression;
 function flatIfStatementForMatch(node) {
-    if (node.alternate.type === 'IfStatement') {
+    if (node?.alternate?.type === 'IfStatement') {
         return [node, ...flatIfStatementForMatch(node.alternate)];
     }
+    if (node.test === null || !node.alternate) {
+        return [node];
+    }
     return [node, {
             type: 'IfStatement',
             test: null,
@@ -272,79 +294,6 @@ function fixLogicNode(node) {
     }
 }
 exports.fixLogicNode = fixLogicNode;
-function transform2Param(node, options) {
-    const exclude = ['event'];
-    if (node.type === 'ObjectProperty') {
-        const typeAnnotation = node?.value?.name ? utils_1.naslTypes.TypeAnnotation.createPrimitive((node?.value).name) : null;
-        const name = node.key.name;
-        if (exclude.includes(name))
-            return null;
-        let defaultValueExpression = node.key.optional ? { type: 'NullLiteral' } : undefined;
-        return new utils_1.naslTypes.Param({
-            name,
-            typeAnnotation,
-            defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
-            }),
-        });
-    }
-    else if (node.type === 'TSPropertySignature') {
-        const typeAnnotation = node.typeAnnotation?.typeAnnotation;
-        const name = node.key.name;
-        if (exclude.includes(name))
-            return null;
-        let defaultValueExpression = node.optional ? { type: 'NullLiteral' } : undefined;
-        return new utils_1.naslTypes.Param({
-            name,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
-            defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
-            }),
-        });
-    }
-    else if (node.type === 'Identifier') {
-        const typeAnnotation = node.typeAnnotation?.typeAnnotation;
-        const name = node.name;
-        if (exclude.includes(name))
-            return null;
-        let defaultValueExpression = node.optional ? { type: 'NullLiteral' } : undefined;
-        return new utils_1.naslTypes.Param({
-            name,
-            required: !node.optional,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
-            defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
-            }),
-        });
-    }
-    else if (node.type === 'AssignmentPattern') {
-        const identifier = node.left;
-        const typeAnnotation = identifier.typeAnnotation?.typeAnnotation;
-        let defaultValueExpression;
-        if (node.type === 'AssignmentPattern') {
-            if (node.right)
-                defaultValueExpression = node.right;
-            else if (identifier.optional) {
-                defaultValueExpression = { type: 'NullLiteral' };
-            }
-        }
-        const exclude = ['event'];
-        const name = identifier.name;
-        if (exclude.includes(name))
-            return null;
-        return new utils_1.naslTypes.Param({
-            name,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
-            defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { ...options, transformType: 'attr', isRestricted: true }),
-            }),
-        });
-    }
-    else {
-        return (0, utils_1.throwError)(options, '在输入参数中不支持节点类型', node);
-    }
-}
-exports.transform2Param = transform2Param;
 function transformCallExpressionToBinaryExpression(node, calleeName, callee, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const argument = node?.arguments;
@@ -360,10 +309,11 @@ function transformCallExpressionToBinaryExpression(node, calleeName, callee, opt
         IN: 'in',
         IS_NULL: 'isNull',
     };
-    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, `${calleeName} 仅支持在数据查询中使用`, node);
-    }
+    // 4.4版本支持使用: https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2903738850213120
+    // const limitMap = ['STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN', 'IS_NULL'];
+    // if (limitMap.includes(calleeName) && options.transformType === 'logic' && !options.inCallQueryComponentField) {
+    //   return throwError(options, `${calleeName} 仅支持在数据查询中使用`, node);
+    // }
     if (calleeName === 'IS_NULL') {
         return new utils_1.naslTypes.UnaryExpression({
             operator: 'isNull',
@@ -403,6 +353,13 @@ function collectExpressions(node, operator, expressions, options) {
         }
     }
 }
+/**
+ * 检查节点是否为 null 或 undefined
+ */
+function isNullOrUndefined(node) {
+    return (node?.type === 'NullLiteral' ||
+        (node?.type === 'Identifier' && node.name === 'undefined'));
+}
 function transform2VariadicExpression(node, options) {
     // 创建一个新的 VariadicExpression
     const result = {
@@ -421,13 +378,13 @@ function transform2BinaryExpression(node, options) {
         node.operator = '==';
     if (node.operator === '!==')
         node.operator = '!=';
-    if (node.operator === '==' && node.right?.type === 'NullLiteral' && options?.inCallQueryComponentField) {
+    if (node.operator === '==' && isNullOrUndefined(node.right) && options?.inCallQueryComponentField) {
         return new utils_1.naslTypes.UnaryExpression({
             operator: 'isNull',
             argument: transformNodeFunction(node.left, options),
         });
     }
-    if (node.operator === '!=' && node.right?.type === 'NullLiteral' && options?.inCallQueryComponentField) {
+    if (node.operator === '!=' && isNullOrUndefined(node.right) && options?.inCallQueryComponentField) {
         return new utils_1.naslTypes.UnaryExpression({
             operator: '!',
             argument: new utils_1.naslTypes.UnaryExpression({
@@ -464,36 +421,13 @@ function transformConditionalExpression(node, options) {
         const else_expr = (0, utils_1.generate)(node.alternate)?.code;
         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 condition = transformNodeFunction(node.test, options);
     const consequent = transformNodeFunction(node.consequent, options);
     const alternate = transformNodeFunction(node.alternate, options);
-    const variables = options.transformType === 'logic' ? [...options?.logic?.variables, ...options?.logic?.returns, ...options?.logic?.params] : [];
-    const testType = variables?.find((item) => item?.name === test?.name)?.typeAnnotation;
-    const expression = testType?.typeName === 'Boolean' || test?.concept === 'BinaryExpression' ? test :
-        new utils_1.naslTypes.CallFunction({
-            calleeNamespace: 'nasl.util',
-            calleeName: 'Convert',
-            arguments: [
-                new utils_1.naslTypes.Argument({
-                    expression: test,
-                }),
-            ],
-            typeArguments: [utils_1.naslTypes.TypeAnnotation.createPrimitive('Boolean')],
-        });
-    return new utils_1.naslTypes.Match({
-        expression,
-        isExpression: true,
-        cases: [
-            new utils_1.naslTypes.MatchCase({
-                patterns: [new utils_1.naslTypes.BooleanLiteral({ value: 'true' })],
-                body: consequent ? [consequent] : [],
-                isMatchedTypeEnumable: true,
-            }),
-            new utils_1.naslTypes.MatchCase({
-                patterns: [],
-                body: alternate ? [alternate] : [],
-            }),
-        ],
+    return new utils_1.naslTypes.IfExpression({
+        condition,
+        consequent,
+        alternate
     });
 }
 function transformArrayExpression(node, options) {
@@ -637,7 +571,7 @@ function transform2ArrayPattern(decl, options) {
     }
     else {
         getVariableNode = new utils_1.naslTypes.Identifier({
-            name: `temp_${(0, utils_2.uuidv4)().slice(0, 4)}`,
+            name: `temp_${(0, utils_1.uuidv4)().slice(0, 4)}`,
         });
         logicItems.push(new utils_1.naslTypes.Assignment({
             left: getVariableNode,
@@ -704,10 +638,22 @@ function transform2VariableAndAddAssignment(node, options) {
         if (options.transformType === 'logic' && ![...options.logic.variables, ...options.logic.returns].some((variable) => variable.name === variableName)) {
             const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
             typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined;
-            options.logic.variables.push(new utils_1.naslTypes.Variable({
+            const variable = new utils_1.naslTypes.Variable({
                 name: variableName,
                 typeAnnotation,
-            }));
+            });
+            // 处理 $Variable 装饰器
+            if (options.decorator && options.decorator.arguments[0]?.type === 'ObjectExpression') {
+                const variableMetadata = (0, parseDecorator_1.pickDecoratorObject)(options.decorator.arguments[0], parseDecorator_1.VARIABLE_DECORATOR.allowedKeys, parseDecorator_1.VARIABLE_DECORATOR.mappings || {}, options);
+                if (variableMetadata.description) {
+                    variable.description = variableMetadata.description;
+                }
+                // autoInferType: true 时跳过类型注解（依赖 TS 推断）
+                if (variableMetadata.autoInferType === true) {
+                    delete variable.typeAnnotation;
+                }
+            }
+            options.logic.variables.push(variable);
         }
         if (decl.init) {
             const calleeName = (0, utils_1.generate)(decl?.init?.callee).code;
@@ -717,9 +663,11 @@ function transform2VariableAndAddAssignment(node, options) {
                 decl.init.typeAnnotations = varTypeAnnotation;
             }
             options.typeAnnotation = typeAnnotation;
+            const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation }), options) || undefined;
+            validateAssignmentRightExpression(right, options, node);
             newNode = new utils_1.naslTypes.Assignment({
                 left: transformNodeFunction(decl.id, options),
-                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation }), options) || undefined,
+                right
             });
         }
     });
@@ -851,13 +799,13 @@ function transform2SelectQueryFieldExpression(node, options) {
     let expression = node.value;
     let asNameNode = node.key;
     if (expression.type === 'Identifier') {
-        const isSameName = (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name;
+        const isSameName = (0, utils_1.firstUpperCase)(asNameNode.name) === expression.name;
         if (!isSameName) {
-            return (0, utils_1.throwError)(options, `字段名需为 ${(0, utils_2.firstLowerCase)(expression.name)}, 目前为: ${asNameNode.name}, 相关代码如下`, node);
+            return (0, utils_1.throwError)(options, `字段名需为 ${(0, utils_1.firstLowerCase)(expression.name)}, 目前为: ${asNameNode.name}, 相关代码如下`, node);
         }
         return new utils_1.naslTypes.QueryFieldExpression({
             isDotStar: true,
-            asName: (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name ? undefined : asNameNode.name,
+            asName: (0, utils_1.firstUpperCase)(asNameNode.name) === expression.name ? undefined : asNameNode.name,
             entityAsName: expression.name,
             propertyName: '',
         });
@@ -865,7 +813,7 @@ function transform2SelectQueryFieldExpression(node, options) {
     else if (expression.type === 'MemberExpression') {
         return new utils_1.naslTypes.QueryFieldExpression({
             isDotStar: false,
-            asName: (0, utils_2.firstUpperCase)(asNameNode.name) === expression.property.name ? undefined : asNameNode.name,
+            asName: (0, utils_1.firstUpperCase)(asNameNode.name) === expression.property.name ? undefined : asNameNode.name,
             entityAsName: expression.object.name,
             propertyName: expression.property.name,
         });
@@ -899,7 +847,7 @@ function transform2AnonymousFunction(node, options) {
         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),
+        params: node.params.map((param) => (0, transform2Param_1.transform2Param)(param, options)).filter(Boolean),
         body: transformNodeFunction(node.body, options),
     });
 }
@@ -926,9 +874,11 @@ function transform2Assignment(node, options) {
     if (options.transformType !== 'logic') {
         return transformNodeFunction(node.right, options);
     }
+    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options), options) || undefined;
+    validateAssignmentRightExpression(right, options, node);
     return new utils_1.naslTypes.Assignment({
         left: transformNodeFunction(node.left, options),
-        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options), options) || undefined,
+        right
     });
 }
 exports.transform2Assignment = transform2Assignment;
@@ -1034,6 +984,22 @@ function transform2StringInterpolation(node, options) {
             end: element.end,
         }))];
     expressions.sort((a, b) => a.start - b.start);
+    // 在数据查询组件字段中，将模板字符串转换为 SQL CONCAT 函数
+    if (options?.inCallQueryComponentField) {
+        const transformedExpressions = expressions
+            // 过滤掉空字符串
+            .filter((item) => !(item.type === 'StringLiteral' && item.value === ''))
+            .map((item) => transformNodeFunction(item, options))
+            .filter(Boolean);
+        return new utils_1.naslTypes.CallFunction({
+            calleeNamespace: 'nasl.sqlFunction',
+            calleeName: 'CONCAT',
+            arguments: transformedExpressions.map((expr, index) => new utils_1.naslTypes.Argument({
+                expression: expr,
+                keyword: `param${index + 1}`,
+            })),
+        });
+    }
     return new utils_1.naslTypes.StringInterpolation({
         expressions: expressions.map((item) => transformNodeFunction(item, options))?.filter(Boolean),
     });
@@ -1056,7 +1022,11 @@ function transform2Comment(node, options) {
 exports.transform2Comment = transform2Comment;
 function transformBlockStatement(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
-    return transformNodeFunction(node?.body?.[0], options);
+    const statements = node.body;
+    return new utils_1.naslTypes.Block({
+        folded: false,
+        logicItems: statements.map((item) => transformNodeFunction(item, options))?.filter(Boolean),
+    });
 }
 function transform2PartialNewComposite(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -1160,7 +1130,6 @@ function transform2NewRegex(node, options) {
         flags = node.arguments[1] ? transformNodeFunction(node.arguments[1], options) : undefined;
     }
     return new utils_1.naslTypes.NewRegex({
-        kind: "dynamic",
         pattern,
         flags
     });
@@ -1247,6 +1216,14 @@ function transformMemberExpression(node, options) {
     const regex = /^(app\..+?)\.variables\.(.+)$/;
     if (regex.test(calleeName)) {
         const [, namespace, variableName] = calleeName.match(regex);
+        const isBackendVariable = calleeName.includes('app.backend.variables');
+        const isLogic = options.transformType === 'logic';
+        if (isLogic && options.logicType === 'global_logic' && !isBackendVariable) {
+            return (0, utils_1.throwError)(options, '服务端逻辑不支持使用前端全局变量', node);
+        }
+        if (isLogic && options.logicType !== 'global_logic' && isBackendVariable) {
+            return (0, utils_1.throwError)(options, '前端逻辑不支持使用服务端全局变量', node);
+        }
         const variableNameList = variableName.split('.');
         if (variableNameList?.length === 1) {
             return new utils_1.naslTypes.Identifier({
@@ -1256,13 +1233,17 @@ function transformMemberExpression(node, options) {
         }
         else {
             // 前后端全局变量
-            const number = calleeName?.includes('app.backend.variables') ? 3 : 6;
+            const number = isBackendVariable ? 3 : 6;
             const newCallee = callee.slice(number);
             const newNode = unflatMemberExpression(newCallee, options, null, `${namespace}.variables`);
             return newNode;
         }
     }
     if (calleeName?.startsWith('nasl.auth.')) {
+        const isLogic = options.transformType === 'logic';
+        if (isLogic && options.logicType === 'global_logic') {
+            return (0, utils_1.throwError)(options, '服务端逻辑不支持使用 nasl.auth 公共变量', node);
+        }
         const variableNameList = calleeName.split('.');
         if (variableNameList?.length === 3) {
             return new utils_1.naslTypes.Identifier({
@@ -1314,35 +1295,77 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
         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, '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, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
                 }
             }
-            const bodyNode = transformNodeFunction(argument, options);
+            let bodyNode = argument ? transformNodeFunction(argument, options) : undefined;
+            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,
@@ -1352,7 +1375,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') {
@@ -1360,13 +1383,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,
                     },
                 });
@@ -1415,23 +1438,30 @@ exports.transformCall2CallViewElementLogic = transformCall2CallViewElementLogic;
 function transformCall2CallEntityLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
         return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
-    const entityName = callee[0].name.replace(/Entity$/, '');
-    // console.log('callee', callee);
-    return new utils_1.naslTypes.CallLogic({
-        calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
-        calleeName: callee[1].name,
-        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
-            expression: fixExpression(arg, options),
-        })),
-    });
+    return (0, utils_1.throwError)(options, '调用实体逻辑必须要有完整的命名空间，如：app.dataSources.defaultDS.entities.XxxEntity.{create,update,delete,batchCreate,...}(...)', node);
+    // const entityName = (callee[0] as babelTypes.Identifier).name.replace(/Entity$/, '');
+    // // console.log('callee', callee);
+    // return new naslTypes.CallLogic({
+    //   calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
+    //   calleeName: (callee[1] as babelTypes.Identifier).name,
+    //   arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+    //     expression: fixExpression(arg, options),
+    //   })) as naslTypes.Argument[],
+    // });
 }
 exports.transformCall2CallEntityLogic = transformCall2CallEntityLogic;
 function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
         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$/, '');
+    if (calleeName.includes('.entities.')) {
+        const obj = node.callee.object;
+        if (obj.type !== 'MemberExpression')
+            return (0, utils_1.throwError)(options, '调用实体逻辑的命名空间不正确。正确示例如：app.dataSources.defaultDS.entities.XxxEntity.{create,update,delete,batchCreate,...}(...)', node);
+        const calleeNamespace = (0, utils_1.generate)(obj.object).code;
+        let entityName = obj.property.name;
+        if (!entityName.endsWith('Entity'))
+            return (0, utils_1.throwError)(options, '调用实体逻辑的实体名必须要有 Entity 后缀。正确示例如：app.dataSources.defaultDS.entities.XxxEntity.{create,update,delete,batchCreate,...}(...)', node);
+        entityName = entityName.replace(/Entity$/, '');
         let newArguments = node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
             expression: fixExpression(arg, options),
         }));
@@ -1439,15 +1469,39 @@ function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
         if (['update', 'batchUpdate']?.includes(newCalleeName)) {
             if (newArguments?.[0])
                 newArguments[0].keyword = 'body';
+            if (newArguments?.[1]) {
+                if (newArguments[1]?.expression.concept === 'AnonymousFunction' && newArguments[1]?.expression?.params?.[0]?.name) {
+                    newArguments[1].expression.params[0].typeAnnotation = utils_1.naslTypes.TypeAnnotation.createReference(entityName, {
+                        typeNamespace: calleeNamespace,
+                        typeName: entityName
+                    });
+                }
+            }
         }
         if (['updateBy', 'deleteBy']?.includes(newCalleeName)) {
-            const expression = newArguments?.[0]?.expression?.toJSON();
+            const expression = newArguments?.[0]?.expression;
+            if (expression && expression.concept === 'AnonymousFunction') {
+                const firstParam = expression.params?.[0];
+                if (firstParam && firstParam.name !== '_') {
+                    return (0, utils_1.throwError)(options, `调用实体逻辑 ${newCalleeName} 的筛选函数参数名必须为 _`, node.arguments[0]);
+                }
+                let hasError = false;
+                expression.traverseStrictChildren((child) => {
+                    if ((child.concept === 'CallFunction' || child.concept === 'CallLogic') && child.calleeNamespace?.startsWith('nasl.util')) {
+                        (0, utils_1.throwError)(options, `调用实体逻辑 ${newCalleeName} 的筛选条件不能使用内置函数`, node.arguments[0]);
+                        hasError = true;
+                    }
+                });
+                if (hasError)
+                    return;
+            }
+            const expressionJson = expression?.toJSON();
             const argument2 = newArguments?.[1];
             newArguments = [new utils_1.naslTypes.Argument({
                     expression: new utils_1.naslTypes.Function({
                         name: "filter",
-                        returnExpression: expression?.body || undefined,
-                        params: expression?.params || [
+                        returnExpression: expressionJson?.body || undefined,
+                        params: expressionJson?.params || [
                             new utils_1.naslTypes.Param({
                                 name: '_',
                                 typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(entityName, {
@@ -1578,7 +1632,7 @@ function transform2CallOtherNASLLogic(node, calleeName, callee, options) {
 }
 exports.transform2CallOtherNASLLogic = transform2CallOtherNASLLogic;
 function transform2CallFunction(node, calleeName, argument, options) {
-    calleeName = utils_1.replaceCallFunctionMap?.[calleeName] || calleeName;
+    calleeName = misc_1.replaceCallFunctionMap?.[calleeName] || calleeName;
     const func = server_1.default ? server_1.default.getBuildInFunction(calleeName) : null;
     let newArguments = argument.map((arg, index) => {
         let supportSubLogic = false;
@@ -1625,6 +1679,16 @@ function transform2CallFunction(node, calleeName, argument, options) {
             new utils_1.naslTypes.TypeAnnotation()
         ];
     }
+    if (calleeName === 'FromString') {
+        if (newTypeArguments?.[0]?.typeName === 'Time' && newArguments?.[0]?.expression?.concept === 'StringLiteral') {
+            const timeValue = newArguments?.[0]?.expression?.value;
+            // 验证时分秒格式：严格的 HH:mm:ss (两位数字)
+            const timeRegex = /^([0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/;
+            if (timeValue && !timeRegex.test(timeValue)) {
+                return (0, utils_1.throwError)(options, `FromString<Time> 的参数值 "${timeValue}" 不符合时分秒格式，必须为 HH:mm:ss 格式`, node);
+            }
+        }
+    }
     if (func) {
         const needTypeMap = [
             'ListDistinctBy',
@@ -1671,6 +1735,14 @@ function transform2CallFunction(node, calleeName, argument, options) {
                     expression: utils_1.naslTypes.BaseNode.from(p.defaultExpression.toJSON()),
                 }));
             }
+            if (np && p?.defaultExpression?.concept === 'AnonymousFunction' && p?.name === 'by' && p?.parentKey === 'params') {
+                // 特殊处理下，因为 Params 中有默认行为，需要占个位
+                if (np.expression?.params) {
+                    np.expression.params.forEach((param) => {
+                        param.typeAnnotation = null;
+                    });
+                }
+            }
             // 类型不匹配时，使用默认值
             if (calleeName === "GetDateCount" && idx === func.params?.length - 1 && np?.expression?.concept !== 'StringLiteral') {
                 np &&
@@ -1713,13 +1785,16 @@ function transform2CallFunction(node, calleeName, argument, options) {
     }
     const nodeElement = new utils_1.naslTypes.CallFunction({
         calleeNamespace: 'nasl.util',
-        calleeName: utils_1.replaceCallFunctionMap?.[calleeName] || calleeName,
+        calleeName: misc_1.replaceCallFunctionMap?.[calleeName] || calleeName,
         arguments: newArguments,
         typeArguments: newTypeArguments
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     if (calleeName === 'ListSort') {
-        const handledNode = (0, utils_1.handleListSort)(nodeElement?.toJSON(), options);
+        const handledNode = (0, misc_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) {
@@ -1751,7 +1826,7 @@ function transform2SqlFunction(node, calleeName, argument, options) {
     }));
     const nodeElement = new utils_1.naslTypes.CallFunction({
         calleeNamespace: 'nasl.sqlFunction',
-        calleeName: utils_1.replaceCallFunctionMap?.[calleeName] || calleeName,
+        calleeName: misc_1.replaceCallFunctionMap?.[calleeName] || calleeName,
         arguments: [...addArguments, ...newArguments],
         typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
@@ -1871,12 +1946,12 @@ function transform2ForEachStatement(node, calleeName, callee, options) {
         each: transformNodeFunction(newCallee[0], options),
         start: transformNodeFunction(newCallee[1], options),
         end: newCallee[2]?.name === '__IDENTIFIER__' ? undefined : transformNodeFunction(newCallee[2], options),
-        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0], options) || undefined : new utils_1.naslTypes.Param({
+        item: arrowFunction?.params?.[0] ? (0, transform2Param_1.transform2Param)(arrowFunction.params[0], options, true) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
-            name: `index_${(0, utils_2.uuidv4)().slice(0, 4)}`,
+        index: arrowFunction?.params?.[1] ? (0, transform2Param_1.transform2Param)(arrowFunction.params[1], options, true) || undefined : new utils_1.naslTypes.Param({
+            name: `index_${(0, utils_1.uuidv4)().slice(0, 4)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         body: transformBlockBody(body, options),
@@ -1919,12 +1994,12 @@ function transformForOf2ForEachStatement(node, options) {
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         end: endNode?.name === '__IDENTIFIER__' ? undefined : endNode ? transformNodeFunction(endNode, options) : undefined,
-        item: itemNode ? transform2Param(itemNode, options) || undefined : new utils_1.naslTypes.Param({
+        item: itemNode ? (0, transform2Param_1.transform2Param)(itemNode, options, true) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: indexNode ? transform2Param(indexNode, options) || undefined : new utils_1.naslTypes.Param({
-            name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
+        index: indexNode ? (0, transform2Param_1.transform2Param)(indexNode, options, true) || undefined : new utils_1.naslTypes.Param({
+            name: `index_${(0, utils_1.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         body: transformBlockBody(body, options),
@@ -1943,9 +2018,9 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
             value: '0',
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
-        item: transform2Param(arrowFunction.params[0], options) || undefined,
-        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
-            name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
+        item: (0, transform2Param_1.transform2Param)(arrowFunction.params[0], options) || undefined,
+        index: arrowFunction.params[1] ? (0, transform2Param_1.transform2Param)(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
+            name: `index_${(0, utils_1.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         body: transformBlockBody(body, options),
@@ -1987,9 +2062,11 @@ function transformCall2Connector(node, calleeName, callee, options) {
         return (0, utils_1.throwError)(options, '调用连接器不支持在组件或默认值表达式中使用', node);
     let calleeConnectionName = undefined;
     let calleeNamespace = undefined;
-    let calleeNamespacePrefix = `connector.${callee[1].name}`;
-    if (callee.length === 5) {
+    const connectorName = callee[1].name;
+    let calleeNamespacePrefix = `connector.${connectorName}`;
+    if (callee.length === 5) { // connectors.connectorName.connect(connectionName).logics.logicName()
         const connectArg = callee[2].arguments[0];
+        console.log('connectArg', connectArg);
         if (!connectArg || connectArg.type !== 'StringLiteral') {
             return (0, utils_1.throwError)(options, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
         }
@@ -2002,14 +2079,11 @@ function transformCall2Connector(node, calleeName, callee, options) {
             calleeNamespace = `${calleeNamespacePrefix}.${callee[3].name}`;
         }
     }
-    else if (callee.length === 4) {
-        calleeNamespace = calleeNamespacePrefix;
-    }
     else {
-        return (0, utils_1.throwError)(options, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
+        return (0, utils_1.throwError)(options, `调用 connector 写法不正确，你可能少写了 .logics, .structures 或 .connect(connectionName)`, node);
     }
     return new utils_1.naslTypes.CallConnector({
-        calleeConnectionName,
+        calleeConnectionName: calleeConnectionName || `${connectorName}Conn`,
         calleeNamespace,
         calleeName: callee[callee.length - 1].name,
         arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
@@ -2062,7 +2136,7 @@ exports.transformCall2CallViewLogic = transformCall2CallViewLogic;
 function transformCall2Logic(node, calleeName, callee, options) {
     if (options?.isRestricted)
         return (0, utils_1.throwError)(options, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
-    if (utils_1.callFunctionMap.includes(calleeName)) {
+    if (misc_1.callFunctionMap.includes(calleeName)) {
         // 未带前缀，补一下
         return transform2CallFunction(node, calleeName, node?.arguments || [], options);
     }
@@ -2194,6 +2268,8 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         return (0, utils_1.throwError)(options, '数据查询组件不支持在前端使用', node);
     if (options?.isRestricted)
         return (0, utils_1.throwError)(options, '数据查询组件不支持在组件或默认值表达式中使用', node);
+    if (options?.inCallQueryComponentField)
+        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')) {
@@ -2206,7 +2282,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     if (!flatted)
         return;
     const calleeNames = flatted && flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
-    const isOrderCorrect = (0, utils_1.checkOQLCalleeNameOrder)(calleeNames);
+    const isOrderCorrect = (0, checkDataQueryCalleeNameOrder_1.checkDataQueryCalleeNameOrder)(calleeNames);
     if (!isOrderCorrect) {
         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);
     }
@@ -2220,6 +2296,12 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     let entity;
     let hasErrorTSScopeColumn = false;
     let useResultItem = false;
+    let simplifyType;
+    if (node.arguments?.[2] &&
+        node.arguments[2]?.type === 'StringLiteral' &&
+        node.arguments[2].value === 'SIMPLIFY') {
+        simplifyType = true;
+    }
     // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
     flatted && flatted.forEach((item) => {
         // console.log(item.calleeName)
@@ -2334,11 +2416,11 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                         }
                         const originName = arg.key?.name || '';
                         if (originName && originName.charAt(0) === originName.charAt(0).toUpperCase()) {
-                            const needName = (0, utils_2.firstLowerCase)(originName);
+                            const needName = (0, utils_1.firstLowerCase)(originName);
                             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('或');
+                        const entityName = (0, utils_1.firstUpperCase)(originName);
+                        const needNameList = entityAsNames.map(item => (0, utils_1.firstLowerCase)(item))?.join('或');
                         if (!entityAsNames.includes(entityName)) {
                             return (0, utils_1.throwError)(options, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
                         }
@@ -2436,6 +2518,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         having: having || null,
         orderBy,
         ideVersion: '2.22',
+        simplifyType
     });
     if (!select) {
         return (0, utils_1.throwError)(options, 'SELECT 不符合规范', node);
@@ -2487,6 +2570,24 @@ function transformNode2Directory(node) {
     return newNode;
 }
 exports.transformNode2Directory = transformNode2Directory;
+/**
+ * 将默认值表达式转换为 NASL DefaultValue 对象
+ */
+function transform2DefaultValue(node, options) {
+    const defaultValue = new utils_1.naslTypes.DefaultValue();
+    try {
+        const expression = transform2LogicItem(node, options);
+        if (expression) {
+            defaultValue.expression = expression;
+            return defaultValue;
+        }
+    }
+    catch (error) {
+        return (0, utils_1.throwError)(options, `默认值解析失败: ${error.message}`, node);
+    }
+    return undefined;
+}
+exports.transform2DefaultValue = transform2DefaultValue;
 function transform2LogicItem(node, options) {
     fixLogicNode(node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;