@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.11

package/src/concepts/CallLogic__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Logic from './Logic__';
 import Param from './Param__';
+import { ElementToVueOptions } from './ViewElement__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -9,15 +10,17 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
+import TypeAnnotation from './TypeAnnotation__';
 import Argument from './Argument__';
 import LogicItem from './LogicItem__';
 
 /**
  * 调用逻辑
  */
-@concept
+@concept('调用逻辑')
 export class CallLogic extends LogicItem {
     /**
      * 产品概念
@@ -25,12 +28,6 @@ export class CallLogic extends LogicItem {
     @property()
     concept: 'CallLogic' = 'CallLogic';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Statement';
-
     /**
      * 调用逻辑标题
      */
@@ -55,6 +52,12 @@ export class CallLogic extends LogicItem {
     @property()
     shortcut: boolean = undefined;
 
+    /**
+     * 类型参数
+     */
+    @property('TypeAnnotation')
+    typeArguments?: Array<TypeAnnotation> = null;
+
     /**
      * 实际参数
      */
@@ -83,6 +86,113 @@ export class CallLogic extends LogicItem {
 
     
 
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotationOptions 类型标注参数
+    */
+    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+    * 插入类型标注
+    * @internal
+    * @param typeAnnotation 已有的类型标注实例
+    */
+    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    _insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const typeAnnotationOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+        let typeAnnotation: TypeAnnotation;
+        if (options instanceof TypeAnnotation) {
+            options.delete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        } else {
+            typeAnnotation = TypeAnnotation.from({
+                ...typeAnnotationOptions,
+                ...options,
+            }, this, 'typeArguments');
+        }
+        this.typeArguments.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    }
+
+    
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+    /**
+     * 插入类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+    insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+        const node = this._insertTypeAnnotationAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeArguments',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+    /**
+     * 添加类型标注
+     * @internal
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    _addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const index = this.typeArguments.length;
+        return this._insertTypeAnnotationAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotationOptions 类型标注参数
+     */
+    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+    /**
+     * 添加类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+    addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+        const node = this._addTypeAnnotation(options as any);
+        const index = this.typeArguments.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeArguments',
+        });
+        return node;
+    }
+
+
+
+
+    
+
     /**
     * 插入实际参数
     * @internal
@@ -104,13 +214,13 @@ export class CallLogic extends LogicItem {
         if (options instanceof Argument) {
             options.delete(); // 同一实例不支持多处存在
             argument = options;
+            Object.assign(argument, relationOptions);
         } else {
             argument = Argument.from({
                 ...argumentOptions,
                 ...options,
-            }, this);
+            }, this, 'arguments');
         }
-        Object.assign(argument, relationOptions);
         this.arguments.splice(index, 0, argument);
         return argument;
     }
@@ -188,6 +298,42 @@ export class CallLogic extends LogicItem {
 
     
 
+    /**
+     * 删除类型标注
+     * @param typeAnnotation 已有的类型标注实例
+     */
+    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+
+    removeTypeAnnotation(options: TypeAnnotation) {
+        let typeAnnotation: TypeAnnotation = options;
+        return typeAnnotation.delete();
+    }
+
+    __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
+        const parentKey = typeAnnotation.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: typeAnnotation,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(typeAnnotation);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === typeAnnotation) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -227,8 +373,27 @@ export class CallLogic extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    get tsCalleeNamespace() {
+        if (this.calleeNamespace) {
+            let tsCalleeNamespace = this.calleeNamespace;
+            tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
+            tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+            return tsCalleeNamespace;
+        }
+        return '';
+    }
     get calleeKey(): string {
-        return `${this.calleeNamespace}.${this.calleeName}`;
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.calleeName;
+        if (!tsCalleeNamespace) {
+            return calleeName ? `logics.${calleeName}` : '__IDENTIFIER__';
+        }
+        // elements单独处理相对路径，和后缀的问题
+        if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
+            const methodName = tsCalleeNamespace.substring(0, tsCalleeNamespace.length - '.logics'.length);
+            return '__' + methodName + `.${calleeName}`;
+        }
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
     }
 
     /**
@@ -271,6 +436,12 @@ export class CallLogic extends LogicItem {
                 keyword: param.name,
             });
         });
+        if (logic.typeParams) {
+            this.typeArguments = [];
+            logic.typeParams.forEach(() => {
+                this._addTypeAnnotation({});
+            });
+        }
     }
 
     setCallee(logic: Logic) {
@@ -284,10 +455,20 @@ export class CallLogic extends LogicItem {
             Object.assign(argument, relationOptions);
             return argument;
         });
+        let typeArguments = null;
+        if (logic.typeParams) {
+            typeArguments = logic.typeParams.map(() => {
+                const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+                const typeArgu = new TypeAnnotation();
+                Object.assign(typeArgu, relationOptions);
+                return typeArgu;
+            });
+        }
         this.update({
             calleeNamespace,
             calleeName,
             arguments: params,
+            typeArguments,
         });
     }
 
@@ -336,24 +517,23 @@ export class CallLogic extends LogicItem {
         });
     }
 
-    toUI(state?: TranslatorState): string {
+    toVue(options?: ElementToVueOptions): string {
         let code = this.calleeName;
         code += '(';
         this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
+            code += arg.toVue(options);
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
         code += ')';
-
         return code;
     }
 
-    toJS(state?: TranslatorState): string {
-        let code = 'this.' + this.calleeName;
+    toUI(state?: TranslatorState): string {
+        let code = this.calleeName;
         code += '(';
         this.arguments.forEach((arg, index) => {
-            code += arg.toJS();
+            code += arg.toUI();
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
@@ -362,6 +542,121 @@ export class CallLogic extends LogicItem {
         return code;
     }
 
+    toJS(state?: TranslatorState): string {
+        let code = 'await ';
+        // 页面逻辑
+        let isViewLogic = true;
+        // 组件逻辑
+        let isComponentLogic = false;
+        let componentName = '';
+        const calleeNamespace = this.calleeNamespace;
+        // 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 (!keywordViews) {
+                    isViewLogic = false;
+                }
+            } else if (start === 'elements' && namespaceArr.length === 2 && namespaceArr[1] === 'logics') {
+                isComponentLogic = true;
+                componentName = namespaceArr[0];
+            }
+        }
+        // 全局逻辑
+        if (!isViewLogic) {
+            code += `this.$logics['${this.calleeName}']`;
+            code += `({
+                config: {
+                    download: false,
+                },
+                query: {},
+                headers: {},
+            `;
+            const namespaceArr = calleeNamespace.split('.');
+            // 去掉app
+            namespaceArr.shift();
+            const keywordEntities = namespaceArr
+                .map((namespaceItem, index) => ({
+                    key: namespaceItem,
+                    index,
+                }))
+                .filter((namespaceItem, index) => index % 2 === 0)
+                .find((namespaceItem) => namespaceItem.key === 'entities');
+            const entityName = namespaceArr[keywordEntities?.index + 1];
+
+            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))}`;
+                        }
+                        code += `},\n`;
+                        break;
+                    }
+                }
+                const bodyArgument = logicArgs.find((arg) => arg.keyword === 'body');
+                if (bodyArgument) {
+                    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 += ', ';
+                });
+                code += '\n}';
+            }
+            code += '\n})';
+        } else {
+            if (isComponentLogic) {
+                code += `this.$refs.${componentName}.${this.calleeName}`;
+            } else if (calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') {
+                switch (this.calleeName) {
+                    case 'showMessage':
+                        code += `this.$toast.show`;
+                        break;
+                    case 'consoleLog':
+                        code += `console.log`;
+                        break;
+                    case 'jsonSerialize':
+                        code += `JSON.stringify`;
+                        break;
+                    case 'jsonDeserialize':
+                        code += `JSON.parse`;
+                        break;
+                }
+            } else {
+                code += `this.${this.calleeName}`;
+            }
+            code += '(';
+            this.arguments.forEach((arg, index) => {
+                code += arg.toJS(shiftState(state, code));
+                if (index !== this.arguments.length - 1)
+                    code += ', ';
+            });
+            code += ')';
+        }
+        return code;
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = this.calleeKey;

package/src/concepts/CallQueryComponent__.ts

@@ -12,6 +12,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import TypeAnnotation from './TypeAnnotation__';
@@ -25,7 +26,7 @@ import QueryLimitExpression from './QueryLimitExpression__';
 /**
  * 数据查询
  */
