@lcap/nasl 1.0.1 → 1.0.2

package/src/concepts/CallQueryComponent__.ts

@@ -4,6 +4,7 @@ import Entity from './Entity__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
 import CompletionProperty from './CompletionProperty__';
+import QueryFieldExpression from './QueryFieldExpression__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -781,10 +782,41 @@ export class CallQueryComponent extends LogicItem {
         //   })`;
     }
 
+    isAutoInfer() {
+        return this.ideVersion === '2.11';
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `(function(): nasl.collection.PageOf<`;
-        code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))}> {\n`;
+        if (!this.typeAnnotation)
+            return `(function () {
+                return;
+            })()`;
+        let code = `(function(): `;
+        if (this.isAutoInfer()) {
+            code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))} {\n`;
+        } else {
+            code += `nasl.collection.PageOf<`;
+            code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))}> {\n`;
+        }
+        // 2.11版本后 分组使用别名
+        if (this.isAutoInfer()) {
+            // 分组别名（列别名）
+            this.groupBy.forEach((item, index, array) => {
+                code += indent(state.tabSize + 1);
+                const groupElement = item.groupElement as QueryFieldExpression;
+                if (groupElement.asName)
+                    code += `const __${groupElement.asName} = `;
+                if (groupElement.propertyName) {
+                    code += groupElement.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+                    code += ';\n';
+                } else
+                    code += `__EMPTY_GROUP_BY_NAME__;\n`;
+
+                if (index === array.length - 1)
+                    code += '\n';
+            });
+        }
         // 聚合属性别名
         this.select.selectElements.forEach((item, index, array) => {
             code += indent(state.tabSize + 1);
@@ -821,7 +853,7 @@ export class CallQueryComponent extends LogicItem {
         });
 
         // 分组属性（Group by）
-        code = this.toEmbeddedTSOfSubPart('GROUP_BY', this.groupBy.map((item) => item.groupElement), {
+        code = this.toEmbeddedTSOfSubPart('GROUP_BY', this.groupBy, {
             code,
             state,
         });
@@ -851,70 +883,242 @@ export class CallQueryComponent extends LogicItem {
         return code;
     }
 
-    genStructure() {
-        const { app } = this;
-        function genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities: any[] = []) {
-            if (!node)
-                return [];
-
-            const entityName = node.entityName;
-            entities.push({
-                concept: 'StructureProperty',
-                name: utils.firstLowerCase(entityName),
-                typeAnnotation: {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'reference',
-                    typeName: entityName,
-                    typeNamespace: `${app.getNamespace()}.entities`,
-                },
+    genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities: any[] = []) {
+        if (!node)
+            return [];
+
+        const entityName = node.entityName;
+        entities.push({
+            concept: 'StructureProperty',
+            name: utils.firstLowerCase(entityName),
+            typeAnnotation: {
+                concept: 'TypeAnnotation',
+                typeKind: 'reference',
+                typeName: entityName,
+                typeNamespace: `${this.app.getNamespace()}.entities`,
+            },
+        });
+
+        for (const sub of node.joinParts) {
+            this.genPropertyListOfFrom(sub, entities);
+        }
+
+        return entities;
+    }
+
+    genPropertyListOfAggregate(node: CallQueryComponent) {
+        return node.select.selectElements
+            .filter((item) => item.aggregateName && item.asName)
+            .map((item) => {
+                let typeName;
+                if (['COUNT', 'COUNTD'].includes(item.aggregateName)) {
+                    typeName = 'Integer';
+                } else if (['AVG'].includes(item.aggregateName)) {
+                    typeName = 'Double';
+                } else {
+                    const { entityAsName, propertyName } = item.aggregateParam;
+                    const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                    const property = entity?.properties.find((item) => item.name === propertyName);
+                    typeName = property?.typeAnnotation.typeName;
+                }
+                return {
+                    concept: 'StructureProperty',
+                    name: item.asName,
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName,
+                    },
+                };
             });
+    }
 
-            for (const sub of node.joinParts) {
-                genPropertyListOfFrom(sub, entities);
-            }
+    genPropertyListOfGroupBy(node: CallQueryComponent) {
+        return node.groupBy
+            .filter((item) => item.groupElement && (item.groupElement as QueryFieldExpression).propertyName && (item.groupElement as QueryFieldExpression).asName)
+            .map((item) => {
+                const { entityAsName, propertyName, asName } = item.groupElement as QueryFieldExpression;
+                const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item) => item.name === propertyName);
+                const typeName = property?.typeAnnotation.typeName;
+                return {
+                    concept: 'StructureProperty',
+                    name: asName,
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeName,
+                        typeNamespace: 'nasl.core',
+                    },
+                };
+            });
+    }
+
+    genStructure(structureName?: string, properties: any[] = []) {
+        return Structure.from({
+            concept: 'Structure',
+            name: structureName || this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`,
+            origin: 'CallQueryComponent',
+            properties,
+        });
+    }
 
