miqro 7.0.1 → 7.0.2

package/src/services/utils/log.ts

@@ -0,0 +1,92 @@
+import { ConsoleTransport, getEnvVariable, Logger, LoggerTransport, MinimalLogger, newURL, normalizePath, Request, WriteArgs } from "@miqro/core";
+import { format } from "node:util";
+
+const DEFAULT_ENV_NAME = "LOG_LEVEL";
+
+export interface LogProviderOptions {
+  name?: string;
+  transports: LoggerTransport[];
+  formatter: (args: WriteArgs) => string;
+}
+
+export const DEFAULT_FORMATTER = ({ identifier, level, message, optionalParams }: WriteArgs) => format(`${new Date().toISOString()} PID[${process.pid}] ` +
+  `${identifier ? `[${identifier}] ` : ""}` +
+  `${level !== "info" ? (level === "error" || level === "warn" ? `[${level.toUpperCase()}] ` : `[${level}] `) : ""}` +
+  `${message}`, ...optionalParams)
+
+export class LogProvider {
+
+  public options: LogProviderOptions;
+  public constructor(options?: LogProviderOptions) {
+    this.options = {
+      formatter: options && options.formatter ? options.formatter : DEFAULT_FORMATTER,
+      transports: options && options.transports ? options.transports : [ConsoleTransport()],
+      name: options?.name
+    };
+    this.requestLoggerFactory = this.requestLoggerFactory.bind(this);
+  }
+
+  public requestLoggerFactory(uuid: string, req: Request): MinimalLogger {
+    let path = "";
+    let query = "";
+    let urlParsingError;
+    let method = "GET";
+    let remoteAddress: string | undefined = "";
+    try {
+      const url = newURL(req.url ? req.url : "/") as URL;
+      query = url.searchParams.toString();
+      path = normalizePath(url.pathname); // normalized path
+      method = req.method ? req.method.toUpperCase() as string : "GET";
+      remoteAddress = req.socket.remoteAddress;
+    } catch (e) {
+      urlParsingError = e;
+    }
+    const pathToEnv = path.replace(/\//ig, "_").replace(/\./ig, "_").replace(/-/ig, "_").toUpperCase();
+    const WORKER_IDENTIFIER = process.env["CLUSTER_NODE_NUMBER"] ? `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}_` : "";
+    const identifier = `${pathToEnv === "_" ? "" : `${pathToEnv.substring(1)}`}${pathToEnv.charAt(pathToEnv.length - 1) !== "_" ? "_" : ""}${method.toUpperCase()}`;
+    const upgrade = req.headers.connection?.indexOf("Upgrade") !== -1;
+
+    const logger = this.getLogger(
+      `${WORKER_IDENTIFIER}${identifier}`, {
+      formatter: (args: WriteArgs) => {
+        args.message = `%s${upgrade ? " UPGRADE" : ""} %s%s [%s] (%s) ${args.message}`;
+        args.optionalParams = [method, path, query ? `?${query}` : "", uuid, remoteAddress].concat(args.optionalParams);
+        args.meta.push(req);
+        args.meta.push(uuid);
+        return this.options.formatter(args);
+      }
+    });
+
+
+    if (urlParsingError) {
+      logger.error(urlParsingError);
+    }
+
+    return logger;
+  };
+
+  public getLogger(identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }): Logger {
+
+    identifier = this.options.name ?
+      `${this.options.name}${identifier ?
+        `_${identifier}` : ""}`.toUpperCase() :
+      identifier ? identifier.toUpperCase() : "";
+
+    const envVarName = `LOG_LEVEL_${identifier}`;
+    const level = options && options.level ? options.level : getEnvVariable(envVarName) ? getEnvVariable(envVarName) : getEnvVariable(DEFAULT_ENV_NAME, "info");
+
+    const logger = new Logger(identifier, level, {
+      transports: [],
+      formatter: options && options.formatter ? options.formatter : this.options.formatter
+    });
+    for (const t of this.options.transports) {
+      logger.addTransport(t);
+    }
+    if (options && options.transports) {
+      for (const t of options.transports) {
+        logger.addTransport(t);
+      }
+    }
+    return logger;
+  }
+}

package/src/services/utils/middleware.ts

@@ -0,0 +1,10 @@
+import { CORS, JSONParser, ReadBuffer, SessionHandler, TextParser, URLEncodedParser } from "@miqro/core";
+
+export const middleware = Object.freeze({
+  buffer: ReadBuffer,
+  url: URLEncodedParser,
+  json: JSONParser,
+  text: TextParser,
+  cors: CORS,
+  session: SessionHandler
+});

