@lcap/nasl 1.0.0 → 2.12.0-beta

package/src/concepts/App__.ts

@@ -14,7 +14,7 @@ import * as utils from '../utils';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
-import Entity from './Entity__';
+import DataSource from './DataSource__';
 import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
@@ -110,10 +110,10 @@ export class App extends BaseNode {
     hasAuth: boolean = undefined;
 
     /**
-     * 实体列表
+     * 数据源列表
      */
-    @property('Entity')
-    entities: Array<Entity> = [];
+    @property('DataSource')
+    dataSources: Array<DataSource> = [];
 
     /**
      * 数据结构列表
@@ -237,143 +237,143 @@ export class App extends BaseNode {
         });
     }
 
-        getEntityExistingNames(excludedList: Array<Entity> = []) {
+        getDataSourceExistingNames(excludedList: Array<DataSource> = []) {
         const excludedSet = new Set(excludedList);
-        return (this.entities || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.dataSources || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
-    getEntityUniqueName(name = 'Entity1') {
-        return utils.unique(name, this.getEntityExistingNames());
+    getDataSourceUniqueName(name = 'DataSource1') {
+        return utils.unique(name, this.getDataSourceExistingNames(), undefined, true);
     }
 
     /**
-    * 插入实体
+    * 插入数据源
     * @internal
-    * @param name 实体名称，如果不填会自动生成一个唯一名称
+    * @param name 数据源名称，如果不填会自动生成一个唯一名称
     */
-    _insertEntityAt(name: string, index: number): Entity;
+    _insertDataSourceAt(name: string, index: number): DataSource;
 
     /**
-    * 插入实体
+    * 插入数据源
     * @internal
-    * @param entityOptions 实体参数
+    * @param dataSourceOptions 数据源参数
     */
-    _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+    _insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
 
     /**
-    * 插入实体
+    * 插入数据源
     * @internal
-    * @param entity 已有的实体实例
+    * @param dataSource 已有的数据源实例
     */
-    _insertEntityAt(entity: Entity, index: number): Entity;
+    _insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
 
-    _insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
-        const entityOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'entities' };
-        let entity: Entity;
+    _insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
+        const dataSourceOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'dataSources' };
+        let dataSource: DataSource;
         if (!options) {
-            entity = Entity.from({
-                ...entityOptions,
-                name: this.getEntityUniqueName(),
-            }, this, 'entities');
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                name: this.getDataSourceUniqueName(),
+            }, this, 'dataSources');
         } else if (typeof options === 'string') {
-            entity = Entity.from({
-                ...entityOptions,
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
                 name: options,
-            }, this, 'entities');
-        } else if (options instanceof Entity) {
+            }, this, 'dataSources');
+        } else if (options instanceof DataSource) {
             options.ensureDelete(); // 同一实例不支持多处存在
-            entity = options;
-            Object.assign(entity, relationOptions);
+            dataSource = options;
+            Object.assign(dataSource, relationOptions);
         } else {
-            entity = Entity.from({
-                ...entityOptions,
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
                 ...options,
-            }, this, 'entities');
+            }, this, 'dataSources');
         }
-        this.entities.splice(index, 0, entity);
-        return entity;
+        this.dataSources.splice(index, 0, dataSource);
+        return dataSource;
     }
 
     /**
-     * 插入实体
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     * 插入数据源
+     * @param name 数据源名称，如果不填会自动生成一个唯一名称
      */
-    insertEntityAt(name: string, index: number): Entity;
+    insertDataSourceAt(name: string, index: number): DataSource;
 
     /**
-     * 插入实体
-     * @param entityOptions 实体参数
+     * 插入数据源
+     * @param dataSourceOptions 数据源参数
      */
-    insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+    insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
 
     /**
-     * 插入实体
-     * @param entity 已有的实体实例
+     * 插入数据源
+     * @param dataSource 已有的数据源实例
      */
-    insertEntityAt(entity: Entity, index: number): Entity;
+    insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
 
-    insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
-        const node = this._insertEntityAt(options as any, index);
+    insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
+        const node = this._insertDataSourceAt(options as any, index);
         node.create({
             index,
             parentNode: this,
-            parentKey: 'entities',
+            parentKey: 'dataSources',
         });
         return node;
     }
 
     /**
-     * 添加实体
+     * 添加数据源
      * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     * @param name 数据源名称，如果不填会自动生成一个唯一名称
      */
-    _addEntity(name?: string): Entity;
+    _addDataSource(name?: string): DataSource;
 
     /**
-     * 添加实体
+     * 添加数据源
      * @internal
-     * @param entityOptions 实体参数
+     * @param dataSourceOptions 数据源参数
      */