-            return entities;
+    saveStructure() {
+        // 没有数据源时不初始化数据结构
+        if (!this.entityNames.length) {
+            return;
+        }
+
+        if (!this.isAutoInfer()) {
+            // 存量应用走之前的逻辑
+            return this.saveStructureNoInfer();
         }
 
-        function genPropertyListOfAggregate(node: CallQueryComponent) {
-            return node.select.selectElements
-                .filter((item) => item.aggregateName && item.asName)
-                .map((item) => {
+        const groupBy = this.groupBy;
+        const selectElements = this.select.selectElements;
+        let structureName;
+        let typeAnnotation;
+
+        // Structures
+        if (this.typeAnnotation) {
+            const { typeNamespace, typeName, typeArguments } = this.typeAnnotation;
+            if (typeNamespace === 'app.structures') {
+                structureName = typeName;
+                this.removeStructure(structureName);
+            } else if (typeNamespace === 'nasl.collection' && typeName === 'PageOf') {
+                // PageOf<Structures>
+                if (typeArguments[0].typeNamespace === 'app.structures') {
+                    structureName = typeArguments[0].typeName;
+                    this.removeStructure(structureName);
+                }
+            }
+        }
+
+        structureName = structureName || utils.unique(`${utils.firstUpperCase(this.logic.name)}Structure`, this.app.getStructureExistingNames());
+        const groupByLength = groupBy.filter((item) => (item.groupElement as QueryFieldExpression)?.propertyName && (item.groupElement as QueryFieldExpression).asName).length;
+        const aggregateLength = selectElements.filter((item) => item.aggregateName && item.asName).length;
+
+        // 1. 有分组
+        if (groupByLength) {
+            if (!aggregateLength && groupByLength === 1) {
+                // 1.1 单分组无聚合：`PageOf<列的类型>`
+                const { entityAsName, propertyName } = groupBy[0].groupElement as any;
+                const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item) => item.name === propertyName);
+                const typeName = property?.typeAnnotation.typeName;
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: `PageOf<${typeName}>`,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'primitive',
+                            typeName,
+                            typeNamespace: 'nasl.core',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            } else {
+                // 1.2 多分组：`PageOf<Structure>`
+                const structure = this.genStructure(structureName, [
+                    ...this.genPropertyListOfGroupBy(this),
+                    ...this.genPropertyListOfAggregate(this),
+                ]);
+                this.app.addStructure(structure);
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: `PageOf<${structureName}>`,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'reference',
+                            typeName: structureName,
+                            typeNamespace: 'app.structures',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            }
+        } else { // 2. 无分组
+            if (aggregateLength) {
+                if (aggregateLength === 1) {
+                    // 2.1 单聚合：`基本类型`
                     let typeName;
-                    if (['COUNT', 'COUNTD'].includes(item.aggregateName))
+                    if (['COUNT', 'COUNTD'].includes(selectElements[0].aggregateName)) {
+                        // 2.1.1. `COUNT`、`COUNTD` 返回 `Integer`
                         typeName = 'Integer';
-                    else {
-                        const { entityAsName, propertyName } = item.aggregateParam;
-                        const entity = app.entities.find((item: Entity) => item.name === entityAsName);
+                    } else if (['AVG'].includes(selectElements[0].aggregateName)) {
+                        // 2.1.2. `AVG` 返回 `Double`
+                        typeName = 'Double';
+                    } else {
+                        // 2.1.3. 其他返回列类型，包含：`Integer`、`Long`、`Double`
+                        const { entityAsName, propertyName } = selectElements[0].aggregateParam;
+                        const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
                         const property = entity?.properties.find((item) => item.name === propertyName);
                         typeName = property?.typeAnnotation.typeName;
                     }
-                    return {
-                        concept: 'StructureProperty',
-                        name: item.asName,
-                        typeAnnotation: {
+                    typeAnnotation = TypeAnnotation.from({
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeName,
+                        typeNamespace: 'nasl.core',
+                    }, this, 'typeAnnotation');
+                } else {
+                    // 2.2. 多聚合：`Structure`（自动创建 `Structure`）
+                    const structure = this.genStructure(structureName, [
+                        ...this.genPropertyListOfAggregate(this),
+                    ]);
+                    this.app.addStructure(structure);
+
+                    typeAnnotation = TypeAnnotation.from({
+                        concept: 'TypeAnnotation',
+                        typeKind: 'reference',
+                        typeName: structureName,
+                        typeNamespace: `app.structures`,
+                    }, this, 'typeAnnotation');
+                }
+            } else {
+                // 2.3. 无聚合(默认情况)：`PageOf<Structure>`（自动创建 `Structure`）
+                const structure = this.genStructure(structureName, [
+                    ...this.genPropertyListOfFrom(this.from),
+                    ...this.genPropertyListOfAggregate(this),
+                ]);
+                this.app.addStructure(structure);
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: structureName,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
                             concept: 'TypeAnnotation',
-                            typeKind: 'primitive',
-                            typeNamespace: 'nasl.core',
-                            typeName,
-                        },
-                    };
-                });
+                            typeKind: 'reference',
+                            typeName: structureName,
+                            typeNamespace: 'app.structures',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            }
         }
 
-        const structureName = this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`;
-
-        return Structure.from({
-            concept: 'Structure',
-            name: structureName,
-            origin: 'CallQueryComponent',
-            properties: [...genPropertyListOfFrom(this.from), ...genPropertyListOfAggregate(this)],
-        });
+        this.update({ typeAnnotation });
     }
 
-    saveStructure() {
-        const source = this.genStructure();
-        // console.log(source);
+    saveStructureNoInfer() {
+        const source = this.genStructure(null, [
+            ...this.genPropertyListOfFrom(this.from),
+            ...this.genPropertyListOfAggregate(this),
+        ]);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
             if (structure) {
@@ -939,9 +1143,22 @@ export class CallQueryComponent extends LogicItem {
         }
     }
 
-    removeStructure() {
+    removeStructure(structureName?: string) {
         try {
-            this.app.removeStructure(this.typeAnnotation?.typeName);
+            if (this.typeAnnotation) {
+                const { typeNamespace, typeName, typeArguments } = this.typeAnnotation;
+                if (typeNamespace === 'app.structures') {
+                    // Structures
+                    structureName = typeName;
+                    this.app.removeStructure(structureName);
+                } else if (typeNamespace === 'nasl.collection' && typeName === 'PageOf') {
+                    // PageOf<Structures>
+                    if (typeArguments[0].typeNamespace === 'app.structures') {
+                        structureName = typeArguments[0].typeName;
+                        this.app.removeStructure(structureName);
+                    }
+                }
+            }
         } catch {}
     }
 
@@ -1017,6 +1234,29 @@ export class CallQueryComponent extends LogicItem {
         return { name: '聚合属性别名', icon: 'category', children, expanded: true };
     }
 
+    getCompletionPropertyOfGroupByAsNames() {
+        const children = this.groupBy
+            ?.filter((item) => item.concept === 'QueryGroupByExpression' && (item.groupElement as QueryFieldExpression)?.asName)
+            .map((item) =>
+                new CompletionProperty({
+                    concept: 'CompletionProperty',
+                    name: (item.groupElement as QueryFieldExpression).asName,
+                    value: `inner.${(item.groupElement as QueryFieldExpression).asName}`,
+                    expression: LogicItem.from({
+                        concept: 'Identifier',
+                        name: (item.groupElement as QueryFieldExpression).asName,
+                        namespace: 'inner',
+                    }),
+                }));
+        if (!children || children.length === 0)
+            return;
+
+        children.forEach((item) => {
+            item.icon = 'variable';
+        });
+        return { name: '分组属性别名', icon: 'category', children, expanded: true };
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Constant__.ts

@@ -230,9 +230,9 @@ export class Constant extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
         return code;
     }
     @withSourceMap()
@@ -242,9 +242,9 @@ export class Constant extends BaseNode {
             code += ': undefined as ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += ` : ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += ` : ${this.defaultValue}`;
+        // }
         return code;
     }
     //================================================================================

