@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/service/storage/init.ts

@@ -1,14 +1,14 @@
-import { App, LogicItem, Logic, Module, View, ViewElement, Argument, SelectMembers, SynatxNode, BindDirective } from '../../concepts';
+import { App, LogicItem, Logic, Module, View, ViewElement, Argument, SelectMembers, SynatxNode, BindDirective, CallLogic } from '../../concepts';
 import { addBreakpointNodesFromApp } from '../../breakpoint';
 import { getConceptConstructor } from '../../decorators';
 import { config } from '../../config';
-import Vue from 'vue';
 import storageService from './service';
 import { v4 as uuidv4 } from 'uuid';
 import stepRecorder from '../../manager/stepRecorder';
 /// #if !process.env.NODE_ENV || process.env.BUILD_TARGET === 'node'
 import * as fs from 'fs-extra';
 import * as jsoner from './jsoner';
+import type { NaslServer } from 'src/server/naslServer';
 /// #endif
 
 export const batchQuery = storageService.batchQuery;
@@ -20,661 +20,696 @@ let tabTimestamp: string;
 export const databaseTypes = storageService.databaseTypes;
 
 function getLogic(key: string, app: any, diffLogicList: string[]) {
-    if (!diffLogicList.includes(key)) {
-        diffLogicList.push(key);
-        if (key.startsWith('app')) {
-            const index = key.lastIndexOf('.');
-            const name = key.slice(index + 1);
-            const logic = app.logics.find((item: any) => item.name === name);
-            if (logic && logic.body && logic.body.length > 2) {
-                logic.body.map((item: any) => getStatement(item, app, diffLogicList));
-            }
-        } else if (key.startsWith('extensions')) {
-            const _pathArr = key.split('.');
-            const _name = _pathArr[1];
-            const _path = _pathArr[3];
-            const _list = app.dependencies;
-            const _module = _list.find((it: Module) => {
-                const name = it.name.replaceAll('-', '_');
-                return name === _name;
-            });
-            const logic = _module?.logics?.find((item: Logic) => item.name === _path);
-            if (logic && logic.body && logic.body.length > 2) {
-                logic.body.map((item: any) => getStatement(item, app, diffLogicList));
-            }
-        }
+  if (!diffLogicList.includes(key)) {
+    diffLogicList.push(key);
+    if (key.startsWith('app')) {
+      const index = key.lastIndexOf('.');
+      const name = key.slice(index + 1);
+      const logic = app.logics.find((item: any) => item.name === name);
+      if (logic && logic.body && logic.body.length > 2) {
+        logic.body.map((item: any) => getStatement(item, app, diffLogicList));
+      }
+    } else if (key.startsWith('extensions')) {
+      const _pathArr = key.split('.');
+      const _name = _pathArr[1];
+      const _path = _pathArr[3];
+      const _list = app.dependencies;
+      const _module = _list.find((it: Module) => {
+        const name = it.name.replaceAll('-', '_');
+        return name === _name;
+      });
+      const logic = _module?.logics?.find((item: Logic) => item.name === _path);
+      if (logic && logic.body && logic.body.length > 2) {
+        logic.body.map((item: any) => getStatement(item, app, diffLogicList));
+      }
     }
+  }
 }
 /* 获取LogicITEM */
 function getStatement(state: any, app: any, diffLogicList: string[]) {
-    let logicItems = [];
-    switch (state.concept) {
-        case 'Assignment':
-            logicItems = [state.left, state.right];
-            break;
-        case 'IfStatement':
-            logicItems = [...state.consequent, ...state.alternate];
-            break;
-        case 'ForEachStatement':
-            logicItems = [...state.body, state.each, state.start, state.end];
-            break;
-        case 'Match':
-            logicItems = [state.expression, ...state.cases.map(getStatement).flat(1)];
-            break;
-        case 'MatchCase':
-            logicItems = [...state.patterns, ...state.body];
-            break;
-        case 'SwitchStatement':
-            logicItems = state.cases.map(getStatement).flat(1);
-            break;
-        case 'SwitchCase':
-            logicItems = [state.test, ...state.consequent];
-            break;
-        case 'WhileStatement':
-            logicItems = [state.test, ...state.body];
-            break;
-        case 'CallLogic':
-            logicItems = state.arguments?.map((item: Argument) => item.expression);
-            getLogic(state.calleewholeKey, app, diffLogicList);
-            break;
-        case 'CallFunction':
-            logicItems = state.arguments?.map((item: Argument) => item.expression);
-            break;
-        case 'CallInterface':
-            logicItems = state.arguments?.map((item: Argument) => item.expression);
-            break;
-        case 'ExternalDestination':
-            logicItems = [state.anchor, state.link];
-            break;
-        case 'BatchAssignment':
-            logicItems = [state.left?.expression, ...state.left?.members, ...state.rights.map((item: SelectMembers) => [item?.expression, ...item?.members]).flat(1)];
-            break;
-        case 'MemberExpression':
-            logicItems = [state.object, state.property];
-            break;
-        case 'StringInterpolation':
-            logicItems = [...state.expressions];
-            break;
-        case 'NewComposite':
-            logicItems = [...state.rights.map((item: SelectMembers) => item.expression)];
-            break;
-        case 'NewList':
-            logicItems = [...state.items];
-            break;
-        default:
-            break;
-    }
-
-    return logicItems.filter((item: LogicItem) => !!item);
+  let logicItems = [];
+  switch (state.concept) {
+    case 'Assignment':
+      logicItems = [state.left, state.right];
+      break;
+    case 'IfStatement':
+      logicItems = [...state.consequent, ...state.alternate];
+      break;
+    case 'ForEachStatement':
+      logicItems = [...state.body, state.each, state.start, state.end];
+      break;
+    case 'Match':
+      logicItems = [state.expression, ...state.cases.map(getStatement).flat(1)];
+      break;
+    case 'MatchCase':
+      logicItems = [...state.patterns, ...state.body];
+      break;
+    case 'SwitchStatement':
+      logicItems = state.cases.map(getStatement).flat(1);
+      break;
+    case 'SwitchCase':
+      logicItems = [state.test, ...state.consequent];
+      break;
+    case 'WhileStatement':
+      logicItems = [state.test, ...state.body];
+      break;
+    case 'CallLogic':
+      logicItems = state.arguments?.map((item: Argument) => item.expression);
+      getLogic(state.calleewholeKey, app, diffLogicList);
+      break;
+    case 'CallFunction':
+      logicItems = state.arguments?.map((item: Argument) => item.expression);
+      break;
+    case 'CallInterface':
+      logicItems = state.arguments?.map((item: Argument) => item.expression);
+      break;
+    case 'ExternalDestination':
+      logicItems = [state.anchor, state.link];
+      break;
+    case 'BatchAssignment':
+      logicItems = [state.left?.expression, ...state.left?.members, ...state.rights.map((item: SelectMembers) => [item?.expression, ...item?.members]).flat(1)];
+      break;
+    case 'MemberExpression':
+      logicItems = [state.object, state.property];
+      break;
+    case 'StringInterpolation':
+      logicItems = [...state.expressions];
+      break;
+    case 'NewComposite':
+      logicItems = [...state.rights.map((item: SelectMembers) => item.expression)];
+      break;
+    case 'NewList':
+      logicItems = [...state.items];
+      break;
+    default:
+      break;
+  }
+
+  return logicItems.filter((item: LogicItem) => !!item);
 }
 
 /* 小程序影响的服务端发布 */
 function getMiniAppChange(target: any, obj: any, action: string) {
-    if (!target.app.miniEnable) {
-        return false;
-    }
-    /* 分端以后需要改 */
-    const len = target.nodePath?.split('.').length;
-    if (len > 2) {
-        return false;
-    }
-    if (action === 'delete') {
-        return true;
-    } else {
-        if ('name' in obj || 'title' in obj) {
-            return true;
-        }
+  if (!target.app.miniEnable) {
+    return false;
+  }
+  /* 分端以后需要改 */
+  const len = target.nodePath?.split('.').length;
+  if (len > 2) {
+    return false;
+  }
+  if (action === 'delete') {
+    return true;
+  } else {
+    if ('name' in obj || 'title' in obj) {
+      return true;
     }
+  }
 }
 
 /**
  *  执行更新
  */
 async function doAction(app: any, actionItem: any) {
-    let hasFrontEnd = false;
-    let hasBackEnd = false;
-    const actionList: any[] = [];
-    const { list, actionMsg, action } = actionItem || {};
-    const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
-        const _l = getStatement(_i, app, diffArr);
-        if (_l.length) {
-            _l.map((_ii: LogicItem) => itemloop(_ii, app, diffArr));
+  let hasFrontEnd = false;
+  let hasBackEnd = false;
+  const actionList: any[] = [];
+  const { list, actionMsg, action } = actionItem || {};
+  const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
+    const _l = getStatement(_i, app, diffArr);
+    if (_l.length) {
+      _l.map((_ii: LogicItem) => itemloop(_ii, app, diffArr));
+    }
+  };
+  const loopEle = (view: View | ViewElement, checkAuth: boolean) => {
+    if (view instanceof View) {
+      view?.elements?.forEach((item) => loopEle(item, checkAuth));
+    }
+    view?.children?.forEach((item) => loopEle(item, checkAuth));
+    if (view instanceof ViewElement) {
+      if (view.bindEvents.length) {
+        const diffArr: string[] = [];
+        view.bindEvents.forEach((bindEvent) => {
+          bindEvent.logics.forEach((logic) => {
+            logic.body.forEach((logicItem) => itemloop(logicItem, app, diffArr));
+          });
+        });
+        const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
+        if (result.length) {
+          hasBackEnd = true;
         }
-    };
-    const loopEle = (view: View | ViewElement, checkAuth: boolean) => {
-        if (view instanceof View) {
-            view?.elements?.forEach((item) => loopEle(item, checkAuth));
+      }
+      if (view.tag === 'u-uploader' || view.tag === 'van-uploader') {
+        const bute = view?.bindAttrs.find((item) => item.name === 'url');
+        const needUpdateBackEnd = bute?.value?.endsWith('/import') || bute?.value?.includes('/upload/');
+        if (checkAuth) {
+          if (needUpdateBackEnd && !view.view.parentAuth) {
+            hasBackEnd = true;
+          }
+        } else {
+          if (needUpdateBackEnd) {
+            hasBackEnd = true;
+          }
         }
-        view?.children?.forEach((item) => loopEle(item, checkAuth));
-        if (view instanceof ViewElement) {
-            if (view.bindEvents.length) {
-                const diffArr: string[] = [];
-                view.bindEvents.forEach((bindEvent) => {
-                    bindEvent.logics.forEach((logic) => {
-                        logic.body.forEach((logicItem) => itemloop(logicItem, app, diffArr));
-                    });
-                });
-                const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
-                if (result.length) {
-                    hasBackEnd = true;
-                }
+      }
+    }
+  };
+
+  const loopEleAuth = (viewElement: ViewElement) => {
+    viewElement?.children?.forEach((item: ViewElement) => {
+      const bindDirective = item?.bindDirectives?.find(
+        (item: BindDirective) => item.name === 'auth'
+      )
+      if (bindDirective) {
+        hasBackEnd = true
+      }
+      loopEleAuth(item)
+    })
+  }
+  try {
+    if (Array.isArray(list)) {
+      list.forEach((event) => {
+        const emitTarget = event?.originEvent?.target as SynatxNode;
+        const _path: string = event.originEvent.path;
+        const _root = _path.split('.')?.[1] || '';
+        if (['backend', 'overriddenLogics', 'dataSources', 'processes', 'roles', 'logics', 'enums', 'structures', 'interfaces', 'interfaceDependencies', 'configuration', 'dependencies', 'authLogics', 'authLogicsForCallInterface', 'triggerLaunchers', 'connections'].some((item) => _root.startsWith(item))) {
+          hasBackEnd = true;
+        }
+        if (emitTarget) {
+          if (emitTarget.concept === 'App') {
+            if (event?.object?.preferenceMap || event?.originEvent?.object?.preferenceMap) {
+              hasBackEnd = true
+              hasFrontEnd = true
             }
-            if (view.tag === 'u-uploader' || view.tag === 'van-uploader') {
-                const bute = view?.bindAttrs.find((item) => item.name === 'url');
-                if (checkAuth) {
-                    if (bute?.value.endsWith('/import') && !view.view.parentAuth) {
-                        hasBackEnd = true;
-                    }
-                } else {
-                    if (bute?.value.endsWith('/import')) {
-                        hasBackEnd = true;
-                    }
-                }
+          }
+          if (emitTarget.concept === 'ValidationRule') {
+            if (
+              event?.object?.enableServerValidation ||
+              event?.originEvent?.object?.enableServerValidation
+            ) {
+              hasBackEnd = true
+              hasFrontEnd = true
+            }
+          }
+          if (emitTarget.concept === 'Logic') {
+            const diffArr: string[] = [];
+            if (emitTarget.body.length > 2) {
+              emitTarget.body.forEach((it: LogicItem) => {
+                itemloop(it, app, diffArr);
+              });
+            }
+            const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
+            if (result.length) {
+              hasBackEnd = true;
             }
+          }
+          if ('view' in emitTarget && emitTarget.view) {
+            hasFrontEnd = true
+          }
+          if (emitTarget.concept === 'BindDirective') {
+            const isDelete = event?.originEvent?.action === 'delete'
+            if (isDelete) {
+              const isAuto = ~event?.originEvent?.path?.indexOf('name=auth')
+              if (isAuto) {
+                hasBackEnd = true
+              }
+            }
+            if (event?.originEvent?.object?.name === 'auth') {
+              hasBackEnd = true
+            }
+          }
+        if (emitTarget.concept === 'View') {
+          if (getMiniAppChange(emitTarget, event?.originEvent?.object, event?.originEvent?.action)) {
+            hasBackEnd = true;
+          }
+          const isDelete = event?.originEvent?.action === 'delete';
+          const isAuthView = emitTarget.auth && event?.originEvent?.object?.name;
+          const isUpdateAuth = event?.originEvent?.action === 'update' && event?.originEvent?.object && event?.originEvent?.object?.auth
+          const isUpdateBindRoles = event?.originEvent?.action === 'update' && event?.originEvent?.object && event?.originEvent?.object?.bindRoles;
+          if (isDelete || isUpdateAuth || isUpdateBindRoles || isAuthView) {
+            hasBackEnd = true;
+            // const app = emitTarget.app;
+            // const diffArr: string[] = [];
+            // emitTarget.logics.forEach((logic: Logic) => {
+            //     if (logic.body.length > 2) {
+            //         logic.body.forEach((it: LogicItem) => {
+            //             itemloop(it, app, diffArr);
+            //         });
+            //     }
+            // });
+            // const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
+            // if (result.length) {
+            //     hasBackEnd = true;
+            // }
+            // emitTarget.children.forEach((item: View | ViewElement) => loopEle(item, isDelete));
+            // emitTarget.elements.forEach((item: View | ViewElement) => loopEle(item, isDelete));
+          }
+          hasFrontEnd = true;
         }
-    };
-
-    const loopEleAuth = (viewElement: ViewElement) => {
-        viewElement?.children?.forEach((item:ViewElement) => {
-            const bindDirective = item?.bindDirectives?.find((item: BindDirective) => item.name === "auth")
+        if (emitTarget.concept === 'ViewElement') {
+          if (event?.originEvent?.object?.name) {
+            const bindDirective = emitTarget.bindDirectives.find(
+              (item: BindDirective) => item.name === 'auth'
+            )
             if (bindDirective) {
-                hasBackEnd = true;
+              hasBackEnd = true;
+        }
+          }
+          if (event?.originEvent?.action === 'delete') {
+            const bindDirective = emitTarget?.bindDirectives?.find(
+              (item: BindDirective) => item.name === 'auth'
+            )
+            if (bindDirective) {
+              hasBackEnd = true
             }
-            loopEleAuth(item);
-        }) 
-    }
-    try {
-        if (Array.isArray(list)) {
-            list.forEach((event) => {
-                const emitTarget = event?.originEvent?.target as SynatxNode;
-                const _path: string = event.originEvent.path;
-                const _root = _path.split('.')?.[1] || '';
-                if (['backend', 'overriddenLogics', 'dataSources', 'processes', 'roles', 'logics', 'enums', 'structures', 'interfaces', 'interfaceDependencies', 'configuration', 'dependencies', 'authLogics', 'authLogicsForCallInterface'].some((item) => _root.startsWith(item))) {
-                    hasBackEnd = true;
-                }
-                if (emitTarget) {
-                    if (emitTarget.concept === 'App') {
-                        if (event?.object?.preferenceMap || event?.originEvent?.object?.preferenceMap) {
-                            hasBackEnd = true;
-                            hasFrontEnd = true;
-                        }
-                    }
-                    if (emitTarget.concept === 'ValidationRule') {
-                        if (event?.object?.enableServerValidation || event?.originEvent?.object?.enableServerValidation) {
-                            hasBackEnd = true;
-                            hasFrontEnd = true;
-                        }
-                    }
-                    if (emitTarget.concept === 'Logic') {
-                        const diffArr: string[] = [];
-                        if (emitTarget.body.length > 2) {
-                            emitTarget.body.forEach((it: LogicItem) => {
-                                itemloop(it, app, diffArr);
-                            });
-                        }
-                        const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
-                        if (result.length) {
-                            hasBackEnd = true;
-                        }
-                    }
-                    if ('view' in emitTarget && emitTarget.view) {
-                        hasFrontEnd = true;
-                    }
-                    if (emitTarget.concept === 'BindDirective') {
-                        const isDelete = event?.originEvent?.action === 'delete';
-                        if (isDelete) {
-                            const isAuto = ~event?.originEvent?.path?.indexOf('name=auth');
-                            if (isAuto) {
-                                hasBackEnd = true;
-                            }
-                        }
-                        if (event?.originEvent?.object?.name === 'auth') {
-                            hasBackEnd = true;
-                        }
-                    }
-                    if (emitTarget.concept === 'View') {
-                        if (getMiniAppChange(emitTarget, event?.originEvent?.object, event?.originEvent?.action)) {
-                            hasBackEnd = true;
-                        }
-                        const isDelete = event?.originEvent?.action === 'delete';
-                        const isAuthView =  emitTarget.auth && event?.originEvent?.object?.name
-                        const isUpdateAuth = event?.originEvent?.action === 'update' && event?.originEvent?.object && event?.originEvent?.object?.auth;
-                        const isUpdateBindRoles = event?.originEvent?.action === 'update' && event?.originEvent?.object && event?.originEvent?.object?.bindRoles;
-                        if (isDelete || isUpdateAuth || isUpdateBindRoles || isAuthView) {
-                            hasBackEnd = true;
-                            // const app = emitTarget.app;
-                            // const diffArr: string[] = [];
-                            // emitTarget.logics.forEach((logic: Logic) => {
-                            //     if (logic.body.length > 2) {
-                            //         logic.body.forEach((it: LogicItem) => {
-                            //             itemloop(it, app, diffArr);
-                            //         });
-                            //     }
-                            // });
-                            // const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
-                            // if (result.length) {
-                            //     hasBackEnd = true;
-                            // }
-                            // emitTarget.children.forEach((item: View | ViewElement) => loopEle(item, isDelete));
-                            // emitTarget.elements.forEach((item: View | ViewElement) => loopEle(item, isDelete));
-                        }
-                        hasFrontEnd = true;
-                    }
-                    if (emitTarget.concept === 'ViewElement') {
-                        if (event?.originEvent?.object?.name) {
-                            const bindDirective = emitTarget.bindDirectives.find((item: BindDirective) => item.name === "auth")
-                            if (bindDirective) {
-                                hasBackEnd = true;
-                            }
-                        } 
-                        if (event?.originEvent?.action === 'delete') { 
-                            const bindDirective = emitTarget?.bindDirectives?.find((item: BindDirective) => item.name === "auth")
-                            if (bindDirective) {
-                                hasBackEnd = true;
-                            }
-                            loopEleAuth(emitTarget);
-                        }
-                        if (event?.originEvent?.action !== 'create') {
-                            if (event?.originEvent?.object && event?.originEvent?.object?.bindRoles) {
-                                hasBackEnd = true;
-                            }
-                        }
-                        loopEle(emitTarget, true);
-                    }
-                    if (emitTarget.concept === 'BindAttribute' && emitTarget.name === 'url' && emitTarget.value.endsWith('/import')) {
-                        if (!emitTarget.view.parentAuth) {
-                            hasBackEnd = true;
-                        }
-                    }
-                    if (emitTarget.concept === 'CallLogic') {
-                        const arrlist: string[] = [];
-                        getLogic(emitTarget.calleeKey, emitTarget.app, arrlist);
-                        const result = arrlist.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
-                        // console.log(result, 'CallLogic');
-                        if (result.length) {
-                            hasBackEnd = true;
-                        }
-                    }
-                    // 更新端时需要出发后端更新
-                    if (emitTarget.concept === 'Frontend') {
-                        hasBackEnd = true;
-                    }
-                }
-                event.eventList.forEach(({ action, path, object: objItem }: { action: string; path: string; object: any }) => {
-                    if (Array.isArray(objItem)) {
-                        if (action === 'update') {
-                            actionList.push({
-                                action,
-                                path,
-                                node: objItem[0],
-                            });
-                        } else {
-                            objItem.forEach((item, index) => {
-                                actionList.push({
-                                    action,
-                                    path,
-                                    node: item,
-                                });
-                            });
-                        }
-                    } else {
-                        actionList.push({
-                            action,
-                            path,
-                            object: objItem,
-                        });
-                    }
+            loopEleAuth(emitTarget)
+          }
+          if (event?.originEvent?.action !== 'create') {
+            if (event?.originEvent?.object && event?.originEvent?.object?.bindRoles) {
+              hasBackEnd = true
+            }
+          }
+          loopEle(emitTarget, true)
+        }
+        if (emitTarget.concept === 'BindAttribute' && emitTarget.name === 'url') {
+          const needUpdateBackEnd =
+            emitTarget?.value?.endsWith('/import') || emitTarget?.value?.includes('/upload/')
+          if (!emitTarget.view.parentAuth && needUpdateBackEnd) {
+            hasBackEnd = true
+          }
+        }
+        if (emitTarget.concept === 'CallLogic') {
+          const arrlist: string[] = [];
+          getLogic((emitTarget as CallLogic).calleeKey, emitTarget.app, arrlist);
+          const result = arrlist.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
+          // console.log(result, 'CallLogic');
+          if (result.length) {
+            hasBackEnd = true;
+          }
+        }
+        // 更新端时需要出发后端更新
+        if (emitTarget.concept === 'Frontend') {
+          hasBackEnd = true;
+        }
+      }
+
+        event.eventList.forEach(({ action, path, object: objItem }: { action: string; path: string; object: any }) => {
+          if (Array.isArray(objItem)) {
+            if (action === 'update') {
+              actionList.push({
+                action,
+                path,
+                node: objItem[0],
+              });
+            } else {
+              objItem.forEach((item, index) => {
+                actionList.push({
+                  action,
+                  path,
+                  node: item,
                 });
+              });
+            }
+          } else {
+            actionList.push({
+              action,
+              path,
+              object: objItem,
             });
-        }
-    } catch (error) {
-        console.log(error);
-        taskQueue.refreshNasl(app, {
-            errorInfo: {
-                message: error?.message,
-                stack: error?.stack,
-            },
+          }
         });
-        return;
+      });
     }
-
-    const instructList = [{
-        uuid: uuidv4().replace(/-/g, ''),
-        actions: actionList,
-    }];
-    saveNasl({ app, hasFrontEnd, hasBackEnd, instructList });
-
-    if (!app._historying) {
-        if (app._historyIndex !== app._historyList.length) {
-            app._historyList = app._historyList.splice(0, app._historyIndex);
-        }
-        app._historyList.push({
-            actionMsg,
-            list: list.map((item: any) => item.originEvent),
-        });
-        app._historyIndex = app._historyList.length;
-    } else {
-        const actionMap = {
-            undo: '已撤销操作：',
-            redo: '已重做操作：',
-        };
-        let msg = actionMap[action as 'undo' | 'redo'];
-        msg += actionMsg;
-        Vue.prototype.$toast.info(msg);
-        app._historying = false;
+  } catch (error) {
+    console.log(error);
+    taskQueue.refreshNasl(app, {
+      errorInfo: {
+        message: error?.message,
+        stack: error?.stack,
+      },
+    });
+    return;
+  }
+
+  const instructList = [{
+    uuid: uuidv4().replace(/-/g, ''),
+    actions: actionList,
+  }];
+  saveNasl({ app, hasFrontEnd, hasBackEnd, instructList });
+
+  if (!app._historying) {
+    if (app._historyIndex !== app._historyList.length) {
+      app._historyList = app._historyList.splice(0, app._historyIndex);
     }
-    stepRecorder.initialized && stepRecorder.record(actionMsg, actionItem, actionList);
+    app._historyList.push({
+      actionMsg,
+      list: list.map((item: any) => item.originEvent),
+    });
+    app._historyIndex = app._historyList.length;
+  } else {
+    const actionMap = {
+      undo: '已撤销操作：',
+      redo: '已重做操作：',
+    };
+    let msg = actionMap[action as 'undo' | 'redo'];
+    msg += actionMsg;
+    if (process.env.BUILD_TARGET !== 'node') {
+      require('element-plus').ElMessage.info(msg);
+    }
+    app._historying = false;
+  }
+  stepRecorder.initialized && stepRecorder.record(actionMsg, actionItem, actionList);
 }
 
 type Instruct = {
-    uuid: string,
-    actions: any[],
+  uuid: string,
+  actions: any[],
 };
 type TaskOption = {
-    app: any,
-    hasFrontEnd: boolean,
-    hasBackEnd: boolean,
-    instructList: Instruct[],
+  app: any,
+  hasFrontEnd: boolean,
+  hasBackEnd: boolean,
+  instructList: Instruct[],
 };
 enum TaskQueueStatus {
-    ExceedMaxTaskCount,
-    Retrying,
+  ExceedMaxTaskCount,
+  Retrying,
 }
 type RefreshNaslOptions = {
-    errorInfo: {
-        message?: string,
-        stack?: string,
-    }
+  errorInfo: {
+    message?: string,
+    stack?: string,
+  }
 };
 
 class TaskQueue {
-    queue: TaskOption[] = []
-    lastQueue: TaskOption[] = []
-    running: Boolean = false
-    maxTaskCount: number = 10
-    status?: TaskQueueStatus = undefined
-
-    addTask(task: TaskOption) {
-        this.queue.push(task);
-
-        if (this.queue.length >= this.maxTaskCount) {
-            this.status = TaskQueueStatus.ExceedMaxTaskCount;
-            task.app.emit('ExceedMaxTaskCount');
-        }
-
-        this.run();
+  queue: TaskOption[] = []
+  lastQueue: TaskOption[] = []
+  running: Boolean = false
+  maxTaskCount: number = 10
+  status?: TaskQueueStatus = undefined
+
+  addTask(task: TaskOption) {
+    this.queue.push(task);
+
+    if (this.queue.length >= this.maxTaskCount) {
+      this.status = TaskQueueStatus.ExceedMaxTaskCount;
+      task.app.emit('ExceedMaxTaskCount');
     }
 
-    clear() {
-        this.queue = [];
-        this.lastQueue = [];
-        this.status = undefined;
-        this.running = false;
-    }
+    this.run();
+  }
 
-    async run(queue = this.queue) {
-        if (this.running)
-            return;
-        if (queue.length === 0)
-            return;
-
-        const app = queue[0].app;
-        let hasFrontEnd = false;
-        let hasBackEnd = false;
-        let instructList: Instruct[] = [];
-
-        for (const task of queue) {
-            if (task.hasFrontEnd)
-                hasFrontEnd = true;
-            if (task.hasBackEnd)
-                hasBackEnd = true;
-            instructList = instructList.concat(task.instructList);
-        }
+  clear() {
+    this.queue = [];
+    this.lastQueue = [];
+    this.status = undefined;
+    this.running = false;
+  }
 
-        if (queue === this.queue) {
-            this.lastQueue = [...queue];
-            this.queue = [];
-        }
-
-        this.running = true;
-        const error = await _saveNasl({
-            app, hasFrontEnd, hasBackEnd, instructList,
-        });
+  async run(queue = this.queue) {
+    if (this.running)
+      return;
+    if (queue.length === 0)
+      return;
 
-        // code: 401650, 检测到当前应用拉取操作已被强制结束, 用户确认后再刷新
-        // code: 500502  msg: "该应用已在新tab 页打开，请刷新!"      不重试或刷新
-        if (!error)
-            this.recover(app);
-        else if (![401650, 500502].includes(error.code)) {
-            // 连接失败，或超时，或后端持久化异常
-            if ((error.message === 'Network Error' || error.message?.includes('timeout') || error.code === 500500)
-                && this.status !== TaskQueueStatus.Retrying) {
-                this.running = false;
-                this.retry();
-            } else
-                this.refreshNasl(app);
-
-            return;
-        }
-
-        this.running = false;
+    const app = queue[0].app;
+    let hasFrontEnd = false;
+    let hasBackEnd = false;
+    let instructList: Instruct[] = [];
+
+    for (const task of queue) {
+      if (task.hasFrontEnd)
+        hasFrontEnd = true;
+      if (task.hasBackEnd)
+        hasBackEnd = true;
+      instructList = instructList.concat(task.instructList);
+    }
 
-        this.run();
+    if (queue === this.queue) {
+      this.lastQueue = [...queue];
+      this.queue = [];
     }
 
-    retry() {
-        if (this.lastQueue.length === 0)
-            return;
+    this.running = true;
+    const error = await _saveNasl({
+      app, hasFrontEnd, hasBackEnd, instructList,
+    });
 
-        const app = this.lastQueue[0].app;
-        this.status = TaskQueueStatus.Retrying;
-        app.emit('Retrying');
-        this.run(this.lastQueue);
-    }
+    // code: 401650, 检测到当前应用拉取操作已被强制结束, 用户确认后再刷新
+    // code: 500502  msg: "该应用已在新tab 页打开，请刷新!"      不重试或刷新
+    if (!error)
+      this.recover(app);
+    else if (![401650, 500502].includes(error.code)) {
+      // 连接失败，或超时，或后端持久化异常
+      if ((error.message === 'Network Error' || error.message?.includes('timeout') || error.code === 500500)
+        && this.status !== TaskQueueStatus.Retrying) {
+        this.running = false;
+        this.retry();
+      } else
+        this.refreshNasl(app);
 
-    async refreshNasl(app: App, options: RefreshNaslOptions = { errorInfo: {} }) {
-        const failedQueue = this.lastQueue.map(({ hasFrontEnd, hasBackEnd, instructList }) => ({
-            hasFrontEnd, hasBackEnd, instructList,
-        }));
-        const queue = this.queue.map(({ hasFrontEnd, hasBackEnd, instructList }) => ({
-            hasFrontEnd, hasBackEnd, instructList,
-        }));
-        await storageService.saveFrontendNasl({
-            body: {
-                nasl: app?.toJSON(),
-                failedQueue,
-                queue,
-                errorInfo: options.errorInfo,
-            },
-        }).catch((err: any) => {
-            console.log('备份 nasl 失败：', err);
-        });
-        this.clear();
-        app.emit('refresh');
+      return;
     }
 
-    recover(app: App) {
-        switch (this.status) {
-            case TaskQueueStatus.ExceedMaxTaskCount:
-                app.emit('BelowMaxTaskCount');
-                this.status = undefined;
-                break;
-            case TaskQueueStatus.Retrying:
-                app.emit('SuccessRetry');
-                this.status = undefined;
-                break;
-        }
+    this.running = false;
+
+    this.run();
+  }
+
+  retry() {
+    if (this.lastQueue.length === 0)
+      return;
+
+    const app = this.lastQueue[0].app;
+    this.status = TaskQueueStatus.Retrying;
+    app.emit('Retrying');
+    this.run(this.lastQueue);
+  }
+
+  async refreshNasl(app: App, options: RefreshNaslOptions = { errorInfo: {} }) {
+    const failedQueue = this.lastQueue.map(({ hasFrontEnd, hasBackEnd, instructList }) => ({
+      hasFrontEnd, hasBackEnd, instructList,
+    }));
+    const queue = this.queue.map(({ hasFrontEnd, hasBackEnd, instructList }) => ({
+      hasFrontEnd, hasBackEnd, instructList,
+    }));
+    await storageService.saveFrontendNasl({
+      body: {
+        nasl: app?.toJSON(),
+        failedQueue,
+        queue,
+        errorInfo: options.errorInfo,
+      },
+    }).catch((err: any) => {
+      console.log('备份 nasl 失败：', err);
+    });
+    this.clear();
+    app.emit('refresh');
+  }
+
+  recover(app: App) {
+    switch (this.status) {
+      case TaskQueueStatus.ExceedMaxTaskCount:
+        app.emit('BelowMaxTaskCount');
+        this.status = undefined;
+        break;
+      case TaskQueueStatus.Retrying:
+        app.emit('SuccessRetry');
+        this.status = undefined;
+        break;
     }
+  }
 }
 
 export const taskQueue = new TaskQueue();
 async function saveNasl(options: TaskOption) {
-    taskQueue.addTask(options);
+  taskQueue.addTask(options);
 }
 
 async function _saveNasl(options: TaskOption) {
-    const { app, hasFrontEnd, hasBackEnd, instructList } = options;
-    app.emit('saving');
-    let ChangedNASLType = '';
-    if (hasFrontEnd && hasBackEnd) {
-        ChangedNASLType = 'both';
-    } else if (hasFrontEnd) {
-        ChangedNASLType = 'web';
-    } else if (hasBackEnd) {
-        ChangedNASLType = 'backend';
+  const { app, hasFrontEnd, hasBackEnd, instructList } = options;
+  app.emit('saving');
+  let ChangedNASLType = '';
+  if (hasFrontEnd && hasBackEnd) {
+    ChangedNASLType = 'both';
+  } else if (hasFrontEnd) {
+    ChangedNASLType = 'web';
+  } else if (hasBackEnd) {
+    ChangedNASLType = 'backend';
+  }
+  let err;
+  if (config.storage.protocol === 'http') {
+    try {
+      await storageService.batchInstruct({
+        body: instructList,
+        headers: {
+          appId: app.id,
+          ChangedNASLType,
+          tabTimestamp,
+          // 其他封装在 storageService 里了
+        },
+      });
+    } catch (error) {
+      err = error;
     }
-    let err;
-    if (config.storage.protocol === 'http') {
-        try {
-            await storageService.batchInstruct({
-                body: instructList,
-                headers: {
-                    appId: app.id,
-                    ChangedNASLType,
-                    tabTimestamp,
-                    // 其他封装在 storageService 里了
-                },
-            });
-        } catch (error) {
-            err = error;
-        }
-    } else if (config.storage.protocol === 'mock') {
-        // Do nothing
-    } else {
-        const json = await fs.readJSON(config.storage.basePath);
-
-        let actionList: any[] = [];
-        for (const { actions } of instructList) {
-            actionList = actionList.concat(actions);
-        }
-
-        jsoner.batchAction(json, actionList);
-        await fs.writeJSON(config.storage.basePath, json, {
-            spaces: 4,
-        });
+  } else if (config.storage.protocol === 'mock') {
+    // Do nothing
+  } else {
+    const json = await fs.readJSON(config.storage.basePath);
+
+    let actionList: any[] = [];
+    for (const { actions } of instructList) {
+      actionList = actionList.concat(actions);
     }
-    app.emit('saved', err);
-    return err;
-}
-
-export function handleApp(app: any) {
-    app._isCollectingCount = 0;
-    app._collectingList = [];
-    app._historyList = [];
-    app._historyIndex = 0;
-    app._historying = false;
-    app._timer = null;
-
-    app.on('undo', () => {
-        app._historying = true;
-    });
 
-    app.on('redo', () => {
-        app._historying = true;
-    });
-
-    /**
-     * 开启收集
-     */
-    app.on('collect:start', (event: any) => {
-        if (app._timer) {
-            clearTimeout(app._timer);
-        }
-        if (!app._noTimer) {
-            app._noTimer = event.noTimer;
-        }
-        if (!app._noTimer) {
-            app._timer = setTimeout(() => {
-                console.error('收集超时，请及时排查原因', event);
-                taskQueue.refreshNasl(app, {
-                    errorInfo: {
-                        message: '收集超时，请及时排查原因',
-                    },
-                });
-            }, 2500);
-        }
-        if (!app._isCollectingCount) {
-            app._actionMsg = event?.actionMsg;
-            app._action = event?.action;
-        }
-        app._isCollectingCount++;
+    jsoner.batchAction(json, actionList);
+    await fs.writeJSON(config.storage.basePath, json, {
+      spaces: 4,
     });
+  }
+  app.emit('saved', err);
+  return err;
+}
 
-    /**
-     * 结束收集
-     */
-    app.on('collect:end', async () => {
-        app._isCollectingCount--;
-        if (app._isCollectingCount === 0) {
-            if (app._timer) {
-                clearTimeout(app._timer);
-            }
-            // 结束收集时，立即将全局收集变量状态重置，防止下次收集数据混乱
-            const collectingList = app._collectingList;
-            const actionMsg = app._actionMsg;
-            const action = app._action;
-            app._collectingList = [];
-            app._actionMsg = '';
-            app._action = '';
-            app._noTimer = undefined;
-            if (Array.isArray(collectingList) && collectingList.length) {
-                mountDatabaseTypes(app);
-                app.naslServer?.embeddedTSEmitter?.emit('change', {
-                    value: collectingList,
-                });
-                await doAction(app, {
-                    list: collectingList,
-                    actionMsg,
-                    action,
-                });
-            }
-        } else if (app._isCollectingCount < 0) {
-            app._isCollectingCount = 0;
-            throw Error('关闭收集有问题，请排查');
-        }
-    });
+export interface ProxyApp extends App {
+  _isCollectingCount: number;
+  _collectingList: number[];
+  _historyList: number[];
+  _historyIndex: number;
+  _historying: boolean;
+  _timer: NodeJS.Timeout;
+  _noTimer: NodeJS.Timeout;
+  _actionMsg: string;
+  _action: string;
+  naslServer: NaslServer;
+}
 
-    /**
-     * 有变更
-     */
-    app.on('storage', (event: any) => {
-        // 是否正在收集
-        if (app._isCollectingCount === 0) {
-            app.naslServer?.embeddedTSEmitter?.emit('change', {
-                value: [event],
-            });
-            let actionMsg = '';
-            const { action, target } = event.originEvent || {};
-            const { concept, name } = target || {};
-            switch (action) {
-                case 'create':
-                    actionMsg = '添加';
-                    break;
-                case 'delete':
-                    actionMsg = '删除';
-                    break;
-                case 'update':
-                    actionMsg = '修改';
-                    break;
-            }
-            actionMsg += getConceptConstructor(concept).nodeTitle;
-            if (name) {
-                actionMsg += `“${name}”`;
-            }
-            doAction(app, {
-                list: [event],
-                actionMsg,
-            });
-        } else {
-            app._collectingList.push(event);
-        }
-    });
+export function handleApp(app: ProxyApp) {
+  app._isCollectingCount = 0;
+  app._collectingList = [];
+  app._historyList = [];
+  app._historyIndex = 0;
+  app._historying = false;
+  app._timer = null;
+
+  app.on('undo', function (this: ProxyApp) {
+    const proxyApp = this;
+    proxyApp._historying = true;
+  });
+
+  app.on('redo', function (this: ProxyApp) {
+    const proxyApp = this;
+    proxyApp._historying = true;
+  });
+
+  /**
+   * 开启收集
+   */
+  app.on('collect:start', function (this: ProxyApp, event: any) {
+    const proxyApp = this;
+    if (proxyApp._timer) {
+      clearTimeout(proxyApp._timer);
+    }
+    if (!proxyApp._noTimer) {
+      proxyApp._noTimer = event.noTimer;
+    }
+    if (!proxyApp._noTimer) {
+      proxyApp._timer = setTimeout(() => {
+        console.error('收集超时，请及时排查原因', event);
+        taskQueue.refreshNasl(proxyApp, {
+          errorInfo: {
+            message: '收集超时，请及时排查原因',
+          },
+        });
+      }, 2500);
+    }
+    if (!proxyApp._isCollectingCount) {
+      proxyApp._actionMsg = event?.actionMsg;
+      proxyApp._action = event?.action;
+    }
+    proxyApp._isCollectingCount++;
+  });
+
+  /**
+   * 结束收集
+   */
+  app.on('collect:end', async function (this: ProxyApp) {
+    const proxyApp = this;
+    proxyApp._isCollectingCount--;
+    if (proxyApp._isCollectingCount === 0) {
+      if (proxyApp._timer) {
+        clearTimeout(proxyApp._timer);
+      }
+      // 结束收集时，立即将全局收集变量状态重置，防止下次收集数据混乱
+      const collectingList = proxyApp._collectingList;
+      const actionMsg = proxyApp._actionMsg;
+      const action = proxyApp._action;
+      proxyApp._collectingList = [];
+      proxyApp._actionMsg = '';
+      proxyApp._action = '';
+      proxyApp._noTimer = undefined;
+      if (Array.isArray(collectingList) && collectingList.length) {
+        mountDatabaseTypes(proxyApp);
+        proxyApp.naslServer?.embeddedTSEmitter?.emit('change', {
+          value: collectingList,
+        });
+        await doAction(proxyApp, {
+          list: collectingList,
+          actionMsg,
+          action,
+        });
+      }
+    } else if (proxyApp._isCollectingCount < 0) {
+      proxyApp._isCollectingCount = 0;
+      throw Error('关闭收集有问题，请排查');
+    }
+  });
+
+  /**
+   * 有变更
+   */
+  app.on('storage', function (this: ProxyApp, event: any) {
+    const proxyApp = this;
+    // 是否正在收集
+    if (proxyApp._isCollectingCount === 0) {
+      proxyApp.naslServer?.embeddedTSEmitter?.emit('change', {
+        value: [event],
+      });
+      let actionMsg = '';
+      const { action, target } = event.originEvent || {};
+      const { concept, name } = target || {};
+      switch (action) {
+        case 'create':
+          actionMsg = '添加';
+          break;
+        case 'delete':
+          actionMsg = '删除';
+          break;
+        case 'update':
+          actionMsg = '修改';
+          break;
+      }
+      actionMsg += getConceptConstructor(concept).nodeTitle;
+      if (name) {
+        actionMsg += `“${name}”`;
+      }
+      doAction(proxyApp, {
+        list: [event],
+        actionMsg,
+      });
+    } else {
+      proxyApp._collectingList.push(event);
+    }
+  });
 }
 
-type BreakpointItem = any | {
-    path: string,
-    breakpointStatus: null | 'ENABLED' | 'DISABLED',
-};
+type BreakpointItem =
+  | any
+  | {
+      path: string
+      breakpointStatus: null | 'ENABLED' | 'DISABLED'
+    }
 
 /**
  * 加载 app
@@ -682,150 +717,148 @@ type BreakpointItem = any | {
  * @returns app 对象
  */
 export async function loadApp(appId?: string) {
-    let app: App;
-    if (config.storage.protocol === 'http') {
-        console.time('batchQuery');
-        const promises = [
-            storageService.batchQuery({
-                body: [
-                    {
-                        path: 'app',
-                        // excludes: ['views'],
-                    },
-                ],
-                headers: {
-                    appId,
-                    checkTabOpenTime: 'true',
-                    // 其他封装在 storageService 里了
-                },
-                config: {
-                    shortResponse: false,
-                },
-            }),
-            storageService.breakpoint({
-                body: { appId },
-            }),
-        ];
-
-        const [batchQueryRes, breakpointRes] = await Promise.all(promises);
-
-        // 请求
-        console.timeEnd('batchQuery');
-
-        tabTimestamp = batchQueryRes?.headers?.tabtimestamp;
-        const data = batchQueryRes?.data?.result;
-
-        console.time('new App');
-        app = new App(Object.assign(data?.[0], { id: appId }));
-
-        breakpointRes?.forEach((item: BreakpointItem = {}) => {
-            const { path, breakpointStatus } = item;
-
-            if (breakpointStatus) {
-                const node = app.findNodeByPath(path);
-
-                if (node) {
-                    node.breakpoint = breakpointStatus;
-                }
-            }
-        });
-        console.timeEnd('new App');
-
-        if (!app.id) {
-            app.id = appId;
+  let app: App;
+  if (config.storage.protocol === 'http') {
+    console.time('batchQuery');
+    const promises = [
+      storageService.batchQuery({
+        body: [
+          {
+            path: 'app'
+            // excludes: ['views'],
+          }
+        ],
+        headers: {
+          appId,
+          checkTabOpenTime: 'true'
+          // 其他封装在 storageService 里了
+        },
+        config: {
+          shortResponse: false
         }
+      }),
+      storageService.breakpoint({
+        body: { appId }
+      })
+    ]
 
-        addBreakpointNodesFromApp(app);
-    } else if (config.storage.protocol === 'mock') {
-        app = new App({
-            id: appId,
-            concept: 'App',
-            name: 'devapp',
-            title: '开发应用',
-            envs: 'dev,online',
-            hasAuth: true,
-            hasUserCenter: true,
-            dataSources: [],
-            structures: [],
-            enums: [],
-            logics: [],
-            interfaces: [],
-            processes: [],
-            roles: [],
-            dependencies: [],
-            interfaceDependencies: [],
-            frontends: [],
-        });
-    } else {
-        const json = await fs.readJSON(config.storage.basePath);
-        app = new App(appId ? Object.assign(json, { id: appId }) : json);
+    const [batchQueryRes, breakpointRes] = await Promise.all(promises)
+
+    // 请求
+    console.timeEnd('batchQuery');
+
+    tabTimestamp = batchQueryRes?.headers?.tabtimestamp;
+    const data = batchQueryRes?.data?.result;
+
+    console.time('new App');
+    app = new App(Object.assign(data?.[0], { id: appId }));
+
+    breakpointRes?.forEach((item: BreakpointItem = {}) => {
+      const { path, breakpointStatus } = item
+
+      if (breakpointStatus) {
+        const node = app.findNodeByPath(path)
+
+        if (node) {
+          node.breakpoint = breakpointStatus
+        }
+      }
+    })
+    console.timeEnd('new App');
+    if (!app.id) {
+      app.id = appId;
     }
-    // config.scope = app.scope;
-    handleApp(app);
-    (app as any)._isCollectingCount = 0;
-    mountDatabaseTypes(app);
-    return app as App;
+    addBreakpointNodesFromApp(app)
+  } else if (config.storage.protocol === 'mock') {
+    app = new App({
+      id: appId,
+      concept: 'App',
+      name: 'devapp',
+      title: '开发应用',
+      envs: 'dev,online',
+      hasAuth: true,
+      hasUserCenter: true,
+      dataSources: [],
+      structures: [],
+      enums: [],
+      logics: [],
+      interfaces: [],
+      processes: [],
+      roles: [],
+      dependencies: [],
+      interfaceDependencies: [],
+      frontends: [],
+    });
+  } else {
+    const json = await fs.readJSON(config.storage.basePath);
+    app = new App(appId ? Object.assign(json, { id: appId }) : json);
+  }
+  // config.scope = app.scope;
+  handleApp(app as ProxyApp);
+  (app as any)._isCollectingCount = 0;
+  mountDatabaseTypes(app);
+  return app as App;
 }
 
 // 在app上挂载所有的数据库类型
 export async function mountDatabaseTypes(app: App) {
-    if (!app.__databaseTypeMap) {
-        app.__databaseTypeMap = {};
-    }
-    const dataSources = app?.dataSources;
-    const dbTypeSet = new Set();
-    if (Array.isArray(dataSources)) {
-        dataSources.forEach((dataSource) => {
-            const dataSourceSqlType = JSON.parse(dataSource.dataSourceConfig?.devProperty?.value || '{}')?.type;
-            if (dataSourceSqlType && !app.__databaseTypeMap[dataSourceSqlType]) {
-                dbTypeSet.add(dataSourceSqlType);
-            }
-        });
-    }
-    const dbTypes = [...dbTypeSet];
-    if (Array.isArray(dbTypes) && dbTypes.length) {
-        const res: any = await databaseTypes({
-            query: {
-                dbTypes: dbTypes.join(','),
-            },
-        });
-        if (Array.isArray(res)) {
-            res.forEach((databaseType: any) => {
-                const { dbType, columnTypes } = databaseType || {};
-                const columnTypeMap: any = {};
-                if (Array.isArray(columnTypes)) {
-                    columnTypes.forEach((columnType) => {
-                        const { naslType, dataBaseTypes } = columnType;
-                        const dataBaseTypeMap: any = {};
-                        let defaultDataBaseType;
-                        if (Array.isArray(dataBaseTypes)) {
-                            dataBaseTypes.forEach((dataBaseType) => {
-                                const { type } = dataBaseType || {};
-                                if (type) {
-                                    dataBaseTypeMap[type] = dataBaseType;
-                                    const { defaultType } = dataBaseType;
-                                    if (defaultType) {
-                                        defaultDataBaseType = dataBaseType;
-                                    }
-                                }
-                            });
-                        }
-                        columnTypeMap[naslType] = {
-                            dataBaseTypes,
-                            dataBaseTypeMap,
-                            defaultDataBaseType,
-                        };
-                    });
+  if (!app.__databaseTypeMap) {
+    app.__databaseTypeMap = {};
+  }
+  const dataSources = app?.dataSources;
+  const dbTypeSet = new Set();
+  if (Array.isArray(dataSources)) {
+    dataSources.forEach((dataSource) => {
+      const dataSourceSqlType = JSON.parse(dataSource.dataSourceConfig?.devProperty?.value || '{}')?.type;
+      if (dataSourceSqlType && !app.__databaseTypeMap[dataSourceSqlType]) {
+        dbTypeSet.add(dataSourceSqlType);
+      }
+    });
+  }
+  const dbTypes = [...dbTypeSet];
+  if (Array.isArray(dbTypes) && dbTypes.length) {
+    const res: any = await databaseTypes({
+      query: {
+        dbTypes: dbTypes.join(','),
+      },
+    });
+    if (Array.isArray(res)) {
+      res.forEach((databaseType: any) => {
+        const { dbType, columnTypes } = databaseType || {};
+        const columnTypeMap: any = {};
+        if (Array.isArray(columnTypes)) {
+          columnTypes.forEach((columnType) => {
+            const { naslType, dataBaseTypes } = columnType;
+            const dataBaseTypeMap: any = {};
+            let defaultDataBaseType;
+            if (Array.isArray(dataBaseTypes)) {
+              dataBaseTypes.forEach((dataBaseType) => {
+                const { type } = dataBaseType || {};
+                if (type) {
+                  dataBaseTypeMap[type] = dataBaseType;
+                  const { defaultType } = dataBaseType;
+                  if (defaultType) {
+                    defaultDataBaseType = dataBaseType;
+                  }
                 }
-                app.__databaseTypeMap[dbType] = columnTypeMap;
-            });
+              });
+            }
+            columnTypeMap[naslType] = {
+              dataBaseTypes,
+              dataBaseTypeMap,
+              defaultDataBaseType,
+            };
+          });
         }
+        app.__databaseTypeMap[dbType] = columnTypeMap;
+      });
     }
-    if (Array.isArray(dataSources)) {
-        dataSources.forEach((dataSource) => {
-            dataSource.__hasDatabaseConfig = !!(app.__databaseTypeMap?.[dataSource.dataSourceSqlType]);
-        });
-    }
+  }
+  if (Array.isArray(dataSources)) {
+    dataSources.forEach((dataSource) => {
+      dataSource.__hasDatabaseConfig = !!(app.__databaseTypeMap?.[dataSource.dataSourceSqlType]);
+    });
+  }
 }
 
 /**
@@ -833,8 +866,8 @@ export async function mountDatabaseTypes(app: App) {
  * @returns app 对象
  */
 export function loadAppSync() {
-    const json = fs.readJSONSync(config.storage.basePath);
-    const app = new App(json);
-    handleApp(app);
-    return app;
+  const json = fs.readJSONSync(config.storage.basePath);
+  const app = new App(json);
+  handleApp(app as ProxyApp);
+  return app;
 }