@lcap/nasl 1.0.0-alpha.7 → 1.0.0

package/src/concepts/QueryLimitExpression__.ts

@@ -35,8 +35,6 @@ export class QueryLimitExpression extends LogicItem {
     @property('LogicItem')
     pageSizeElement: LogicItem = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -50,7 +48,6 @@ export class QueryLimitExpression extends LogicItem {
         return super.from(source, parentNode, parentKey) as QueryLimitExpression;
     }
 
-    
     /**
      * 设置逻辑项
      */
@@ -81,10 +78,6 @@ export class QueryLimitExpression extends LogicItem {
         });
     }
 
-    
-
-    
-
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -110,8 +103,6 @@ export class QueryLimitExpression extends LogicItem {
         return pageElement.delete();
     }
 
-    
-
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -168,8 +159,8 @@ export class QueryLimitExpression extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         const { pageElement, pageSizeElement } = this;
-        let code = '';
-        code += `[${pageElement.toEmbeddedTS(shiftState(state, code))}, `;
+        let code = '[';
+        code += `${pageElement.toEmbeddedTS(shiftState(state, code))}, `;
         code += `${pageSizeElement.toEmbeddedTS(shiftState(state, code))}]`;
         return code;
     }
@@ -180,7 +171,7 @@ export class QueryLimitExpression extends LogicItem {
     //================================================================================
 }
 
-classMap['QueryLimitExpression'] = QueryLimitExpression;
+classMap.QueryLimitExpression = QueryLimitExpression;
 export default QueryLimitExpression;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/QuerySelectExpression__.ts

@@ -113,7 +113,7 @@ export class QuerySelectExpression extends LogicItem {
                 name: options,
             }, this, 'selectElements');
         } else if (options instanceof QueryAggregateExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryAggregateExpression = options;
             Object.assign(queryAggregateExpression, relationOptions);
         } else {
@@ -201,7 +201,7 @@ export class QuerySelectExpression extends LogicItem {
 
     addQueryAggregateExpression(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
         const node = this._addQueryAggregateExpression(options as any);
-        const index = this.selectElements.length;
+        const index = this.selectElements.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Return__.ts

@@ -5,6 +5,7 @@ import Entity from './Entity__';
 import EntityProperty from './EntityProperty__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -233,13 +234,26 @@ export class Return extends BaseNode {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.name;
+        let code = this.name || '__return';
         if (this.typeAnnotation) {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
+        return code;
+    }
+
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        }
         if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
+            code += `: ${this.defaultValue}`;
         }
         return code;
     }