package/src/concepts/Destination__.ts

@@ -52,8 +52,6 @@ export class Destination extends LogicItem {
     @property('Argument')
     arguments: Array<Argument> = [];
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -67,7 +65,6 @@ export class Destination extends LogicItem {
         return super.from(source, parentNode, parentKey) as Destination;
     }
 
-    
     /**
      * 设置viewNamespace
      */
@@ -92,10 +89,6 @@ export class Destination extends LogicItem {
         });
     }
 
-    
-
-    
-
     /**
     * 插入实际参数
     * @internal
@@ -128,8 +121,6 @@ export class Destination extends LogicItem {
         return argument;
     }
 
-    
-
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -152,8 +143,6 @@ export class Destination extends LogicItem {
         return node;
     }
 
-    
-
     /**
      * 添加实际参数
      * @internal
@@ -173,8 +162,6 @@ export class Destination extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
-
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -198,9 +185,6 @@ export class Destination extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -208,7 +192,7 @@ export class Destination extends LogicItem {
     removeArgument(argument: Argument): void;
 
     removeArgument(options: Argument) {
-        let argument: Argument = options;
+        const argument: Argument = options;
         return argument.delete();
     }
 
@@ -281,7 +265,14 @@ export class Destination extends LogicItem {
             url += ':destination="`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments?.map((arg) => `${arg?.keyword}=` + `${arg?.toVue(options) === '' ? '' : '${' + arg?.toVue(options) + '}'}`);
+                const args = this.arguments.map((arg) => {
+                    const value = arg?.toVue();
+                    let argStr = '';
+                    if (value) {
+                        argStr += `${arg.keyword}=` + '${' + `${value}` + '}';
+                    }
+                    return argStr;
+                }).filter((arg) => !!arg);
                 url += `?${args.join('&')}`;
             }
             url += '`"';
@@ -311,7 +302,14 @@ export class Destination extends LogicItem {
             url += 'this.$destination(`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toJS()}` + '}');
+                const args = this.arguments.map((arg) => {
+                    const value = arg?.toJS();
+                    let argStr = '';
+                    if (value) {
+                        argStr += `${arg.keyword}=` + '${' + `${value}` + '}';
+                    }
+                    return argStr;
+                }).filter((arg) => !!arg);
                 url += `?${args.join('&')}`;
             }
             url += '`)';
@@ -466,7 +464,7 @@ export class Destination extends LogicItem {
     //================================================================================
 }
 
-classMap['Destination'] = Destination;
+classMap.Destination = Destination;
 export default Destination;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/EntityIndex__.ts

@@ -177,7 +177,8 @@ export class EntityIndex extends BaseNode {
      */
     moveUp() {
         const indexes = [...(this.parentNode as Entity).indexes];
-        const oldIndex = indexes.indexOf(this);
+        const indexesNameList = indexes.map((item) => item.name);
+        const oldIndex = indexesNameList.indexOf(this.name);
         this.changeSort(indexes, oldIndex, 'up');
         this.parentNode.update({
             indexes,
@@ -188,7 +189,8 @@ export class EntityIndex extends BaseNode {
      */
     moveDown() {
         const indexes = [...(this.parentNode as Entity).indexes];
-        const oldIndex = indexes.indexOf(this);
+        const indexesNameList = indexes.map((item) => item.name);
+        const oldIndex = indexesNameList.indexOf(this.name);
         this.changeSort(indexes, oldIndex, 'down');
         this.parentNode.update({
             indexes,

package/src/concepts/EntityProperty__.ts

@@ -369,11 +369,9 @@ export class EntityProperty extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
-                }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/Entity__.ts

@@ -107,7 +107,6 @@ export class Entity extends BaseNode {
         }
         return params;
     }
-
     /**
      * 设置实体描述
      */
@@ -120,7 +119,7 @@ export class Entity extends BaseNode {
         });
     }
 
-    getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
+        getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
         const excludedSet = new Set(excludedList);
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -261,6 +260,7 @@ export class Entity extends BaseNode {
         return node;
     }
 
+
     getEntityIndexExistingNames(excludedList: Array<EntityIndex> = []) {
         const excludedSet = new Set(excludedList);
         return (this.indexes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -402,6 +402,9 @@ export class Entity extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
     * 删除实体字段
     * @param name 实体字段名称
@@ -450,6 +453,8 @@ export class Entity extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除实体索引
     * @param name 实体索引名称
@@ -503,6 +508,13 @@ export class Entity extends BaseNode {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    getPropertyExistingNameList(excludedList: Array<EntityProperty> = []) {
+        const excludedSet = Array.from(new Set(excludedList));
+        const namelist = excludedSet.map((item) => item.name);
+        console.log(namelist);
+
+        return (this.properties || []).filter((item) => !namelist.includes(item.name)).map((item) => item.name);
+    }
     /**
      * 设置实体表名并修改表名
      */
@@ -716,7 +728,7 @@ export class Entity extends BaseNode {
     //================================================================================
 }
 
-classMap.Entity = Entity;
+classMap['Entity'] = Entity;
 export default Entity;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