miqro 6.1.4 → 6.2.1

package/build/esm/src/services/app.js

@@ -19,7 +19,7 @@ import { initAssets } from "../common/assets.js";
 import { setupExitHandlers } from "../common/exit.js";
 import { inflateDBConfig, inflateDBMigrations } from "../inflate/setup-db.js";
 import { getServicePath } from "../common/paths.js";
-import { ServerInterfaceImpl } from "./utils/server-interface.js";
+import { createServerInterface } from "./utils/server-interface.js";
 import { getPORT, importMiqroJSON } from "../common/arguments.js";
 import { createLogProviderOptions } from "./utils/log-transport.js";
 import { createAdminInterface } from "./utils/admin-interface.js";
@@ -30,6 +30,7 @@ export class Miqro {
     status = "stopped";
     options;
     server = null;
+    httpsRedirectServer = null;
     cache;
     localCache;
     webSocketManager;
@@ -90,6 +91,7 @@ export class Miqro {
         this.localCache = new LocalCache(`MiqroApplicationLocalCache[${this.options.name}]`, this.logger);
         this.webSocketManager = new WebSocketManager({
             logger: this.logger,
+            loggerProvider: this.loggerProvider,
             name: `MiqroApplicationWebsocketManager[${this.options.name}]`,
             avoidLogSocket: this.options.editor
         });
@@ -100,11 +102,11 @@ export class Miqro {
             loggerProvider: this.loggerProvider,
             logger: this.logger
         });
-        this.serverInterface = new ServerInterfaceImpl({
+        this.serverInterface = createServerInterface({
             cache: this.cache,
-            localCache: this.localCache,
             dbManager: this.dbManager,
-            wsManager: this.webSocketManager,
+            localCache: this.localCache,
+            webSocketManager: this.webSocketManager,
             app: this,
             logger: this.logger,
             loggerProvider: this.loggerProvider,
@@ -342,6 +344,7 @@ export class Miqro {
         //this.disconnect();
         this.status = "starting";
         this.server = undefined;
+        this.httpsRedirectServer = undefined;
         this.connect();
         await this.dbManager.connectAll();
         this.server = new App({
@@ -349,8 +352,17 @@ export class Miqro {
                 req.server = this.serverInterface;
                 return this.webSocketManager.onUpgrade(req, socket, head);
             },
-            loggerFactory: this.loggerProvider.requestLoggerFactory
+            loggerFactory: this.loggerProvider.requestLoggerFactory,
+            serverOptions: this.options?.serverOptions,
+            https: this.options?.https
         });
+        if (this.options?.httpRedirect) {
+            this.httpsRedirectServer = new App();
+            this.httpsRedirectServer.use(async (req, res) => {
+                const hostname = req.headers.host.split(":").length > 1 ? req.headers.host.split(":")[0] : req.headers.host;
+                return await res.redirect('https://' + hostname + ":" + this.options.port + req.url);
+            });
+        }
         this.webSocketManager.replaceALLWS(this.inflated.wsConfigList);
         reloadInflatedRouter(this);
         await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "load");
@@ -367,11 +379,20 @@ export class Miqro {
         }
         this.logger?.trace("calling listen on [%s]", this.options.port);
         await this.server.listen(this.options.port);
+        if (this.options?.httpRedirect) {
+            await this.httpsRedirectServer.listen(this.options.httpRedirect);
+        }
+        if (this.options?.httpRedirect && this.logger && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+            this.logger?.log("\t\t==listening on [http][%s] for [https][%s] redirection==", this.options?.httpRedirect, this.options.port);
+        }
+        else if (this.options?.httpRedirect) {
+            this.logger?.debug("\t\t==listening on [http][%s] for [https][%s] redirection==", this.options?.httpRedirect, 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);
+            this.logger?.log("\t\t==listening on [%s][%s]==", this.options.https ? "https" : "http", this.options.port);
         }
         else {
-            this.logger?.debug("\t\t==listening on [%s]==", this.options.port);
+            this.logger?.debug("\t\t==listening on [%s][%s]==", this.options.https ? "https" : "http", 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")) {
@@ -391,7 +412,9 @@ export class Miqro {
             this.watcher = null;
         }
         const server = this.server;
+        const httpsRedirectServer = this.httpsRedirectServer;
         this.server = null;
+        this.httpsRedirectServer = null;
         this.disconnect();
         this.logger?.debug("\t\t==stop==");
         this.logger?.debug("clear running server routes");
@@ -402,6 +425,9 @@ export class Miqro {
         notifiyServerConfigSync(this, "unload");
         //server.ws.disconnectAll();
         this.logger?.debug("stopping");
+        if (httpsRedirectServer) {
+            await httpsRedirectServer.close();
+        }
         const p = server.close();
         await p;
         await pD;

package/build/esm/src/services/globals.js

@@ -1,11 +1,16 @@
 //@ts-ignore
 import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
+import cluster from "node:cluster";
 import { strictEqual } from "node:assert";
 import { HTMLEncode } from "@miqro/jsx-node";
 import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, Router, usePathname, Fragment, useEffect, useRef, useState, useQuery, useRefresh, useElement, createContext, useContext } from "@miqro/jsx";
 import { jsx2HTML } from "../common/jsx.js";
 import { inflateMD2HTML } from "../inflate/md.js";
 import { EXIT_CODES } from "../common/constants.js";
+import { ClusterCache, LocalCache } from "../lib.js";
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../common/jwt.js";
+import { createSecretKey } from "node:crypto";
+import { Parser } from "@miqro/parser";
 /*const globaljsx: any = Object.freeze({
   useContext,
   useRuntime,
@@ -80,7 +85,46 @@ const globalServer = Object.freeze({
         session: SessionHandler
     }),
     encodeHTML: HTMLEncode,
-    inflateMDtoHTML: inflateMD2HTML
+    inflateMDtoHTML: inflateMD2HTML,
+    createSecretKey,
+    newParser() {
+        return new Parser();
+    },
+    newClusterCache(name, logger) {
+        return new ClusterCache(name, logger);
+    },
+    newLocalCache(name, logger) {
+        return new LocalCache(name, logger);
+    },
+    getWorkerNumber() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+    },
+    getWorkerCount() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+    },
+    isPrimaryWorker() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+    },
+    jwt: {
+        decode(jwt) {
+            return decodeJWT(jwt);
+        },
+        decodeProtectedHeader(token) {
+            return decodeProtectedHeaderJWT(token);
+        },
+        decrypt(jwt, secret, options) {
+            return decryptJWT(jwt, secret, options);
+        },
+        encrypt(payload, secret, options) {
+            return encryptJWT(payload, secret, options);
+        },
+        sign(payload, secret, options) {
+            return signJWT(payload, secret, options);
+        },
+        verify(jwt, secret, options) {
+            return verifyJWT(jwt, secret, options);
+        }
+    }
 });
 export function browserJSXGlobals(inFile, jsxPath = false, useExport = true) {
     const PRE = `import { enableDebugLog, useRuntime, Link, usePathname, createContext, useContext, useElement, useRefresh, useQuery, define, Router, useState, useEffect, useRef, createElement, Fragment } from "${jsxPath}";

package/build/esm/src/services/utils/cluster-ws.d.ts

@@ -1,4 +1,4 @@
-import { WebSocketServer, WebSocketServerOptions } from "@miqro/core";
+import { Logger, WebSocketServer, WebSocketServerOptions } from "@miqro/core";
 import { Serializable } from "node:child_process";
 declare const ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
 export interface ClusterWebSocketServer2Message {
@@ -13,9 +13,11 @@ export interface ClusterWebSocketServer2Message {
 }
 export declare class ClusterWebSocketServer2 extends WebSocketServer {
     protected name: string;
+    path: string;
+    logger: Logger | Console;
     remoteClients: Set<string>;
     listener: (data: any) => Promise<void>;
-    constructor(name: string, options: WebSocketServerOptions);
+    constructor(name: string, path: string, logger: Logger | Console, options: WebSocketServerOptions);
     connect(): void;
     dispose(): void;
     broadcast(payload: string, fromUUID?: string): Promise<void>;

package/build/esm/src/services/utils/cluster-ws.js

@@ -2,14 +2,17 @@ import { WebSocketServer } from "@miqro/core";
 const ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
 export class ClusterWebSocketServer2 extends WebSocketServer {
     name;
+    path;
+    logger;
     remoteClients = new Set();
     listener;
-    constructor(name, options) {
+    constructor(name, path, logger, options) {
         super({
             ...options,
             validate: (req) => {
                 if (this.options.maxConnections !== undefined &&
                     this.clients.size + this.remoteClients.size >= this.options.maxConnections) {
+                    this.logger?.warn("[%s] max web socket connection reached! connection refused from [%s]", req.uuid, req.socket.remoteAddress);
                     return false;
                 }
                 else {
@@ -27,6 +30,8 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         errorMessage: error.message
                     });
                 }
+                this.logger?.error("[%s] error from (%s) error [%s]", req.uuid, req.req.socket.remoteAddress, error);
+                this.logger?.error(error);
                 if (options.onError) {
                     options.onError(req, error);
                 }
@@ -41,6 +46,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         clientUUID: req.uuid
                     });
                 }
+                this.logger?.log("[%s] new web socket connection from (%s)", req.uuid, req.req.socket.remoteAddress);
                 if (options.onConnection) {
                     options.onConnection(req);
                 }
@@ -55,12 +61,15 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         clientUUID: req.uuid
                     });
                 }
+                this.logger?.log("[%s] [%s] web socket disconnection from (%s)", req.uuid, this.path, req.req.socket.remoteAddress);
                 if (options.onDisconnect) {
                     options.onDisconnect(req);
                 }
             }
         });
         this.name = name;
+        this.path = path;
+        this.logger = logger;
         this.listener = async (data) => {
             try {
                 const msg = data;

package/build/esm/src/services/utils/server-interface.d.ts

@@ -1,6 +1,5 @@
-import { WebSocketServer, Logger } from "@miqro/core";
-import { Database } from "@miqro/query";
-import { CacheInterface, MigrateOptions, NamedMigration, ServerInterface } from "../../types.js";
+import { Logger } from "@miqro/core";
+import { CacheInterface, ServerInterface } from "../../types.js";
 import { DBManager } from "./db-manager.js";
 import { Miqro } from "../app.js";
 import { WebSocketManager } from "./websocketmanager.js";
@@ -9,35 +8,10 @@ export interface ServerInterfaceImplOptions {
     cache: CacheInterface;
     localCache: CacheInterface;
     dbManager: DBManager;
-    wsManager: WebSocketManager;
+    webSocketManager: WebSocketManager;
     logger?: Logger;
     app?: Miqro;
     port?: string;
     loggerProvider?: LogProvider;
 }
-export declare class ServerInterfaceImpl implements ServerInterface {
-    cache: CacheInterface;
-    localCache: CacheInterface;
-    logger?: Logger;
-    port?: string;
-    db: {
-        get(name: string): Database | null;
-        getMigrations(): NamedMigration[];
-        migrate(options: MigrateOptions): Promise<void>;
-    };
-    ws: {
-        get(path: string): WebSocketServer | undefined;
-        disconnectAll(path: string): void;
-    };
-    loggerProvider?: LogProvider;
-    openBrowser: (path: string) => void;
-    constructor(options: ServerInterfaceImplOptions);
-    getWorkerNumber(): number;
-    getWorkerCount(): number;
-    isPrimaryWorker(): boolean;
-    getLogger(identifier: string, options?: {
-        level?: any;
-        transports?: any[];
-        formatter?: any;
-    }): Logger;
-}
+export declare function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface;

package/build/esm/src/services/utils/server-interface.js

@@ -1,49 +1,28 @@
-import cluster from "node:cluster";
 import { execSync } from "node:child_process";
-export class ServerInterfaceImpl {
-    cache;
-    localCache;
-    logger;
-    port;
-    db;
-    ws;
-    loggerProvider;
-    openBrowser;
-    constructor(options) {
-        this.cache = options.cache;
-        this.localCache = options.localCache;
-        this.logger = options.logger ? options.logger : options.loggerProvider ? options.loggerProvider.getLogger("server") : undefined;
-        this.port = options.port;
-        const dbManager = options.dbManager;
-        const wsManager = options.wsManager;
-        this.loggerProvider = options.loggerProvider;
-        const app = options.app;
-        this.openBrowser = (path) => {
-            const PORT = this.port;
-            const URL = `http://localhost${PORT ? `:${PORT}` : ""}${path}`;
-            const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
-            const OPEN = app.options.browser !== undefined && String(app.options.browser).toUpperCase() !== "TRUE" && String(app.options.browser).toUpperCase() !== "1" ?
-                String(app.options.browser).toUpperCase() !== "0" && String(app.options.browser).toUpperCase() !== "FALSE" && String(app.options.browser).toUpperCase() !== "NONE" && app.options.browser ?
-                    app.options.browser : false :
-                process.env["BROWSER"] ?
-                    process.env["BROWSER"] === "none" ? false : process.env["BROWSER"] : DEFAULT_OPEN;
-            if (OPEN) {
-                const openCMD = `${OPEN} "${URL}"`;
-                this.logger?.info("opening browser with [%s]", openCMD);
-                execSync(openCMD);
-            }
-            else {
-                this.logger?.warn("ignoring browser [%s]", OPEN);
-            }
-        };
-        this.db = Object.freeze({
-            get: (name) => {
-                return dbManager.getDB(name);
+import { initGlobals } from "../globals.js";
+export function createServerInterface(options) {
+    initGlobals();
+    return Object.freeze({
+        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 (app?.inflated) {
+            getMigrations() {
+                if (options.app?.inflated) {
                     const ret = [];
-                    for (const d of app?.inflated.dbList) {
+                    for (const d of options.app?.inflated.dbList) {
                         ret.push(...(d.migrations.map(m => {
                             return {
                                 name: m.name,
@@ -56,29 +35,39 @@ export class ServerInterfaceImpl {
                 }
                 return [];
             },
-            migrate: (options) => {
-                return app?.migrate(options);
-            }
-        });
-        this.ws = Object.freeze({
+            migrate(migrateOptions) {
+                return options?.app?.migrate(migrateOptions);
+            },
+        },
+        ws: {
             get: (name) => {
-                return wsManager?.getWS(name);
+                return options?.webSocketManager?.getWS(name);
             },
             disconnectAll: (path) => {
-                return wsManager?.disconnectAllButLOGSocket();
+                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);
             }
-        });
-    }
-    getWorkerNumber() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
-    }
-    getWorkerCount() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
-    }
-    isPrimaryWorker() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-    }
-    getLogger(identifier, options) {
-        return this.loggerProvider?.getLogger(identifier, options);
-    }
+        },
+        getLogger(identifier, loggerOptions) {
+            return options?.loggerProvider?.getLogger(identifier, loggerOptions);
+        },
+        ...server
+    });
 }

package/build/esm/src/services/utils/websocketmanager.d.ts

@@ -1,8 +1,10 @@
 import { Logger } from "@miqro/core";
 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;
 }
@@ -11,6 +13,7 @@ export declare class WebSocketManager {
     logger?: Logger | Console | null;
     name: string;
     avoidLogSocket: boolean;
+    loggerProvider: LogProvider;
     constructor(options?: WebSocketManagerOptions);
     deleteWS(path: string): void;
     deleteAllWS(): void;

package/build/esm/src/services/utils/websocketmanager.js

@@ -5,10 +5,12 @@ export class WebSocketManager {
     logger = null;
     name;
     avoidLogSocket;
+    loggerProvider;
     constructor(options) {
         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.loggerProvider;
         this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
     }
     deleteWS(path) {
@@ -33,7 +35,9 @@ export class WebSocketManager {
                     throw new Error(`ws on path ${wsConfig.path} already setup!`);
                 }
                 this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-                const server = new ClusterWebSocketServer2(wsConfig.path, wsConfig);
+                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);
             }
         }
@@ -51,7 +55,9 @@ export class WebSocketManager {
                         throw new Error(`ws on path ${wsConfig.path} already setup!`);
                     }
                     this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-                    const server = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig);
+                    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);
                 }
             }

package/build/esm/src/types.d.ts

@@ -1,10 +1,29 @@
 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 { ParserInterface } from "@miqro/parser";
+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 {
     var JSX: {
         createElement: typeof createElement;
@@ -42,6 +61,61 @@ export interface ServerGlobal {
         cors: typeof CORS;
         session: typeof SessionHandler;
     };
+    newParser(): Parser;
+    newClusterCache: (name: string, logger?: Logger) => CacheInterface;
+    newLocalCache: (name: string, logger?: Logger) => CacheInterface;
+    createSecretKey: (key: string, encoding: BufferEncoding) => KeyObject;
+    getWorkerCount: () => number;
+    getWorkerNumber: () => number;
+    isPrimaryWorker: () => boolean;
+    jwt: {
+        /**
+       * 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 CacheInterface {
     get<T = any>(key: string): T | undefined;
@@ -72,7 +146,7 @@ export interface LogConfig {
     replaceFileTransport?: boolean;
     write: (args: LoggerTransportWriteArgs) => Promise<void> | void;
 }
-export interface ServerInterface {
+export interface ServerInterface extends ServerGlobal {
     db: {
         get(name: string): Database | null;
         getMigrations(): NamedMigration[];
@@ -85,15 +159,21 @@ export interface ServerInterface {
     cache: CacheInterface;
     localCache: CacheInterface;
     logger?: Logger;
-    isPrimaryWorker: () => boolean;
-    getWorkerNumber: () => number;
-    getWorkerCount: () => number;
     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;