@@ -264,15 +278,19 @@ export class Return extends BaseNode {
             if (!typeAnnotation)
                 throw new Error('找不到类型：' + typeAnnotation);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
-
+        // 处理下拉属性
+        try {
+            this.completionChildren = this.getSelectRef();
+        } catch (err) {
+            this.completionChildren = [];
+            console.log(err);
+        }
         const object = {
             typeAnnotation,
-            // 处理下拉属性
-            // completionChildren: this.getSelectRef(),
         };
 
         return this.update({
@@ -297,26 +315,47 @@ export class Return extends BaseNode {
     get readonly() {
         return !!this.module;
     }
-
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        const moduleNames = typeNamespace.split('.');
-        let completionChildren;
-        if (typeKind === 'reference') {
-            let type: 'entities' | 'structures';
-            if (typeNamespace.endsWith('entities')) {
-                type = 'entities';
-            } else if (typeNamespace.endsWith('structures')) {
-                // 数据结构比较复杂，会有
-                type = 'structures';
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else {
+                completionChildren = undefined;
             }
-            const data = this.app.dependencies.find((item) => item.name === moduleNames[2]);
-            const properties = (data[type] as Array<Entity | Structure>).find((item) => item.name === typeName)?.properties;
-            completionChildren = properties;
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/Role__.ts

@@ -36,6 +36,12 @@ export class Role extends BaseNode {
     @property()
     uuid: string = uuidv4().replace(/-/g, '');
 
+    /**
+     * 创建时间
+     */
+    @property()
+    createdTime: string = undefined;
+
     /**
      * 角色描述
      */
@@ -105,9 +111,6 @@ export class Role extends BaseNode {
 
     get tsName() {
         let tsName = this.name;
-        if (/^\d/.test(tsName)) {
-            tsName = '$' + tsName;
-        }
         // 匹配所有特殊字符都转为_
         tsName = tsName.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, '_');
         return tsName;
@@ -132,7 +135,11 @@ export class Role extends BaseNode {
         let code = `namespace ${this.getNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {

package/src/concepts/SqlQueryComponent__.ts

@@ -128,8 +128,8 @@ export class SqlQueryComponent extends LogicItem {
     //================================================================================
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `(function(): nasl.collection.PageOf<`
-        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): 'unknown'}> {\n`;
+        let code = `(function(): nasl.collection.List<`
+        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): '__IDENTIFIER__'}> {\n`;
         code += '\n';
         code += indent(state.tabSize + 1) + 'return;\n';
         code += indent(state.tabSize) + '})();\n';

package/src/concepts/StringLiteral__.ts

@@ -58,53 +58,42 @@ export class StringLiteral extends LogicItem {
     //================================================================================
     toVue(options?: ElementToVueOptions): string {
         let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        if (typeof this.value === 'string') {
+            code = `'${this.value}'`;
+            if (options?.finalCode !== false) {
+                code = `'${this.value.replace(/['"`\\]/g, (m) => {
+                    const escape = '\\\\';
+                    if (m === '\\') {
+                        return `${escape}${escape}`;
+                    } else {
+                        return `${escape}${m}`;
+                    }
+                })}'`;
+            }
         }
         return code;
     }
 
     toUI(): string {
         let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        if (typeof this.value === 'string') {
+            code = `'${this.value}'`;
         }
         return code;
     }
 
     toJS(): string {
-        let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        let code = ``;
+        if (typeof this.value === 'string') {
+            code += `'${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}'`;
         }
         return code;
     }
 
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
+    toEmbeddedTS(state?: TranslatorState, isRequired?: boolean): string {
         let code = '';
-        if (this.value) {
+        if (typeof this.value === 'string') {
             if (!this.value.includes("'"))
                 code += `'${this.value}'`;
             else if (!this.value.includes('"'))
@@ -114,7 +103,7 @@ export class StringLiteral extends LogicItem {
             else
                 code += `'${this.value.replace(/'/g, "\\'")}'`;
         } else {
-            code += '__IDENTIFIER__';
+            code += isRequired ? '__IDENTIFIER__' : `''`;
         }
         return code;
     }

package/src/concepts/StructureProperty__.ts

@@ -2,6 +2,7 @@ import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import EntityProperty from './EntityProperty__';
 import Entity from './Entity__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -226,10 +227,55 @@ export class StructureProperty extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     /**
-     * 自动补全的字段列表
+     * 是否展开
      */
-    completionChildren: Array<EntityProperty | StructureProperty> = undefined;
+    @property()
+    isLeaf: boolean = true;
+
+    getSelectRef() {
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
@@ -261,7 +307,7 @@ export class StructureProperty extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -290,28 +336,7 @@ export class StructureProperty extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
-    }
-
-    getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        const moduleNames = typeNamespace.split('.');
-        let completionChildren;
-        if (typeKind === 'reference') {
-            let type: 'entities' | 'structures';
-            if (typeNamespace.endsWith('entities')) {
-                type = 'entities';
-            } else if (typeNamespace.endsWith('structures')) {
-                // 数据结构比较复杂，会有
-                type = 'structures';
-            }
-            const data = this.app.dependencies.find((item) => item.name === moduleNames[2]);
-            const properties = (data[type] as Array<Entity | Structure>).find((item) => item.name === typeName)?.properties;
-            completionChildren = properties;
-        } else {
-            completionChildren = undefined;
-        }
-        return completionChildren;
+        return !!this.module || (this.parentNode as Structure).origin === 'CallQueryComponent';
     }
 
     //================================================================================

package/src/concepts/Structure__.ts

@@ -39,6 +39,18 @@ export class Structure extends BaseNode {
     @property()
     description: string = undefined;
 
+    /**
+     * 数据结构来源
+     */
+    @property()
+    origin: 'CallQueryComponent' = undefined;
+
+    /**
+     * 编译器信息
+     */
+    @property()
+    compilerInfoMap: { java?: { packageName: string, className: string } } = undefined;
+
     /**
      * 类型参数列表
      */
@@ -113,7 +125,7 @@ export class Structure extends BaseNode {
         });
     }
 
-    getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
         return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -122,24 +134,24 @@ export class Structure extends BaseNode {
     }
 
     /**
-     * 插入类型参数
-     * @internal
-     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入类型参数
+    * @internal
+    * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+    */
     _insertTypeParamAt(name: string, index: number): TypeParam;
 
     /**
-     * 插入类型参数
-     * @internal
-     * @param typeParamOptions 类型参数参数
-     */
+    * 插入类型参数
+    * @internal
+    * @param typeParamOptions 类型参数参数
+    */
     _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
 
     /**
-     * 插入类型参数
-     * @internal
-     * @param typeParam 已有的类型参数实例
-     */
+    * 插入类型参数
+    * @internal
+    * @param typeParam 已有的类型参数实例
+    */
     _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
 
     _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
@@ -157,7 +169,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'typeParams');
         } else if (options instanceof TypeParam) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeParam = options;
             Object.assign(typeParam, relationOptions);
         } else {
@@ -245,7 +257,7 @@ export class Structure extends BaseNode {
 
     addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
         const node = this._addTypeParam(options as any);
-        const index = this.typeParams.length;
+        const index = this.typeParams.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -254,6 +266,7 @@ export class Structure extends BaseNode {
         return node;
     }
 
+
     getPropertyExistingNames(excludedList: Array<StructureProperty> = []) {
         const excludedSet = new Set(excludedList);
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -263,24 +276,24 @@ export class Structure extends BaseNode {
     }
 
     /**
-     * 插入数据结构字段
-     * @internal
-     * @param name 数据结构字段名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入数据结构字段
+    * @internal
+    * @param name 数据结构字段名称，如果不填会自动生成一个唯一名称
+    */
     _insertPropertyAt(name: string, index: number): StructureProperty;
 
     /**
-     * 插入数据结构字段
-     * @internal
-     * @param propertyOptions 数据结构字段参数
-     */
+    * 插入数据结构字段
+    * @internal
+    * @param propertyOptions 数据结构字段参数
+    */
     _insertPropertyAt(propertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
 
     /**
-     * 插入数据结构字段
-     * @internal
-     * @param property 已有的数据结构字段实例
-     */
+    * 插入数据结构字段
+    * @internal
+    * @param property 已有的数据结构字段实例
+    */
     _insertPropertyAt(property: StructureProperty, index: number): StructureProperty;
 
     _insertPropertyAt(options: string | Partial<StructureProperty> | StructureProperty, index: number) {
@@ -298,7 +311,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof StructureProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             property = options;
             Object.assign(property, relationOptions);
         } else {
@@ -386,7 +399,7 @@ export class Structure extends BaseNode {
 
     addProperty(options?: string | Partial<StructureProperty> | StructureProperty) {
         const node = this._addProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -395,10 +408,13 @@ export class Structure extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
-     * 删除类型参数
-     * @param name 类型参数名称
-     */
+    * 删除类型参数
+    * @param name 类型参数名称
+    */
     removeTypeParam(name: string): void;
 
     /**
@@ -443,10 +459,12 @@ export class Structure extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除数据结构字段
-     * @param name 数据结构字段名称
-     */
+    * 删除数据结构字段
+    * @param name 数据结构字段名称
+    */
     removeProperty(name: string): void;
 
     /**
@@ -500,7 +518,7 @@ export class Structure extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
+        return !!this.module || this.origin === 'CallQueryComponent';
     }
     /* 删除空数据模块 */
     deleteLogincAndModule() {
@@ -512,9 +530,9 @@ export class Structure extends BaseNode {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `export class ${this.name} {\n`;
+        let code = `export class ${this.tsName} {\n`;
         code += indent(state.tabSize + 1);
-        code += `__name: '${this.getNamespace()}.${this.name}';\n`;
+        code += `__name: '${this.getTsNamespace()}.${this.tsName}';\n`;
         this.properties.forEach((property) => {
             code += indent(state.tabSize + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
@@ -532,6 +550,18 @@ export class Structure extends BaseNode {
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
+    getTsNamespace() {
+        if (this.parentNode.concept === 'App') {
+            return `${(this.parentNode as Namespace).getNamespace()}.structures`;
+        } else {
+            if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
+                return `${(this.parentNode as Namespace).getTsNamespace()}.structures`;
+            } else {
+                throw new Error('无法获取命名空间，请设置 parentNode！');
+            }
+        }
+    }
+
     /**
      * 生成宿主语言的文件路径
      * @param name 一般不用传，用于 rename
@@ -542,10 +572,14 @@ export class Structure extends BaseNode {
     }
 
     toEmbeddedTSFile() {
-        let code = `namespace ${this.getNamespace()} {\n`;
+        let code = `namespace ${this.getTsNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {
@@ -561,7 +595,7 @@ export class Structure extends BaseNode {
     //================================================================================
 }
 
-classMap.Structure = Structure;
+classMap['Structure'] = Structure;
 export default Structure;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