-@concept
+@concept('数据查询')
 export class CallQueryComponent extends LogicItem {
     /**
      * 产品概念
@@ -33,12 +34,6 @@ export class CallQueryComponent extends LogicItem {
     @property()
     concept: 'CallQueryComponent' = 'CallQueryComponent';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Statement';
-
     /**
      * 类型
      */
@@ -204,7 +199,7 @@ export class CallQueryComponent extends LogicItem {
 
         getQueryGroupByExpressionExistingNames(excludedList: Array<QueryGroupByExpression> = []) {
         const excludedSet = new Set(excludedList);
-        return this.groupBy.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.groupBy || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getQueryGroupByExpressionUniqueName(name = 'queryGroupByExpression1') {
         return utils.unique(name, this.getQueryGroupByExpressionExistingNames());
@@ -239,22 +234,22 @@ export class CallQueryComponent extends LogicItem {
             queryGroupByExpression = QueryGroupByExpression.from({
                 ...queryGroupByExpressionOptions,
                 name: this.getQueryGroupByExpressionUniqueName(),
-            }, this);
+            }, this, 'groupBy');
         } else if (typeof options === 'string') {
             queryGroupByExpression = QueryGroupByExpression.from({
                 ...queryGroupByExpressionOptions,
                 name: options,
-            }, this);
+            }, this, 'groupBy');
         } else if (options instanceof QueryGroupByExpression) {
             options.delete(); // 同一实例不支持多处存在
             queryGroupByExpression = options;
+            Object.assign(queryGroupByExpression, relationOptions);
         } else {
             queryGroupByExpression = QueryGroupByExpression.from({
                 ...queryGroupByExpressionOptions,
                 ...options,
-            }, this);
+            }, this, 'groupBy');
         }
