@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.3

package/src/concepts/Interface__.ts

@@ -8,6 +8,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import InterfaceParam from './InterfaceParam__';
@@ -163,22 +164,22 @@ export class Interface extends BaseNode {
             interfaceParam = InterfaceParam.from({
                 ...interfaceParamOptions,
                 name: this.getInterfaceParamUniqueName(),
-            }, this);
+            }, this, 'params');
         } else if (typeof options === 'string') {
             interfaceParam = InterfaceParam.from({
                 ...interfaceParamOptions,
                 name: options,
-            }, this);
+            }, this, 'params');
         } else if (options instanceof InterfaceParam) {
             options.delete(); // 同一实例不支持多处存在
             interfaceParam = options;
+            Object.assign(interfaceParam, relationOptions);
         } else {
             interfaceParam = InterfaceParam.from({
                 ...interfaceParamOptions,
                 ...options,
-            }, this);
+            }, this, 'params');
         }
-        Object.assign(interfaceParam, relationOptions);
         this.params.splice(index, 0, interfaceParam);
         return interfaceParam;
     }
@@ -301,22 +302,22 @@ export class Interface extends BaseNode {
             ret = Return.from({
                 ...retOptions,
                 name: this.getReturnUniqueName(),
-            }, this);
+            }, this, 'returns');
         } else if (typeof options === 'string') {
             ret = Return.from({
                 ...retOptions,
                 name: options,
-            }, this);
+            }, this, 'returns');
         } else if (options instanceof Return) {
             options.delete(); // 同一实例不支持多处存在
             ret = options;
+            Object.assign(ret, relationOptions);
         } else {
             ret = Return.from({
                 ...retOptions,
                 ...options,
-            }, this);
+            }, this, 'returns');
         }
-        Object.assign(ret, relationOptions);
         this.returns.splice(index, 0, ret);
         return ret;
     }
