@lcap/nasl 1.0.1 → 2.12.0-beta.1

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 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -750,16 +751,16 @@ export class CallQueryComponent extends LogicItem {
         if (list.length === 0)
             return code;
 
-        code += indent(state.tabSize + 1) + `.${key}(() => `;
+        code += indent((state?.tabSize || 0) + 1) + `.${key}(() => `;
         list.forEach((item, index) => {
             if (index > 0)
-                code += `,\n${indent(state.tabSize + 2)}() => `;
+                code += `,\n${indent((state?.tabSize || 0) + 2)}() => `;
             code += item?.toEmbeddedTS?.(shiftState(state, code, { tabSize: 0 }));
         });
         if (list.length > 1) {
             if (multipleErrorType)
-                code += `,\n${indent(state.tabSize + 2)}() => ${multipleErrorType}`;
-            code += `\n${indent(state.tabSize + 1)}`;
+                code += `,\n${indent((state?.tabSize || 0) + 2)}() => ${multipleErrorType}`;
+            code += `\n${indent((state?.tabSize || 0) + 1)}`;
         }
         code += ')\n';
 
@@ -781,13 +782,44 @@ 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);
+            code += indent((state?.tabSize || 0) + 1);
             const { asName, aggregateName, aggregateParam } = item;
             if (asName)
                 code += `const __${asName} = `;
@@ -803,9 +835,9 @@ export class CallQueryComponent extends LogicItem {
         });
 
         if (this.from)
-            code += this.from.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            code += this.from.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
         else
-            code += `${indent(state.tabSize + 1)}nasl.langUtil.FROM()\n`;
+            code += `${indent((state?.tabSize || 0) + 1)}nasl.langUtil.FROM()\n`;
 
         // where 子句
         code = this.toEmbeddedTSOfSubPart('WHERE', this.where ? [this.where] : [], {
@@ -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,
         });
@@ -846,75 +878,250 @@ export class CallQueryComponent extends LogicItem {
         });
 
         code += '\n';
-        code += indent(state.tabSize + 1) + 'return;\n';
-        code += indent(state.tabSize) + '})();\n';
+        code += indent((state?.tabSize || 0) + 1) + 'return;\n';
+        code += indent((state?.tabSize || 0)) + '})();\n';
         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 [];
 
-            for (const sub of node.joinParts) {
-                genPropertyListOfFrom(sub, entities);
-            }
+        const entityName = node.entityName;
+        const entityNamespace = node.entityNamespace;
+        entities.push({
+            concept: 'StructureProperty',
+            name: utils.firstLowerCase(entityName),
+            typeAnnotation: {
+                concept: 'TypeAnnotation',
+                typeKind: 'reference',
+                typeName: entityName,
+                typeNamespace: entityNamespace,
+            },
+        });
 
-            return entities;
+        for (const sub of node.joinParts) {
+            this.genPropertyListOfFrom(sub, entities);
         }
 
-        function 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 {
-                        const { entityAsName, propertyName } = item.aggregateParam;
-                        const entity = 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,
-                        },
-                    };
-                });
-        }
+        return entities;
+    }
 
-        const structureName = this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`;
+    genPropertyListOfAggregate(node: CallQueryComponent, entities: Entity[]) {
+        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 = 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,
+                    },
+                };
+            });
+    }
 
+    genPropertyListOfGroupBy(node: CallQueryComponent, entities: Entity[]) {
+        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 = entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item) => item.name === propertyName);
+                const propertyTypeAnnotation = property.typeAnnotation;
+
+                return {
+                    concept: 'StructureProperty',
+                    name: asName,
+                    typeAnnotation: {
+                        concept: propertyTypeAnnotation.concept,
+                        typeKind: propertyTypeAnnotation.typeKind,
+                        typeName: propertyTypeAnnotation.typeName,
+                        typeNamespace: propertyTypeAnnotation.typeNamespace,
+                    },
+                };
+            });
+    }
+
+    genStructure(structureName?: string, properties: any[] = []) {
         return Structure.from({
             concept: 'Structure',
-            name: structureName,
+            name: structureName || this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`,
             origin: 'CallQueryComponent',
