@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/CallFunction__.ts

@@ -11,12 +11,12 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Function from './Function__';
+import type Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
-import Identifier from './Identifier__';
+import type Identifier from './Identifier__';
 import { getBuildInFunction } from '../server/getFunctions';
-import AnonymousFunction from './AnonymousFunction__';
-import MemberExpression from './MemberExpression__';
+import type AnonymousFunction from './AnonymousFunction__';
+import type MemberExpression from './MemberExpression__';
 import asyncFuncMap from '../common/asyncFuncMap';
 
 //================================================================================
@@ -24,27 +24,26 @@ import asyncFuncMap from '../common/asyncFuncMap';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
-import TypeAnnotation from './TypeAnnotation__';
-import Argument from './Argument__';
 import LogicItem from './LogicItem__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type Argument from './Argument__';
 
 /**
  * 调用函数
  */
-@className
 @concept('调用函数')
-// @ts-ignore
 export class CallFunction extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'CallFunction';
+  static readonly ConceptName: string = 'CallFunction';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -63,21 +62,18 @@ export class CallFunction extends LogicItem {
    * calleeNamespace
    */
   @property()
-  // @ts-ignore
   calleeNamespace!: string;
 
   /**
    * calleeName
    */
   @property()
-  // @ts-ignore
   calleeName!: string;
 
   /**
    * shortcut
    */
   @property()
-  // @ts-ignore
   shortcut!: boolean;
 
   /**
@@ -130,8 +126,9 @@ export class CallFunction extends LogicItem {
   _insertTypeAnnotationAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
     const typeAnnotationOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
     let typeAnnotation: TypeAnnotation;
-    if (options instanceof TypeAnnotation) {
+    if (asserts.isTypeAnnotation(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeAnnotation = options;
       Object.assign(typeAnnotation, relationOptions);
@@ -230,8 +227,9 @@ export class CallFunction extends LogicItem {
   _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
     const argumentOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'arguments' };
+    const Argument = getConceptConstructor('Argument');
     let argument: Argument;
-    if (options instanceof Argument) {
+    if (asserts.isArgument(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       argument = options;
       Object.assign(argument, relationOptions);
@@ -500,7 +498,7 @@ export class CallFunction extends LogicItem {
 
     if (Array.isArray(this.arguments) && this.arguments.length) {
       this.arguments.forEach((arg: any, index) => {
-        let argStr = arg?.toJS(shiftState(state, code));
+        let argStr = arg?.toJS(state);
         const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
         transfromUnionTypeAnnotation(argTypeAnnotation, this.app);
         const { sortedTypeKey } = transfromMetadataType(argTypeAnnotation, this.app);
@@ -521,7 +519,7 @@ export class CallFunction extends LogicItem {
       if (this.arguments?.length) code += ', ';
 
       this.typeArguments?.forEach((tyArg, index) => {
-        code += tyArg?.toJS(shiftState(state, code));
+        code += tyArg?.toJS(state);
         if (index !== this.typeArguments?.length - 1) code += ', ';
       });
     }
@@ -558,6 +556,9 @@ export class CallFunction extends LogicItem {
   setCallee(func: Function) {
     const calleeNamespace = func.getNamespace();
     const calleeName = func.name;
+    const Argument = getConceptConstructor('Argument');
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+    const BaseNode = getBaseNode();
     const params = func.params.map((param) => {
       const relationOptions = { parentNode: this, parentKey: 'arguments' };
       const argument = Argument.from(
@@ -566,10 +567,10 @@ export class CallFunction extends LogicItem {
         },
         this,
       );
-      if (param.defaultExpression instanceof Identifier) {
+      if (asserts.isIdentifier(param.defaultExpression)) {
         argument.expression = BaseNode.from(param.defaultExpression, argument, 'expression') as Identifier;
       }
-      if (param.defaultExpression instanceof Function) {
+      if (asserts.isFunction(param.defaultExpression)) {
         (param.defaultExpression as Function).returnExpression = null;
         argument.expression = BaseNode.from(param.defaultExpression, argument, 'expression') as Identifier;
       }
@@ -714,7 +715,7 @@ export class CallFunction extends LogicItem {
   checkParamNameOfAnonymousFunction() {
     const fns = this.arguments
       .map((arg) => arg.expression)
-      .filter((exp) => exp instanceof AnonymousFunction) as unknown as AnonymousFunction[];
+      .filter((exp) => asserts.isAnonymousFunction(exp)) as unknown as AnonymousFunction[];
 
     fns.forEach((fn) => {
       fn.checkParamName();

package/src/concepts/CallInterface__.ts

@@ -8,15 +8,15 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Interface from './Interface__';
+import type Interface from './Interface__';
 import { ElementToVueOptions } from './ViewElement__';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
-import InterfaceParam from './InterfaceParam__';
-import Structure from './Structure__';
-import Module from './Module__';
-import AuthInterface from './AuthInterface__';
+import type InterfaceParam from './InterfaceParam__';
+import type Structure from './Structure__';
+import type Module from './Module__';
+import type AuthInterface from './AuthInterface__';
 import type { MemberExpression } from './MemberExpression__';
-import Frontend from './Frontend__';
+import type Frontend from './Frontend__';
 import type Connector from './Connector__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
@@ -25,26 +25,25 @@ import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
-import Argument from './Argument__';
 import LogicItem from './LogicItem__';
+import type Argument from './Argument__';
 
 /**
  * 调用接口
  */
-@className
 @concept('调用接口')
-// @ts-ignore
 export class CallInterface extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'CallInterface';
+  static readonly ConceptName: string = 'CallInterface';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -63,21 +62,18 @@ export class CallInterface extends LogicItem {
    * calleeNamespace
    */
   @property()
-  // @ts-ignore
   calleeNamespace!: string;
 
   /**
    * calleeName
    */
   @property()
-  // @ts-ignore
   calleeName!: string;
 
   /**
    * shortcut
    */
   @property()
-  // @ts-ignore
   shortcut!: boolean;
 
   /**
@@ -120,8 +116,9 @@ export class CallInterface extends LogicItem {
   _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
     const argumentOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'arguments' };
+    const Argument = getConceptConstructor('Argument');
     let argument: Argument;
-    if (options instanceof Argument) {
+    if (asserts.isArgument(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       argument = options;
       Object.assign(argument, relationOptions);
@@ -269,8 +266,8 @@ export class CallInterface extends LogicItem {
           const refs = (await oldItf.findUsage()) as Map<any, any>;
 
           const isOnlyUsedByFronted =
-            refs.size === 1 && Array.from(refs.keys()).filter((key) => key instanceof Frontend).length > 0;
-          const isAuthInterface = oldItf instanceof AuthInterface;
+            refs.size === 1 && Array.from(refs.keys()).filter((key) => asserts.isFrontend(key)).length > 0;
+          const isAuthInterface = asserts.isAuthInterface(oldItf);
           // 当仅仅只有前端使用，且该接口是鉴权接口时需要将接口还原为普通接口
           if (isOnlyUsedByFronted && isAuthInterface) {
             this.replaceToInterface(oldItf);
@@ -314,6 +311,7 @@ export class CallInterface extends LogicItem {
   replaceToInterface(oldItf: AuthInterface) {
     this.app.emit('collect:start', { actionMsg: '调用接口恢复为非鉴权' });
     const { name, originLogicName, path, method, description, params, returns, protocol, protocolParams } = oldItf;
+    const Interface = getConceptConstructor('Interface');
     const newInterface = new Interface({
       name,
       originLogicName,
@@ -410,11 +408,11 @@ export class CallInterface extends LogicItem {
 
       filledArgs.forEach((arg, index) => {
         if (useRest) {
-          code += ` ...${arg?.toJS(shiftState(state, code))}`;
+          code += ` ...${arg?.toJS(state)}`;
         } else if (useKeyWord) {
-          code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+          code += `\n'${arg?.keyword}': ${arg?.toJS(state)}`;
         } else {
-          code += ` ${arg?.toJS(shiftState(state, code))}`;
+          code += ` ${arg?.toJS(state)}`;
         }
 
         if (index !== args.length - 1) {
@@ -648,6 +646,7 @@ export class CallInterface extends LogicItem {
 
   setCallee(_interface: Interface) {
     const calleeNamespace = _interface.getNamespace();
+    const Argument = getConceptConstructor('Argument');
     const calleeName = _interface.name;
     // 保留之前的参数
     const params = _interface.params.map((param) => {
@@ -723,7 +722,7 @@ export class CallInterface extends LogicItem {
         const idx = logicParam.findIndex((params) => arg.keyword === params.name);
         const param = logicParam[idx];
 
-        arg.paramRequired = Boolean(!param?.defaultValue?.expression);
+        arg.paramRequired = param?.required;
         arg.paramTypeAnnotation = undefined;
         arg.paramDefaultValue = undefined;
         // 取到是不是必填放入参数中
@@ -807,6 +806,8 @@ export class CallInterface extends LogicItem {
     let targetItf = module.interfaces.find((item) => item.name === itfData.name) as Interface | AuthInterface;
     // 根据 targetItf 是否是AuthInterface 来确定生成什么类型的接口
     let newItf;
+    const AuthInterface = getConceptConstructor('AuthInterface');
+    const Interface = getConceptConstructor('Interface');
     if (targetItf && targetItf.concept === 'AuthInterface') {
       newItf = new AuthInterface({
         ...itfData,
@@ -876,6 +877,7 @@ export class CallInterface extends LogicItem {
 
     this.setCallee(targetItf as Interface);
 
+    const Structure = getConceptConstructor('Structure');
     const oldStructuresSet = targetItf.getRefStructures(targetItf.module.structures);
     // 递归找出 response/request 的 Body/Returns 引用的数据结构
     const newStructuresSet = targetItf.getRefStructures(moduleData.structures);