package/src/services/utils/server-interface.ts

@@ -0,0 +1,122 @@
+import { Logger } from "@miqro/core";
+import cluster from "node:cluster";
+import { CacheInterface, NamedMigration, ServerInterface } from "../../types.js";
+import { DBManager } from "./db-manager.js";
+import { Miqro } from "../app.js";
+import { WebSocketManager } from "./websocketmanager.js";
+import { execSync } from "node:child_process";
+import { LogProvider } from "./log.js";
+import { HTMLEncode } from "../../../editor/common/html-encode.js";
+import { inflateMD2HTML } from "../../inflate/md.js";
+
+import { Parser } from "@miqro/parser";
+import { ClusterCache } from "./cluster-cache.js";
+import { LocalCache } from "./cache.js";
+import { middleware } from "./middleware.js";
+import { jwt } from "./jwt.js";
+
+// import { initGlobals } from "../globals.js";
+
+export interface ServerInterfaceImplOptions {
+  cache: CacheInterface;
+  localCache: CacheInterface;
+  dbManager: DBManager;
+  webSocketManager: WebSocketManager;
+  logger?: Logger;
+  app?: Miqro;
+  port?: string;
+  loggerProvider?: LogProvider;
+}
+
+export function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface {
+  // initGlobals();
+  return Object.freeze<ServerInterface>({
+    middleware,
+    encodeHTML: HTMLEncode,
+    inflateMDtoHTML: inflateMD2HTML,
+    newParser() {
+      return new Parser();
+    },
+    newClusterCache(name, logger) {
+      return new ClusterCache(name, logger);
+    },
+    newLocalCache(name, logger) {
+      return new LocalCache(name, logger);
+    },
+    getWorkerNumber(): number {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+    },
+    getWorkerCount(): number {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+    },
+    isPrimaryWorker(): boolean {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+    },
+    jwt,
+    cache: options.cache,
+    localCache: options.localCache,
+    logger: options.logger,
+    reload() {
+      return options?.app?.reload();
+    },
+    restart() {
+      return options?.app?.restart();
+    },
+    stop() {
+      return options?.app?.stop();
+    },
+    db: {
+      get(name) {
+        return options.dbManager.getDB(name);
+      },
+      getMigrations() {
+        if (options.app?.inflated) {
+          const ret: NamedMigration[] = [];
+          for (const d of options.app?.inflated.dbList) {
+            ret.push(...(d.migrations.map(m => {
+              return {
+                name: m.name,
+                service: m.service,
+                dbName: m.dbName
+              }
+            })));
+          }
+          return ret;
+        }
+        return [];
+      },
+      migrate(migrateOptions) {
+        return options?.app?.migrate(migrateOptions);
+      },
+    },
+    ws: {
+      get: (name: string) => {
+        return options?.webSocketManager?.getWS(name);
+      },
+      disconnectAll: (path: string) => {
+        return options?.webSocketManager?.disconnectAllButLOGSocket();
+      }
+    },
+    openBrowser(path) {
+      const PORT = options.port;
+      const URL = `http://localhost${PORT ? `:${PORT}` : ""}${path}`;
+      const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
+      const OPEN = options?.app?.options.browser !== undefined && String(options?.app?.options.browser).toUpperCase() !== "TRUE" && String(options?.app?.options.browser).toUpperCase() !== "1" ?
+        String(options?.app.options.browser).toUpperCase() !== "0" && String(options?.app?.options.browser).toUpperCase() !== "FALSE" && String(options?.app?.options.browser).toUpperCase() !== "NONE" && options?.app?.options.browser ?
+          options?.app.options.browser : false :
+        process.env["BROWSER"] ?
+          process.env["BROWSER"] === "none" ? false : process.env["BROWSER"] : DEFAULT_OPEN;
+      if (OPEN) {
+        const openCMD = `${OPEN} "${URL}"`;
+        options?.logger?.info("opening browser with [%s]", openCMD);
+        execSync(openCMD);
+      } else {
+        options?.logger?.warn("ignoring browser [%s]", OPEN);
+      }
+    },
+    getLogger(identifier, loggerOptions) {
+      return options?.loggerProvider?.getLogger(identifier, loggerOptions);
+    }
+    // ...server
+  });
+}

package/src/services/utils/websocketmanager.ts

