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

package/src/concepts/CallFunction__.ts

@@ -32,7 +32,7 @@ export class CallFunction extends LogicItem {
      * 调用函数标题
      */
     @property()
-    label: string = '调用逻辑';
+    label: string = '内置函数';
 
     /**
      * calleeNamespace
@@ -105,7 +105,7 @@ export class CallFunction extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -212,7 +212,7 @@ export class CallFunction extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -404,6 +404,14 @@ export class CallFunction extends LogicItem {
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
+        if (this.typeArguments && this.typeArguments.length) {
+            code += ', ';
+            this.typeArguments.forEach((arg, index) => {
+                code += arg.toJS(shiftState(state, code));
+                if (index !== this.arguments.length - 1)
+                    code += ', ';
+            });
+        }
         code += ')';
         return code;
     }
@@ -429,7 +437,7 @@ export class CallFunction extends LogicItem {
             const argument = Argument.from({
                 keyword: param.name,
             }, this);
-            if(param.defaultExpression instanceof Identifier) {
+            if (param.defaultExpression instanceof Identifier) {
                 argument.expression = BaseNode.from(param.defaultExpression, argument, 'expression') as Identifier;
             }
             Object.assign(argument, relationOptions);
@@ -470,14 +478,19 @@ export class CallFunction extends LogicItem {
             code += ')';
             // 如果有内容
             const typeAnnotation = this.typeArguments[0];
-            if (typeAnnotation.typeNamespace && typeAnnotation.typeName) {
-                code += `<${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}>()`;
-            }
+            code += `<`;
+            code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>()`;
             code += '\n';
         } else {
             code = this.calleeKey;
+            if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                // 如果有内容
+                const typeAnnotation = this.typeArguments[0];
+                code += `<`;
+                code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>`;
+            }
             code += '(';
-            this.arguments.forEach((arg, index) => {
+            Array.isArray(this.arguments) && this.arguments.forEach((arg, index) => {
                 code += arg.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
                 if (index !== this.arguments.length - 1)
                     code += ', ';

package/src/concepts/CallInterface__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Interface from './Interface__';
 import { ElementToVueOptions } from './ViewElement__';
+import { getConceptConstructor } from '../decorators';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -14,6 +15,7 @@ import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Argument from './Argument__';
 import LogicItem from './LogicItem__';
+import NullLiteral from './NullLiteral__';
 
 /**
  * 调用接口
@@ -56,8 +58,6 @@ export class CallInterface extends LogicItem {
     @property('Argument')
     arguments: Array<Argument> = [];
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -71,25 +71,18 @@ export class CallInterface extends LogicItem {
         return super.from(source, parentNode, parentKey) as CallInterface;
     }
 
-    
-    
-
-    
-
-    
-
     /**
-    * 插入实际参数
-    * @internal
-    * @param argumentOptions 实际参数参数
-    */
+     * 插入实际参数
+     * @internal
+     * @param argumentOptions 实际参数参数
+     */
     _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
 
     /**
-    * 插入实际参数
-    * @internal
-    * @param argument 已有的实际参数实例
-    */
+     * 插入实际参数
+     * @internal
+     * @param argument 已有的实际参数实例
+     */
     _insertArgumentAt(argument: Argument, index: number): Argument;
 
     _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
@@ -97,7 +90,7 @@ export class CallInterface extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -110,8 +103,6 @@ export class CallInterface extends LogicItem {
         return argument;
     }
 
-    
-
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -134,8 +125,6 @@ export class CallInterface extends LogicItem {
         return node;
     }
 
-    
-
     /**
      * 添加实际参数
      * @internal
@@ -155,8 +144,6 @@ export class CallInterface extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
-
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -180,9 +167,6 @@ export class CallInterface extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -190,7 +174,7 @@ export class CallInterface extends LogicItem {
     removeArgument(argument: Argument): void;
 
     removeArgument(options: Argument) {
-        let argument: Argument = options;
+        const argument: Argument = options;
         return argument.delete();
     }
 
@@ -269,6 +253,7 @@ export class CallInterface extends LogicItem {
         const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
         const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
         const _body = _params.filter((item) => item.in === 'body').map((item) => item.name);
+        const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
 
         let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
         code += `({
@@ -283,6 +268,15 @@ export class CallInterface extends LogicItem {
                 if (index !== this.arguments.length - 1)
                     code += ', ';
             });
+        code += `},
+            path: {`;
+        this.arguments
+            .filter((arg) => _paths.includes(arg.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg.keyword}': ${arg.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments.length - 1)
+                    code += ', ';
+            });
         code += `},
             headers: {`;
         this.arguments
@@ -294,38 +288,52 @@ export class CallInterface extends LogicItem {
             });
         code += `},
         `;
-        code += `path: {},
+        code += `
         body: {`;
         this.arguments
             .filter((arg) => _body.includes(arg.keyword))
             .forEach((arg, index) => {
-                code += `\n'${arg.keyword}': ${arg.toJS(shiftState(state, code))}`;
+                code += ` ...${arg.toJS(shiftState(state, code))}`;
                 if (index !== this.arguments.length - 1)
                     code += ', ';
             });
-        code += '\n}';
+        code += '}';
         code += '\n})';
         return code;
     }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.calleeKey;
+        let code = this.tsCalleeKey;
         const _keys = this.calleeDefaultKey.split('.');
         const _module = this.app.interfaceDependencies.find((item) => item.name === _keys[1]);
         let params: string[] = [];
         const _interface = _module?.interfaces?.find((item) => item.name === _keys[3]);
         if (_interface) {
             params = _interface.params.filter((item) => item.required).map((item) => item.name) || [];
+            // const _bodyParams = _interface.params.find((item) => item.name === 'Body');
+            // if (_bodyParams) {
+            //     const _typeKey = _bodyParams.typeAnnotation.typeKey;
+            //     const _list = _typeKey.split('.');
+            //     const _structure = _module.structures.find((item) => item.name === _list[3]);
+            //     const isBodyRequired = _structure.properties.some((item) => item.required === true);
+            //     if (isBodyRequired) {
+            //         params.push('Body');
+            //     }
+            // }
+        }
+        code += '(';
+        if (this.arguments.length) {
+            code += '{';
+            this.arguments.forEach((arg, index) => {
+                code += arg.toEmbeddedTS(shiftState(state, code), params.includes(arg.keyword), true);
+                if (index !== this.arguments.length - 1)
+                    code += ', ';
+            });
+            code += '}';
         }
-        code += '({';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toEmbeddedTS(shiftState(state, code), params.includes(arg.keyword), true);
-            if (index !== this.arguments.length - 1)
-                code += ', ';
-        });
-        code += '});\n';
 
+        code += ');\n';
         return code;
     }
 
@@ -334,6 +342,96 @@ export class CallInterface extends LogicItem {
         const calleeName = this.calleeName;
         return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
     }
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
+    get tsCalleeName(): string {
+        const excludeds = [
+            'abstract',
+            'arguments',
+            'await',
+            'boolean',
+            'break',
+            'byte',
+            'case',
+            'catch',
+            'char',
+            'class',
+            'const',
+            'continue',
+            'debugger',
+            'default',
+            'delete',
+            'do',
+            'double',
+            'else',
+            'enum',
+            'eval',
+            'export',
+            'extends',
+            'false',
+            'final',
+            'finally',
+            'float',
+            'for',
+            'function',
+            'goto',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'instanceof',
+            'int',
+            'interface',
+            'let',
+            'long',
+            'native',
+            'new',
+            'null',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'return',
+            'short',
+            'static',
+            'super',
+            'switch',
+            'synchronized',
+            'this',
+            'throw',
+            'throws',
+            'transient',
+            'true',
+            'try',
+            'typeof',
+            'var',
+            'void',
+            'volatile',
+            'while',
+            'with',
+            'yield,as',
+            'any',
+            'number',
+            'string',
+            'get',
+            'type',
+            'typeof',
+            'instanceof',
+            'require',
+        ];
+        if (excludeds.includes(this.calleeName)) {
+            return '_' + this.calleeName;
+        }
+        return this.calleeName;
+    }
+
+    get tsCalleeKey(): string {
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.tsCalleeName;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    }
     get calleeDefaultKey(): string {
         return `${this.calleeNamespace}.${this.calleeName}`;
     }
@@ -351,9 +449,30 @@ export class CallInterface extends LogicItem {
         const calleeName = _interface.name;
         const params = _interface.params.map((param) => {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
-            const argument = Argument.from({
+            let expression;
+            if (param.defaultValue && param.typeAnnotation.typeKind === 'primitive') {
+                const conceptMap: { [name: string]: string } = {
+                    String: 'StringLiteral',
+                    Boolean: 'BooleanLiteral',
+                    Integer: 'NumericLiteral',
+                    Double: 'NumericLiteral',
+                    Long: 'NumericLiteral',
+                };
+                const typeName = param.typeAnnotation.typeName;
+                const concept: string = conceptMap[typeName] || 'StringLiteral';
+                const Ctor = getConceptConstructor(concept);
+                expression = new Ctor({
+                    concept,
+                    value: param.defaultValue,
+                    typeAnnotation: param.typeAnnotation,
+                });
+            } else if (!param.required) {
+                expression = new NullLiteral();
+            }
+            const argument = new Argument({
                 keyword: param.name,
-            }, this);
+                expression,
+            });
             Object.assign(argument, relationOptions);
             return argument;
         });
@@ -369,7 +488,7 @@ export class CallInterface extends LogicItem {
     //================================================================================
 }
 
-classMap['CallInterface'] = CallInterface;
+classMap.CallInterface = CallInterface;
 export default CallInterface;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/CallLogic__.ts

@@ -2,6 +2,8 @@ import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Logic from './Logic__';
 import Param from './Param__';
 import { ElementToVueOptions } from './ViewElement__';
+import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -105,7 +107,7 @@ export class CallLogic extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -212,7 +214,7 @@ export class CallLogic extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -382,11 +384,16 @@ export class CallLogic extends LogicItem {
         }
         return '';
     }
+
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
     get calleeKey(): string {
         const tsCalleeNamespace = this.tsCalleeNamespace;
         const calleeName = this.calleeName;
         if (!tsCalleeNamespace) {
-            return calleeName ? `logics.${calleeName}` : '__IDENTIFIER__';
+            return calleeName ? `${calleeName}` : '__IDENTIFIER__';
         }
         // elements单独处理相对路径，和后缀的问题
         if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
@@ -399,7 +406,7 @@ export class CallLogic extends LogicItem {
     /**
      * 设置argment 触发别的地方的更新
      */
-    setArgumentName({ argument }: { argument: Argument[]}) {
+    setArgumentName({ argument }: { argument: Argument[] }) {
         // argument.setKeyword(newKeyword);
         // this.arguments = argument;
     }
@@ -521,7 +528,7 @@ export class CallLogic extends LogicItem {
 
     toVue(options?: ElementToVueOptions): string {
         let code = '';
-        if (this.calleeNamespace === 'nasl.browser') {
+        if (this.calleeNamespace === 'nasl.browser' || this.calleeNamespace === 'nasl.auth' || this.calleeNamespace === 'nasl.configuration') {
             code += '$global.';
         }
         code += this.calleeName;
@@ -660,7 +667,7 @@ export class CallLogic extends LogicItem {
                         code += `JSON.parse`;
                         break;
                 }
-            } else if (calleeNamespace === 'nasl.browser') {
+            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration') {
                 code += `this.$global.${this.calleeName}`;
             } else {
                 code += `this.${this.calleeName}`;
@@ -681,20 +688,25 @@ export class CallLogic extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = this.calleeKey;
+        if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+            // 如果有内容
+            const typeAnnotation = this.typeArguments[0];
+            code += `<`;
+            code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>`;
+        }
         code += '(';
         this.arguments.forEach((arg, index) => {
             const tsCalleeNamespace = this.tsCalleeNamespace;
             // 页面逻辑先都非必填
             if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
-                code += arg.toEmbeddedTS(shiftState(state, code));
+                code += arg.toEmbeddedTS(shiftState(state, code), false);
             } else {
-                code += arg.toEmbeddedTS(shiftState(state, code), true);
+                code += arg.toEmbeddedTS(shiftState(state, code));
             }
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
         code += ');\n';
-
         return code;
     }
 

package/src/concepts/CallQueryComponent__.ts

@@ -82,6 +82,12 @@ export class CallQueryComponent extends LogicItem {
     @property('QueryLimitExpression')
     limit: QueryLimitExpression = undefined;
 
+    /**
+     * 查询组件的局部版本
+     */
+    @property()
+    ideVersion: string = undefined;
+
     
 
     /**
@@ -241,7 +247,7 @@ export class CallQueryComponent extends LogicItem {
                 name: options,
             }, this, 'groupBy');
         } else if (options instanceof QueryGroupByExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryGroupByExpression = options;
             Object.assign(queryGroupByExpression, relationOptions);
         } else {
@@ -359,7 +365,7 @@ export class CallQueryComponent extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'orderBy' };
         let queryOrderByExpression: QueryOrderByExpression;
         if (options instanceof QueryOrderByExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryOrderByExpression = options;
             Object.assign(queryOrderByExpression, relationOptions);
         } else {
@@ -784,7 +790,7 @@ export class CallQueryComponent extends LogicItem {
             code += indent(state.tabSize + 1);
             const { asName, aggregateName, aggregateParam } = item;
             if (asName)
-                code += `const ${asName} = `;
+                code += `const __${asName} = `;
             if (aggregateName) {
                 code += `nasl.langUtil.${aggregateName}(`;
                 code += aggregateParam.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
@@ -901,13 +907,14 @@ export class CallQueryComponent extends LogicItem {
         return Structure.from({
             concept: 'Structure',
             name: structureName,
+            origin: 'CallQueryComponent',
             properties: [...genPropertyListOfFrom(this.from), ...genPropertyListOfAggregate(this)],
         });
     }
 
     saveStructure() {
         const source = this.genStructure();
-        console.log(source);
+        // console.log(source);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
             if (structure) {
@@ -938,11 +945,6 @@ export class CallQueryComponent extends LogicItem {
         } catch {}
     }
 
-    delete() {
-        this.removeStructure();
-        super.delete();
-    }
-
     getEntityNames(node: QueryFromExpression | QueryJoinExpression, set = new Set()) {
         if (node?.entityName)
             set.add(node.entityName);
@@ -999,20 +1001,20 @@ export class CallQueryComponent extends LogicItem {
                 new CompletionProperty({
                     concept: 'CompletionProperty',
                     name: item.asName,
-                    value: item.asName,
+                    value: `inner.${item.asName}`,
                     expression: LogicItem.from({
                         concept: 'Identifier',
                         name: item.asName,
-                        // namespace: '', @todo
+                        namespace: 'inner',
                     }),
                 }));
         if (!children || children.length === 0)
             return;
-        
+
         children.forEach((item) => {
             item.icon = 'variable';
         });
-        return { name: '聚合属性别名', icon: "category", children };
+        return { name: '聚合属性别名', icon: 'category', children, expanded: true };
     }
 
     //================================================================================

package/src/concepts/Comment__.ts

@@ -67,7 +67,7 @@ export class Comment extends LogicItem {
     //================================================================================
 
     toJS(state?: TranslatorState): string {
-        return `\n${indent(state.tabSize)}// ${this.value}\n`;
+        return `/* ${this.value} */`;
     }
 
     public static getDefaultOptions() {
@@ -79,7 +79,11 @@ export class Comment extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
-        code += `\n${indent(state.tabSize)}// ${this.value}\n`;
+        code += `\n${indent(state.tabSize)}
+        /**
+         * 注释不用翻译
+         */
+        \n`;
         return code;
     }
     //================================================================================

package/src/concepts/ConfigGroup__.ts

@@ -123,7 +123,7 @@ export class ConfigGroup extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof ConfigProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configProperty = options;
             Object.assign(configProperty, relationOptions);
         } else {

package/src/concepts/ConfigProperty__.ts

@@ -129,7 +129,7 @@ export class ConfigProperty extends BaseNode {
                 name: options,
             }, this, 'values');
         } else if (options instanceof ConfigPropertyValue) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configPropertyValue = options;
             Object.assign(configPropertyValue, relationOptions);
         } else {

package/src/concepts/Configuration__.ts

@@ -107,7 +107,7 @@ export class Configuration extends BaseNode {
                 name: options,
             }, this, 'groups');
         } else if (options instanceof ConfigGroup) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configGroup = options;
             Object.assign(configGroup, relationOptions);
         } else {