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

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__';
@@ -26,7 +29,7 @@ import Process from './Process__';
 /**
  * 逻辑
  */
-@concept
+@concept('逻辑')
 export class Logic extends BaseNode {
     /**
      * 产品概念
@@ -186,9 +189,48 @@ export class Logic extends BaseNode {
         });
     }
 
+    /**
+     * 设置triggerType
+     */
+    setTriggerType(triggerType: string) {
+        const object = {
+            triggerType,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置cron
+     */
+    setCron(cron: string) {
+        const object = {
+            cron,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置事务
+     */
+    setTransactional(transactional: Transactional) {
+        transactional._delete();
+        const relationOptions = { parentNode: this, parentKey: 'transactional' };
+        Object.assign(transactional, relationOptions);
+        const object = {
+            transactional,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
         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 +265,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 +403,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 +541,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 +679,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 +809,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 +913,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;
     }
@@ -1256,7 +1298,16 @@ export class Logic extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-
+    // 设置定时任务
+    setCronAndTriggerType(cron: string, triggerType: string) {
+        const object = {
+            cron,
+            triggerType,
+        };
+        this.update({
+            ...object,
+        });
+    }
     findLogicItemByConcept(concept: string) {
         let result: any;
 
@@ -1280,51 +1331,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 +1357,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 +1366,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 +1447,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 +1489,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();
+            }
+            parentNodeNamespace = parentNodeNamespace.includes('.logics') ? parentNodeNamespace : `${parentNodeNamespace}.logics`;
+            if (this.parentNode instanceof View) {
+                return (parentNodeNamespace = '');
             }
-            return parentNodeNamespace.includes('.logics.') ? parentNodeNamespace : `${parentNodeNamespace}.logics`;
+            return parentNodeNamespace;
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
@@ -1416,11 +1517,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() {
@@ -1472,6 +1570,12 @@ export class Logic extends BaseNode {
         }
     }
 
+    // 通过开关设置数据库事务
+    setTransactionEnabled(flag: boolean) {
+        this.setTransactional(new Transactional({
+            enabled: flag,
+        }));
+    }
     fake: boolean;
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/MemberExpression__.ts

@@ -1,4 +1,6 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
+import BinaryExpression from './BinaryExpression__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -8,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 LogicItem from './LogicItem__';
@@ -15,7 +18,7 @@ import LogicItem from './LogicItem__';
 /**
  * 成员表达式
  */
-@concept
+@concept('成员表达式')
 export class MemberExpression extends LogicItem {
     /**
      * 产品概念
@@ -23,12 +26,6 @@ export class MemberExpression extends LogicItem {
     @property()
     concept: 'MemberExpression' = 'MemberExpression';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Expression';
-
     /**
      * 逻辑项
      */
@@ -143,20 +140,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 +166,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 +199,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,8 +219,14 @@ 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.property ? this.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
+        const leftCode = this.object ? this.object.toEmbeddedTS(shiftState(state, code, { inline: true })) + '.' : '';
+        const rightCode = this.property ? this.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
+
+        // 就说明这是一个枚举取值操作，直接啊app.enums.color.red 要转成字符串
+        code += leftCode + rightCode;
+        // if (leftCode.startsWith('app.enums.') && !(this.parentNode instanceof BinaryExpression)) {
+        //     code += '.toList()';
+        // }
         return code;
     }