@lcap/nasl 3.8.0-beta.6 → 3.8.0-beta.7

package/src/generator/permission.ts

@@ -15,6 +15,8 @@ import {
   BindStyle,
   BindDirective,
   Connector,
+  Identifier,
+  Event,
 } from '../concepts';
 import { processToTreeFragment } from '../server/process2LogicNamespace';
 
@@ -145,14 +147,14 @@ function removeRedundantResourceData(resources: ResourceNode[][]) {
   resources.sort((a, b) => wm.get(a).length - wm.get(b).length);
 
   const res: ResourceNode[][] = [];
-  const hashs: string[] = [];
+  const hashes: string[] = [];
 
   for (const resource of resources) {
     const hash = wm.get(resource);
-    if (hashs.some((h) => hash.endsWith(h))) continue;
+    if (hashes.some((h) => hash.endsWith(h))) continue;
 
     res.push(resource);
-    hashs.push(hash);
+    hashes.push(hash);
   }
   return res;
 }
@@ -278,7 +280,7 @@ function checkUploadAuth(uploaders: Map<string, ViewElement[]>) {
   // 如果开启控制权限-component，没开启权限-page
   uploaders.forEach((value, key) => {
     const authValue: ResourceNode[] = [];
-    value.map((node) => {
+    value.forEach((node) => {
       if (node instanceof ViewElement && node.view) {
         const path = node.auth ? node.authPath : `${node.view.path}`;
         const type = node.auth ? 'component' : 'page';
@@ -290,25 +292,29 @@ function checkUploadAuth(uploaders: Map<string, ViewElement[]>) {
   });
   return res;
 }
-function checkPageAndUploadAuth(uploaders: Map<string, ViewElement[]>, key: string) {
-  let flag: number = -1;
-  flag = uploaders.get(key)?.findIndex((node) => {
-    if (node.getAncestor('View') instanceof View) {
+
+function checkPageAndUploadAuth(uploaders: Map<string, ViewElement[]>, key: string): boolean {
+  let flag: boolean = false;
+
+  uploaders.get(key).forEach((node) => {
+    if (node.view instanceof View) {
       // 当前页面未开启权限且文件上传组件也未开启权限
-      if (!(node.getAncestor('View') as View).auth && node instanceof ViewElement && !node.auth) {
-        return true;
+      if (!node.view.auth && node instanceof ViewElement && !node.auth) {
+        flag = true;
       }
     } else if (node.getAncestor('BusinessComponent')) {
-      return true;
+      flag = true;
     }
   });
+
   return flag;
 }
+
 function convertArray(arr: ResourceNode[]) {
   return arr.map((item: any) => [item]);
 }
-export async function genPermissionData(app: App) {
-  // console.time('xxx');
+
+export async function genPermissionDataOld(app: App) {
   openCache();
   const logicPageResourceDtoList: { [key: string]: ResourceNode[][]; } = {};
   const { logics, processLogics } = getAllLogics(app);
@@ -316,31 +322,335 @@ export async function genPermissionData(app: App) {
   for (const logic of [...logics, ...processLogics]) {
     const resources = await findResourcesOfLogic(logic, uploaders);
     if (resources.length === 0) continue;
-    const service = logics.includes(logic) ? logic.toService() : (logic.toProcessService() as { url: { method: string; path: string; }; });
+    const service = logics.includes(logic)
+      ? logic.toService()
+      : (logic.toProcessService() as { url: { method: string; path: string; }; });
     const key = `${service.url.path}:${service.url.method}`;
     logicPageResourceDtoList[key] = resources;
   }
-  const authValue = checkUploadAuth(uploaders);
-  if (authValue?.length) {
-    authValue.forEach((item) => {
+  const authVals = checkUploadAuth(uploaders);
+  if (authVals?.length) {
+    authVals.forEach((item) => {
       const { key, authValue } = item;
       if (key.startsWith('/upload' || '/api/')) {
-        logicPageResourceDtoList[`${key}:POST`] = checkPageAndUploadAuth(uploaders, key) !== -1 ? [[]] : convertArray(authValue);
+        logicPageResourceDtoList[`${key}:POST`] = checkPageAndUploadAuth(uploaders, key) ? [[]] : convertArray(authValue);
       }
     });
   }
   logicPageResourceDtoList['/upload/download_files:POST'] = callLogicUploadList;
   closeCache();
-  // console.timeEnd('xxx');
   return logicPageResourceDtoList;
 }
+
+
+
+function generateServiceKey(logic : Logic, kind : 'server' | 'process') {
+  let service : { url: { method: string; path: string; }};
+  if (kind === 'server') {
+    service = logic.toService()
+  } else if (kind === 'process') {
+    service  = (logic.toProcessService() as { url: { method: string; path: string; }; })
+  } else {
+    throw new Error('Invalid service key kind')
+  }
+  const key = `${service.url.path}:${service.url.method}`;
+  return key;
+}
+
+function createArrayOnAdd<K, V>(k : K, v : V, m: Map<K, Array<V>>) {
+  if (m.get(k)) {
+    m.get(k).push(v);
+  } else {
+    m.set(k, [v]);
+  }
+}
+
+// 需要区分：前端逻辑、后端逻辑、流程逻辑
+// 需要的信息：后端逻辑、流程逻辑的 service path；逻辑调用到其定义的映射；
+// 流程逻辑 call 的 getCallNode() 每次都不同
+// 表单验证 $refs.validate 的定义缺少 calleewholeKey 且访问时会抛异常
+// 不跳过 playground 草稿区内容：赫基有用到 JS代码块，在代码块里调用逻辑。JS代码块里的引用没有识别出来。但恰巧在草稿区的东西，提供了引用关系。赫基项目，删除了草稿区的东西会导致401。
+export function genPermissionData(app: App): { [key: string]: ResourceNode[][]; } {
+  type TraverseCtx = { viewElement : ViewElement, viewElements: Set<ViewElement>, thisLogic : Logic, bindEvent : BindEvent, event : Event, view : View};
+  type LogicCtx = { view : View, viewElements : Set<ViewElement> }
+  type FrontendLogicCtx = { view : View, viewElements : Set<ViewElement>, thisLogic : Logic }
+
+  function clearCtx(ctx: TraverseCtx) {
+    ctx.viewElement = null;
+    ctx.viewElements = new Set();
+    ctx.thisLogic = null;
+    ctx.bindEvent = null;
+    ctx.event = null;
+    ctx.view = null;
+  }
+  const { logics : tmpLogics, processLogics : tmpProcessLogics } = getAllLogics(app);
+
+  // 调用后端逻辑的Map
+  const backendLogicCallCtx : Map<string, Array<LogicCtx>> = new Map();
+
+  // 调用前端逻辑的Map
+  const frontendLogicCallCtx: Array<FrontendLogicCtx> = [];
+
+  // from calleeWholeKey to Logic，消除流程逻辑每次找到的定义都是即时演算生成的，地址不同的问题。
+  const frontNdCache = new Map<string, Logic>();
+  const processNdCache = new Map<string, Logic>();
+  const serverNdCache = new Map<string, Logic>();
+
+  tmpProcessLogics.forEach(l => processNdCache.set(l.calleewholeKey, l));
+  tmpLogics.forEach(l => serverNdCache.set(l.calleewholeKey, l));
+
+  // 上传组件
+  const uploaders = new Map<string, Array<ViewElement>>();
+  const callLogicUploadList = new Map<string, any>();
+  let callLogicUploadFlag = false;
+
+  const defToCalls : Map<Logic, Array<CallLogic>> = new Map();
+  app.frontendTypes.forEach((frontendType) => {
+    frontendType.traverseChildrenWithContext((nd, ctx : TraverseCtx) => {
+      switch (nd.concept) {
+        case 'ViewElement': {
+          ctx.thisLogic = null;
+          ctx.viewElement = nd;
+          ctx.viewElements = new Set(ctx.viewElements); // if use ctx.viewElements.add(node) directly, will encounter a SEVERE slow down. For example, 3s vs 12s
+          ctx.viewElements.add(nd);
+          // collect uploaders
+          if (nd.tag?.includes('uploader')) {
+            const urlAttr = nd.bindAttrs.find((item : BindAttribute) => item.name === 'url');
+            const url = urlAttr?.value;
+            if (url) {
+              if (!uploaders.has(url)) uploaders.set(url, [nd]);
+              else uploaders.get(url).push(nd);
+            }
+          }
+          break;
+        }
+        case 'BindEvent': ctx.bindEvent = nd; break;
+        case 'Event': ctx.event = nd; break;
+        case 'CallLogic': {
+          const { thisLogic, event, bindEvent, view, viewElement, viewElements } = ctx;
+          createArrayOnAdd(thisLogic, nd, defToCalls);
+          if (viewElement || bindEvent || event) {
+            const [kind, logicDecl] = (nd as CallLogic).getCallNodeUsingCache(frontNdCache, serverNdCache, processNdCache);
+            switch (kind) {
+              case 'server': {
+                const key = generateServiceKey(logicDecl, 'server');
+                createArrayOnAdd(key, { view, viewElements }, backendLogicCallCtx);
+                break;
+              }
+              case 'process': {
+                const key = generateServiceKey(logicDecl, 'process');
+                createArrayOnAdd(key, { view, viewElements }, backendLogicCallCtx);
+                break;
+              }
+              case 'front': {
+                frontendLogicCallCtx.push({ view, viewElements, thisLogic: logicDecl });
+                break;
+              }
+              default: throw new Error('Invalid logic kind');
+            }
+          }
+
+          // 收集 callLogicUploadList
+          if (nd?.calleeName?.includes('downloadFile') && nd?.calleeNamespace === 'nasl.io' && !callLogicUploadFlag) {
+            // ViewElement 权限优先
+            if (viewElement instanceof ViewElement && viewElement?.auth) {
+              callLogicUploadList.set(viewElement?.authPath, [{
+                type: 'component',
+                path: viewElement?.authPath
+              }]);
+            } else if (view instanceof View && view?.auth) {
+              callLogicUploadList.set(view?.authPath, [{
+                type: 'page',
+                path: view?.authPath
+              }]);
+            } else {
+              // 如果开启权限和未开启权限都有，以未开启权限为准，清空 map，设置为 [[]]
+              callLogicUploadFlag = true;
+              callLogicUploadList.clear()
+            }
+          }
+          break;
+        }
+        case 'BindAttribute': {
+          if (nd.name === 'dataSource'
+              && nd.type === 'dynamic'
+              && nd.expression instanceof Identifier
+              && (ctx.view) // View | BusinessComponent
+          ) {
+            const viewLogics = ctx.view.logics; // Array<Logic> | Array<BusinessLogic>
+            const identName = nd.expression.name;
+            const logic = viewLogics.find((viewLogic : any) => {
+              return viewLogic?.name === identName;
+            });
+            if (logic) {
+              const { viewElements, view } = ctx;
+              frontendLogicCallCtx.push({ viewElements, view, thisLogic: logic });
+            }
+          }
+          break;
+        }
+        case 'Logic': ctx.thisLogic = nd; break;
+        case 'BusinessLogic': ctx.thisLogic = nd; break;
+        case 'View': clearCtx(ctx); ctx.view = nd; break;
+        case 'Identifier': {
+          // 参数选了函数名。高阶函数。
+          if (nd?.namespace === "app.logics") {
+            const key = `/api/lcplogics/${nd.name}:POST`;
+            createArrayOnAdd(key, { view: ctx.view, viewElements: ctx.viewElements }, backendLogicCallCtx);
+          }
+          // 草稿区也可能有这种 concept 是 Identifier 的调用
+          if (ctx?.view) {
+            const viewLogics = ctx.view.logics; // Array<Logic> | Array<BusinessLogic>
+            const identName = nd.name;
+            const logic = viewLogics.find((viewLogic : any) => {
+              return viewLogic?.name === identName;
+            });
+            if (logic) {
+              const { viewElements, view } = ctx;
+              frontendLogicCallCtx.push({ viewElements, view, thisLogic: logic });
+            }
+          }
+          break;
+        }
+        case 'BusinessComponent': clearCtx(ctx); ctx.view = nd; break;
+        default: break;
+      }
+    });
+  });
+
+  frontendLogicCallCtx.forEach(({ view, viewElements, thisLogic }) => {
+    const findCallBackendLogic = ([kind, l] : ['process' | 'server' | 'front', Logic]) => {
+      if (!l) {
+        return;
+      }
+      switch (kind) {
+        case 'server': {
+          const key = generateServiceKey(l, 'server');
+          createArrayOnAdd(key, { view, viewElements }, backendLogicCallCtx);
+          break;
+        }
+        case 'process': {
+          const key = generateServiceKey(l, 'process');
+          createArrayOnAdd(key, { view, viewElements }, backendLogicCallCtx);
+          break;
+        }
+        case 'front': {
+          const lgcCalls : Array<CallLogic> = defToCalls.get(l);
+          lgcCalls?.forEach( call => findCallBackendLogic(call.getCallNodeUsingCache(frontNdCache, serverNdCache, processNdCache)));
+          break;
+        }
+        default: {
+          throw new Error('Invalid logic kind in frontendLogicCallCtx');
+        }
+      }
+    };
+    findCallBackendLogic(['front', thisLogic]);
+  });
+
+  const logicPageResourceDtoList: { [key: string]: ResourceNode[][]; } = {};
+  backendLogicCallCtx.forEach((ctx, key) => {
+    const resources: ResourceNode[][] = [];
+    ctx?.forEach(({ viewElements, view }) => {
+      const pathInfos: Array<ResourceNode> = [];
+      viewElements?.forEach((viewElement) => {
+        if (viewElement?.auth) {
+          pathInfos.push({
+            path: viewElement?.authPath,
+            type: 'component',
+          });
+        }
+      });
+      let viewIter : BaseNode = view;
+      while (viewIter) {
+        if (viewIter instanceof View && viewIter.auth) {
+          pathInfos.push({
+            path: viewIter.authPath,
+            type: 'page',
+          });
+        }
+        viewIter = viewIter.parentNode;
+      }
+      resources.push(pathInfos);
+    });
+    logicPageResourceDtoList[key] = optimizeResourceData(resources);
+  });
+
+  const authVals = checkUploadAuth(uploaders);
+  if (authVals?.length) {
+    authVals.forEach((item) => {
+      const { key, authValue } = item;
+      if (key.startsWith('/upload' || '/api/')) {
+        logicPageResourceDtoList[`${key}:POST`] =
+            checkPageAndUploadAuth(uploaders, key) ? [[]] : convertArray(authValue);
+      }
+    });
+  }
+  logicPageResourceDtoList['/upload/download_files:POST'] =
+      callLogicUploadList.size === 0 ? [[]] : Array.from(callLogicUploadList.values());
+
+  return logicPageResourceDtoList;
+}
+
 export function genLogicAuthFlag(app: App) {
   let flag = false;
-  app.traverseChildren((node) => {
-    if (flag) return;
-
+  app.traverseStrictChildrenStopWhen((node) => {
     if ((node instanceof View || node instanceof ViewElement) && node.auth) flag = true;
-  });
+  }, (nd) => (nd instanceof View || nd instanceof ViewElement) && Boolean(nd.auth), []);
 
   return flag;
 }
+
+
+function compareResourceNode(a: ResourceNode, b: ResourceNode) {
+  if (a.path < b.path) {
+    return -1;
+  }
+  if (a.path > b.path) {
+    return 1;
+  }
+  if (a.type < b.type) {
+    return -1;
+  }
+  if (a.type > b.type) {
+    return 1;
+  }
+  return 0;
+}
+
+function compareResourceNodeList(a: Array<ResourceNode>, b: Array<ResourceNode>) {
+  a.sort(compareResourceNode);
+  b.sort(compareResourceNode);
+  for (let i = 0; i < a.length; i++) {
+    const result = compareResourceNode(a[i], b[i]);
+    if (result !== 0) {
+      return result;
+    }
+  }
+  return 0;
+}
+
+export function sortResourceDtoMap<K>(m : Map<K, Array<Array<ResourceNode>>>){
+  const keys = Array.from(m.keys()).sort();
+  const sortedMap = new Map<K,Array<Array<ResourceNode>>>();
+  keys.forEach((key) => {
+    sortedMap.set(key, m.get(key).sort(compareResourceNodeList));
+  });
+
+  keys.forEach((key) => {
+    sortedMap.get(key).forEach((item) => {
+      item.sort(compareResourceNode);
+    });
+  });
+  return sortedMap;
+}
+
+export async function testWithOldPermissionResult(app: App, newRes : { [key: string]: ResourceNode[][]; }) {
+  const newResMap = sortResourceDtoMap(new Map(Object.entries(newRes)));
+  console.log('newResMap', newResMap)
+  const oldRes : { [key: string]: ResourceNode[][]; } = await genPermissionDataOld(app);
+  const oldResMap = sortResourceDtoMap(new Map(Object.entries(oldRes)));
+  console.log('oldResMap', oldResMap)
+
+  console.log("oldLogicPageResourceDtoListMap  ===  newLogicPageResourceDtoListMap?",
+    JSON.stringify(Array.from(newResMap.entries())) === JSON.stringify(Array.from(oldResMap.entries())));
+}

package/src/generator/release-body/body.ts

@@ -6,7 +6,7 @@ import {
 import { genFrontendBundleFiles } from '../genBundleFiles';
 import { InternalReleaseData } from './internal';
 import { replaceAssetUrl, getAuthReport, getFrontendByTypes, findAllReportIdList, getProcessFormDefinitions } from './utils';
-import { genPermissionData, genLogicAuthFlag } from '../permission';
+import { genPermissionDataOld, genPermissionData, genLogicAuthFlag, testWithOldPermissionResult } from '../permission';
 import { getCallLogicData } from './validation';
 
 import * as utils from '../../utils';
@@ -80,7 +80,7 @@ export async function getNaslAnnotatedJSON(app: App, opt: InternalReleaseData) {
 
   try {
     NaslAnnotatedJSON = await app.naslServer.getNaslAnnotatedJSON(app, true);
-    await opt.logPublishFunc?.('语言', '获取类型标注成功');
+    await opt.logPublishFunc?.('语言', '获取全量类型标注成功');
 
     // // 打印传给服务端的 nasl,为了服务端排查问题方便
     // if (globalThis.window) {
@@ -165,6 +165,8 @@ export async function getNaslAnnotatedJSON(app: App, opt: InternalReleaseData) {
     }
   });
 
+  await opt.logPublishFunc?.('资源', '前端静态资源替换完成');
+
   return {
     name: 'nasl-annotated.json',
     content: JSON.stringify(NaslAnnotatedJSON),
@@ -203,12 +205,16 @@ async function getFrontendBundleFiles(app: App, opt: InternalReleaseData) {
   return files;
 }
 
+
 async function mergeBodyData(app: App, opt: InternalReleaseData) {
   await utils.delay(500);
 
   const authReport: ReturnType<typeof getAuthReport> = getAuthReport(app, opt.frontends);
   await opt.logPublishFunc?.('权限', '分析权限数据成功！');
-  const logicPageResourceDtoList = await genPermissionData(app);
+  const logicPageResourceDtoList = genPermissionData(app);
+
+  // 与老板逻辑权限数据对比
+  // await testWithOldPermissionResult(app, logicPageResourceDtoList);
   const allFrontends = getFrontendByTypes(app?.frontendTypes);
   const releaseFrontends = allFrontends.map((frontend: Frontend) => ({
     name: frontend.name,
@@ -217,6 +223,8 @@ async function mergeBodyData(app: App, opt: InternalReleaseData) {
     selected: opt.frontends.includes(frontend),
     title: frontend.title,
   }));
+  const callbackLogicsName = app.getExtensionsCallbackLogics()
+
   const body = {
     ...authReport, // 如果发布需要上报权限，导出源码不需要
     logicPageResourceDtoList,
@@ -228,7 +236,7 @@ async function mergeBodyData(app: App, opt: InternalReleaseData) {
     branchId: opt.branchId,
     replicas: opt.replicas,
     appSpecification: opt.appSpecification,
-    callbackLogicsName: app.getExtensionsCallbackLogics(),
+    callbackLogicsName,
     frontends: releaseFrontends,
     callLogicValidations: {},
     files: [] as Array<{ name: string; content: string }>,
@@ -242,14 +250,25 @@ async function mergeBodyData(app: App, opt: InternalReleaseData) {
 }
 
 export async function genReleaseBody(app: App, opt: InternalReleaseData) {
+  console.time('--backend--');
+  console.time('mergeBodyData');
   const body = await mergeBodyData(app, opt);
+  console.timeEnd('mergeBodyData');
   const callLogicValidations = await getCallLogicData(app, opt.validations);
+  console.timeEnd('--backend--');
+
+  console.time('--frontend--');
+  console.time('getNaslAnnotatedJSON');
   const annotationFile = await getNaslAnnotatedJSON(app, opt);
+  console.timeEnd('getNaslAnnotatedJSON');
+  console.time('getFrontendBundleFiles');
   const files = opt.ignoreFiles ? [] : await getFrontendBundleFiles(app, opt);
+  console.timeEnd('getFrontendBundleFiles');
+  console.timeEnd('--frontend--');
 
   files.push(annotationFile);
 
-  // nodejs 环境下某些情况下字符会发生错误，需要转译
+  // nodejs 环境下的极速开发模式，在某些情况下字符会发生错误，需要转译
   if (utils.isNode) {
     files.forEach((file) => {
       file.name = encodeURIComponent(file.name);

package/src/generator/release-body/data.ts

@@ -18,7 +18,8 @@ import { Logger, File } from '../../utils';
 export async function getReleaseData(app: App, data: ReleaseData, naslServer: NaslServer, inputLogger?: Logger) {
   const { http, logger: defaultLogger } = naslServer;
   const logger = inputLogger ?? defaultLogger;
-  defaultLogger.time('前端构建');
+  console.time('all');
+  console.time('request');
   const appInfo = await getAppInfo(http, data);
   await logger.info('构建环境', '获取环境信息成功');
   const { version, fullVersion, dependencies } = await getVersionDetail(http, app);
@@ -77,7 +78,9 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
       await logger.info('生成器', '服务端验证数据获取成功');
     }
   }
+  console.timeEnd('request');
 
+  console.time('前端构建');
   await logger.info('构建环境', '构建环境完成，开始拼装发布数据');
 
   const releaseBody = await genReleaseBody(app, {
@@ -86,7 +89,9 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
   });
 
   await logger.info('前端生成器', '应用发布数据准备完成');
-  defaultLogger.timeEnd('前端构建');
+  console.timeEnd('前端构建');
+
+  console.timeEnd('all');
 
   return releaseBody;
 }

package/src/generator/release-body/utils.ts

@@ -80,7 +80,7 @@ export function getAuthReport(app: App, frontends: Array<Frontend>) {
  * 获取页面中所有 分析报告组件 的reportId
  */
 export function findAllReportIdList(app: App, frontends: Array<Frontend>) {
-  const reportIds: string[] = [];
+  const reportIds: Set<string> = new Set();
 
   frontends.forEach((frontend) => {
     frontend.views.forEach((view) => loop(view));
@@ -90,7 +90,7 @@ export function findAllReportIdList(app: App, frontends: Array<Frontend>) {
     if (root.concept === 'ViewElement') {
       root.bindAttrs.forEach((attr) => {
         if (attr.name === 'reportId') {
-          reportIds.push(JSON.parse(attr.value || '{}').id);
+          reportIds.add(JSON.parse(attr.value || '{}').id);
         }
       });
     }
@@ -101,7 +101,7 @@ export function findAllReportIdList(app: App, frontends: Array<Frontend>) {
       root.elements.forEach((item) => loop(item));
     }
   }
-  return [...new Set(reportIds)].filter(Boolean);
+  return Array.from(reportIds).filter(Boolean);
 }
 
 export function replaceAssetUrl(

package/src/generator/release-body/validation.ts

@@ -31,9 +31,9 @@ export async function getCallLogicData(app: App, validations: InputServerValidat
 
     nasl.traverseStrictChildren((node) => {
       if (
-        'uuid' in node &&
         node.concept === 'CallLogic' &&
         node.validation &&
+        'uuid' in node &&
         map.has(node.uuid)
       ) {
         const data = map.get(node.uuid)!;

package/src/index.ts

@@ -8,7 +8,19 @@ export * as utils from './utils';
 export * from './config';
 export * from './eventBus';
 export * as breakpoint from './breakpoint';
-export { getOperationRecords, operationRecordInfoMap, doOperationRecord, operationRecordQuery, operationRecordPlayback, loadApp, loadAppSync, handleApp, batchAction, batchQuery, mountDatabaseTypes } from './service/storage/init';
+export {
+  getOperationRecords,
+  operationRecordInfoMap,
+  doOperationRecord,
+  operationRecordQuery,
+  operationRecordPlayback,
+  loadApp,
+  loadAppSync,
+  handleApp,
+  batchAction,
+  batchQuery,
+  mountDatabaseTypes,
+} from './service/storage/init';
 export { createService } from './service/creator';
 export { stepRecorder } from './manager/stepRecorder';
 export * from './natural';

package/src/natural/genNaturalTS.ts

@@ -36,11 +36,12 @@ export function genNaturalTSContextForLogic(
   app: App,
   currentNode?: BaseNode,
   focusedNodePath?: string,
-  requiredIndexes?: string[]
+  requiredIndexes?: string[],
+  experimental?: boolean
 ) {
   const frontend = currentNode?.getAncestor('Frontend') as Frontend;
   const logicType = currentNode?.parentNode?.concept === 'App' ? 'global_logic' : 'view_logic';
-  const state = createCompilerState();
+  const state = createCompilerState('', { descriptionComment: true });
 
   let code = '';
   code += '### [1] 标准库\n';
@@ -98,7 +99,7 @@ export function genNaturalTSContextForLogic(
 
   if (focusedNodePath) {
     code += '\n### 当前逻辑上下文\n';
-    code += getCurrentNodeContext(currentNode, focusedNodePath).code;
+    code += getCurrentNodeContext(currentNode, focusedNodePath, experimental).code;
   }
   return code;
 }
@@ -113,7 +114,7 @@ export function genNaturalTSContextForUI(
   material?: { basicMaterials: { json: any; tsDeclaration: string; }, extensionMaterials: { name: string; title: string; description: string; tsDescription: string; }[]; },
 ) {
   const frontend = currentNode.getAncestor('Frontend') as Frontend;
-  const state = createCompilerState();
+  const state = createCompilerState('', { descriptionComment: true });
 
   let code = '';
   code += '### [1] 标准库\n';
@@ -168,11 +169,12 @@ export function genNaturalTSContextForUI(
 export function genNaturalTSContextJSONForLogic(
   app: App,
   currentNode?: BaseNode,
-  focusedNodePath?: string
+  focusedNodePath?: string,
+  experimental?: boolean
 ) {
   const frontend = currentNode?.getAncestor('Frontend') as Frontend;
   const logicType = currentNode?.parentNode?.concept === 'App' ? 'global_logic' : 'view_logic';
-  const state = createCompilerState();
+  const state = createCompilerState('', { descriptionComment: true });
 
   const { naslCore } = getNaslCore(logicType);
   const { naslUtil } = getNaslUtil();
@@ -190,7 +192,7 @@ export function genNaturalTSContextJSONForLogic(
     state
   );
   const { views } = getFrontendViews(frontend, state, currentNode, false);
-  const { currentLogic } = getCurrentNodeContext(currentNode, focusedNodePath);
+  const { currentLogic } = getCurrentNodeContext(currentNode, focusedNodePath, experimental);
 
   return {
     naslCore,