-        Object.assign(queryGroupByExpression, relationOptions);
         this.groupBy.splice(index, 0, queryGroupByExpression);
         return queryGroupByExpression;
     }
@@ -366,13 +361,13 @@ export class CallQueryComponent extends LogicItem {
         if (options instanceof QueryOrderByExpression) {
             options.delete(); // 同一实例不支持多处存在
             queryOrderByExpression = options;
+            Object.assign(queryOrderByExpression, relationOptions);
         } else {
             queryOrderByExpression = QueryOrderByExpression.from({
                 ...queryOrderByExpressionOptions,
                 ...options,
-            }, this);
+            }, this, 'orderBy');
         }
-        Object.assign(queryOrderByExpression, relationOptions);
         this.orderBy.splice(index, 0, queryOrderByExpression);
         return queryOrderByExpression;
     }
@@ -765,6 +760,21 @@ export class CallQueryComponent extends LogicItem {
         return code;
     }
 
+    toJS() {
+        return '';
+        // const { entityName } = this.from;
+        // return `await this.$services["_custom"]["load${entityName}"]({
+        //     config: {
+        //       download: false,
+        //     },
+        //     path: {},
+        //     query: {},
+        //     headers: {},
+        //     body: {
+        //     },
+        //   })`;
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `(function(): nasl.collection.PageOf<`;
@@ -912,7 +922,7 @@ export class CallQueryComponent extends LogicItem {
                 concept: 'TypeAnnotation',
                 typeKind: 'reference',
                 typeName: source.name,
-                typeNamespace: `app.${this.app.name}.structures`,
+                typeNamespace: `app.structures`,
             }, this);
             this.update({
                 typeAnnotation,
@@ -953,8 +963,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}`,
@@ -965,12 +975,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() {

package/src/concepts/Comment__.ts

@@ -7,6 +7,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -14,7 +15,7 @@ import LogicItem from './LogicItem__';
 /**
  * 注释
  */
-@concept
+@concept('注释')
 export class Comment extends LogicItem {
     /**
      * 产品概念
@@ -22,12 +23,6 @@ export class Comment extends LogicItem {
     @property()
     concept: 'Comment' = 'Comment';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Statement';
-
     /**
      * 注释内容
      */
@@ -70,9 +65,6 @@ export class Comment extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-    toUI(state?: TranslatorState): string {
-        return `\n${indent(state.tabSize)}// ${this.value}\n`;
-    }
 
     toJS(state?: TranslatorState): string {
         return `\n${indent(state.tabSize)}// ${this.value}\n`;

package/src/concepts/CompletionProperty__.ts

@@ -7,6 +7,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import TypeAnnotation from './TypeAnnotation__';
@@ -14,7 +15,7 @@ import TypeAnnotation from './TypeAnnotation__';
 /**
  * 自动补全字段
  */
-@concept
+@concept('自动补全字段')
 export class CompletionProperty extends BaseNode {
     /**
      * 产品概念
@@ -230,6 +231,11 @@ export class CompletionProperty extends BaseNode {
      */
     @property()
     expression: LogicItem = undefined;
+
+    /**
+     * 用于展示图标
+     */
+    icon: string = undefined;
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