@@ -514,10 +515,22 @@ export class Interface extends BaseNode {
     /**
      * 是否可编辑
      * */
-    get nodeReadonly() {
+    get readonly() {
         return !!this.module;
     }
 
+    /**
+     * 设置逻辑名称
+     */
+    setOriginLogicName(originLogicName: string) {
+        const object = {
+            originLogicName,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
     toEmbeddedTSFile() {
         let code = `namespace ${this.getNamespace()} {\n`;
 
@@ -541,12 +554,14 @@ export class Interface extends BaseNode {
      * @param name 一般不用传，用于 rename
      */
     getEmbeddedFilePath(name = this.name) {
-        return `/embedded/${this.app.name}/interfaces/${name}.ts`;
+        const _path = this.module ? `/${this.module.parentKey}/${this.module.name}` : '';
+        return `/embedded/${this.app.name}${_path}/interfaces/${name}.ts`;
     }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `export function ${this.name}(`;
+        let code = '';
+        code += `export function ${this.name}(`;
         this.params.forEach((param, index) => {
             if (index === 0) {
                 code += '{';
@@ -575,10 +590,13 @@ export class Interface extends BaseNode {
                 code += ret.typeAnnotation.toEmbeddedTS(shiftState(state, code));
             });
             code += '{\n';
+            code += 'let logic =' + (this.parentNode as Namespace).getNamespace() + '.logics.' + this.originLogicName + '\n';
             code += `return new ${this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code))}();`;
             code += '\n }';
         } else {
-            code += 'void {};';
+            code += 'void {';
+            code += 'let logic =' + (this.parentNode as Namespace).getNamespace() + '.logics.' + this.originLogicName + '\n';
+            code += '};';
         }
         code += '\n';
         return code;

package/src/concepts/JSBlock__.ts

@@ -7,6 +7,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -22,12 +23,6 @@ export class JSBlock extends LogicItem {
     @property()
     concept: 'JSBlock' = 'JSBlock';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Expression';
-
     /**
      * JS 代码块标题
      */
@@ -77,17 +72,6 @@ export class JSBlock extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
-    toUI(state?: TranslatorState): string {
-        /**
-         * 生成 JS 脚本
-         */
-        return `const jsBlock_number = async () => {
-            ${this.code}
-        }
-    
-        await jsBlock_number();`;
-    }
-
     toJS(state?: TranslatorState): string {
         /**
          * 生成 JS 脚本

package/src/concepts/LogicItem__.ts

@@ -1,5 +1,6 @@
 import { TranslatorState } from '../translator';
 import CallFunction from './CallFunction__';
+import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -9,6 +10,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Logic from './Logic__';
@@ -42,10 +44,10 @@ export class LogicItem extends BaseNode {
     description: string = undefined;
 
     /**
-     * 是否展开
+     * 是否折叠
      */
     @property()
-    folded: boolean = true;
+    folded: boolean = false;
 
     /**
      * offsetX
@@ -145,7 +147,7 @@ export class LogicItem extends BaseNode {
     }
 
     /**
-     * 设置是否展开
+     * 设置是否折叠
      */
     setFolded(folded: boolean) {
         const object = {
@@ -187,7 +189,11 @@ export class LogicItem extends BaseNode {
         return '[编译方法未实现]';
     }
 
-    toUI(state?: TranslatorState): string {
+    toVue(options?: ElementToVueOptions) {
+        return '[编译方法未实现]';
+    }
+
+    toUI(state?: TranslatorState, isLast?: boolean): string {
         return '[编译方法未实现]';
     }
 

package/src/concepts/Logic__.ts

@@ -1,6 +1,8 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
 import Namespace from './Namespace__';
 import CallQueryComponent from './CallQueryComponent__';
+import pluralize = require('pluralize');
+import { kebabCase } from 'lodash';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -9,6 +11,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Transactional from './Transactional__';
@@ -188,7 +191,7 @@ export class Logic extends BaseNode {
 
         getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
-        return this.typeParams.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getTypeParamUniqueName(name = 'typeParam1') {
         return utils.unique(name, this.getTypeParamExistingNames());
@@ -223,22 +226,22 @@ export class Logic extends BaseNode {
             typeParam = TypeParam.from({
                 ...typeParamOptions,
                 name: this.getTypeParamUniqueName(),
-            }, this);
+            }, this, 'typeParams');
         } else if (typeof options === 'string') {
             typeParam = TypeParam.from({
                 ...typeParamOptions,
                 name: options,
-            }, this);
+            }, this, 'typeParams');
         } else if (options instanceof TypeParam) {
             options.delete(); // 同一实例不支持多处存在
             typeParam = options;
+            Object.assign(typeParam, relationOptions);
         } else {
             typeParam = TypeParam.from({
                 ...typeParamOptions,
                 ...options,
-            }, this);
+            }, this, 'typeParams');
         }
-        Object.assign(typeParam, relationOptions);
         this.typeParams.splice(index, 0, typeParam);
         return typeParam;
     }
@@ -361,22 +364,22 @@ export class Logic extends BaseNode {
             param = Param.from({
                 ...paramOptions,
                 name: this.getParamUniqueName(),
-            }, this);
+            }, this, 'params');
         } else if (typeof options === 'string') {
             param = Param.from({
                 ...paramOptions,
                 name: options,
-            }, this);
+            }, this, 'params');
         } else if (options instanceof Param) {
             options.delete(); // 同一实例不支持多处存在
             param = options;
+            Object.assign(param, relationOptions);
         } else {
             param = Param.from({
                 ...paramOptions,
                 ...options,
-            }, this);
+            }, this, 'params');
         }
-        Object.assign(param, relationOptions);
         this.params.splice(index, 0, param);
         return param;
     }
@@ -499,22 +502,22 @@ export class Logic extends BaseNode {
             ret = Return.from({
                 ...retOptions,
                 name: this.getReturnUniqueName(),
-            }, this);
+            }, this, 'returns');
         } else if (typeof options === 'string') {
             ret = Return.from({
                 ...retOptions,
                 name: options,
-            }, this);
+            }, this, 'returns');
         } else if (options instanceof Return) {
             options.delete(); // 同一实例不支持多处存在
             ret = options;
+            Object.assign(ret, relationOptions);
         } else {
             ret = Return.from({
                 ...retOptions,
                 ...options,
-            }, this);
+            }, this, 'returns');
         }