-    _addEntity(entityOptions: Partial<Entity>): Entity;
+    _addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
 
     /**
-     * 添加实体
+     * 添加数据源
      * @internal
-     * @param entity 已有的实体实例
+     * @param dataSource 已有的数据源实例
      */
-    _addEntity(entity: Entity): Entity;
+    _addDataSource(dataSource: DataSource): DataSource;
 
-    _addEntity(options?: string | Partial<Entity> | Entity) {
-        const index = 0;
-        return this._insertEntityAt(options as any, index);
+    _addDataSource(options?: string | Partial<DataSource> | DataSource) {
+        const index = this.dataSources.length;
+        return this._insertDataSourceAt(options as any, index);
     }
 
     /**
-     * 添加实体
+     * 添加数据源
      * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     * @param name 数据源名称，如果不填会自动生成一个唯一名称
      */
-    addEntity(name?: string): Entity;
+    addDataSource(name?: string): DataSource;
 
     /**
-     * 添加实体
-     * @param entityOptions 实体参数
+     * 添加数据源
+     * @param dataSourceOptions 数据源参数
      */
-    addEntity(entityOptions: Partial<Entity>): Entity;
+    addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
 
     /**
-     * 添加实体
-     * @param entity 已有的实体实例
+     * 添加数据源
+     * @param dataSource 已有的数据源实例
      */
-    addEntity(entity: Entity): Entity;
+    addDataSource(dataSource: DataSource): DataSource;
 
-    addEntity(options?: string | Partial<Entity> | Entity) {
-        const node = this._addEntity(options as any);
-        const index = this.entities.indexOf(node);
+    addDataSource(options?: string | Partial<DataSource> | DataSource) {
+        const node = this._addDataSource(options as any);
+        const index = this.dataSources.indexOf(node);
         node.create({
             index,
             parentNode: this,
-            parentKey: 'entities',
+            parentKey: 'dataSources',
         });
         return node;
     }
@@ -384,7 +384,7 @@ export class App extends BaseNode {
         return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getStructureUniqueName(name = 'Structure1') {
-        return utils.unique(name, this.getStructureExistingNames());
+        return utils.unique(name, this.getStructureExistingNames(), undefined, true);
     }
 
     /**
@@ -526,7 +526,7 @@ export class App extends BaseNode {
         return (this.enums || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getEnumUniqueName(name = 'Enum1') {
-        return utils.unique(name, this.getEnumExistingNames());
+        return utils.unique(name, this.getEnumExistingNames(), undefined, true);
     }
 
     /**
@@ -668,7 +668,7 @@ export class App extends BaseNode {
         return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getLogicUniqueName(name = 'logic1') {
-        return utils.unique(name, this.getLogicExistingNames());
+        return utils.unique(name, this.getLogicExistingNames(), undefined, true);
     }
 
     /**
@@ -810,7 +810,7 @@ export class App extends BaseNode {
         return (this.interfaces || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getInterfaceUniqueName(name = 'Interface1') {
-        return utils.unique(name, this.getInterfaceExistingNames());
+        return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
     }
 
     /**
@@ -952,7 +952,7 @@ export class App extends BaseNode {
         return (this.views || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getViewUniqueName(name = 'view1') {
-        return utils.unique(name, this.getViewExistingNames());
+        return utils.unique(name, this.getViewExistingNames(), undefined, true);
     }
 
     /**
@@ -1094,7 +1094,7 @@ export class App extends BaseNode {
         return (this.processes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getProcessUniqueName(name = 'Process1') {
-        return utils.unique(name, this.getProcessExistingNames());
+        return utils.unique(name, this.getProcessExistingNames(), undefined, true);
     }
 
     /**
@@ -1236,7 +1236,7 @@ export class App extends BaseNode {
         return (this.roles || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getRoleUniqueName(name = 'role1') {
-        return utils.unique(name, this.getRoleExistingNames());
+        return utils.unique(name, this.getRoleExistingNames(), undefined, true);
     }
 
     /**
@@ -1378,7 +1378,7 @@ export class App extends BaseNode {
         return (this.dependencies || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getModuleUniqueName(name = 'module1') {
-        return utils.unique(name, this.getModuleExistingNames());
+        return utils.unique(name, this.getModuleExistingNames(), undefined, false);
     }
 
     /**
@@ -1784,46 +1784,46 @@ export class App extends BaseNode {
     
 
     /**
-    * 删除实体
-    * @param name 实体名称
+    * 删除数据源
+    * @param name 数据源名称
     */
-    removeEntity(name: string): void;
+    removeDataSource(name: string): void;
 
     /**
-     * 删除实体
-     * @param entity 已有的实体实例
+     * 删除数据源
+     * @param dataSource 已有的数据源实例
      */
-    removeEntity(entity: Entity): void;
+    removeDataSource(dataSource: DataSource): void;
 
-    removeEntity(options: string | Entity) {
-        let entity: Entity;
+    removeDataSource(options: string | DataSource) {
+        let dataSource: DataSource;
         if (typeof options === 'string') {
-            entity = this.entities.find((item) => item.name === options);
-            if (!entity) {
-                throw new Error('找不到实体 ' + options);
+            dataSource = this.dataSources.find((item) => item.name === options);
+            if (!dataSource) {
+                throw new Error('找不到数据源 ' + options);
             }
         } else {
-            entity = options;
+            dataSource = options;
         }
-        return entity.delete();
+        return dataSource.delete();
     }
 
-    __removeEntity(entity: Entity) {
-        const parentKey = entity.parentKey;
+    __removeDataSource(dataSource: DataSource) {
+        const parentKey = dataSource.parentKey;
         const params: Params = {
             parentNode: this,
             parentKey,
             index: -1,
             object: null,
-            oldObject: entity,
+            oldObject: dataSource,
         };
         if (parentKey) {
             params.parentKey = parentKey;
             if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(entity);
+                const index = (this as any)[parentKey].indexOf(dataSource);
                 ~index && (this as any)[parentKey].splice(index, 1);
                 params.index = index;
-            } else if ((this as any)[parentKey] === entity) {
+            } else if ((this as any)[parentKey] === dataSource) {
                 params.index = 0;
                 (this as any)[parentKey] = undefined;
             }
@@ -2393,8 +2393,12 @@ export class App extends BaseNode {
         return this.componentDependencies.find((componentDependency) => componentDependency.name === name);
     }
 
-    findEntityByName(name: string) {
-        return this.entities.find((entity) => entity.name === name);
+    findDataSourceByName(name: string) {
+        return this.dataSources.find((dataSourceItem) => dataSourceItem.name === name);
+    }
+
+    get defaultDS() {
+        return this.dataSources?.find((dataSource) => dataSource.name === 'defaultDS');
     }
 
     findEnumByName(name: string) {
@@ -2467,6 +2471,10 @@ export class App extends BaseNode {
      * 获取命名空间
      */
     getNamespace() {
+        return 'app';
+    }
+
+    getTsNamespace() {
         return `app`;
     }
 
@@ -2494,6 +2502,35 @@ export class App extends BaseNode {
         return node;
     }
 
+    findNodeByCompleteName(completeName: string) {
+        const nameArr = completeName?.split('.') || [];
+        const start = nameArr.shift();
+        let node: any = this;
+        const mod = 0;
+        const modulesMap: any = {
+            extensions: node.dependencies,
+            apis: node.interfaceDependencies,
+        };
+        const modules = modulesMap[start];
+        if (Array.isArray(modules)) {
+            const moduleName = nameArr.shift();
+            node = modules.find((moduleItem) => moduleItem.name === moduleName);
+        }
+        for (let index = 0; index < nameArr.length; index++) {
+            if (!node) {
+                return null;
+            }
+            const nameItem = nameArr[index];
+            const isKeyword = index % 2 === mod;
+            if (!isKeyword && Array.isArray(node)) {
+                node = node.find(({ name }) => name === nameItem);
+            } else {
+                node = node[nameItem];
+            }
+        }
+        return node;
+    }
+
     /**
      * @param path 路径
      * path 为要查找路径：如 /dashboard/student/list、/dashboard/student/list

package/src/concepts/Argument__.ts

@@ -209,7 +209,7 @@ export class Argument extends LogicItem {
     //================================================================================
 }
 
-classMap['Argument'] = Argument;
+classMap.Argument = Argument;
 export default Argument;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Assignee__.ts

@@ -1,3 +1,6 @@
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+import { ProcessElement, Process,  } from '..';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -71,7 +74,7 @@ export class Assignee extends LogicItem {
         return (this.dynamicUsers || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getLogicItemUniqueName(name = 'logicItem1') {
-        return utils.unique(name, this.getLogicItemExistingNames());
+        return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
     }
 
     /**
@@ -422,14 +425,41 @@ export class Assignee extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    /**
+     * 祖先 ProcessElement
+     */
+        get processElement() {
+        return this.getAncestor('ProcessElement') as ProcessElement;
+    }
+    /**
+     * 祖先 Process
+     */
+    get process() {
+        return this.getAncestor('Process') as Process;
+    }
 
+    @withSourceMap()
+    toEmbeddedTSInProcess(state: TranslatorState, prevCode: string): string {
+        // const tab = indent(state.tabSize);
+        // let code = `const plainuser = [];\n`
+        // code += `const dynamicuser = [];\n`
+        let code = prevCode;
+        code += `return nasl.util.concatString(`;
+        this.dynamicUsers.forEach(u => {
+            code += u.toEmbeddedTS(shiftState(state, code));
+            code += ',\n';
+        })
+        code += ')\n';
+        // code += `${this.dynamicUsers.map(u => u.toEmbeddedTS(shiftState(state, code))).join(',\n')})\n`;
+        return code;
+}
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
     //================================================================================
 }
 
-classMap['Assignee'] = Assignee;
+classMap.Assignee = Assignee;
 export default Assignee;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Assignment__.ts

@@ -231,7 +231,7 @@ export class Assignment extends LogicItem {
     //================================================================================
 }
 
-classMap['Assignment'] = Assignment;
+classMap.Assignment = Assignment;
 export default Assignment;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Attribute__.ts

@@ -244,7 +244,7 @@ export class Attribute extends BaseNode {
     //================================================================================
 }
 
-classMap['Attribute'] = Attribute;
+classMap.Attribute = Attribute;
 export default Attribute;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/BinaryExpression__.ts

@@ -281,7 +281,7 @@ export class BinaryExpression extends LogicItem {
     //================================================================================
 }
 
-classMap['BinaryExpression'] = BinaryExpression;
+classMap.BinaryExpression = BinaryExpression;
 export default BinaryExpression;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/BindAttribute__.ts

@@ -223,7 +223,7 @@ export class BindAttribute extends BaseNode {
         return (this.rules || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getValidationRuleUniqueName(name = 'validationRule1') {
-        return utils.unique(name, this.getValidationRuleExistingNames());
+        return utils.unique(name, this.getValidationRuleExistingNames(), undefined, false);
     }
 
     /**
@@ -548,9 +548,9 @@ export class BindAttribute extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
         if (this.name === 'destination') {
-            code += this.destination.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            code += this.destination.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
         } else if (this.expression) {
-            code += this.expression.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            code += this.expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
         }
         return code;
     }
@@ -560,7 +560,7 @@ export class BindAttribute extends BaseNode {
     //================================================================================
 }
 
-classMap['BindAttribute'] = BindAttribute;
+classMap.BindAttribute = BindAttribute;
 export default BindAttribute;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/BindDirective__.ts

@@ -218,7 +218,7 @@ export class BindDirective extends BaseNode {
         if (this.expression) {
             value = this.expression.toVue(options);
             if (this.expression.concept === 'StringLiteral') {
-                value = `'${value}'`;
+                value = `${value}`;
             }
             value = value?.replace(/"/g, "'");
         }
@@ -253,7 +253,7 @@ export class BindDirective extends BaseNode {
     //================================================================================
 }
 
-classMap['BindDirective'] = BindDirective;
+classMap.BindDirective = BindDirective;
 export default BindDirective;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/BindEvent__.ts

@@ -339,10 +339,10 @@ export class BindEvent extends BaseNode {
                 return `${this.calleeKey}();`;
             }
             let code = `${this.toHump(this.name) || '__IDENTIFIER__'}: (event) => [\n`;
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += `() => {${this.calleeKey}()}`;
             code += '\n';
-            code += indent(state.tabSize);
+            code += indent((state?.tabSize || 0));
             code += '],\n';
             return code;
         }
@@ -354,10 +354,10 @@ export class BindEvent extends BaseNode {
     //     let code = '';
     //     if (this.name) {
     //         code = `function ${this.name || '__IDENTIFIER__'} () {\n`;
-    //         code += indent(state.tabSize + 1);
+    //         code += indent((state?.tabSize || 0) + 1);
     //         code += `${this.calleeKey}()`;
     //         code += '\n';
-    //         code += indent(state.tabSize);
+    //         code += indent((state?.tabSize || 0));
     //         code += '};\n';
     //     }
     //     return code;
@@ -367,8 +367,12 @@ export class BindEvent extends BaseNode {
      * 设置callee
      */
     setCallee(logic: Logic) {
+        let calleeNamespace = logic.getNamespace();
+        if (logic.parentNode instanceof View) {
+            calleeNamespace = '';
+        }
         const object = {
-            calleeNamespace: logic.getNamespace(),
+            calleeNamespace,
             calleeName: logic.name,
         };
         this.update({
@@ -436,7 +440,7 @@ export class BindEvent extends BaseNode {
     //================================================================================
 }
 
-classMap['BindEvent'] = BindEvent;
+classMap.BindEvent = BindEvent;
 export default BindEvent;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/BooleanLiteral__.ts

@@ -82,7 +82,7 @@ export class BooleanLiteral extends LogicItem {
     //================================================================================
 }
 
-classMap['BooleanLiteral'] = BooleanLiteral;
+classMap.BooleanLiteral = BooleanLiteral;
 export default BooleanLiteral;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