@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/src/concepts/AuthLogicForCallInterface__.ts

@@ -0,0 +1,573 @@
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+import Namespace from './Namespace__';
+import CallQueryComponent from './CallQueryComponent__';
+import Assignment from './Assignment__';
+import Identifier from './Identifier__';
+import BatchAssignment from './BatchAssignment__';
+import OqlQueryComponent from './OqlQueryComponent__';
+import Return from './Return__';
+import Variable from './Variable__';
+import TypeParam from './TypeParam__';
+import TypeAnnotation from './TypeAnnotation__';
+
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+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 Param from './Param__';
+import AuthLogic from './AuthLogic__';
+
+/**
+ * 调用的鉴权逻辑
+ */
+@concept('调用的鉴权逻辑')
+export class AuthLogicForCallInterface extends AuthLogic {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'AuthLogicForCallInterface' = 'AuthLogicForCallInterface';
+
+    /**
+     * 鉴权配置参数, 调用接口鉴权独有
+     */
+    @property('Param')
+    authParams: Array<Param> = [];
+
+    
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<AuthLogicForCallInterface>) {
+        source = Object.assign({}, AuthLogicForCallInterface.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+    getClassName() {
+        return 'AuthLogicForCallInterface';
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): AuthLogicForCallInterface {
+        return super.from(source, parentNode, parentKey) as AuthLogicForCallInterface;
+    }
+
+    
+    
+
+        getParamExistingNames(excludedList: Array<Param> = []) {
+        const excludedSet = new Set(excludedList);
+        return ((this.authParams as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getParamUniqueName(name = 'param1') {
+        return utils.unique(name, this.getParamExistingNames(), undefined, false);
+    }
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertParamAt(name: string, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param paramOptions 输入参数参数
+    */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param param 已有的输入参数实例
+    */
+    _insertParamAt(param: Param, index: number): Param;
+
+    _insertParamAt(options: string | Partial<Param> | Param, index: number) {
+        const paramOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'authParams' };
+        let param: Param;
+        if (!options) {
+            param = Param.from({
+                ...paramOptions,
+                name: this.getParamUniqueName(),
+            }, this, 'authParams');
+        } else if (typeof options === 'string') {
+            param = Param.from({
+                ...paramOptions,
+                name: options,
+            }, this, 'authParams');
+        } else if (options instanceof Param) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            param = options;
+            Object.assign(param, relationOptions);
+        } else {
+            param = Param.from({
+                ...paramOptions,
+                ...options,
+            }, this, 'authParams');
+        }
+        this.authParams.splice(index, 0, param);
+        return param;
+    }
+
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+
+    insertParamAt(options: string | Partial<Param> | Param, index: number) {
+        const node = this._insertParamAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authParams',
+        });
+        return node;
+    }
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addParam(name?: string): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+
+    _addParam(options?: string | Partial<Param> | Param) {
+        const index = this.authParams.length;
+        return this._insertParamAt(options as any, index);
+    }
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+
+    addParam(options?: string | Partial<Param> | Param) {
+        const node = this._addParam(options as any);
+        const index = this.authParams.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authParams',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除输入参数
+    * @param name 输入参数名称
+    */
+    removeParam(name: string): void;
+
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+
+    removeParam(options: string | Param) {
+        let param: Param;
+        if (typeof options === 'string') {
+            param = (this.authParams as Param[]).find((item) => item.name === options);
+            if (!param) {
+                throw new Error('找不到输入参数 ' + options);
+            }
+        } else {
+            param = options;
+        }
+        return param.delete();
+    }
+
+    __removeParam(param: Param) {
+        const parentKey = param.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: param,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(param);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === param) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState, prefix?: string): string {
+        // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
+        let code = '';
+        if (!prefix) {
+            // T、U分别用来定义 api 入参和返回值
+            code += `export function ${this.name}`;
+        } else if (prefix === 'noExport') {
+            code += `function ${this.name}`;
+        } else if (prefix === 'inObject') {
+            code += `${this.name}`;
+        }
+        const typeParams = [
+            ...(this.typeParams || []),
+            new TypeParam({
+                name: 'ApiParams',
+            }),
+            new TypeParam({
+                name: 'ApiReturn',
+            }),
+        ];
+        if (typeParams?.length) {
+            code += '<';
+            typeParams.forEach((typeParam, typeParamIndex) => {
+                code += typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                if (typeParamIndex !== typeParams.length - 1) {
+                    code += ', ';
+                }
+            });
+            code += '>';
+        }
+        // 有参数长度 && 鉴权参数
+        if (this.authParams.length) {
+            // const params = [...this.authParams, ...this.params];
+            const params = [...this.authParams];
+            params.forEach((param, index) => {
+                if (index === 0) {
+                    code += '({';
+                }
+                code += param.tsName;
+                if (index !== params.length - 1) {
+                    code += ', ';
+                } else {
+                    code += ', api}:';
+                }
+            });
+            params.forEach((param, index) => {
+                if (index === 0) {
+                    code += '{';
+                }
+                code += param.toEmbeddedTS(shiftState(state, code), !(param).required);
+                if (index !== params.length - 1) {
+                    code += ', ';
+                } else {
+                    code += ', api?: ApiReturn}';
+                }
+            });
+            code += '): ApiReturn';
+        } else {
+            // 没有参数的
+            code += '({api}: {api?: ApiReturn}): ApiReturn';
+        }
+
+        // 需要类型推导的局部变量/返回值需要调整申明顺序
+        const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+        const needGetSourceMapOqlList: Promise<any>[] = [];
+        this.traverseChildren((el) => {
+            if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
+                if (el instanceof Assignment) {
+                    const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && (el.left?.name === variable.name));
+                    if (advanceVar && !advanceMap.get(advanceVar)) {
+                        advanceMap.set(advanceVar, el);
+                    }
+                    const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
+                    if (advanceRn && !advanceMap.get(advanceRn)) {
+                        advanceMap.set(advanceRn, el);
+                    }
+                } else if (el instanceof BatchAssignment) {
+                    el.assignmentLines.forEach(({ leftIndex }) => {
+                        const leftCode
+                            = leftIndex.length === 1 ? el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                        const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && (leftCode === variable.name));
+                        if (advanceVar && !advanceMap.get(advanceVar)) {
+                            advanceMap.set(advanceVar, el);
+                        }
+                        const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
+                        if (advanceRn && !advanceMap.get(advanceRn)) {
+                            advanceMap.set(advanceRn, el);
+                        }
+                    });
+                }
+            }
+            // 如果有sql查询组件就需要把他们存起来
+            if (el instanceof OqlQueryComponent) {
+                if (!el.codeSourceMap) {
+                    needGetSourceMapOqlList.push(el.requestEmbeddedTS());
+                }
+            }
+        });
+
+        if (needGetSourceMapOqlList.length) {
+            Promise.all(needGetSourceMapOqlList).then(() => {
+                // 触发一下更新重新生成代码
+                (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
+                    value: [
+                        {
+                            originEvent: {
+                                action: 'update',
+                                target: this,
+                            },
+                        },
+                    ],
+                });
+            });
+        }
+
+        code += '{\n';
+
+        // 用于虚拟节点的查找引用
+        this.virtualParams
+            && Array.isArray(this.virtualParams)
+            && this.virtualParams.forEach((param) => {
+                code += indent((state?.tabSize || 0) + 1);
+                code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+                code += '\n';
+            });
+
+        const variables = [
+            ...this.variables,
+            new Variable({ // 将默认参数加为变量 用于参数选择校验
+                name: 'request',
+                typeAnnotation: new TypeAnnotation({
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeNamespace: 'nasl.http',
+                    typeName: 'HttpRequest',
+                    typeArguments: [{
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName: 'String',
+                    } as TypeAnnotation],
+                }),
+            }),
+        ];
+        variables.forEach((variable) => {
+            if (!advanceMap.get(variable)) {
+                code += indent((state?.tabSize || 0) + 1) + 'let ';
+                code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            }
+        });
+
+        advanceMap.forEach((assignment, node) => {
+            code += indent((state?.tabSize || 0) + 1) + '// @ts-ignore\n';
+            code += indent((state?.tabSize || 0) + 1) + 'let ';
+            code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            if (assignment instanceof BatchAssignment) {
+                assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+                    const leftCode
+                        = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    if (leftCode === node.name) {
+                        const rightNode: any = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
+                        // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+                        if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                            code += ': ';
+                            code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
+                        } else {
+                            code += ' = ';
+                            const rightCode = rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                            code += this.getRightCode(rightCode, assignment, rightNode);
+                        }
+                    }
+                });
+            } else if (['NewList', 'NewMap'].includes(assignment.right?.concept) && !(assignment.right as any)?.typeAnnotation) {
+                const rightNode: any = assignment.right;
+                code += ' = ';
+                code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
+            } else if (assignment.right?.concept === 'NewComposite' && (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure') {
+                const rightNode: any = assignment.right;
+                code += ' = ';
+                code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
+            } else {
+                const rightNode: any = assignment.right;
+                // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+                if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                    code += ': ';
+                    code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
+                } else {
+                    code += ' = ';
+                    let rightCode = '';
+                    // 因为右侧枚举要赋值就得new 一下；
+                    if (rightNode && rightNode instanceof Identifier && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
+                        rightCode += 'new ';
+                    }
+                    rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
+                    code += this.getRightCode(rightCode, assignment, rightNode);
+                }
+            }
+            code += ';\n';
+        });
+
+        if (!this.body.length) {
+            // 必有返回值，且返回值为 api 对应的返回参数
+            code += `${indent((state?.tabSize || 0) + 1)}let ${this.name}Result: ApiReturn; \n ${indent((state?.tabSize || 0) + 1)}return ${this.name}Result;\n`;
+        } else {
+            // 如果长度小于2 并且不是虚拟节点就 加 报错，
+            if (this.body.length <= 2 && !(this.parentNode instanceof Namespace)) {
+                code += indent((state?.tabSize || 0) + 1);
+                code += 'const __LogicEmpty: any = null;';
+            }
+            this.body.forEach((item) => {
+                code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+                code += ';\n';
+            });
+        }
+
+        // 在body渲染完成之后把其余的节点放到下面
+        this.playground.forEach((item) => {
+            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+            code += ';\n';
+        });
+
+        code += indent(state?.tabSize || 0) + '}';
+        if (prefix === 'inObject') {
+            code += `,`;
+        }
+        code += '\n';
+        return code;
+    }
+
+    public static getDefaultOptions() {
+        return {
+            body: [
+                {
+                    concept: 'Start',
+                    label: '开始',
+                    kind: 'Statement',
+                    type: 'Start',
+                },
+                {
+                    concept: 'End',
+                    label: '结束',
+                    kind: 'Statement',
+                    type: 'End',
+                },
+            ],
+            params: [
+                {
+                    concept: 'Param', // 产品概念
+                    name: 'request', // 输入参数名称
+                    description: '请求信息，系统自动注入，包含 method、url、header、cookie、body等', // 输入参数描述
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'generic',
+                        typeNamespace: 'nasl.http',
+                        typeName: 'HttpRequest',
+                        typeArguments: [{
+                            concept: 'TypeAnnotation',
+                            typeKind: 'primitive',
+                            typeNamespace: 'nasl.core',
+                            typeName: 'String',
+                        }],
+                    }, // 类型
+                    required: false, // 是否必填
+                },
+            ],
+            returns: [] as Array<any>,
+        };
+    }
+
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name = this.name) {
+        const _path = this.module ? `/${this.module.parentKey}/${this.module.name}` : '';
+        return `/embedded/${this.app.name}${_path}/authLogicsForCallInterface/${name}.ts`;
+    }
+
+    getTsNamespace(): string {
+        if (this.parentNode) {
+            const parentNamespace = (this.parentNode as any)?.getTsNamespace();
+            const parentName = this.parentNode.tsName || this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
+            }
+            let namespace = arr.join('.');
+            if (
+                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
+                && !namespace.includes('.authLogicsForCallInterface')
+            ) {
+                namespace = `${namespace}.authLogicsForCallInterface`;
+            }
+            return namespace;
+        } else
+            throw new Error('无法获取命名空间，请设置 parentNode！');
+    }
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap.AuthLogicForCallInterface = AuthLogicForCallInterface;
+export default AuthLogicForCallInterface;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================