@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/out/concepts/CallQueryComponent__.js

@@ -205,48 +205,6 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         });
         return node;
     }
-    _insertQueryGroupByExpressionInGroupByAt(options, index) {
-        const queryGroupByExpressionOptions = {};
-        const relationOptions = { parentNode: this, parentKey: 'groupBy' };
-        const QueryGroupByExpression = (0, decorators_1.getConceptConstructor)('QueryGroupByExpression');
-        let queryGroupByExpression;
-        if (asserts.isQueryGroupByExpression(options)) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            queryGroupByExpression = options;
-            Object.assign(queryGroupByExpression, relationOptions);
-        }
-        else {
-            queryGroupByExpression = QueryGroupByExpression.from({
-                ...queryGroupByExpressionOptions,
-                ...options,
-            }, this, 'groupBy');
-        }
-        this.groupBy.splice(index, 0, queryGroupByExpression);
-        return queryGroupByExpression;
-    }
-    insertQueryGroupByExpressionInGroupByAt(options, index) {
-        const node = this._insertQueryGroupByExpressionInGroupByAt(options, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'groupBy',
-        });
-        return node;
-    }
-    _addQueryGroupByExpressionInGroupBy(options) {
-        const index = this.groupBy.length;
-        return this._insertQueryGroupByExpressionInGroupByAt(options, index);
-    }
-    addQueryGroupByExpressionInGroupBy(options) {
-        const node = this._addQueryGroupByExpressionInGroupBy(options);
-        const index = this.groupBy.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'groupBy',
-        });
-        return node;
-    }
     _insertItemInHavingPlaygroundAt(options, index) {
         const logicItemOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'havingPlayground' };
@@ -289,7 +247,49 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         });
         return node;
     }
-    _insertQueryOrderByExpressionInOrderByAt(options, index) {
+    _insertQueryGroupByExpressionAt(options, index) {
+        const queryGroupByExpressionOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'groupBy' };
+        const QueryGroupByExpression = (0, decorators_1.getConceptConstructor)('QueryGroupByExpression');
+        let queryGroupByExpression;
+        if (asserts.isQueryGroupByExpression(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            queryGroupByExpression = options;
+            Object.assign(queryGroupByExpression, relationOptions);
+        }
+        else {
+            queryGroupByExpression = QueryGroupByExpression.from({
+                ...queryGroupByExpressionOptions,
+                ...options,
+            }, this, 'groupBy');
+        }
+        this.groupBy.splice(index, 0, queryGroupByExpression);
+        return queryGroupByExpression;
+    }
+    insertQueryGroupByExpressionAt(options, index) {
+        const node = this._insertQueryGroupByExpressionAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'groupBy',
+        });
+        return node;
+    }
+    _addQueryGroupByExpression(options) {
+        const index = this.groupBy.length;
+        return this._insertQueryGroupByExpressionAt(options, index);
+    }
+    addQueryGroupByExpression(options) {
+        const node = this._addQueryGroupByExpression(options);
+        const index = this.groupBy.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'groupBy',
+        });
+        return node;
+    }
+    _insertQueryOrderByExpressionAt(options, index) {
         const queryOrderByExpressionOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'orderBy' };
         const QueryOrderByExpression = (0, decorators_1.getConceptConstructor)('QueryOrderByExpression');
@@ -308,8 +308,8 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         this.orderBy.splice(index, 0, queryOrderByExpression);
         return queryOrderByExpression;
     }
