@lcap/nasl 1.0.2 → 2.12.0

package/src/concepts/CallLogic__.ts

@@ -1,8 +1,10 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Logic from './Logic__';
 import Param from './Param__';
+import View from './View__';
 import { ElementToVueOptions } from './ViewElement__';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
+import { findConceptKeyWordIndexFromNamespace } from '../utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -387,6 +389,10 @@ export class CallLogic extends LogicItem {
 
     // 用于logic回填
     get calleewholeKey(): string {
+        if (!this.calleeNamespace && this.calleeName && this.view) {
+            // 页面逻辑单独处理
+            return `${this.view.getNamespace()}.${this.view.name}.logics.${this.calleeName}`;
+        }
         return this.calleeNamespace + '.' + this.calleeName;
     }
     get calleeKey(): string {
@@ -437,6 +443,9 @@ export class CallLogic extends LogicItem {
 
     _setCallee(logic: Logic) {
         this.calleeNamespace = logic.getNamespace();
+        if (logic.parentNode instanceof View) {
+            this.calleeNamespace = '';
+        }
         this.calleeName = logic.name;
         this.arguments = [];
         logic.params.forEach((param) => {
@@ -453,7 +462,10 @@ export class CallLogic extends LogicItem {
     }
 
     setCallee(logic: Logic) {
-        const calleeNamespace = logic.getNamespace();
+        let calleeNamespace = logic.getNamespace();
+        if (logic.parentNode instanceof View) {
+            calleeNamespace = '';
+        }
         const calleeName = logic.name;
         const params = logic.params.map((param) => {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
@@ -482,7 +494,10 @@ export class CallLogic extends LogicItem {
     }
 
     setCalleeArgName(logic: Logic) {
-        const calleeNamespace = logic.getNamespace();
+        let calleeNamespace = logic.getNamespace();
+        if (logic.parentNode instanceof View) {
+            calleeNamespace = '';
+        }
         const calleeName = logic.name;
         /**
          * a: logic.params b: this.arguments
@@ -528,7 +543,7 @@ export class CallLogic extends LogicItem {
 
     toVue(options?: ElementToVueOptions): string {
         let code = '';
-        if (this.calleeNamespace === 'nasl.browser' || this.calleeNamespace === 'nasl.auth' || this.calleeNamespace === 'nasl.configuration') {
+        if (this.calleeNamespace === 'nasl.browser' || this.calleeNamespace === 'nasl.auth' || this.calleeNamespace === 'nasl.configuration' || this.calleeNamespace === 'nasl.process') {
             code += '$global.';
         }
         code += this.calleeName;
@@ -563,21 +578,20 @@ export class CallLogic extends LogicItem {
         let isComponentLogic = false;
         let componentName = '';
         const calleeNamespace = this.calleeNamespace;
-        const isProcessLogic = this.calleeNamespace?.startsWith('app.processes');
-
+        const keywordProcessIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'processes');
+        const isProcessLogic = keywordProcessIndex !== -1;
         // calleeNamespace不存在，一定是页面逻辑
         if (calleeNamespace) {
             const namespaceArr = calleeNamespace.split('.');
-            const start = namespaceArr.shift();
+            const start = namespaceArr[0];
             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) {
+                const keywordViewsIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'views');
+                if (keywordViewsIndex === -1) {
                     isViewLogic = false;
                 }
-            } else if (start === 'elements' && namespaceArr.length === 2 && namespaceArr[1] === 'logics') {
+            } else if (start === 'elements' && namespaceArr.length === 3 && namespaceArr[2] === 'logics') {
                 isComponentLogic = true;
-                componentName = namespaceArr[0];
+                componentName = namespaceArr[1];
             }
         }
         // 全局逻辑
@@ -598,17 +612,7 @@ export class CallLogic extends LogicItem {
                 };
             });
             const args = logic?.params || [];
-
-            // 去掉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];
+            const keywordEntitiesIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'entities');
             code += `this.$logics['${this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName}']`;
             code += `({
                 config: {
@@ -629,7 +633,7 @@ export class CallLogic extends LogicItem {
                 headers: {},
             `;
 
-            if (entityName) {
+            if (keywordEntitiesIndex !== -1) {
                 let logicArgs = this.arguments;
                 switch (this.calleeName) {
                     case 'get':
@@ -688,19 +692,30 @@ export class CallLogic extends LogicItem {
                         code += `JSON.parse`;
                         break;
                 }
-            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration') {
+            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration' || calleeNamespace === 'nasl.process') {
                 code += `this.$global.${this.calleeName}`;
             } else {
                 code += `this.${this.calleeName}`;
             }
-            code += '(';
-            this.arguments?.filter((arg) => arg?.expression)
-                .forEach((arg, index) => {
-                    code += arg?.toJS(shiftState(state, code));
-                    if (index !== this.arguments?.length - 1)
-                        code += ', ';
-                });
-            code += ')';
+            if (calleeNamespace === 'nasl.process') {
+                code += '({';
+                this.arguments?.filter((arg) => arg?.expression)
+                    .forEach((arg, index) => {
+                        code += `${arg.keyword}: ${arg?.toJS(shiftState(state, code))}`;
+                        if (index !== this.arguments?.length - 1)
+                            code += ', ';
+                    });
+                code += '})';
+            } else {
+                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;
     }

package/src/concepts/CallQueryComponent__.ts

@@ -751,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';
 
@@ -819,7 +819,7 @@ export class CallQueryComponent extends LogicItem {
         }
         // 聚合属性别名
         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} = `;
@@ -835,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] : [], {
@@ -878,8 +878,8 @@ 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;
     }
 
@@ -888,6 +888,7 @@ export class CallQueryComponent extends LogicItem {
             return [];
 
         const entityName = node.entityName;
+        const entityNamespace = node.entityNamespace;
         entities.push({
             concept: 'StructureProperty',
             name: utils.firstLowerCase(entityName),
@@ -895,7 +896,7 @@ export class CallQueryComponent extends LogicItem {
                 concept: 'TypeAnnotation',
                 typeKind: 'reference',
                 typeName: entityName,
-                typeNamespace: `${this.app.getNamespace()}.entities`,
+                typeNamespace: entityNamespace,
             },
         });
 
@@ -906,7 +907,7 @@ export class CallQueryComponent extends LogicItem {
         return entities;
     }
 
-    genPropertyListOfAggregate(node: CallQueryComponent) {
+    genPropertyListOfAggregate(node: CallQueryComponent, entities: Entity[]) {
         return node.select.selectElements
             .filter((item) => item.aggregateName && item.asName)
             .map((item) => {
@@ -917,9 +918,9 @@ export class CallQueryComponent extends LogicItem {
                     typeName = 'Double';
                 } else {
                     const { entityAsName, propertyName } = item.aggregateParam;
-                    const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                    const entity = entities.find((item: Entity) => item.name === entityAsName);
                     const property = entity?.properties.find((item) => item.name === propertyName);
-                    typeName = property?.typeAnnotation.typeName;
+                    typeName = property?.typeAnnotation?.typeName;
                 }
                 return {
                     concept: 'StructureProperty',
@@ -934,22 +935,23 @@ export class CallQueryComponent extends LogicItem {
             });
     }
 
-    genPropertyListOfGroupBy(node: CallQueryComponent) {
+    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 = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                const entity = entities.find((item: Entity) => item.name === entityAsName);
                 const property = entity?.properties.find((item) => item.name === propertyName);
-                const typeName = property?.typeAnnotation.typeName;
+                const propertyTypeAnnotation = property.typeAnnotation;
+
                 return {
                     concept: 'StructureProperty',
                     name: asName,
                     typeAnnotation: {
-                        concept: 'TypeAnnotation',
-                        typeKind: 'primitive',
-                        typeName,
-                        typeNamespace: 'nasl.core',
+                        concept: propertyTypeAnnotation.concept,
+                        typeKind: propertyTypeAnnotation.typeKind,
+                        typeName: propertyTypeAnnotation.typeName,
+                        typeNamespace: propertyTypeAnnotation.typeNamespace,
                     },
                 };
             });
@@ -966,13 +968,14 @@ export class CallQueryComponent extends LogicItem {
 
     saveStructure() {
         // 没有数据源时不初始化数据结构
-        if (!this.entityNames.length) {
+        if (!this.entityInfos.length) {
             return;
         }
-
+        const entityNamespace = this.from?.entityNamespace;
+        const entities = this.app.findNodeByCompleteName(entityNamespace);
         if (!this.isAutoInfer()) {
             // 存量应用走之前的逻辑
-            return this.saveStructureNoInfer();
+            return this.saveStructureNoInfer(entities);
         }
 
         const groupBy = this.groupBy;
@@ -999,35 +1002,35 @@ export class CallQueryComponent extends LogicItem {
         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;
+                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<${typeName}>`,
+                    text: `PageOf<${propertyTypeAnnotation.typeName}>`,
                     concept: 'TypeAnnotation',
                     typeKind: 'generic',
                     typeName: 'PageOf',
                     typeNamespace: `nasl.collection`,
-                    typeArguments: [
-                        TypeAnnotation.from({
-                            concept: 'TypeAnnotation',
-                            typeKind: 'primitive',
-                            typeName,
-                            typeNamespace: 'nasl.core',
-                        }, this.typeAnnotation, 'typeAnnotation'),
-                    ],
+                    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),
-                    ...this.genPropertyListOfAggregate(this),
+                    ...this.genPropertyListOfGroupBy(this, entities),
+                    ...this.genPropertyListOfAggregate(this, entities),
                 ]);
                 this.app.addStructure(structure);
 
@@ -1061,9 +1064,9 @@ export class CallQueryComponent extends LogicItem {
                     } 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;
+                        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',
@@ -1074,7 +1077,7 @@ export class CallQueryComponent extends LogicItem {
                 } else {
                     // 2.2. 多聚合：`Structure`（自动创建 `Structure`）
                     const structure = this.genStructure(structureName, [
-                        ...this.genPropertyListOfAggregate(this),
+                        ...this.genPropertyListOfAggregate(this, entities),
                     ]);
                     this.app.addStructure(structure);
 
@@ -1089,7 +1092,7 @@ export class CallQueryComponent extends LogicItem {
                 // 2.3. 无聚合(默认情况)：`PageOf<Structure>`（自动创建 `Structure`）
                 const structure = this.genStructure(structureName, [
                     ...this.genPropertyListOfFrom(this.from),
-                    ...this.genPropertyListOfAggregate(this),
+                    ...this.genPropertyListOfAggregate(this, entities),
                 ]);
                 this.app.addStructure(structure);
 
@@ -1114,10 +1117,10 @@ export class CallQueryComponent extends LogicItem {
         this.update({ typeAnnotation });
     }
 
-    saveStructureNoInfer() {
+    saveStructureNoInfer(entities: any[] = []) {
         const source = this.genStructure(null, [
             ...this.genPropertyListOfFrom(this.from),
-            ...this.genPropertyListOfAggregate(this),
+            ...this.genPropertyListOfAggregate(this, entities),
         ]);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
@@ -1162,53 +1165,61 @@ export class CallQueryComponent extends LogicItem {
         } 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() {

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 自动生成，请不手动修改！