@lcap/nasl 1.0.0-alpha.8 → 1.0.1

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 { getNodeByNodeCallee } 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 {
@@ -179,7 +181,7 @@ export class CallLogic extends LogicItem {
 
     addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
         const node = this._addTypeAnnotation(options as any);
-        const index = this.typeArguments.length;
+        const index = this.typeArguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -286,7 +288,7 @@ export class CallLogic extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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')) {
@@ -397,10 +404,11 @@ export class CallLogic extends LogicItem {
     }
 
     /**
-     * 设置setArgumentName
+     * 设置argment 触发别的地方的更新
      */
-    setArgumentName({ argument, newKeyword }: { argument: Argument; newKeyword: string }) {
-        argument.setKeyword(newKeyword);
+    setArgumentName({ argument }: { argument: Argument[] }) {
+        // argument.setKeyword(newKeyword);
+        // this.arguments = argument;
     }
 
     /**
@@ -451,6 +459,7 @@ export class CallLogic extends LogicItem {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
             const argument = Argument.from({
                 keyword: param.name,
+                expression: param.defaultExpression,
             }, this);
             Object.assign(argument, relationOptions);
             return argument;
@@ -518,11 +527,15 @@ export class CallLogic extends LogicItem {
     }
 
     toVue(options?: ElementToVueOptions): string {
-        let code = this.calleeName;
+        let code = '';
+        if (this.calleeNamespace === 'nasl.browser' || this.calleeNamespace === 'nasl.auth' || this.calleeNamespace === 'nasl.configuration') {
+            code += '$global.';
+        }
+        code += this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toVue(options);
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toVue(options);
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -532,9 +545,9 @@ export class CallLogic extends LogicItem {
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toUI();
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -550,12 +563,15 @@ export class CallLogic extends LogicItem {
         let isComponentLogic = false;
         let componentName = '';
         const calleeNamespace = this.calleeNamespace;
+        const isProcessLogic = this.calleeNamespace?.startsWith('app.processes');
+
         // calleeNamespace不存在，一定是页面逻辑
         if (calleeNamespace) {
             const namespaceArr = calleeNamespace.split('.');
             const start = namespaceArr.shift();
-            if (start === 'app') {
-                const keywordViews = namespaceArr.filter((namespaceItem, index) => index % 2 === 0).find((namespaceItem) => namespaceItem === 'views');
+            if (start === 'app' || start === 'extensions') {
+                const mod = start === 'app' ? 0 : 1;
+                const keywordViews = namespaceArr.filter((namespaceItem, index) => index % 2 === mod).find((namespaceItem) => namespaceItem === 'views');
                 if (!keywordViews) {
                     isViewLogic = false;
                 }
@@ -566,15 +582,23 @@ export class CallLogic extends LogicItem {
         }
         // 全局逻辑
         if (!isViewLogic) {
-            code += `this.$logics['${this.calleeName}']`;
-            code += `({
-                config: {
-                    download: false,
-                },
-                query: {},
-                headers: {},
-            `;
-            const namespaceArr = calleeNamespace.split('.');
+            const namespaceArr = calleeNamespace?.split('.');
+            const logic = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: string, tempPoint: any) => {
+                // 处理 NASL 中未定义的假的节点
+                if (key === tempPoint.name) {
+                    return {
+                        tempPoint,
+                        state: 1,
+                    };
+                }
+                const t = tempPoint[key];
+                return {
+                    tempPoint: t,
+                    state: Array.isArray(t) ? 2 : 1,
+                };
+            });
+            const args = logic?.params || [];
+
             // 去掉app
             namespaceArr.shift();
             const keywordEntities = namespaceArr
@@ -585,43 +609,64 @@ export class CallLogic extends LogicItem {
                 .filter((namespaceItem, index) => index % 2 === 0)
                 .find((namespaceItem) => namespaceItem.key === 'entities');
             const entityName = namespaceArr[keywordEntities?.index + 1];
+            code += `this.$logics['${this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName}']`;
+            code += `({
+                config: {
+                    download: false,
+                },
+                query: {`;
+            if (isProcessLogic) {
+                const argsStr = args.map((arg: any, index: number) => {
+                    const actualArg = this.arguments?.[index];
+                    return {
+                        keyword: arg?.name,
+                        arg: actualArg,
+                    };
+                }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                code += argsStr;
+            }
+            code += `},
+                headers: {},
+            `;
 
             if (entityName) {
                 let logicArgs = this.arguments;
                 switch (this.calleeName) {
                     case 'get':
                     case 'delete': {
-                        let idArgument: Argument;
-                        logicArgs = logicArgs.filter((arg) => {
-                            if (arg.keyword === 'id') {
-                                idArgument = arg;
-                                return false;
-                            } else {
-                                return true;
-                            }
-                        });
-                        code += `path: {`;
-                        if (idArgument) {
-                            code += `\n${idArgument.keyword}: ${idArgument.toJS(shiftState(state, code))}`;
-                        }
+                        logicArgs = [];
+                        code += `query: {`;
+                        const argsStr = args.map((arg: any, index: number) => {
+                            const actualArg = this.arguments?.[index];
+                            return {
+                                keyword: arg?.name,
+                                arg: actualArg,
+                            };
+                        }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                        code += argsStr;
                         code += `},\n`;
                         break;
                     }
                 }
                 const bodyArgument = logicArgs.find((arg) => arg.keyword === 'body');
                 if (bodyArgument) {
-                    code += `\n${bodyArgument.keyword}: ${bodyArgument.toJS(shiftState(state, code))}`;
+                    code += `\n${bodyArgument?.keyword}: ${bodyArgument?.toJS(shiftState(state, code))}`;
                 } else {
                     code += `body: {}`;
                 }
             } else {
                 code += `path: {},
                 body: {`;
-                this.arguments.forEach((arg, index) => {
-                    code += `\n${arg.keyword}: ${arg.toJS(shiftState(state, code))}`;
-                    if (index !== this.arguments.length - 1)
-                        code += ', ';
-                });
+                if (!isProcessLogic) {
+                    const argsStr = args.map((arg: any, index: number) => {
+                        const actualArg = this.arguments?.[index];
+                        return {
+                            keyword: arg?.name,
+                            arg: actualArg,
+                        };
+                    }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                    code += argsStr;
+                }
                 code += '\n}';
             }
             code += '\n})';
@@ -643,15 +688,18 @@ export class CallLogic extends LogicItem {
                         code += `JSON.parse`;
                         break;
                 }
+            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration') {
+                code += `this.$global.${this.calleeName}`;
             } else {
                 code += `this.${this.calleeName}`;
             }
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toJS(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
-                    code += ', ';
-            });
+            this.arguments?.filter((arg) => arg?.expression)
+                .forEach((arg, index) => {
+                    code += arg?.toJS(shiftState(state, code));
+                    if (index !== this.arguments?.length - 1)
+                        code += ', ';
+                });
             code += ')';
         }
         return code;
@@ -660,14 +708,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) => {
-            code += arg.toEmbeddedTS(shiftState(state, code));
+            const tsCalleeNamespace = this.tsCalleeNamespace;
+            // 页面逻辑先都非必填
+            if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
+                code += arg.toEmbeddedTS(shiftState(state, code), false);
+            } else {
+                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;
+
     
 
     /**
@@ -202,7 +208,7 @@ export class CallQueryComponent extends LogicItem {
         return (this.groupBy || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getQueryGroupByExpressionUniqueName(name = 'queryGroupByExpression1') {
-        return utils.unique(name, this.getQueryGroupByExpressionExistingNames());
+        return utils.unique(name, this.getQueryGroupByExpressionExistingNames(), undefined, false);
     }
 
     /**
@@ -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 {
@@ -329,7 +335,7 @@ export class CallQueryComponent extends LogicItem {
 
     addQueryGroupByExpressionInGroupBy(options?: string | Partial<QueryGroupByExpression> | QueryGroupByExpression) {
         const node = this._addQueryGroupByExpressionInGroupBy(options as any);
-        const index = this.groupBy.length;
+        const index = this.groupBy.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -433,7 +439,7 @@ export class CallQueryComponent extends LogicItem {
 
     addQueryOrderByExpressionInOrderBy(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
         const node = this._addQueryOrderByExpressionInOrderBy(options as any);
-        const index = this.orderBy.length;
+        const index = this.orderBy.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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,20 +907,23 @@ 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);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
             if (structure) {
-                const properties = source.properties.map((property) => StructureProperty.from(property, structure));
+                const properties = source.properties.map((property) => StructureProperty.from(property, structure, 'properties'));
                 structure.update({
                     properties,
                 });
-            }
+            } else
+                this.app.addStructure(source);
         } else {
             source.name = utils.unique(source.name, this.app.getStructureExistingNames());
             this.app.addStructure(source);
@@ -922,8 +931,8 @@ export class CallQueryComponent extends LogicItem {
                 concept: 'TypeAnnotation',
                 typeKind: 'reference',
                 typeName: source.name,
-                typeNamespace: `app.${this.app.name}.structures`,
-            }, this);
+                typeNamespace: `app.structures`,
+            }, this, 'typeAnnotation');
             this.update({
                 typeAnnotation,
             });
@@ -936,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);
@@ -963,8 +967,8 @@ export class CallQueryComponent extends LogicItem {
             .map((entity) => ({
                 concept: 'Entity',
                 name: entity.name,
-                children: entity.properties.map((property) =>
-                    new CompletionProperty({
+                children: entity.properties.map((property) => {
+                    const completionProperty = new CompletionProperty({
                         concept: 'CompletionProperty',
                         name: property.name,
                         value: `${entity.name}.${property.name}`,
@@ -975,12 +979,19 @@ export class CallQueryComponent extends LogicItem {
                             entityAsName: entity.name,
                             propertyName: property.name,
                         }),
-                    })),
+                    });
+                    completionProperty.icon = 'property';
+                    return completionProperty;
+                }),
             }));
         if (children.length === 0)
             return;
 
-        return { name: '实体', children };
+        return {
+            name: '实体',
+            icon: 'category',
+            children,
+        };
     }
 
     getCompletionPropertyOfAggregateAsNames() {
@@ -990,16 +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: 'inner',
                     }),
                 }));
         if (!children || children.length === 0)
             return;
 
-        return { name: '聚合属性别名', children };
+        children.forEach((item) => {
+            item.icon = 'variable';
+        });
+        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/CompletionProperty__.ts

@@ -224,7 +224,7 @@ export class CompletionProperty extends BaseNode {
      * 子集
      */
     @property()
-    children: Array<LogicItem> = undefined;
+    children: Array<CompletionProperty> = undefined;
 
     /**
      * 表达式
@@ -236,6 +236,10 @@ export class CompletionProperty extends BaseNode {
      * 用于展示图标
      */
     icon: string = undefined;
+
+    isProcess: boolean = false;
+
+    noFurther: boolean = false;
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/ConfigGroup__.ts

@@ -84,7 +84,7 @@ export class ConfigGroup extends BaseNode {
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigPropertyUniqueName(name = 'configProperty1') {
-        return utils.unique(name, this.getConfigPropertyExistingNames());
+        return utils.unique(name, this.getConfigPropertyExistingNames(), undefined, false);
     }
 
     /**
@@ -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 {
@@ -211,7 +211,7 @@ export class ConfigGroup extends BaseNode {
 
     addConfigProperty(options?: string | Partial<ConfigProperty> | ConfigProperty) {
         const node = this._addConfigProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/ConfigProperty__.ts

@@ -90,7 +90,7 @@ export class ConfigProperty extends BaseNode {
         return (this.values || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigPropertyValueUniqueName(name = 'configPropertyValue1') {
-        return utils.unique(name, this.getConfigPropertyValueExistingNames());
+        return utils.unique(name, this.getConfigPropertyValueExistingNames(), undefined, false);
     }
 
     /**
@@ -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 {
@@ -217,7 +217,7 @@ export class ConfigProperty extends BaseNode {
 
     addConfigPropertyValue(options?: string | Partial<ConfigPropertyValue> | ConfigPropertyValue) {
         const node = this._addConfigPropertyValue(options as any);
-        const index = this.values.length;
+        const index = this.values.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Configuration__.ts

@@ -68,7 +68,7 @@ export class Configuration extends BaseNode {
         return (this.groups || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigGroupUniqueName(name = 'configGroup1') {
-        return utils.unique(name, this.getConfigGroupExistingNames());
+        return utils.unique(name, this.getConfigGroupExistingNames(), undefined, false);
     }
 
     /**
@@ -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 {
@@ -195,7 +195,7 @@ export class Configuration extends BaseNode {
 
     addConfigGroup(options?: string | Partial<ConfigGroup> | ConfigGroup) {
         const node = this._addConfigGroup(options as any);
-        const index = this.groups.length;
+        const index = this.groups.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Constant__.ts

@@ -235,6 +235,18 @@ export class Constant extends BaseNode {
         }
         return code;
     }
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        }
+        if (this.defaultValue) {
+            code += ` : ${this.defaultValue}`;
+        }
+        return code;
+    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