-            properties: [...genPropertyListOfFrom(this.from), ...genPropertyListOfAggregate(this)],
+            properties,
         });
     }
 
     saveStructure() {
-        const source = this.genStructure();
-        // console.log(source);
+        // 没有数据源时不初始化数据结构
+        if (!this.entityInfos.length) {
+            return;
+        }
+        const entityNamespace = this.from?.entityNamespace;
+        const entities = this.app.findNodeByCompleteName(entityNamespace);
+        if (!this.isAutoInfer()) {
+            // 存量应用走之前的逻辑
+            return this.saveStructureNoInfer(entities);
+        }
+
+        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 QueryFieldExpression;
+                const entity = entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item: any) => item.name === propertyName);
+                const propertyTypeAnnotation = property.typeAnnotation;
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: `PageOf<${propertyTypeAnnotation.typeName}>`,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [TypeAnnotation.from({
+                        concept: propertyTypeAnnotation.concept,
+                        typeKind: propertyTypeAnnotation.typeKind,
+                        typeName: propertyTypeAnnotation.typeName,
+                        typeNamespace: propertyTypeAnnotation.typeNamespace,
+                    }, this.typeAnnotation, 'typeAnnotation')],
+                }, this, 'typeAnnotation');
+            } else {
+                // 1.2 多分组：`PageOf<Structure>`
+                const structure = this.genStructure(structureName, [
+                    ...this.genPropertyListOfGroupBy(this, entities),
+                    ...this.genPropertyListOfAggregate(this, entities),
+                ]);
+                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(selectElements[0].aggregateName)) {
+                        // 2.1.1. `COUNT`、`COUNTD` 返回 `Integer`
+                        typeName = 'Integer';
+                    } 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 = entities.find((item: Entity) => item.name === entityAsName);
+                        const property = entity?.properties.find((item: any) => item.name === propertyName);
+                        typeName = property?.typeAnnotation?.typeName;
+                    }
+                    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, entities),
+                    ]);
+                    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, entities),
+                ]);
+                this.app.addStructure(structure);
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: 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');
+            }
+        }
+
+        this.update({ typeAnnotation });
+    }
+
+    saveStructureNoInfer(entities: any[] = []) {
+        const source = this.genStructure(null, [
+            ...this.genPropertyListOfFrom(this.from),
+            ...this.genPropertyListOfAggregate(this, entities),
+        ]);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
             if (structure) {
@@ -939,59 +1146,80 @@ 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 {}
     }
 
-    getEntityNames(node: QueryFromExpression | QueryJoinExpression, set = new Set()) {
+    getEntityInfos(node: QueryFromExpression | QueryJoinExpression, set = new Set()) {
         if (node?.entityName)
-            set.add(node.entityName);
+            set.add({
+                namespace: node.entityNamespace,
+                name: node.entityName,
+            });
 
         node?.joinParts?.forEach((child) => {
-            this.getEntityNames(child, set);
+            this.getEntityInfos(child, set);
         });
         return Array.from(set);
     }
 
-    get entityNames() {
-        return this.getEntityNames(this.from);
+    get entityInfos() {
+        return this.getEntityInfos(this.from);
     }
 
     getCompletionPropertyOfEntities() {
-        const entities = this.app.entities;
-        const children = this.entityNames
-            .map((name) => entities.find((item) => item.name === name))
-            .filter((item) => item)
-            .map((entity) => ({
-                concept: 'Entity',
-                name: entity.name,
-                children: entity.properties.map((property) => {
-                    const completionProperty = new CompletionProperty({
-                        concept: 'CompletionProperty',
-                        name: property.name,
-                        value: `${entity.name}.${property.name}`,
-                        expression: LogicItem.from({
-                            concept: 'QueryFieldExpression',
-                            name: property.name,
-                            value: `${entity.name}.${property.name}`,
-                            entityAsName: entity.name,
-                            propertyName: property.name,
+        const firstEntityInfo: any = this.entityInfos[0];
+        if (firstEntityInfo) {
+            const namespace = firstEntityInfo.namespace;
+            const entities: Entity[] = this.app.findNodeByCompleteName(namespace);
+            if (Array.isArray(entities)) {
+                const children = this.entityInfos
+                    .map(({ name }) => entities.find((item) => item.name === name))
+                    .filter((item) => item)
+                    .map((entity) => ({
+                        concept: 'Entity',
+                        name: entity.name,
+                        children: entity.properties.map((property) => {
+                            const completionProperty = new CompletionProperty({
+                                concept: 'CompletionProperty',
+                                name: property.name,
+                                value: `${entity.name}.${property.name}`,
+                                expression: LogicItem.from({
+                                    concept: 'QueryFieldExpression',
+                                    name: property.name,
+                                    value: `${entity.name}.${property.name}`,
+                                    entityAsName: entity.name,
+                                    propertyName: property.name,
+                                }),
+                            });
+                            completionProperty.icon = 'property';
+                            return completionProperty;
                         }),
-                    });
-                    completionProperty.icon = 'property';
-                    return completionProperty;
-                }),
-            }));
-        if (children.length === 0)
-            return;
-
-        return {
-            name: '实体',
-            icon: 'category',
-            children,
-        };
+                    }));
+                if (children.length) {
+                    return {
+                        name: '实体',
+                        icon: 'category',
+                        children,
+                    };
+                }
+            }
+        }
     }
 
     getCompletionPropertyOfAggregateAsNames() {
@@ -1017,6 +1245,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/Comment__.ts

@@ -79,7 +79,7 @@ export class Comment extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
-        code += `\n${indent(state.tabSize)}
+        code += `\n${indent((state?.tabSize || 0))}
         /**
          * 注释不用翻译
          */

package/src/concepts/ConfigGroup__.ts

@@ -275,7 +275,9 @@ export class ConfigGroup extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-
+    getProperty(name = '') {
+        return this.properties.find((item) => item.name === name);
+    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/ConfigProperty__.ts

@@ -292,6 +292,10 @@ export class ConfigProperty extends BaseNode {
             ...object,
         });
     }
+
+    getPropertyEnv(env = '') {
+        return this.values.find((item) => item.env === env);
+    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Configuration__.ts

@@ -271,6 +271,9 @@ export class Configuration extends BaseNode {
             ],
         };
     }
+    getGroup(name = '') {
+        return this.groups.find((item) => item.name === name);
+    }
 
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 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;
     }
     //================================================================================