miqro 5.0.5 → 6.0.3

package/src/services/app.ts

@@ -0,0 +1,718 @@
+import cluster from "node:cluster";
+import { App, Router, Logger, LoggerHandler, ConsoleTransport, FileTransport, LogLevel, LoggerTransportWriteArgs } from "@miqro/core";
+import { migration } from "@miqro/query";
+import { WebSocketManager } from "./utils/websocketmanager.js";
+import { DBManager } from "./utils/db-manager.js";
+import { inflateApp } from "../inflate/inflate.js";
+import { InflateError } from "../common/jsx.js";
+import { DBConfig, MigrateOptions, ServerInterface, ServerRequest, WSConfig } from "../types.js";
+import { RouteFileMap } from "../inflate/setup-http.js";
+import { ServerConfigMap, setupServerConfig } from "../inflate/setup-server-config.js";
+import { BASEEDITOR_PATH, LOG_SOCKET_PATH, LOG_WRITE_EVENT } from "../../editor/common/constants.js";
+import editorWSConfig from "../../editor/ws.js";
+import editorServerConfig from "../../editor/server.js";
+
+import { ClusterCache } from "./utils/cluster-cache.js";
+import { createEditorRouter } from "./editor.js";
+import { EDITOR_CONFIG_KEY } from "../common/constants.js";
+import { watchAndServer } from "../common/watch.js";
+import { LocalCache } from "./utils/cache.js";
+import { initGlobals } from "./globals.js";
+import { EditorAdminInterface } from "../../editor/common/admin-interface.js";
+import { getHotReloadScript } from "./hot-reload.js";
+import { LogProvider, LogProviderOptions } from "./utils/log.js";
+import { initAssets } from "../common/assets.js";
+import { setupExitHandlers } from "../common/exit.js";
+import { inflateDBConfig, inflateDBMigrations, MigrationModule } from "../inflate/setup-db.js";
+import { getServicePath } from "../common/paths.js";
+import { LogConfigMap } from "../inflate/setup-log.js";
+import { format } from "node:util";
+import { ServerInterfaceImpl } from "./utils/server-interface.js";
+import { getPORT } from "../common/arguments.js";
+
+export interface MiqroOptions {
+  name: string;
+  logger?: Logger;
+  logProviderOptions?: LogProviderOptions;
+  services: string[];
+  editor: boolean;
+  port: string;
+  hotreload?: boolean;
+}
+
+export interface InflateOptions {
+  inflateDir?: string;
+  inflateSea?: boolean;
+}
+
+export interface InflatedResult {
+  router: Router;
+  errors: InflateError[];
+  fileMap: RouteFileMap;
+  dbList: {
+    dbConfig: DBConfig;
+    service: string;
+    migrations: MigrationModule[];
+  }[];
+  wsConfigList: WSConfig[];
+  serverConfigMap: ServerConfigMap;
+  logConfigMap: LogConfigMap;
+}
+
+export const MiqroApplicationMessageType = "$$$MiqroApplicationMessageType$$$";
+
+export interface MiqroClusterMessage {
+  type: typeof MiqroApplicationMessageType;
+  action: "reload" | "restart";
+  target: string;
+  fromPID: number;
+}
+
+export class Miqro {
+  public options: MiqroOptions;
+  public server?: App | null = null;
+  public cache: ClusterCache;
+  public localCache: LocalCache;
+  public webSocketManager: WebSocketManager;
+  public dbManager: DBManager;
+
+  public serverInterface: ServerInterface;
+  public adminInterface: EditorAdminInterface;
+
+  public inflated: InflatedResult | null | undefined = null;
+  private listener: (msg: MiqroClusterMessage) => void;
+  public serverRequestHandler: (req: ServerRequest) => void;
+  public logger?: Logger;
+  public loggerProvider: LogProvider;
+  public static initAssetsPromise: Promise<any> | null = null;
+
+  constructor(options?: Partial<MiqroOptions>) {
+    this.options = {
+      editor: false,
+      name: "server",
+      port: getPORT(),
+      services: [],
+      ...(options ? options : {})
+    };
+    const defaultConsole = ConsoleTransport();
+    const defaultFile = FileTransport();
+    const defaultWrite = async (args: LoggerTransportWriteArgs, level?: LogLevel) => {
+      try {
+        const serviceNamesWithLogConfigReplaceConsole = level === undefined && this.inflated ?
+          Object.keys(this.inflated.logConfigMap).filter(serviceName => this.inflated.logConfigMap[serviceName].replaceConsoleTransport) : [];
+        const serviceNamesWithLogConfigReplaceFile = level === undefined && this.inflated ?
+          Object.keys(this.inflated.logConfigMap).filter(serviceName => this.inflated.logConfigMap[serviceName].replaceFileTransport) : [];
+        await Promise.allSettled((level === undefined ?
+          [
+            level === undefined && serviceNamesWithLogConfigReplaceConsole.length === 0 ?
+              defaultConsole.write(args) : Promise.resolve(),
+            level === undefined && serviceNamesWithLogConfigReplaceFile.length === 0 ?
+              defaultFile.write(args) : Promise.resolve()
+          ] : []).concat(this.inflated ?
+            Object.keys(this.inflated.logConfigMap).map(serviceName => this.inflated.logConfigMap[serviceName]).filter(c => c.level === level).map(c => c.write(args)) : []
+          ));
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    this.loggerProvider = new LogProvider({
+      name: this.options.name,
+      formatter: ({ identifier, level, message, optionalParams }) => format(`${new Date().toISOString()} PID[${process.pid}] ` +
+        `${identifier ? `[${identifier}] ` : ""}` +
+        `${level !== "info" ? (level === "error" || level === "warn" ? `[${level.toUpperCase()}] ` : `[${level}] `) : ""}` +
+        `${message}`, ...optionalParams),
+      transports: [
+        ...(([undefined, "error", "warn", "info", "debug", "trace"] as LogLevel[]).map(level => {
+          return level ? {
+            level,
+            write: async (args) => {
+              await defaultWrite(args, level);
+            }
+          } : {
+            write: async (args) => {
+              await defaultWrite(args, undefined);
+            }
+          }
+        })), {
+          level: "trace",
+          write: async (args) => {
+            try {
+              if (this.options.editor) {
+                try {
+                  const ws = this.webSocketManager.getWS(LOG_SOCKET_PATH);
+                  if (ws) {
+                    //console.log("\n\n" + process.pid + " broadcasting " + LOG_SOCKET_PATH + "\n\n\n")
+                    await ws.broadcast(JSON.stringify({
+                      type: LOG_WRITE_EVENT,
+                      level: args.level,
+                      identifier: args.identifier,
+                      out: args.out
+                    }));
+                  }
+                } catch (e) {
+                  console.error(e);
+                }
+              }
+            } catch (e) {
+              console.error(e);
+            }
+          }
+        }],
+      ...(this.options.logProviderOptions ? this.options.logProviderOptions : {})
+    });
+    //if (!this.options.logger) {
+    const SERVER_IDENTIFIER = cluster.isPrimary ?
+      "" :
+      process.env["CLUSTER_NODE_NUMBER"] ?
+        `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}`.toUpperCase() :
+        `WORKER`;
+    this.logger = this.options.logger ? this.options.logger : this.loggerProvider.getLogger(SERVER_IDENTIFIER);
+    //}
+    this.listener = async (data: any) => {
+      try {
+        const msg = (data as MiqroClusterMessage);
+        if (
+          msg &&
+          msg.action &&
+          msg.type === MiqroApplicationMessageType &&
+          msg.target === this.options.name,
+          msg.fromPID !== process.pid,
+          (msg.action === "reload" || msg.action === "restart")) {
+          this.logger?.debug("remote server message from [%s] [%s]", msg.fromPID, msg.action);
+          switch (msg.action) {
+            case "reload":
+              await this.reload(true);
+              break;
+            case "restart":
+              await this.restart(true);
+              break;
+            default:
+              throw new Error("unsopported message for ApplicaitonServer");
+          }
+        }
+      } catch (e) {
+        this.logger?.error(e);
+      }
+    };
+    this.cache = new ClusterCache(`MiqroApplicationCache[${this.options.name}]`, this.logger);
+    this.localCache = new LocalCache(`MiqroApplicationLocalCache[${this.options.name}]`, this.logger);
+    this.webSocketManager = new WebSocketManager({
+      logger: this.logger,
+      name: `MiqroApplicationWebsocketManager[${this.options.name}]`,
+      avoidLogSocket: this.options.editor
+    });
+    this.listener = this.listener.bind(this);
+    //this.requestLoggerFactory = this.requestLoggerFactory.bind(this);
+    //this.loggerFactory = this.loggerFactory.bind(this);
+    this.dbManager = new DBManager({
+      loggerProvider: this.loggerProvider,
+      logger: this.logger
+    });
+
+    this.serverInterface = new ServerInterfaceImpl({
+      cache: this.cache,
+      localCache: this.localCache,
+      dbManager: this.dbManager,
+      wsManager: this.webSocketManager,
+      app: this,
+      logger: this.logger,
+      loggerProvider: this.loggerProvider,
+      port: this.options.port
+    });
+    this.serverRequestHandler = ServerRequestHandler(this.serverInterface);
+    const adminCache = new ClusterCache("EditorCache[" + this.options.name + "]");
+
+    this.adminInterface = {
+      getCache: () => adminCache,
+      stop: () => this.stop(),
+      restart: () => this.restart(),
+      reload: () => this.reload(),
+      getHotReloadHTML: getHotReloadScript,
+      getMigrations: () => {
+        if (this.inflated) {
+          const ret: MigrationModule[] = [];
+          for (const db of this.inflated.dbList) {
+            for (const m of db.migrations) {
+              ret.push(m);
+            }
+          }
+          return ret;
+        }
+        return [];
+      },
+      getServices: () => {
+        return this.options.services;
+      },
+      getRouteFileMap: () => {
+        return this.inflated ? this.inflated.fileMap : {};
+      },
+      getInflateErrors: () => {
+        return this.inflated ? this.inflated.errors : [];
+      }/*,
+      inflateJSX: async function inflateJSX(path, minify: boolean = true) {
+        return realInflateJSX(path, {
+          embemedJSX: true,
+          minify,
+          useExport: true
+        });
+      }*/
+    };
+
+    setupExitHandlers(this);
+
+    if (process.send) {
+      process.on("message", this.listener);
+    }
+  }
+
+  public dispose() {
+    if (this.server !== null) {
+      throw new Error("already running! call stop() first");
+    }
+    if (process.send) {
+      process.removeListener("message", this.listener);
+    }
+    this.cache.dispose();
+    this.webSocketManager.disconnectAll();
+    this.dbManager.closeAll();
+  }
+
+  public async inflateWith(inflated?: Partial<InflatedResult>) {
+    if (this.inflated !== null) {
+      throw new Error("already inflated! call deflate()");
+    }
+    initGlobals();
+    // block others from inflating while inflateApp is running
+    this.inflated = undefined;
+    this.inflated = {
+      router: inflated && inflated.router ? inflated.router : new Router(),
+      errors: inflated && inflated.errors ? inflated.errors : [],
+      fileMap: inflated && inflated.fileMap ? inflated.fileMap : {},
+      logConfigMap: inflated && inflated.logConfigMap ? inflated.logConfigMap : {},
+      //migrations: inflated && inflated.migrations ? inflated.migrations : [],
+      dbList: inflated && inflated.dbList ? inflated.dbList : [],
+      wsConfigList: inflated && inflated.wsConfigList ? inflated.wsConfigList : [],
+      serverConfigMap: inflated && inflated.serverConfigMap ? inflated.serverConfigMap : {}
+    };
+    await Promise.all(this.inflated.dbList.map(db => this.dbManager.setupDB(db.dbConfig)));
+  }
+
+  public async loadServerConfig(options?: InflateOptions) {
+    const serverConfigMap: ServerConfigMap = {};
+    const errors: InflateError[] = [];
+    for (const service of this.options.services) {
+      const servicePath = getServicePath(service);
+      await setupServerConfig(this.logger, servicePath, service, serverConfigMap, options && options.inflateSea ? options.inflateDir : undefined, errors);
+    }
+    return {
+      serverConfigMap,
+      errors
+    }
+  }
+
+  public async loadDBConfig(options?: InflateOptions): Promise<{
+    dbList: {
+      dbConfig: DBConfig;
+      service: string;
+      migrations: MigrationModule[];
+    }[]; errors: InflateError[]
+  }> {
+    const errors: InflateError[] = [];
+    const dbList: {
+      service: string;
+      dbConfig: DBConfig;
+      migrations: MigrationModule[];
+    }[] = [];
+    const dbConfigList: DBConfig[] = [];
+    for (const service of this.options.services) {
+      const dbConfig = await inflateDBConfig(this.logger, service, dbConfigList, options?.inflateSea ? options?.inflateDir : undefined, errors);
+      if (dbConfig) {
+        const migrations = await inflateDBMigrations(this.logger, service, dbConfig.name, options?.inflateSea ? options?.inflateDir : undefined, errors);
+        dbList.push({
+          service,
+          dbConfig,
+          migrations: migrations ? migrations : []
+        });
+      }
+    }
+    return { dbList, errors };
+  }
+
+  public async migrate({ direction, service, name, dbName }: MigrateOptions = { direction: "up" }) {
+    // init assets only once for all ApplicationServer's
+    if (Miqro.initAssetsPromise === null) {
+      // init globals only once for all inflations
+      initGlobals();
+      Miqro.initAssetsPromise = initAssets(this.logger);
+    }
+    await Miqro.initAssetsPromise;
+    const { dbList } = await this.loadDBConfig();
+
+    for (const serviceDB of dbList) {
+      if ((!service || serviceDB.service === service) && (!dbName || serviceDB.dbConfig.name === dbName)) {
+        const db = this.dbManager.getDB(serviceDB.dbConfig.name) ? this.dbManager.getDB(serviceDB.dbConfig.name) : await this.dbManager.setupDB(serviceDB.dbConfig);
+        if (db) {
+          this.logger.info("\t\t====== [init migration table] ======");
+          await migration.init(db, this.logger);
+          const migrations = direction === "down" ? serviceDB.migrations.reverse() : serviceDB.migrations;
+          if (!name) {
+            for (const m of migrations) {
+              if (direction === "down") {
+                await migration.down.module(db, m.name, m, this.logger);
+              } else {
+                await migration.up.module(db, m.name, m, this.logger);
+              }
+            }
+          } else {
+            for (const m of migrations) {
+              if (m.name === name) {
+                if (direction === "down") {
+                  await migration.down.module(db, m.name, m, this.logger);
+                } else {
+                  await migration.up.module(db, m.name, m, this.logger);
+                }
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  public async inflate(options?: InflateOptions): Promise<InflatedResult> {
+    if (this.inflated !== null) {
+      throw new Error("already inflated! call await deflate() first!");
+    }
+    try {
+      // block others from inflating while inflateApp is running
+      this.inflated = undefined;
+      // init assets only once for all ApplicationServer's
+      if (Miqro.initAssetsPromise === null) {
+        // init globals only once for all inflations
+        initGlobals();
+        Miqro.initAssetsPromise = initAssets(this.logger);
+      }
+      await Miqro.initAssetsPromise;
+
+      // store the result
+      const router = new Router();
+      const wsConfigList: WSConfig[] = [];
+
+      /* setup db connection before inflate app router and */
+      const { dbList, errors: dbConfigErrors } = await this.loadDBConfig(options);
+      await Promise.all(dbList.map(db => this.dbManager.setupDB(db.dbConfig)));
+
+      /* setup server config before inflate app router and ws and bs for preload*/
+      const { errors: serviceConfigErrors, serverConfigMap } = await this.loadServerConfig(options);
+
+      // editor WSConfig must be put a head of the service WSConfig to avoid LOG_SOCKET replacement
+      if (this.options.editor) {
+        this.logger?.debug("setting up editor on %s", BASEEDITOR_PATH);
+        const editorRouter = await createEditorRouter(this.adminInterface);
+        router.use(editorRouter);
+        this.logger?.debug("setting up log websocket on [%s]", LOG_SOCKET_PATH);
+        wsConfigList.push(editorWSConfig);
+        serverConfigMap[EDITOR_CONFIG_KEY] = editorServerConfig;
+      }
+
+      if (this.options?.hotreload/* && !options?.inflateTests*/) {
+        this.logger?.debug("setting up websocket on [/hot-reload]");
+        wsConfigList.push({
+          path: "/hot-reload/"
+        });
+      }
+
+      await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, serverConfigMap, "preload");
+
+      /* setup app (router, websocket servers files)*/
+      const [serviceRouter, errors, fileMap/*, migrations*/, serviceWSConfigList/*, serverConfigMap*/, serviceLogConfigMap] = await inflateApp({
+        logger: this.logger,
+        services: this.options.services,
+        serverInterface: this.serverInterface,
+        //dbManager: this.dbManager,
+        inflateDir: options?.inflateDir,
+        inflateSea: options?.inflateSea ? true : false,
+        //inflateTests: options?.inflateTests ? true : false,
+        hotreload: this.options?.hotreload ? true : false
+      });
+
+      wsConfigList.push(...serviceWSConfigList);
+      router.use(serviceRouter);
+      this.inflated = {
+        router,
+        logConfigMap: serviceLogConfigMap,
+        errors: (errors ? errors : []).concat(dbConfigErrors).concat(serviceConfigErrors),
+        fileMap,
+        //migrations,
+        dbList,
+        wsConfigList,
+        serverConfigMap
+      };
+
+      return this.inflated;
+    } catch (e) {
+      this.inflated = null;
+      throw e;
+    }
+  }
+
+  public isInflated() {
+    return this.inflated ? true : false;
+  }
+
+  public isRunning() {
+    return this.server !== null;
+  }
+
+  public async deflate() {
+    if (this.isRunning()) {
+      throw new Error("cannot deflate app running. call app.stop() first.");
+    }
+    if (this.inflated !== null) {
+      if (this.inflated === undefined) {
+        throw new Error("cannot deflate an app that is currently inflating. wait for the result with await app.inflate() first.");
+      } else {
+        throw new Error("cannot deflate uninflated app. call await app.inflate() first.");
+      }
+    }
+    await this.dbManager.closeAll();
+    await this.dbManager.deleteAll();
+    this.inflated = null;
+  }
+
+  public async start() {
+    if (this.server !== null) {
+      throw new Error("cannot start app already running.");
+    }
+    if (!this.isInflated()) {
+      throw new Error("cannot start uninflated app. call await app.inflate() first.");
+    }
+    //this.logger?.debug("starting");
+    this.logger?.debug("\t\t==start==");
+
+    this.server = undefined;
+    this.server = new App({
+      onUpgrade: (req: ServerRequest, socket, head) => {
+        req.server = this.serverInterface;
+        return this.webSocketManager.onUpgrade(req, socket, head);
+      },
+      loggerFactory: this.loggerProvider.requestLoggerFactory
+    });
+
+    this.webSocketManager.replaceALLWS(this.inflated.wsConfigList);
+
+    reloadInflatedRouter(this);
+
+    await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "load");
+
+    if (this.logger && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+      this.logger?.debug("\t\t==http routes==");
+      this.server.logPaths({
+        debug: this.logger.debug.bind(this.logger),
+        error: this.logger.error.bind(this.logger),
+        info: this.logger.debug.bind(this.logger),
+        log: this.logger.debug.bind(this.logger),
+        trace: this.logger.trace.bind(this.logger),
+        warn: this.logger.warn.bind(this.logger)
+      });
+    }
+
+    this.logger?.trace("calling listen on [%s]", this.options.port);
+
+    await this.server.listen(this.options.port);
+
+    if (this.logger && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+      this.logger?.log("\t\t==listening on [%s]==", this.options.port);
+    } else {
+      this.logger?.debug("\t\t==listening on [%s]==", this.options.port);
+    }
+
+    await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "start");
+
+    if (this.options.hotreload && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+      await watchAndServer(this);
+    }
+
+    this.logger?.debug("\t\t==start done==");
+
+    return this.inflated.errors && this.inflated.errors.length > 0 ? this.inflated.errors : null;
+  }
+
+  public async stop() {
+    if (!this.server || !this.inflated) {
+      throw new Error("cannot stop server not running");
+    }
+    const server = this.server;
+    this.server = null;
+    this.logger?.debug("\t\t==stop==");
+    this.logger?.debug("clear running server routes");
+    server.clear();
+    this.webSocketManager.disconnectAll();
+    this.webSocketManager.deleteAllWS();
+    const pD = this.dbManager.deleteAll();
+    notifiyServerConfigSync(this, "unload");
+    //server.ws.disconnectAll();
+    this.logger?.debug("stopping");
+    const p = server.close();
+    notifiyServerConfigSync(this, "stop");
+    await p;
+    await pD;
+    this.logger?.debug("\t\t==stop done==");
+  }
+
+  public async restart(avoidSend?: boolean) {
+    if (!this.server || !this.inflated) {
+      throw new Error("cannot start server not running");
+    }
+    this.logger?.debug("\t\t==restart==");
+    if (process.send && !avoidSend) {
+      process.send({
+        type: MiqroApplicationMessageType,
+        target: this.options.name,
+        action: "restart",
+        fromPID: process.pid
+      } as MiqroClusterMessage);
+    }
+    await this.stop();
+    const ret = await this.start();
+    this.logger?.debug("\t\t==restart done==");
+    return ret;
+  }
+
+  public async reload(avoidSend?: boolean) {
+    if (!this.server || !this.inflated) {
+      throw new Error("cannot reload server not running");
+    }
+    /*this.logger?.log("====================");
+    this.logger?.log("=======reload=======");
+    this.logger?.log("====================");*/
+
+    if (!avoidSend) {
+      this.logger?.debug("\t\t==reload==");
+    } else {
+      this.logger?.debug("\t\t==reload==");
+    }
+    // block others from calling this
+    const oldServerConfigMap = this.inflated.serverConfigMap;
+    this.inflated = undefined;
+    if (process.send && !avoidSend) {
+      process.send({
+        type: MiqroApplicationMessageType,
+        target: this.options.name,
+        action: "reload",
+        fromPID: process.pid
+      } as MiqroClusterMessage);
+    }
+
+    this.logger?.debug("clear running server routes");
+    this.server.clear();
+    await this.webSocketManager.disconnectAllButLOGSocket();
+    await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, oldServerConfigMap, "unload");
+
+    /* force deflation*/
+    await this.dbManager.closeAll();
+    await this.dbManager.deleteAll();
+    this.inflated = null;
+    /* re-inflation */
+    this.inflated = await this.inflate();
+    if (!this.inflated) {
+      throw new Error("inflation failed!");
+    }
+
+    reloadInflatedRouter(this);
+    await this.webSocketManager.disconnectAllButLOGSocket();
+    this.webSocketManager.replaceALLWSBuLOGSocket(this.inflated.wsConfigList);
+
+    await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "load");
+
+    if (this.logger && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+      this.logger?.debug("\t\t==http routes==");
+      this.server.logPaths({
+        debug: this.logger.debug.bind(this.logger),
+        error: this.logger.error.bind(this.logger),
+        info: this.logger.debug.bind(this.logger),
+        log: this.logger.debug.bind(this.logger),
+        trace: this.logger.trace.bind(this.logger),
+        warn: this.logger.warn.bind(this.logger)
+      });
+    }
+
+    //this.logger?.log("=====================");
+    this.logger?.debug("\t\t==reload done==");
+    //this.logger?.log("=====================");
+
+    return this.inflated.errors && this.inflated.errors.length > 0 ? this.inflated.errors : null;
+
+  }
+}
+
+export function ServerRequestHandler(server: ServerInterface) {
+  return function ServerRequestHandler(req: ServerRequest) {
+    req.server = server;
+  }
+}
+
+function reloadInflatedRouter(app: Miqro) {
+  if (!app.server) {
+    throw new Error("not running");
+  }
+  if (!app.inflated) {
+    throw new Error("not inflated");
+  }
+  app.logger?.debug("clear running server routes");
+  app.server.clear();
+  app.logger?.debug("load running server with new routes");
+
+  app.server.use(app.serverRequestHandler);
+
+  app.server.use(LoggerHandler());
+  if (app.options.editor) {
+    app.server.use(async (req, res) => {
+      res.setHeader("x-uuid", req.uuid);
+    });
+  }
+
+  app.server.use(app.inflated.router);
+}
+
+async function notifiyServerConfig(logger: Logger, serverInterface: ServerInterface, adminInterface: EditorAdminInterface, serverConfigMap: ServerConfigMap, method: "load" | "start" | "unload" | "stop" | "preload") {
+  if (serverConfigMap) {
+    await Promise.allSettled(Object.keys(serverConfigMap).map(name => {
+      return new Promise<void>(async (resolve) => {
+        try {
+          const serverConfig = serverConfigMap[name];
+          if (serverConfig && serverConfig[method]) {
+            if (name === EDITOR_CONFIG_KEY) {
+              await (serverConfig[method] as any)(serverInterface, adminInterface);
+            } else {
+              await serverConfig[method](serverInterface);
+            }
+
+          }
+          resolve();
+        } catch (e) {
+          logger?.error(e);
+          resolve();
+        }
+      })
+    }));
+  }
+}
+
+export function notifiyServerConfigSync(app: Miqro, method: "unload" | "stop") {
+  if (app.inflated) {
+    Object.keys(app.inflated.serverConfigMap).map(name => {
+      try {
+        if (app.inflated) {
+          const serverConfig = app.inflated.serverConfigMap[name];
+          if (serverConfig && serverConfig[method]) {
+            serverConfig[method](app.serverInterface);
+          }
+        }
+      } catch (e) {
+        app.logger?.error(e);
+      }
+    });
+  }
+}