@@ -0,0 +1,157 @@
+import { Logger } from "@miqro/core";
+import { LOG_SOCKET_PATH } from "../../../editor/common/constants.js";
+import { ClusterWebSocketServer2 } from "./cluster-ws.js";
+import { WSConfig } from "../../types.js";
+import { LogProvider } from "./log.js";
+
+export interface WebSocketManagerOptions {
+  logger?: Logger | Console;
+  loggerProvider?: LogProvider;
+  name?: string;
+  avoidLogSocket?: boolean;
+}
+
+export class WebSocketManager {
+  public runningGlobalWSMap = new Map<string, ClusterWebSocketServer2>();
+  public logger?: Logger | Console | null = null;
+  public name: string;
+  public avoidLogSocket: boolean;
+  public loggerProvider: LogProvider;
+  constructor(options?: WebSocketManagerOptions) {
+    this.onUpgrade = this.onUpgrade.bind(this);
+    this.logger = options && options.logger ? options.logger : null;
+    this.name = options && options.name ? options.name : "WebSocketManager";
+    this.loggerProvider = options && options.loggerProvider;
+    this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
+  }
+
+  public deleteWS(path: string) {
+    const ws = this.runningGlobalWSMap.get(path);
+    this.disconnectAllFrom(path);
+    ws.dispose();
+    this.runningGlobalWSMap.delete(path);
+  }
+
+  public deleteAllWS() {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      this.deleteWS(path);
+    }
+  }
+
+  public getWS(path: string): ClusterWebSocketServer2 | undefined {
+    return this.runningGlobalWSMap.get(path);
+  }
+
+  public replaceALLWS(list: WSConfig[]) {
+    this.deleteAllWS();
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (this.runningGlobalWSMap.has(wsConfig.path)) {
+          throw new Error(`ws on path ${wsConfig.path} already setup!`);
+        }
+        this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
+        const identifier = wsConfig.path.replaceAll("/", "_").toUpperCase();
+        const logger = this.loggerProvider && identifier.length >= 0 ? this.loggerProvider.getLogger(identifier.substring(identifier.charAt(0) === "_" ? 1 : 0)) : this.logger;
+        const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig.path, logger, wsConfig);
+        this.runningGlobalWSMap.set(wsConfig.path, server);
+      }
+    }
+  }
+
+  public replaceALLWSBuLOGSocket(list: WSConfig[]) {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      if (path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+        this.deleteWS(path);
+      }
+    }
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (wsConfig.path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          if (this.runningGlobalWSMap.has(wsConfig.path)) {
+            throw new Error(`ws on path ${wsConfig.path} already setup!`);
+          }
+          this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
+          const identifier = wsConfig.path.replaceAll("/", "_").toUpperCase();
+          const logger = this.loggerProvider && identifier.length >= 0 ? this.loggerProvider.getLogger(identifier.substring(identifier.charAt(0) === "_" ? 1 : 0)) : this.logger;
+          const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig.path, logger, wsConfig);
+          this.runningGlobalWSMap.set(wsConfig.path, server);
+        }
+      }
+    }
+  }
+
+  /*public setupWS(path: string, server: ClusterWebSocketServer2) {
+    if (this.runningGlobalWSMap.has(path)) {
+      throw new Error(`ws on path ${path} already setup!`);
+    }
+    this.runningGlobalWSMap.set(path, server);
+  }*/
+
+  public disconnectAllFrom(path: string) {
+    try {
+      this.logger?.debug("disconnect all from [%s]", path);
+      const ws = this.getWS(path);
+      if (ws) {
+        const clients = ws.clients.values();
+        if (clients) {
+          for (const client of clients) {
+            try {
+              client.socket.destroy();
+            } catch (e2) {
+              this.logger?.error("error disconnecting web socket client");
+              this.logger?.error(e2);
+            }
+          }
+        }
+        //ws.dispose();
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public disconnectAllButLOGSocket() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        if (wsPath !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          this.disconnectAllFrom(wsPath);
+        }
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public disconnectAll() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        this.disconnectAllFrom(wsPath);
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public onUpgrade(req, socket, head) {
+    try {
+      const wsServer = this.getWS(req.path);
+      if (wsServer) {
+        return wsServer.onUpgrade(req, socket, head);
+      } else {
+        socket.destroy();
+      }
+    } catch (e) {
+      this.logger?.error(e);
+    }
+  }
+}
+
+/*export interface WSMapConfig {
+  [path: string]: {
+    name: string;
+    options: WSConfig;
+  } | undefined;
+}*/

package/src/types.ts

@@ -0,0 +1,307 @@
+import { Database } from "@miqro/query";
+import { WebSocketServerOptions, SessionHandlerOptions, Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler, RouteOptions, Handler, Request, Response, LogLevel, LoggerTransportWriteArgs, CORSOptions, HandlerWithOptions, ErrorHandler } from "@miqro/core";
+import { request } from "@miqro/request";
+import { Parser, ParserInterface } from "@miqro/parser";
+import { RuntimeHTMLElement, Runtime, RuntimeContainer, RuntimeURL, RuntimeOptions, RuntimeShadowRootInit } from "@miqro/jsx";
+import {
+  RuntimeElementDefinitionOptions,
+  Component,
+  createElement,
+  Fragment,
+  enableDebugLog
+} from "@miqro/jsx";
+import * as jsxLib from "@miqro/jsx";
+import { EncryptOptions, JWTDecryptOptions, JWTDecryptResult, JWTPayload, JWTVerifyOptions, JWTVerifyResult, ProtectedHeaderParameters, SignOptions } from "jose";
+import { KeyObject } from "node:crypto";
+
+export interface EncryptJWTOptions {
+  alg?: string;
+  enc?: string;
+  iat?: number | string | Date;
+  iss?: string;
+  aud?: string;
+  exp?: number | string | Date;
+  options?: EncryptOptions;
+}
+
+export interface JWTSignOptions {
+  alg?: string;
+  iat?: number | string | Date;
+  iss?: string;
+  aud?: string;
+  exp?: number | string | Date;
+  options?: SignOptions;
+}
+
+/*declare global {
+  // jsx only for the default value of tsconfig.json
+  //var React: {};
+  var JSX: {
+    createElement: typeof createElement;
+    Fragment: typeof Fragment;
+    enableDebugLog: typeof enableDebugLog;
+  }
+}
+
+declare global {
+  // only available browser side
+  var jsx: {
+    define: (tagName: string, component: Component, options?: RuntimeElementDefinitionOptions) => void;
+    useRuntime: typeof jsxLib.useRuntime;
+    usePathname: typeof jsxLib.usePathname;
+    Link: typeof jsxLib.Link;
+    Router: typeof jsxLib.Router;
+    createContext: typeof jsxLib.createContext;
+    useContext: typeof jsxLib.useContext;
+    useState: typeof jsxLib.useState;
+    useEffect: typeof jsxLib.useEffect;
+    useQuery: typeof jsxLib.useQuery;
+    useRef: typeof jsxLib.useRef;
+    useElement: typeof jsxLib.useElement;
+    useRefresh: typeof jsxLib.useRefresh;
+  }
+}*/
+
+export { APIRoute } from "@miqro/core";
+export { Migration } from "@miqro/query";
+
+export interface JWTInterface {
+  createSecretKey: (key: string, encoding: BufferEncoding) => KeyObject;
+  /**
+ * creates a JWT encrypted token with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+  encrypt: (payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>) => Promise<string>
+  /**
+   * decrypts a JWT token with jose
+   * @param jwt the JWT token
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like issuer and audience
+   * @returns 
+   */
+  decrypt: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>) => Promise<JWTDecryptResult<PayloadType>>;
+  /**
+   * verify a JWT token with jose
+   * @param jwt the JWT token
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like issuer and audience
+   * @returns 
+   */
+  verify: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>) => Promise<JWTVerifyResult<PayloadType>>;
+  /**
+   * creates a signed JWT with jose
+   * 
+   * @param payload the payload to encrypt
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like expiratation date, issuer and audience
+   * @returns 
+   */
+  sign: (payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>) => Promise<string>;
+  /**
+   * decodes a protected header with jose
+   * @param token 
+   * @returns 
+   */
+  decodeProtectedHeader: (token: string | object) => ProtectedHeaderParameters;
+  /**
+   * decodes a jwt token
+   * @param jwt 
+   * @returns 
+   */
+  decode: <PayloadType = JWTPayload>(jwt: string) => PayloadType & JWTPayload;
+}
+
+export interface ServerGlobal {
+  encodeHTML: (str: string) => string;
+  inflateMDtoHTML: (str: string) => string;
+  middleware: {
+    buffer: typeof ReadBuffer;
+    url: typeof URLEncodedParser;
+    json: typeof JSONParser;
+    text: typeof TextParser;
+    cors: typeof CORS;
+    session: typeof SessionHandler;
+  };
+  newParser(): Parser;
+  newClusterCache: (name: string, logger?: Logger) => CacheInterface;
+  newLocalCache: (name: string, logger?: Logger) => CacheInterface;
+  
+  getWorkerCount: () => number;
+  getWorkerNumber: () => number;
+  isPrimaryWorker: () => boolean;
+  jwt: JWTInterface;
+}
+
+export interface CacheInterface {
+  get<T = any>(key: string): T | undefined;
+  set: (key: string, value: unknown) => void;
+  unset: (key: string) => void;
+  has: (key: string) => boolean;
+
+  set_add: (key: string, value: unknown) => void;
+  set_delete: (key: string, value: unknown) => void;
+  set_has: (key: string, value: unknown) => boolean;
+  set_clear: (key: string) => void;
+
+  array_push: (key: string, value: unknown) => void;
+  array_clear: (key: string) => void;
+}
+
+export interface NamedMigration {
+  name: string;
+  service: string;
+  dbName: string;
+}
+
+export interface MigrateOptions {
+  direction: "up" | "down";
+  service?: string;
+  dbName?: string;
+  name?: string;
+}
+
+export interface LogConfig {
+  level?: LogLevel;
+  replaceConsoleTransport?: boolean;
+  replaceFileTransport?: boolean;
+  write: (args: LoggerTransportWriteArgs) => Promise<void> | void;
+}
+
+export interface ServerInterface extends ServerGlobal {
+  // null values are if the feature has been disabled
+  db: {
+    get(name: string): Database | null;
+    getMigrations(): NamedMigration[];
+    migrate(options: MigrateOptions): Promise<void>;
+  },
+  ws: {
+    get(path: string): WebSocketServer | undefined;
+    disconnectAll(path: string): void;
+  };
+  cache: CacheInterface;
+  localCache: CacheInterface;
+  logger?: Logger;
+  openBrowser: (path: string) => void;
+  getLogger: (identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }) => Logger;
+  stop: () => Promise<void>;
+  reload: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+  restart: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+}
+
+export interface ServerRequest extends Request {
+  server?: ServerInterface;
+}
+
+export interface ServerResponse extends Response {
+}
+
+export interface TestHelperGlobal {
+  PORT: string;
+  request: typeof request,
+  logger: Logger,
+  sleep: (ms: number) => Promise<void>,
+  jsx: {
+    createRuntime: (args?: {
+      basePath?: string | null;
+      url?: RuntimeURL;
+      logger?: {
+        log: Function,
+        error: Function
+      }
+    }) => Runtime;
+    test: (cb: (container: RuntimeContainer, root: RuntimeHTMLElement, runtime: Runtime) => (Promise<void> | void), args?: {
+      runtimeOptions?: {
+        basePath?: string | null;
+        url?: RuntimeURL;
+        logger?: {
+          log: Function;
+          error: Function;
+        };
+      },
+      containerOptions?: {
+        runtimeOptions?: RuntimeOptions;
+        shadowInit?: boolean | RuntimeShadowRootInit;
+      };
+    }) => () => Promise<void>;
+  }
+}
+
+/*declare global {
+  // only available server side
+  var server: ServerGlobal;
+
+  //var utils: UtilsGlobal;
+
+  var test: TestHelperGlobal;
+
+  var it: Function;
+  var describe: Function;
+  var before: Function;
+  var after: Function;
+}*/
+
+export interface AuthConfig extends SessionHandlerOptions {
+
+}
+
+export interface MiddlewareConfig {
+  middleware?: Array<HandlerWithOptions | Handler>;
+  post?: Array<HandlerWithOptions | Handler>;
+}
+
+export interface ErrorConfig {
+  catch?: Array<ErrorHandler>;
+}
+
+export interface DocConfig {
+  publish: {
+    [path: string]: {
+      type?: "HTML" | "MD" | "JSON",
+      all?: boolean;
+    }
+  }
+}
+
+export interface WSConfig extends WebSocketServerOptions {
+  path: string;
+  disabled?: boolean;
+}
+
+export interface CORSConfig extends CORSOptions {
+
+}
+
+export interface ServerConfig {
+  preload?: (server: ServerInterface) => Promise<void> | void;
+  start?: (server: ServerInterface) => Promise<void> | void;
+  load?: (server: ServerInterface) => Promise<void> | void;
+  unload?: (server: ServerInterface) => void;
+  stop?: (server: ServerInterface) => void;
+}
+
+export interface DBConfig {
+  dialect?: string;
+  storage?: string;
+  url?: string;
+  disabled?: boolean;
+  name: string;
+}
+
+export interface APIOptions extends Partial<RouteOptions> {
+  basePath?: string;
+  path?: string | string[];
+  method?: string | string[];
+  parser?: ParserInterface;
+  middleware?: Handler | Handler[];
+  session?: SessionHandlerOptions | Handler;
+}