@lcap/nasl 3.8.3-beta.4 → 3.8.3-beta.6

package/src/common/BaseNode.ts

@@ -20,6 +20,8 @@ export function setActionable(value: boolean) {
   actionable = value;
 }
 
+import { varScopeCtx } from '../server/semanticData';
+
 const patchCompose = (node: BaseNode, type = 'add') => {
   if (node?.composedBy) {
     const app = (node as any)?.app;
@@ -942,7 +944,7 @@ export class BaseNode extends EventEmitter {
   }
 
   get app() {
-    return this.getAncestor('App') as App;
+    return varScopeCtx.isFirstScreen ? varScopeCtx.app : this.getAncestor('App') as App;
   }
 
   /**
@@ -1435,13 +1437,9 @@ export class BaseNode extends EventEmitter {
    * @description 与`traverseChildren`不同，此方法会过滤掉非节点值
    */
   *traverseChildrenGenerator(cb: (node: types.SyntaxNode) => (void | Generator<any, any, any>)) {
-    const isNode = (node: unknown): node is types.SyntaxNode => {
-      return Boolean(node) && typeof node === 'object' && ('concept' in node) && typeof (node as any).concept === 'string';
-    };
-
     function* traverse(node: BaseNode): Generator<any, any, any> {
-      if (isNode(node)) {
-        const result = cb(node);
+      if (asserts.isBaseNode(node)) {
+        const result = cb(node as types.SyntaxNode);
 
         if (utils.isGenerator(result)) {
           yield* result;
@@ -1486,50 +1484,122 @@ export class BaseNode extends EventEmitter {
    * @description 严格迭代所有子节点！排除属性！
    */
   traverseStrictChildren(cb: (el: types.SyntaxNode) => void, whitelist?: string[]): void {
-    this.traverseChildren((el) => {
-      if (asserts.isBaseNode(el)) {
-        cb(el as types.SyntaxNode);
+    function traverse(node: any) {
+      if (!node) {
+        return;
+      }
+
+      if (asserts.isBaseNode(node)) {
+        cb(node as types.SyntaxNode);
       }
-    }, whitelist);
+
+      const propertyMap = getConceptPropertyMap(node?.concept);
+
+      if (!propertyMap) {
+        return;
+      }
+
+      const keys = (whitelist && whitelist.length > 0)
+        ? Array.from(propertyMap.keys()).concat(whitelist)
+        : propertyMap.keys();
+
+      for (const property of keys) {
+        const prop = node[property as keyof BaseNode];
+
+        if (!prop) {
+          continue;
+        }
+        else if (Array.isArray(prop)) {
+          for (const child of prop) {
+            traverse(child);
+          }
+        }
+        else {
+          traverse(prop);
+        }
+      }
+    }
+
+    traverse(this);
   }
 
-   /**
+  /**
    * 迭代所有子节点
    *
-   * @description 严格迭代所有子节点！排除属性！条件满足时可提前终止！
+   * @description 严格迭代所有子节点！排除属性！条件满足时整个遍历全部终止！
    */
-    traverseStrictChildrenStopWhen(cb: (el: types.SyntaxNode) => void, setStopFlag: (el: types.SyntaxNode) => boolean, whitelist?: string[]): void {
-      let shouldStop = false;
+  traverseStrictChildrenStopWhen(cb: (el: types.SyntaxNode) => void, setStopFlag: (el: types.SyntaxNode) => boolean, whitelist?: string[]): void {
+    let shouldStop = false;
 
-      // if ((node instanceof View || node instanceof ViewElement) && node.auth) flag = true;
-      function traverse(node: any) {
-        if (asserts.isBaseNode(node)) {
-          cb(node as types.SyntaxNode);
-        }
+    function __traverse(node: any) {
+      if (asserts.isBaseNode(node)) {
+        cb(node as types.SyntaxNode);
+      }
 
-        shouldStop = shouldStop || setStopFlag(node);
-        if (shouldStop) {
-          return;
-        }
+      shouldStop = shouldStop || setStopFlag(node);
 
-        const propertyMap = getConceptPropertyMap(node?.concept);
-        if (!propertyMap) return;
+      if (shouldStop) {
+        return;
+      }
 
-        const propertyKeys = [...propertyMap.keys()];
-        if (Array.isArray(whitelist) && whitelist.length) {
-          propertyKeys.push(...whitelist);
-        }
-        for (const property of propertyKeys) {
-          const child = node[property as keyof BaseNode];
-          if (!child) continue;
-          else if (Array.isArray(child)) child?.forEach?.((node: types.SyntaxNode) => traverse(node));
-          else traverse(child);
+      const propertyMap = getConceptPropertyMap(node?.concept);
+      if (!propertyMap) return;
+
+      const propertyKeys = [...propertyMap.keys()];
+      if (Array.isArray(whitelist) && whitelist.length) {
+        propertyKeys.push(...whitelist);
+      }
+      for (const property of propertyKeys) {
+        const child = node[property as keyof BaseNode];
+        if (!child) continue;
+        else if (Array.isArray(child)) child?.forEach?.((node: types.SyntaxNode) => __traverse(node));
+        else __traverse(child);
+      }
+    }
+
+    __traverse(this);
+  }
+
+  /**
+   * 迭代所有子节点
+   * @description 严格迭代所有子节点，排除属性；多函数特化版本，不做额外检查
+   */
+  *traverseStrictChildrenDoMultiTasks(
+    tasks: Array<(_: BaseNode) => Generator<any, any, any>>,
+    cleanups: Array<(_: BaseNode) => Generator<any, any, any>>): Generator<any, any, any> {
+
+    function __traverse(nd: BaseNode) {
+      if (!asserts.isBaseNode(nd)) {
+        return;
+      }
+      tasks.forEach(task => utils.runGeneratorSync(task(nd)));
+
+      const props = getConceptPropertyMap(nd?.concept)?.keys();
+      if (!props) {
+        cleanups.forEach(task => utils.runGeneratorSync(task(nd)));
+        return;
+      }
+
+      for (const p of props) {
+        const child = nd[p as keyof BaseNode];
+        if (!child) {
+          continue;
+        } else if (Array.isArray(child)) {
+          child?.forEach?.((node: types.SyntaxNode) => {
+              __traverse(node);
+          });
+        } else {
+          __traverse(child);
         }
       }
 
-      traverse(this);
+      cleanups.forEach(task => utils.runGeneratorSync(task(nd)));
     }
 
+    __traverse(this);
+  }
+
+
   /**
    *  获取当前节点在nasl标注节点上的节点
    */

package/src/common/utils.ts

@@ -1,17 +1,239 @@
+import type { AxiosInstance } from 'axios';
 import type { types } from '../concepts';
+import EntityProperty from '../concepts/EntityProperty__';
+import Entity from '../concepts/Entity__';
+import OqlQueryComponent from '../concepts/OqlQueryComponent__';
+import api from '../service/logic/api';
+import { naslOQLCacheStore } from '../utils/language-cache/nasl';
 
-export function waitOqlQueryComponentChildrenFinish(node: types.SyntaxNode) {
-  const needGetSourceMapOqlList: Promise<any>[] = [];
+type OQLEmbeddedTSRequestPayload = {
+  appId: 'myAppId';
+  oqlIdentifier: 'myoqlIdentifier';
+  dataSourceName: string;
+  oql: string;
+  ideVersion: string;
+  dataSourceNasl: any[];
+  typeScriptStartLine: 1;
+  typeScriptStartLineColumn: 1;
+};
+
+type PayloadWithCacheKey = {
+  payload: OQLEmbeddedTSRequestPayload | null;
+  cacheKey: string;
+};
+
+function preparePayloadAndCacheKey(oql: OqlQueryComponent): PayloadWithCacheKey {
+  if (oql.code) {
+    let dataSourceNasl = oql.app.findNodeByCompleteName(oql.dataSource)?.toJSON();
+    if (dataSourceNasl) {
+      dataSourceNasl = {
+        concept: 'DataSource',
+        entities: (dataSourceNasl.entities = dataSourceNasl.entities?.map((entity: Entity) => {
+          return {
+            name: entity.name,
+            concept: entity.concept,
+            tableName: entity.tableName,
+            properties: entity.properties?.map((prop: EntityProperty) => {
+              return {
+                name: prop.name,
+                concept: prop.concept,
+                columnName: prop.columnName,
+              };
+            }),
+          };
+        })),
+      };
+    }
+    const payload: OQLEmbeddedTSRequestPayload = {
+      appId: 'myAppId',
+      oqlIdentifier: 'myoqlIdentifier',
+      dataSourceName: oql.dataSource,
+      oql: oql.code,
+      ideVersion: oql.app.ideVersion,
+      dataSourceNasl,
+      typeScriptStartLine: 1,
+      typeScriptStartLineColumn: 1,
+    };
+    return {
+      cacheKey: JSON.stringify(payload),
+      payload: payload,
+    };
+  }
+  return {
+    cacheKey: '',
+    payload: null,
+  };
+}
+
+type RequestedEmbeddedTS = {
+  typescript: string;
+  lexicalErrorCode: number;
+};
+
+// 从服务端获取 SQL -> TS 的翻译和 sourceMap
+export async function requestEmbeddedTS(this: OqlQueryComponent): Promise<void> {
+  const { http, logger } = this.rootNode.naslServer;
+
+  if (this.code) {
+    let dataSourceNasl = this.app.findNodeByCompleteName(this.dataSource)?.toJSON();
+    if (dataSourceNasl) {
+      dataSourceNasl = {
+        concept: 'DataSource',
+        entities: (dataSourceNasl.entities = dataSourceNasl.entities?.map((entity: Entity) => {
+          return {
+            name: entity.name,
+            concept: entity.concept,
+            tableName: entity.tableName,
+            properties: entity.properties?.map((prop: EntityProperty) => {
+              return {
+                name: prop.name,
+                concept: prop.concept,
+                columnName: prop.columnName,
+              };
+            }),
+          };
+        })),
+      };
+    }
+
+    const queryWithCache = async () => {
+      const params = {
+        appId: 'myAppId',
+        oqlIdentifier: 'myoqlIdentifier',
+        dataSourceName: this.dataSource,
+        oql: this.code,
+        ideVersion: this.app.ideVersion,
+        dataSourceNasl,
+        typeScriptStartLine: 1,
+        typeScriptStartLineColumn: 1,
+      };
+      const key = JSON.stringify(params);
+      let res = null;
+      let canUseCache = false;
+      try {
+        res = await naslOQLCacheStore.getItem(key);
+        canUseCache = true;
+      } catch (error) {}
+      if (res !== null) {
+        return res;
+      }
+      return http.post(api.queryDebugTypescript.url.path, params).then(async ({ data }) => {
+        if (canUseCache) {
+          try {
+            await naslOQLCacheStore.setItem(key, data);
+          } catch (error) {}
+        }
+        return data;
+      });
+    };
+
+    return queryWithCache()
+      .then((data: any) => {
+        this.codeSourceMap = data.result ?? { typescript: '', lexicalErrorCode: 1001 };
+      })
+      .catch((err) => {
+        logger.error('Oql 请求失败', err.toString());
+        this.codeSourceMap = { typescript: '', lexicalErrorCode: 1001 };
+      });
+  }
+  this.codeSourceMap = { typescript: '', lexicalErrorCode: 1001 };
+}
+
+async function makeCachedBatchRequest(
+  http: AxiosInstance,
+  payloadWithCacheKeyList: PayloadWithCacheKey[]
+): Promise<(RequestedEmbeddedTS | null)[]> {
+  const itemsWithIndex = payloadWithCacheKeyList.map((item, index) => {
+    return { item, index };
+  });
+
+  const cacheTest = await Promise.all(
+    itemsWithIndex.map(async ({ item, index }) => {
+      const cached: RequestedEmbeddedTS | null = await naslOQLCacheStore.getItem(item.cacheKey);
+      return { item, index, cached };
+    })
+  );
+
+  const notCachedList = cacheTest.filter((x) => !x.cached);
+  const cachedList = cacheTest.filter((x) => x.cached);
+
+  const resultContainer = Array.from<RequestedEmbeddedTS | null>({
+    length: payloadWithCacheKeyList.length,
+  }).fill(null);
+
+  for (const { cached, index } of cachedList) {
+    resultContainer[index] = cached;
+  }
+  const paramList = notCachedList.map((x) => x.item.payload);
+  const tempResultList: (RequestedEmbeddedTS | null)[] = paramList.length
+    ? await http
+        .post(api.queryDebugTypescriptBatch.url.path, paramList)
+        .then((x) => x.data.result)
+        .then(async (resultList: (RequestedEmbeddedTS | null)[]) => {
+          await Promise.all(
+            resultList.map((res, index) => {
+              const payload = notCachedList[index];
+              resultContainer[payload.index] = res;
+              return naslOQLCacheStore.setItem(payload.item.cacheKey, res);
+            })
+          );
+          return resultList;
+        })
+    : [];
+  if (tempResultList.length !== paramList.length) {
+    throw new Error('返回的数据长度不一致');
+  }
+  return resultContainer;
+}
+
+// 从服务端获取 SQL -> TS 的翻译和 sourceMap
+export async function requestEmbeddedTSBatch(
+  http: AxiosInstance,
+  oqlList: OqlQueryComponent[]
+): Promise<void> {
+  const paramList = oqlList.map((oql) => {
+    const { cacheKey, payload } = preparePayloadAndCacheKey(oql);
+    return { oql, cacheKey, payload };
+  });
+
+  return makeCachedBatchRequest(http, paramList)
+    .then((data) => {
+      if (data.length !== oqlList.length) {
+        throw new Error('返回的数据长度不一致');
+      }
+      data.forEach((item, index) => {
+        const targetOql = oqlList[index];
+        targetOql.codeSourceMap = item ?? { typescript: '', lexicalErrorCode: 1001 };
+      });
+    })
+    .catch((err) => {
+      // TODO wudengke logger
+      console.error('Oql 请求失败', err.toString());
+      console.error(err);
+    });
+}
+
+export async function waitOqlQueryComponentChildrenFinish(node: types.SyntaxNode) {
+  const oqlList: OqlQueryComponent[] = [];
 
   node.traverseStrictChildren((el) => {
     if (el.concept === 'OqlQueryComponent') {
       if (!el.codeSourceMap) {
-        needGetSourceMapOqlList.push(el.requestEmbeddedTS());
+        oqlList.push(el);
       }
     }
   });
 
-  if (needGetSourceMapOqlList.length > 0) {
-    return Promise.all(needGetSourceMapOqlList);
+  if (oqlList.length > 0) {
+    const http =
+      node.rootNode?.naslServer.http ??
+      // @ts-expect-error
+      // 若是App节点
+      node?.naslServer.http;
+    if (http) {
+      return requestEmbeddedTSBatch(http, oqlList);
+    } else {
+      throw new Error('http client 不存在');
+    }
   }
 }

package/src/concepts/App__.ts

@@ -3839,23 +3839,24 @@ export class App extends BaseNode {
   deleteCompose(path: string[]) {
     if (!Array.isArray(path)) return;
     let compose = this.composeCache;
-
-    const delNodes = (_compose: composeCacheType) => {
+    const delNodes = (_compose: composeCacheType, key: string) => {
       if (_compose?.nodes) {
         for (const key in _compose) {
-          if (key !== 'nodes') {
-            delNodes(_compose[key]);
+          // 只有form和table层级触发删除
+          if (key !== 'nodes' && key !== 'saveModalForm') {
+            delNodes(_compose[key], key);
           }
         }
         const arr = [..._compose.nodes] || [];
-        const triggerNode: BaseNode[] = []; // 触点放在最后删
-        arr.forEach((node) => {
-          if (node.name === path?.[0]) {
-            triggerNode.push(node);
-          } else {
-            node && node.delete();
-          }
-        });
+        // table内的saveModalForm.nodes也在table层级一起删除，避免先删父后删子的情况
+        if (_compose.hasOwnProperty('saveModalForm')) {
+          arr.push(..._compose.saveModalForm.nodes);
+        }
+        // 按照路径长度，粗粒度处理好父子关系后，再删除节点
+        const triggerNode = arr
+          .map((item, index) => ({ nodePath: item?.nodePath, index }))
+          .sort((a, b) => b.nodePath.length - a.nodePath.length)
+          .map((item) => arr[item.index]);
 
         triggerNode.forEach((node) => {
           node && node.delete();
@@ -3867,10 +3868,13 @@ export class App extends BaseNode {
 
     this.emit('collect:start', {
       actionMsg: '删除同一分组节点',
+      extra: {
+        isCustomDesigner: true,
+      },
     });
     path.forEach((key, index) => {
       if (index === path.length - 1) {
-        delNodes(compose?.[key]);
+        delNodes(compose?.[key], key);
       } else {
         compose = compose[key];
       }

package/src/concepts/AuthLogicForCallInterface__.ts

@@ -42,6 +42,7 @@ import * as asserts from './utils/asserts';
 
 import Param from './Param__';
 import AuthLogic from './AuthLogic__';
+import { reCollectTyInferCtx } from '../server/semanticData';
 
 /**
  * 调用接口的鉴权逻辑
@@ -352,61 +353,7 @@ export class AuthLogicForCallInterface extends AuthLogic {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
     code += '{\n';
     // 用于虚拟节点的查找引用
     if (Array.isArray(self.virtualParams)) {
@@ -551,7 +498,7 @@ export class AuthLogicForCallInterface extends AuthLogic {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {

package/src/concepts/BusinessComponent__.ts

@@ -46,6 +46,7 @@ import Variable from './Variable__';
 import BindEvent from './BindEvent__';
 import BusinessLogic from './BusinessLogic__';
 import ViewElement from './ViewElement__';
+import { reCollectTyInferCtx } from '../server/semanticData';
 
 /**
  * 业务组件
@@ -1999,53 +2000,7 @@ export class BusinessComponent extends BaseNode {
 
     const advanceMap: Map<Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          const advanceVar = self.variables?.find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('')
-                : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
 
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
     const IDENTIFIERMAP = new Set<Variable>();
@@ -2155,7 +2110,7 @@ export class BusinessComponent extends BaseNode {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {
@@ -2523,11 +2478,11 @@ export class BusinessComponent extends BaseNode {
   @withSourceMap()
   toTextualNASL(state = createCompilerState()): string {
     let code = '';
-    
+
     code += createDecoratorCode(state, this, ['title', 'description']);
 
     code += `viewComponent ${this.name}`;
-    
+
     code += `(\n`;
     this.params.forEach((param, index) => {
       code += param.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
@@ -2551,7 +2506,7 @@ export class BusinessComponent extends BaseNode {
       code += '\n';
     });
     if (this.logics.length) code += '\n';
-    
+
     code += this.elements[0].toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
 
     code += `\n${indent(state.tabSize)}}`;