-    insertQueryOrderByExpressionInOrderByAt(options, index) {
-        const node = this._insertQueryOrderByExpressionInOrderByAt(options, index);
+    insertQueryOrderByExpressionAt(options, index) {
+        const node = this._insertQueryOrderByExpressionAt(options, index);
         node.create({
             index,
             parentNode: this,
@@ -317,12 +317,12 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         });
         return node;
     }
-    _addQueryOrderByExpressionInOrderBy(options) {
+    _addQueryOrderByExpression(options) {
         const index = this.orderBy.length;
-        return this._insertQueryOrderByExpressionInOrderByAt(options, index);
+        return this._insertQueryOrderByExpressionAt(options, index);
     }
-    addQueryOrderByExpressionInOrderBy(options) {
-        const node = this._addQueryOrderByExpressionInOrderBy(options);
+    addQueryOrderByExpression(options) {
+        const node = this._addQueryOrderByExpression(options);
         const index = this.orderBy.indexOf(node);
         node.create({
             index,
@@ -331,162 +331,22 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         });
         return node;
     }
-    removeTypeAnnotation(options) {
-        let typeAnnotation;
-        if (typeof options === 'string') {
-            typeAnnotation = this.typeAnnotation;
-            if (!typeAnnotation) {
-                throw new Error('找不到类型标注 ' + options);
-            }
-        }
-        else {
-            typeAnnotation = options;
-        }
-        return typeAnnotation.delete();
-    }
-    __removeTypeAnnotation(typeAnnotation) {
-        const parentKey = typeAnnotation.parentKey;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: typeAnnotation,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = typeAnnotation.__v_raw || typeAnnotation;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
-    removeSelect(options) {
-        let select;
-        if (typeof options === 'string') {
-            select = this.select;
-            if (!select) {
-                throw new Error('找不到查询选择子句 ' + options);
-            }
-        }
-        else {
-            select = options;
-        }
-        return select.delete();
-    }
-    removeFrom(options) {
-        let from;
-        if (typeof options === 'string') {
-            from = this.from;
-            if (!from) {
-                throw new Error('找不到查询 From 子句 ' + options);
-            }
-        }
-        else {
-            from = options;
-        }
-        return from.delete();
-    }
-    removeWhere(options) {
-        let where;
-        if (typeof options === 'string') {
-            where = this.where;
-            if (!where) {
-                throw new Error('找不到逻辑项 ' + options);
-            }
-        }
-        else {
-            where = options;
-        }
-        return where.delete();
-    }
     removeItemInWherePlayground(options) {
         let logicItem = options;
         return logicItem.delete();
     }
-    removeQueryGroupByExpressionInGroupBy(options) {
-        let queryGroupByExpression = options;
-        return queryGroupByExpression.delete();
-    }
-    removeHaving(options) {
-        let having;
-        if (typeof options === 'string') {
-            having = this.having;
-            if (!having) {
-                throw new Error('找不到逻辑项 ' + options);
-            }
-        }
-        else {
-            having = options;
-        }
-        return having.delete();
-    }
     removeItemInHavingPlayground(options) {
         let logicItem = options;
         return logicItem.delete();
     }
-    removeQueryOrderByExpressionInOrderBy(options) {
+    removeQueryGroupByExpression(options) {
+        let queryGroupByExpression = options;
+        return queryGroupByExpression.delete();
+    }
+    removeQueryOrderByExpression(options) {
         let queryOrderByExpression = options;
         return queryOrderByExpression.delete();
     }
-    removeLimit(options) {
-        let limit;
-        if (typeof options === 'string') {
-            limit = this.limit;
-            if (!limit) {
-                throw new Error('找不到查询分页子句 ' + options);
-            }
-        }
-        else {
-            limit = options;
-        }
-        return limit.delete();
-    }
-    __removeLogicItem(logicItem) {
-        const parentKey = logicItem.parentKey;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logicItem,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = logicItem.__v_raw || logicItem;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -512,18 +372,19 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
             groupBy: [],
             having: null,
             orderBy: [],
-            limit: {
-                concept: 'QueryLimitExpression',
-                label: '查询组件Limit子句',
-                pageElement: {
-                    concept: 'NumericLiteral',
-                    value: 1,
-                },
-                pageSizeElement: {
-                    concept: 'NumericLiteral',
-                    value: 1000,
-                },
-            },
+            limit: null,
+            // limit: {
+            //   concept: 'QueryLimitExpression',
+            //   label: '查询组件Limit子句',
+            //   pageElement: {
+            //     concept: 'NumericLiteral',
+            //     value: 1,
+            //   },
+            //   pageSizeElement: {
+            //     concept: 'NumericLiteral',
+            //     value: 1000,
+            //   },
+            // },
         };
     }
     *toEmbeddedTSOfSubPart(key, list, options) {
@@ -544,6 +405,30 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         code += ')\n';
         return code;
     }
+    entityNames() {
+        const entityNames = this.entityInfos.map(({ namespace, name }) => {
+            const namespaceArr = namespace?.split('.') || [];
+            const keywordDataSourceIndex = utils.findConceptKeyWordIndexFromNamespace(namespace, 'dataSources');
+            const dataSourceName = keywordDataSourceIndex !== -1 ? namespaceArr[keywordDataSourceIndex + 1] : '';
+            const names = [name];
+            if (dataSourceName) {
+                names.unshift(dataSourceName);
+            }
+            return names.join('.');
+        });
+        const lines = [];
+        const fontCount = 60;
+        const entityNamesStr = entityNames.join(',') || '-';
+        for (let i = 0; i < entityNamesStr.length; i += fontCount) {
+            lines.push(entityNamesStr.slice(i, i + fontCount));
+        }
+        return lines;
+    }
+    toUI(state, hideDetails) {
+        let code = '';
+        code += `数据查询（数据源：${this.entityNames()}）`;
+        return code;
+    }
     toJS() {
         return '';
         // const { entityName } = this.from;
@@ -624,16 +509,9 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
             state,
             multipleErrorType: '__WHERE_MULTIPLE_CONDITION__',
         });
-        if (self.select.selectAggregateElements.length) {
-            // 聚合属性
-            code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectAggregateElements, {
-                code,
-                state,
-            });
-        }
-        else {
-            // select实体字段
-            code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectFieldElements, {
+        // 聚合属性 & select实体字段
+        if (self.select.selectElements.length) {
+            code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectElements, {
                 code,
                 state,
             });
@@ -654,11 +532,6 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
             code,
             state,
         });
-        // 分页参数
-        code = yield* self.toEmbeddedTSOfSubPart('LIMIT', self.limit ? [self.limit] : [], {
-            code,
-            state,
-        });
         code += '\n';
         code += `${(0, translator_1.indent)((state?.tabSize || 0) + 1)}return;\n`;
         code += `${(0, translator_1.indent)(state?.tabSize || 0)}})()`;
@@ -852,77 +725,41 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
         // 1. 有分组
         if (groupByLength) {
             if (!aggregateLength && groupByLength === 1) {
-                // 1.1 单分组无聚合：`{ list: List<列的类型>, total: Long }`
+                // 1.1 单分组无聚合：`List<列的类型>`
                 const { entityAsName, propertyName } = groupBy[0].groupElement;
                 const entity = entities.find((item) => item.name === entityAsName);
                 const property = entity?.properties.find((item) => item.name === propertyName);
                 const propertyTypeAnnotation = property.typeAnnotation;
                 typeAnnotation = TypeAnnotation.from({
                     concept: 'TypeAnnotation',
-                    typeKind: 'anonymousStructure',
-                    properties: [
-                        StructureProperty.from({
-                            name: 'list',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'generic',
-                                typeName: 'List',
-                                typeNamespace: 'nasl.collection',
-                                typeArguments: [
-                                    TypeAnnotation.from({
-                                        concept: propertyTypeAnnotation.concept,
-                                        typeKind: propertyTypeAnnotation.typeKind,
-                                        typeName: propertyTypeAnnotation.typeName,
-                                        typeNamespace: propertyTypeAnnotation.typeNamespace,
-                                    }),
-                                ],
-                            }, this.typeAnnotation, 'typeAnnotation'),
-                        }),
-                        StructureProperty.from({
-                            name: 'total',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'primitive',
-                                typeNamespace: 'nasl.core',
-                                typeName: 'Long',
-                            }, this.typeAnnotation, 'typeAnnotation'),
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: propertyTypeAnnotation.concept,
+                            typeKind: propertyTypeAnnotation.typeKind,
+                            typeName: propertyTypeAnnotation.typeName,
+                            typeNamespace: propertyTypeAnnotation.typeNamespace,
                         }),
                     ],
                 }, this, 'typeAnnotation');
             }
             else {
-                // 1.2 多分组：`{ list: List<anonymousStructure>, total: Long }`
+                // 1.2 多分组：`List<anonymousStructure>`
                 typeAnnotation = TypeAnnotation.from({
                     concept: 'TypeAnnotation',
-                    typeKind: 'anonymousStructure',
-                    properties: [
-                        StructureProperty.from({
-                            name: 'list',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'generic',
-                                typeName: 'List',
-                                typeNamespace: 'nasl.collection',
-                                typeArguments: [
-                                    TypeAnnotation.from({
-                                        concept: 'TypeAnnotation',
-                                        typeKind: 'anonymousStructure',
-                                        properties: [
-                                            ...this.genPropertyListOfGroupBy(this, entities),
-                                            ...this.genPropertyListOfAggregate(this, entities),
-                                        ],
-                                    }),
-                                ],
-                            }, this.typeAnnotation, 'typeAnnotation'),
-                        }),
-                        StructureProperty.from({
-                            name: 'total',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'primitive',
-                                typeNamespace: 'nasl.core',
-                                typeName: 'Long',
-                            }, this.typeAnnotation, 'typeAnnotation'),
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'anonymousStructure',
+                            properties: [
+                                ...this.genPropertyListOfGroupBy(this, entities),
+                                ...this.genPropertyListOfAggregate(this, entities),
+                            ],
                         }),
                     ],
                 }, this, 'typeAnnotation');
