@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/concepts/CallInterface__.ts

@@ -1,6 +1,8 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Interface from './Interface__';
+import NullLiteral from './NullLiteral__';
 import { ElementToVueOptions } from './ViewElement__';
+import { getConceptConstructor } from '../decorators';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -97,7 +99,7 @@ export class CallInterface extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -171,7 +173,7 @@ export class CallInterface extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -221,12 +223,23 @@ export class CallInterface extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get tsCalleeNamespace() {
+        if (this.calleeNamespace) {
+            let tsCalleeNamespace = this.calleeNamespace;
+            tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
+            tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+            return tsCalleeNamespace;
+        }
+        return '';
+    }
+
     toVue(options?: ElementToVueOptions): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toVue(options);
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toVue(options);
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -236,9 +249,9 @@ export class CallInterface extends LogicItem {
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toUI();
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -246,32 +259,208 @@ export class CallInterface extends LogicItem {
     }
 
     toJS(state?: TranslatorState): string {
-        let code = this.calleeName;
-        code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toJS(shiftState(state, code));
-            if (index !== this.arguments.length - 1)
-                code += ', ';
-        });
-        code += ')';
+        const _arr = this.calleewholeKey.split('.');
+        const _name = _arr[1];
+        const _interfaceName = _arr[3];
+        const _module = this.app.interfaceDependencies.find((item) => item.name === _name);
+        const _interface = _module.interfaces.find((item) => item.name === _interfaceName);
+        if (!_interface) {
+            throw new Error(`${_name}下的${_interfaceName}接口未找到`);
+        }
+        let isSimpleBody = false; // 兼容body只有基本类型的
+        const _params = _interface.params;
+        const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
+        const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
+        const _body = _params
+            .filter((item) => item.in === 'body')
+            .map((item) => {
+                if (item.typeAnnotation.typeKind === 'primitive') {
+                    isSimpleBody = true;
+                }
+                return item.name;
+            });
+        const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
+
+        let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
+        code += `({
+            config: {
+                download: false,
+            },
+            query: {`;
+        this.arguments?.filter((arg) => _queries.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},
+            path: {`;
+        this.arguments?.filter((arg) => _paths.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},
+            headers: {`;
+        this.arguments?.filter((arg) => _headers.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},\n`;
+        if (isSimpleBody) {
+            code += `body: `;
+            this.arguments?.forEach((arg, index) => {
+                code += ` ${arg?.toJS(shiftState(state, code))}`;
+            });
+        } else {
+            code += `body: {`;
+            this.arguments?.filter((arg) => _body.includes(arg?.keyword))
+                .forEach((arg, index) => {
+                    code += ` ...${arg?.toJS(shiftState(state, code))}`;
+                    if (index !== this.arguments?.length - 1)
+                        code += ', ';
+                });
+            code += '}';
+        }
+
+        code += '\n})';
         return code;
     }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.calleeKey;
-        code += '({';
-        this.arguments.forEach((arg, index) => {
-            code += `${arg.keyword}:` + arg.toEmbeddedTS(shiftState(state, code));
-            if (index !== this.arguments.length - 1)
-                code += ', ';
-        });
-        code += '});\n';
+        let code = this.tsCalleeKey;
+        const _keys = this.calleeDefaultKey.split('.');
+        const _module = this.app.interfaceDependencies.find((item) => item.name === _keys[1]);
+        let params: string[] = [];
+        const _interface = _module?.interfaces?.find((item) => item.name === _keys[3]);
+        if (_interface) {
+            params = _interface.params.filter((item) => item.required).map((item) => item.name) || [];
+            // const _bodyParams = _interface.params.find((item) => item.name === 'Body');
+            // if (_bodyParams) {
+            //     const _typeKey = _bodyParams.typeAnnotation.typeKey;
+            //     const _list = _typeKey.split('.');
+            //     const _structure = _module.structures.find((item) => item.name === _list[3]);
+            //     const isBodyRequired = _structure.properties.some((item) => item.required === true);
+            //     if (isBodyRequired) {
+            //         params.push('Body');
+            //     }
+            // }
+        }
+        code += '(';
+        if (this.arguments?.length) {
+            code += '{';
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toEmbeddedTS(shiftState(state, code), params.includes(arg?.keyword), true);
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+            code += '}';
+        }
 
+        code += ');\n';
         return code;
     }
 
     get calleeKey(): string {
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.calleeName;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    }
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
+    get tsCalleeName(): string {
+        const excludeds = [
+            'abstract',
+            'arguments',
+            'await',
+            'boolean',
+            'break',
+            'byte',
+            'case',
+            'catch',
+            'char',
+            'class',
+            'const',
+            'continue',
+            'debugger',
+            'default',
+            'delete',
+            'do',
+            'double',
+            'else',
+            'enum',
+            'eval',
+            'export',
+            'extends',
+            'false',
+            'final',
+            'finally',
+            'float',
+            'for',
+            'function',
+            'goto',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'instanceof',
+            'int',
+            'interface',
+            'let',
+            'long',
+            'native',
+            'new',
+            'null',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'return',
+            'short',
+            'static',
+            'super',
+            'switch',
+            'synchronized',
+            'this',
+            'throw',
+            'throws',
+            'transient',
+            'true',
+            'try',
+            'typeof',
+            'var',
+            'void',
+            'volatile',
+            'while',
+            'with',
+            'yield,as',
+            'any',
+            'number',
+            'string',
+            'get',
+            'type',
+            'typeof',
+            'instanceof',
+            'require',
+        ];
+        if (excludeds.includes(this.calleeName)) {
+            return '_' + this.calleeName;
+        }
+        return this.calleeName;
+    }
+
+    get tsCalleeKey(): string {
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.tsCalleeName;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    }
+    get calleeDefaultKey(): string {
         return `${this.calleeNamespace}.${this.calleeName}`;
     }
     _setCallee(_interface: Interface) {
@@ -288,9 +477,30 @@ export class CallInterface extends LogicItem {
         const calleeName = _interface.name;
         const params = _interface.params.map((param) => {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
-            const argument = Argument.from({
+            let expression;
+            if (param.defaultValue && param.typeAnnotation.typeKind === 'primitive') {
+                const conceptMap: { [name: string]: string } = {
+                    String: 'StringLiteral',
+                    Boolean: 'BooleanLiteral',
+                    Integer: 'NumericLiteral',
+                    Double: 'NumericLiteral',
+                    Long: 'NumericLiteral',
+                };
+                const typeName = param.typeAnnotation.typeName;
+                const concept: string = conceptMap[typeName] || 'StringLiteral';
+                const Ctor = getConceptConstructor(concept);
+                expression = new Ctor({
+                    concept,
+                    value: param.defaultValue,
+                    typeAnnotation: param.typeAnnotation,
+                });
+            } else if (!param.required) {
+                expression = new NullLiteral();
+            }
+            const argument = new Argument({
                 keyword: param.name,
-            }, this);
+                expression,
+            });
             Object.assign(argument, relationOptions);
             return argument;
         });

package/src/concepts/CallLogic__.ts

@@ -2,6 +2,8 @@ import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Logic from './Logic__';
 import Param from './Param__';
 import { ElementToVueOptions } from './ViewElement__';
+import { getNodeByNodeCallee } from '../automate/engine/utils';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -105,7 +107,7 @@ export class CallLogic extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -179,7 +181,7 @@ export class CallLogic extends LogicItem {
 
     addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
         const node = this._addTypeAnnotation(options as any);
-        const index = this.typeArguments.length;
+        const index = this.typeArguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -212,7 +214,7 @@ export class CallLogic extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -286,7 +288,7 @@ export class CallLogic extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -382,11 +384,16 @@ export class CallLogic extends LogicItem {
         }
         return '';
     }
+
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
     get calleeKey(): string {
         const tsCalleeNamespace = this.tsCalleeNamespace;
         const calleeName = this.calleeName;
         if (!tsCalleeNamespace) {
-            return calleeName ? `logics.${calleeName}` : '__IDENTIFIER__';
+            return calleeName ? `${calleeName}` : '__IDENTIFIER__';
         }
         // elements单独处理相对路径，和后缀的问题
         if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
@@ -397,10 +404,11 @@ export class CallLogic extends LogicItem {
     }
 
     /**
-     * 设置setArgumentName
+     * 设置argment 触发别的地方的更新
      */
-    setArgumentName({ argument, newKeyword }: { argument: Argument; newKeyword: string }) {
-        argument.setKeyword(newKeyword);
+    setArgumentName({ argument }: { argument: Argument[] }) {
+        // argument.setKeyword(newKeyword);
+        // this.arguments = argument;
     }
 
     /**
@@ -451,6 +459,7 @@ export class CallLogic extends LogicItem {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
             const argument = Argument.from({
                 keyword: param.name,
+                expression: param.defaultExpression,
             }, this);
             Object.assign(argument, relationOptions);
             return argument;
@@ -518,11 +527,15 @@ export class CallLogic extends LogicItem {
     }
 
     toVue(options?: ElementToVueOptions): string {
-        let code = this.calleeName;
+        let code = '';
+        if (this.calleeNamespace === 'nasl.browser' || this.calleeNamespace === 'nasl.auth' || this.calleeNamespace === 'nasl.configuration') {
+            code += '$global.';
+        }
+        code += this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toVue(options);
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toVue(options);
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -532,9 +545,9 @@ export class CallLogic extends LogicItem {
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toUI();
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -550,12 +563,15 @@ export class CallLogic extends LogicItem {
         let isComponentLogic = false;
         let componentName = '';
         const calleeNamespace = this.calleeNamespace;
+        const isProcessLogic = this.calleeNamespace?.startsWith('app.processes');
+
         // calleeNamespace不存在，一定是页面逻辑
         if (calleeNamespace) {
             const namespaceArr = calleeNamespace.split('.');
             const start = namespaceArr.shift();
-            if (start === 'app') {
-                const keywordViews = namespaceArr.filter((namespaceItem, index) => index % 2 === 0).find((namespaceItem) => namespaceItem === 'views');
+            if (start === 'app' || start === 'extensions') {
+                const mod = start === 'app' ? 0 : 1;
+                const keywordViews = namespaceArr.filter((namespaceItem, index) => index % 2 === mod).find((namespaceItem) => namespaceItem === 'views');
                 if (!keywordViews) {
                     isViewLogic = false;
                 }
@@ -566,15 +582,23 @@ export class CallLogic extends LogicItem {
         }
         // 全局逻辑
         if (!isViewLogic) {
-            code += `this.$logics['${this.calleeName}']`;
-            code += `({
-                config: {
-                    download: false,
-                },
-                query: {},
-                headers: {},
-            `;
-            const namespaceArr = calleeNamespace.split('.');
+            const namespaceArr = calleeNamespace?.split('.');
+            const logic = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: string, tempPoint: any) => {
+                // 处理 NASL 中未定义的假的节点
+                if (key === tempPoint.name) {
+                    return {
+                        tempPoint,
+                        state: 1,
+                    };
+                }
+                const t = tempPoint[key];
+                return {
+                    tempPoint: t,
+                    state: Array.isArray(t) ? 2 : 1,
+                };
+            });
+            const args = logic?.params || [];
+
             // 去掉app
             namespaceArr.shift();
             const keywordEntities = namespaceArr
@@ -585,43 +609,64 @@ export class CallLogic extends LogicItem {
                 .filter((namespaceItem, index) => index % 2 === 0)
                 .find((namespaceItem) => namespaceItem.key === 'entities');
             const entityName = namespaceArr[keywordEntities?.index + 1];
+            code += `this.$logics['${this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName}']`;
+            code += `({
+                config: {
+                    download: false,
+                },
+                query: {`;
+            if (isProcessLogic) {
+                const argsStr = args.map((arg: any, index: number) => {
+                    const actualArg = this.arguments?.[index];
+                    return {
+                        keyword: arg?.name,
+                        arg: actualArg,
+                    };
+                }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                code += argsStr;
+            }
+            code += `},
+                headers: {},
+            `;
 
             if (entityName) {
                 let logicArgs = this.arguments;
                 switch (this.calleeName) {
                     case 'get':
                     case 'delete': {
-                        let idArgument: Argument;
-                        logicArgs = logicArgs.filter((arg) => {
-                            if (arg.keyword === 'id') {
-                                idArgument = arg;
-                                return false;
-                            } else {
-                                return true;
-                            }
-                        });
-                        code += `path: {`;
-                        if (idArgument) {
-                            code += `\n${idArgument.keyword}: ${idArgument.toJS(shiftState(state, code))}`;
-                        }
+                        logicArgs = [];
+                        code += `query: {`;
+                        const argsStr = args.map((arg: any, index: number) => {
+                            const actualArg = this.arguments?.[index];
+                            return {
+                                keyword: arg?.name,
+                                arg: actualArg,
+                            };
+                        }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                        code += argsStr;
                         code += `},\n`;
                         break;
                     }
                 }
                 const bodyArgument = logicArgs.find((arg) => arg.keyword === 'body');
                 if (bodyArgument) {
-                    code += `\n${bodyArgument.keyword}: ${bodyArgument.toJS(shiftState(state, code))}`;
+                    code += `\n${bodyArgument?.keyword}: ${bodyArgument?.toJS(shiftState(state, code))}`;
                 } else {
                     code += `body: {}`;
                 }
             } else {
                 code += `path: {},
                 body: {`;
-                this.arguments.forEach((arg, index) => {
-                    code += `\n${arg.keyword}: ${arg.toJS(shiftState(state, code))}`;
-                    if (index !== this.arguments.length - 1)
-                        code += ', ';
-                });
+                if (!isProcessLogic) {
+                    const argsStr = args.map((arg: any, index: number) => {
+                        const actualArg = this.arguments?.[index];
+                        return {
+                            keyword: arg?.name,
+                            arg: actualArg,
+                        };
+                    }).filter((obj: any) => obj?.arg?.expression).map((obj: any) => `\n${obj?.keyword}: ${obj?.arg?.toJS(shiftState(state, code))}`).join(', ');
+                    code += argsStr;
+                }
                 code += '\n}';
             }
             code += '\n})';
@@ -643,15 +688,18 @@ export class CallLogic extends LogicItem {
                         code += `JSON.parse`;
                         break;
                 }
+            } else if (calleeNamespace === 'nasl.browser' || calleeNamespace === 'nasl.auth' || calleeNamespace === 'nasl.configuration') {
+                code += `this.$global.${this.calleeName}`;
             } else {
                 code += `this.${this.calleeName}`;
             }
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toJS(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
-                    code += ', ';
-            });
+            this.arguments?.filter((arg) => arg?.expression)
+                .forEach((arg, index) => {
+                    code += arg?.toJS(shiftState(state, code));
+                    if (index !== this.arguments?.length - 1)
+                        code += ', ';
+                });
             code += ')';
         }
         return code;
@@ -660,14 +708,25 @@ export class CallLogic extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = this.calleeKey;
+        if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+            // 如果有内容
+            const typeAnnotation = this.typeArguments[0];
+            code += `<`;
+            code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>`;
+        }
         code += '(';
         this.arguments.forEach((arg, index) => {
-            code += arg.toEmbeddedTS(shiftState(state, code));
+            const tsCalleeNamespace = this.tsCalleeNamespace;
+            // 页面逻辑先都非必填
+            if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
+                code += arg.toEmbeddedTS(shiftState(state, code), false);
+            } else {
+                code += arg.toEmbeddedTS(shiftState(state, code));
+            }
             if (index !== this.arguments.length - 1)
                 code += ', ';
         });
         code += ');\n';
-
         return code;
     }