-        Object.assign(ret, relationOptions);
         this.returns.splice(index, 0, ret);
         return ret;
     }
@@ -637,22 +640,22 @@ export class Logic extends BaseNode {
             variable = Variable.from({
                 ...variableOptions,
                 name: this.getVariableUniqueName(),
-            }, this);
+            }, this, 'variables');
         } else if (typeof options === 'string') {
             variable = Variable.from({
                 ...variableOptions,
                 name: options,
-            }, this);
+            }, this, 'variables');
         } else if (options instanceof Variable) {
             options.delete(); // 同一实例不支持多处存在
             variable = options;
+            Object.assign(variable, relationOptions);
         } else {
             variable = Variable.from({
                 ...variableOptions,
                 ...options,
-            }, this);
+            }, this, 'variables');
         }
-        Object.assign(variable, relationOptions);
         this.variables.splice(index, 0, variable);
         return variable;
     }
@@ -767,13 +770,13 @@ export class Logic extends BaseNode {
         if (options instanceof LogicItem) {
             options.delete(); // 同一实例不支持多处存在
             logicItem = options;
+            Object.assign(logicItem, relationOptions);
         } else {
             logicItem = LogicItem.from({
                 ...logicItemOptions,
                 ...options,
-            }, this);
+            }, this, 'body');
         }
-        Object.assign(logicItem, relationOptions);
         this.body.splice(index, 0, logicItem);
         return logicItem;
     }
@@ -871,13 +874,13 @@ export class Logic extends BaseNode {
         if (options instanceof LogicItem) {
             options.delete(); // 同一实例不支持多处存在
             logicItem = options;
+            Object.assign(logicItem, relationOptions);
         } else {
             logicItem = LogicItem.from({
                 ...logicItemOptions,
                 ...options,
-            }, this);
+            }, this, 'playground');
         }
-        Object.assign(logicItem, relationOptions);
         this.playground.splice(index, 0, logicItem);
         return logicItem;
     }