@@ -974,35 +811,17 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
                 }
             }
             else {
-                // 2.3 无分组&&无聚合 (默认情况)：`{ list: List<Structure>, total: Long }`
+                // 2.3 无分组&&无聚合 (默认情况)：`List<Structure>`
                 typeAnnotation = TypeAnnotation.from({
                     concept: 'TypeAnnotation',
-                    typeKind: 'anonymousStructure',
-                    properties: [
-                        StructureProperty.from({
-                            name: 'list',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'generic',
-                                typeName: 'List',
-                                typeNamespace: 'nasl.collection',
-                                typeArguments: [
-                                    TypeAnnotation.from({
-                                        concept: 'TypeAnnotation',
-                                        typeKind: 'anonymousStructure',
-                                        properties: this.genPropertiesFrom(this.from),
-                                    }),
-                                ],
-                            }, this.typeAnnotation, 'typeAnnotation'),
-                        }),
-                        StructureProperty.from({
-                            name: 'total',
-                            typeAnnotation: TypeAnnotation.from({
-                                concept: 'TypeAnnotation',
-                                typeKind: 'primitive',
-                                typeNamespace: 'nasl.core',
-                                typeName: 'Long',
-                            }, this.typeAnnotation, 'typeAnnotation'),
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'anonymousStructure',
+                            properties: this.genPropertiesFrom(this.from),
                         }),
                     ],
                 }, this, 'typeAnnotation');
@@ -1201,7 +1020,7 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
     // 将所有from的实体，在selectElements中初始化一个isDotStar=true的QueryFieldExpression
     initFieldSelectElement(node = this) {
         const loop = (from) => {
-            node.select.addQueryFieldExpressionInSelectElements({
+            node.select.addQueryFieldExpression({
                 entityAsName: from.entityName,
                 isDotStar: true,
             });
@@ -1212,6 +1031,11 @@ let CallQueryComponent = CallQueryComponent_1 = class CallQueryComponent extends
 };
 /** 类名 */
 CallQueryComponent.ConceptName = 'CallQueryComponent';
+/**
+ * 是否为抽象类
+ * 抽象类不能产生 concept: string
+ */
+CallQueryComponent.isAbstract = false;
 /** 继承链 */
 CallQueryComponent.inheritanceChain = ['LogicItem', 'BaseNode'];
 __decorate([
@@ -1276,7 +1100,9 @@ __decorate([
     })
 ], CallQueryComponent.prototype, "limit", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], CallQueryComponent.prototype, "ideVersion", void 0);
 __decorate([
     translator_1.withSourceMapGenerator