@@ -1280,51 +1283,25 @@ export class Logic extends BaseNode {
         return [...this.params, ...this.returns, ...this.variables].filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
 
-    toUI(state?: TranslatorState): string {
-        let code = `function ${this.name}(`;
-
-        this.params.forEach((param, index) => {
-            code += param.toUI(shiftState(state, code, { inline: true }));
-            if (index !== this.params.length - 1)
-                code += ', ';
-        });
-        code += `) {\n`;
-
-        this.variables.forEach((variable) => {
-            code += indent(state.tabSize + 1) + 'let ';
-            code += variable.toUI(shiftState(state, code, { inline: true }));
-            code += ';\n';
-        });
-
-        this.returns.forEach((ret) => {
-            code += indent(state.tabSize + 1) + 'let ';
-            code += ret.toUI(shiftState(state, code, { inline: true }));
-            code += ';\n';
-        });
-
-        if (!this.body.length && this.returns.length) {
-            code += indent(state.tabSize + 1) + `return ${this.returns[0].name};\n`;
-        } else {
-            this.body.forEach((item) => {
-                code += item.toUI && item.toUI(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-                code += '\n';
-            });
-        }
-
-        code += indent(state.tabSize) + '}\n';
-        return code;
-    }
-
     toJS(state?: TranslatorState): string {
         let code = `methods['${this.name}'] = async function (`;
         if (Array.isArray(this.params)) {
             this.params.forEach((param, index) => {
-                code += param.toJS(shiftState(state, code, { inline: true }));
+                code += param.name;
                 if (index !== this.params.length - 1)
                     code += ', ';
             });
         }
         code += `) {\n`;
+        // params
+        if (Array.isArray(this.params)) {
+            this.params.forEach((param) => {
+                code += indent(state.tabSize + 1) + '';
+                code += param.toJS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            });
+        }
+        // variables
         if (Array.isArray(this.variables)) {
             this.variables.forEach((variable) => {
                 code += indent(state.tabSize + 1) + 'let ';
@@ -1332,6 +1309,8 @@ export class Logic extends BaseNode {
                 code += ';\n';
             });
         }
+
+        // returns
         if (Array.isArray(this.returns)) {
             this.returns.forEach((ret) => {
                 code += indent(state.tabSize + 1) + 'let ';
@@ -1339,18 +1318,80 @@ export class Logic extends BaseNode {
                 code += ';\n';
             });
         }
-        if (!this.body.length && this.returns.length) {
-            code += indent(state.tabSize + 1) + `return ${this.returns[0].name};\n`;
-        } else {
+        if (Array.isArray(this.body)) {
             this.body.forEach((item) => {
                 code += item.toJS && item.toJS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
                 code += '\n';
             });
         }
+
+        if (Array.isArray(this.returns) && this.returns.length) {
+            code += `return ${this.returns[0].name};\n`;
+        }
+
         code += indent(state.tabSize) + '}\n';
+
         return code;
     }
 
+    toService() {
+        const parentNode = this.parentNode;
+        const { concept, name: entityName } = parentNode || {};
+        const logicName = this.name;
+        let serviceType = 'micro';
+        let method = 'POST';
+        let path = `/api/${logicName}`;
+        if (concept === 'Namespace') {
+            serviceType = 'entity';
+            const pluralized = pluralize(entityName);
+            path = `/api/${pluralized.toLowerCase()}`;
+            switch (this.name) {
+                case 'get':
+                    method = 'GET';
+                    path = `/api/${pluralized.toLowerCase()}/{id}`;
+                    break;
+                case 'create':
+                    method = 'POST';
+                    break;
+                case 'update':
+                    method = 'PUT';
+                    break;
+                case 'delete':
+                    method = 'DELETE';
+                    path = `/api/${pluralized.toLowerCase()}/{id}`;
+                    break;
+                case 'batchCreate':
+                    method = 'POST';
+                    path = `/api/${pluralized.toLowerCase()}/batch`;
+                    break;
+                case 'batchUpdate':
+                    method = 'PUT';
+                    path = `/api/${pluralized.toLowerCase()}/batch`;
+                    break;
+                case 'batchDelete':
+                    method = 'DELETE';
+                    path = `/api/${pluralized.toLowerCase()}/batch`;
+                    break;
+                case 'import':
+                    method = 'POST';
+                    path = `/api/${pluralized.toLowerCase()}/import`;
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        return {
+            config: {
+                serviceType,
+            },
+            url: {
+                method,
+                path,
+            },
+        };
+    }
+
     toEmbeddedTSNoExport(state?: TranslatorState): string {
         return this.toEmbeddedTS(state, 'noExport');
     }
@@ -1358,8 +1399,14 @@ export class Logic extends BaseNode {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState, prefix?: string): string {
         // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
-        const funcPrefix = prefix === 'noExport' ? '' : 'export';
-        let code = `${funcPrefix} function ${this.name}(`;
+        let code = '';
+        if (!prefix) {
+            code += `export function ${this.name}(`;
+        } else if (prefix === 'noExport') {
+            code += ` function ${this.name}(`;
+        } else if (prefix === 'inObject') {
+            code += ` ${this.name}(`;
+        }
         this.params.forEach((param, index) => {
             code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
             if (index !== this.params.length - 1)
@@ -1394,19 +1441,25 @@ export class Logic extends BaseNode {
             code += '\n';
         });
 
-        code += indent(state.tabSize) + '}\n';
+        code += indent(state.tabSize) + '}';
+        if (prefix === 'inObject') {
+            code += `,`;
+        }
+        code += '\n';
         return code;
     }
 
     getNamespace(): string {
         if (this.parentNode) {
             let parentNodeNamespace = '';
-            if ((this.parentNode as Namespace).getNamespace) {
-                parentNodeNamespace = (this.parentNode as Namespace).getNamespace();
-            } else if ((this.parentNode as View).getNamespace) {
-                parentNodeNamespace = `${(this.parentNode as View).getNamespace()}.${this.parentNode.name}`;
+            if (this.parentNode instanceof Namespace || this.parentNode instanceof App || this.parentNode instanceof Module) {
+                parentNodeNamespace = this.parentNode.getNamespace();
             }
-            return parentNodeNamespace.includes('.logics.') ? parentNodeNamespace : `${parentNodeNamespace}.logics`;
+            parentNodeNamespace = parentNodeNamespace.includes('.logics') ? parentNodeNamespace : `${parentNodeNamespace}.logics`;
+            if (this.parentNode instanceof View) {
+                return (parentNodeNamespace = '');
+            }
+            return parentNodeNamespace;
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
@@ -1416,11 +1469,8 @@ export class Logic extends BaseNode {
      * @param name 一般不用传，用于 rename
      */
     getEmbeddedFilePath(name = this.name) {
-        return `/embedded/${this.app.name}/logics/${name}.ts`;
-    }
-
-    get calleeKey(): string {
-        return `${this.getNamespace()}.${this.name}`;
+        const _path = this.module ? `/${this.module.parentKey}/${this.module.name}` : '';
+        return `/embedded/${this.app.name}${_path}/logics/${name}.ts`;
     }
 
     toEmbeddedTSFile() {

package/src/concepts/MemberExpression__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -8,6 +9,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -23,12 +25,6 @@ export class MemberExpression extends LogicItem {
     @property()
     concept: 'MemberExpression' = 'MemberExpression';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Expression';
-
     /**
      * 逻辑项
      */
@@ -143,20 +139,21 @@ export class MemberExpression extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
-    /**
-     * object的替代品(用object值会丢失)
-     */
-    @property('LogicItem')
-    objectqwer: LogicItem = undefined;
+    toVue(options?: ElementToVueOptions) {
+        const object: string = this.object.toVue(options);
+        const property = this.property.toVue(options);
+        const lastPart = object.split(' && ').pop();
+        return options?.finalCode === false ? `${object}.${property}` : `${object} && ${lastPart}.${property}`;
+    }
 
-    toUI(state?: TranslatorState): string {
-        const object: string = this.objectqwer.toUI();
+    toUI(): string {
+        const object: string = this.object.toUI();
         const property = this.property.toUI();
         return `${object}.${property}`;
     }
 
-    toJS(state?: TranslatorState): string {
-        const object: string = this.objectqwer.toJS();
+    toJS(): string {
+        const object: string = this.object.toJS();
         const property = this.property.toJS();
         const lastPart = object.split(' && ').pop();
         return `${object} && ${lastPart}.${property}`;
@@ -168,12 +165,12 @@ export class MemberExpression extends LogicItem {
         let arrIndex = 0;
 
         let current: any = this;
-        while (current.objectqwer) {
+        while (current.object) {
             if (current.property.name !== newValueList[arrIndex]) {
                 current.property.setName(newValueList[arrIndex]);
                 return;
             }
-            current = current.objectqwer;
+            current = current.object;
             arrIndex++;
         }
         // 前面没有找到，到这里就是最后一项的值要修改
@@ -201,10 +198,10 @@ export class MemberExpression extends LogicItem {
         let value: string = '';
         // MemberExpression 有两个属性object代表父级，property代表自己
         // 先向上找父级的值在获取自己的值进行拼接
-        while (current.objectqwer) {
+        while (current.object) {
             const currentValue = current.property.name;
             value = value ? currentValue + '.' + value : currentValue;
-            current = current.objectqwer;
+            current = current.object;
         }
 
         // 最后一个是Identifier,他的值是自己的name
@@ -221,7 +218,7 @@ export class MemberExpression extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
-        code += this.objectqwer ? this.objectqwer.toEmbeddedTS(shiftState(state, code, { inline: true })) + '.' : '';
+        code += this.object ? this.object.toEmbeddedTS(shiftState(state, code, { inline: true })) + '.' : '';
         code += this.property ? this.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
         return code;
     }