miqro 6.1.3 → 6.2.0

package/src/services/globals.ts

@@ -1,5 +1,6 @@
 //@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, Component, Props } from "@miqro/jsx";
@@ -7,7 +8,10 @@ import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, R
 import { jsx2HTML } from "../common/jsx.js";
 import { inflateMD2HTML } from "../inflate/md.js";
 import { EXIT_CODES } from "../common/constants.js";
-import { ServerGlobal } from "../lib.js";
+import { ClusterCache, LocalCache, ServerGlobal } 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,
@@ -83,7 +87,46 @@ const globalServer: ServerGlobal = Object.freeze<ServerGlobal>({
     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(): 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: {
+    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);
+    }
+  }
 }) as ServerGlobal;
 
 export function browserJSXGlobals(inFile: string, jsxPath: string | false = false, useExport = true): string {

package/src/services/utils/cluster-ws.ts

@@ -17,7 +17,7 @@ export interface ClusterWebSocketServer2Message {
 export class ClusterWebSocketServer2 extends WebSocketServer {
   public remoteClients: Set<string> = new Set();
   listener: (data: any) => Promise<void>;
-  public constructor(protected name: string, options: WebSocketServerOptions) {
+  public constructor(protected name: string, public path: string, public logger: Logger | Console, options: WebSocketServerOptions) {
     super({
       ...options,
       validate: (req) => {
@@ -25,6 +25,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
           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 {
           return options.validate ? options.validate(req) : true;
@@ -41,6 +42,8 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             errorMessage: error.message
           } as ClusterWebSocketServer2Message);
         }
+        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);
         }
@@ -55,6 +58,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             clientUUID: req.uuid
           } as ClusterWebSocketServer2Message);
         }
+        this.logger?.log("[%s] new web socket connection from (%s)", req.uuid, req.req.socket.remoteAddress);
         if (options.onConnection) {
           options.onConnection(req);
         }
@@ -69,6 +73,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
             clientUUID: req.uuid
           } as ClusterWebSocketServer2Message);
         }
+        this.logger?.log("[%s] [%s] web socket disconnection from (%s)", req.uuid, this.path, req.req.socket.remoteAddress);
         if (options.onDisconnect) {
           options.onDisconnect(req);
         }

package/src/services/utils/log-transport.ts

@@ -1,11 +1,17 @@
-import { ConsoleTransport, FileTransport, LoggerTransportWriteArgs, LogLevel, WriteArgs } from "@miqro/core";
+import { ConsoleTransport, FileTransport, LoggerTransport, LoggerTransportWriteArgs, LogLevel, WriteArgs } from "@miqro/core";
 import { format } from "node:util";
 import { LOG_SOCKET_PATH, LOG_WRITE_EVENT } from "../../../editor/common/constants.js";
 import { Miqro } from "../app.js";
 
 export function createLogProviderOptions(app: Miqro) {
   const defaultConsole = ConsoleTransport();
-  const defaultFile = FileTransport();
+  //console.log("app.options.logFile [%s]", app.options.logFile);
+  const defaultFile: LoggerTransport | undefined =
+    app.options.logFile !== true && app.options.logFile !== false && String(app.options.logFile).toUpperCase() !== "TRUE" && String(app.options.logFile).toUpperCase() !== "FALSE" &&
+      app.options.logFile ? FileTransport(app.options.logFile) :
+      String(app.options.logFile).toUpperCase() === "TRUE" || app.options.logFile === true || app.options.logFile === undefined ?
+        FileTransport() :
+        undefined;
   const defaultWrite = async (args: LoggerTransportWriteArgs, level?: LogLevel) => {
     try {
       const serviceNamesWithLogConfigReplaceConsole = level === undefined && app.inflated ?
@@ -14,9 +20,9 @@ export function createLogProviderOptions(app: Miqro) {
         Object.keys(app.inflated.logConfigMap).filter(serviceName => app.inflated.logConfigMap[serviceName].replaceFileTransport) : [];
       await Promise.allSettled((level === undefined ?
         [
-          level === undefined && serviceNamesWithLogConfigReplaceConsole.length === 0 ?
+          level === undefined && serviceNamesWithLogConfigReplaceConsole.length === 0 && defaultConsole ?
             defaultConsole.write(args) : Promise.resolve(),
-          level === undefined && serviceNamesWithLogConfigReplaceFile.length === 0 ?
+          level === undefined && serviceNamesWithLogConfigReplaceFile.length === 0 && defaultFile ?
             defaultFile.write(args) : Promise.resolve()
         ] : []).concat(app.inflated ?
           Object.keys(app.inflated.logConfigMap).map(serviceName => app.inflated.logConfigMap[serviceName]).filter(c => c.level === level).map(c => c.write(args)) : []

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

@@ -7,118 +7,33 @@ import { Miqro } from "../app.js";
 import { WebSocketManager } from "./websocketmanager.js";
 import { execSync } from "node:child_process";
 import { LogProvider } from "./log.js";
-
-/*
-{
-      cache: this.cache,
-      localCache: this.localCache,
-      db: {
-        get: (name: string) => {
-          return this.dbManager.getDB(name);
-        },
-        getMigrations: () => {
-          if (this.inflated) {
-            const ret: NamedMigration[] = [];
-            for (const d of this.inflated.dbList) {
-              ret.push(...(d.migrations.map(m => {
-                return {
-                  name: m.name,
-                  service: m.service,
-                  dbName: m.dbName
-                }
-              })));
-            }
-            return ret;
-          }
-          return [];
-        },
-        migrate: (options) => {
-          return this.migrate(options);
-        },
-      },
-      ws: {
-        get: (path: string) => {
-          if (path === LOG_SOCKET_PATH) {
-            throw new Error("cannot use this path");
-          }
-          return this.webSocketManager.getWS(path);
-        },
-        disconnectAll: (path: string) => {
-          if (path === LOG_SOCKET_PATH) {
-            throw new Error("cannot use this path");
-          }
-          this.webSocketManager.disconnectAllFrom(path);
-        }
-      },
-      isPrimaryWorker: () => {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-      },
-      openBrowser: (path: string) => {
-        const PORT = this.options.port;
-        const URL = `http://localhost:${PORT}${path}`;
-        const DEFAULT_OPEN = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
-        const OPEN = 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]", process.env["BROWSER"]);
-        }
-      },
-      logger: this.logger,
-      getLogger: (identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }) => {
-        return this.loggerProvider.getLogger(identifier, options);
-      }
-    }*/
+import { initGlobals } from "../globals.js";
 
 export interface ServerInterfaceImplOptions {
   cache: CacheInterface;
   localCache: CacheInterface;
   dbManager: DBManager;
-  wsManager: WebSocketManager;
+  webSocketManager: WebSocketManager;
   logger?: Logger;
   app?: Miqro;
   port?: string;
   loggerProvider?: LogProvider;
 }
 
-export class ServerInterfaceImpl implements ServerInterface {
-  public cache: CacheInterface;
-  public localCache: CacheInterface;
-  public logger?: Logger;
-  public port?: string;
-
-  public db: {
-    get(name: string): Database | null;
-    getMigrations(): NamedMigration[];
-    migrate(options: MigrateOptions): Promise<void>;
-  };
-  public ws: {
-    get(path: string): WebSocketServer | undefined;
-    disconnectAll(path: string): void;
-  };
-  public loggerProvider?: LogProvider;
-
-  constructor(options: ServerInterfaceImplOptions) {
-    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.db = Object.freeze({
-      get: (name: string) => {
-        return dbManager.getDB(name);
+export function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface {
+  initGlobals();
+  return Object.freeze<ServerInterface>({
+    cache: options.cache,
+    localCache: options.localCache,
+    logger: options.logger,
+    db: {
+      get(name) {
+        return options.dbManager.getDB(name);
       },
-      getMigrations: () => {
-        if (app?.inflated) {
+      getMigrations() {
+        if (options.app?.inflated) {
           const ret: NamedMigration[] = [];
-          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,
@@ -131,42 +46,38 @@ export class ServerInterfaceImpl implements ServerInterface {
         }
         return [];
       },
-      migrate: (options: MigrateOptions) => {
-        return app?.migrate(options);
-      }
-    });
-    this.ws = Object.freeze({
+      migrate(migrateOptions) {
+        return options?.app?.migrate(migrateOptions);
+      },
+    },
+    ws: {
       get: (name: string) => {
-        return wsManager?.getWS(name);
+        return options?.webSocketManager?.getWS(name);
       },
       disconnectAll: (path: string) => {
-        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);
       }
-    });
-  }
-  public getWorkerNumber(): number {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
-  }
-  public getWorkerCount(): number {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
-  }
-  public isPrimaryWorker(): boolean {
-    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-  }
-  public openBrowser(path: string): void {
-    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 = 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]", process.env["BROWSER"]);
-    }
-  }
-  public getLogger(identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }): Logger {
-    return this.loggerProvider?.getLogger(identifier, options);
-  }
+    },
+    getLogger(identifier, loggerOptions) {
+      return options?.loggerProvider?.getLogger(identifier, loggerOptions);
+    },
+    ...server
+  });
 }

package/src/services/utils/websocketmanager.ts

@@ -2,9 +2,11 @@ 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;
 }
@@ -14,10 +16,12 @@ export class WebSocketManager {
   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.loggerProvider;
     this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
   }
 
@@ -46,7 +50,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);
       }
     }
@@ -65,7 +71,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/src/types/cookie.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "cookie/index.js";

package/src/types/jose.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "jose/types/index.js";

package/src/types/miqro.d.ts

@@ -1,7 +1,10 @@
 import "./globals.js";
 import { Database, Migration } from "@miqro/query/lib.js";
+import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core/lib.js";
 import { ErrorHandler, HandlerWithOptions, CORSOptions, LogLevel, LoggerTransportWriteArgs, Request, Response, WebSocketServer, Logger, WebSocketServerOptions, SessionHandlerOptions, RouteOptions, Handler } from "@miqro/core/lib.js";
-import { ParserInterface } from "@miqro/parser/lib.js";
+import { Parser, ParserInterface } from "@miqro/parser/lib.js";
+import { ProtectedHeaderParameters, EncryptOptions, SignOptions, JWTPayload, JWTDecryptOptions, JWTDecryptResult, JWTVerifyResult, JWTVerifyOptions } from "jose/types/index.js";
+import { KeyObject } from "node:crypto";
 
 /*export * from "@miqro/core/lib.js";
 export * from "@miqro/query/lib.js";*/
@@ -10,6 +13,93 @@ export interface AuthConfig extends SessionHandlerOptions {
 
 }
 
+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;
+}
+
+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;
+  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 MiddlewareConfig {
   middleware?: Array<HandlerWithOptions | Handler>;
   post?: Array<HandlerWithOptions | Handler>;
@@ -97,7 +187,7 @@ export interface MigrateOptions {
   name?: string;
 }
 
-export interface ServerInterface {
+export interface ServerInterface extends ServerGlobal{
   // null values are if the feature has been disabled
   db: {
     get(name: string): Database | null;

package/src/types/server.globals.d.ts

@@ -1,38 +1,13 @@
 import "./jsx.globals.js";
 
-import { Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core/lib.js";
-import { request } from "./@miqro/request.js";
+import { Logger } from "./@miqro/core/lib.js";
+import { request } from "./@miqro/request/lib.js";
 import { RuntimeHTMLElement, Runtime, RuntimeContainer, RuntimeURL, RuntimeOptions, RuntimeShadowRootInit } from "./@miqro/jsx.js";
+import { ServerGlobal } from "./miqro.js";
 
 declare global {
   // only available server side
-  var server: {
-    /*// null values are if the feature has been disabled
-    db: {
-      get(name: string): Database | null;
-    },
-    ws: {
-      get(path: string): WebSocketServer | undefined;
-      disconnectAll(path: string): void;
-    };
-    cache: {
-      get: (key: string) => any;
-      set: (key: string, value: unknown) => void;
-      delete: (key: string) => void;
-      has: (key: string) => boolean;
-    };
-    logger: Logger;*/
-    middleware: {
-      buffer: typeof ReadBuffer;
-      url: typeof URLEncodedParser;
-      json: typeof JSONParser;
-      text: typeof TextParser;
-      cors: typeof CORS;
-      session: typeof SessionHandler;
-    }
-    encodeHTML: (str: string) => string;
-    inflateMDtoHTML: (str: string) => string;
-  }
+  var server: ServerGlobal;
 
   var test: {
     PORT: string;

package/src/types.ts

@@ -1,7 +1,7 @@
 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,
@@ -11,6 +11,27 @@ import {
   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
@@ -55,6 +76,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 {
@@ -92,7 +168,7 @@ export interface LogConfig {
   write: (args: LoggerTransportWriteArgs) => Promise<void> | void;
 }
 
-export interface ServerInterface {
+export interface ServerInterface extends ServerGlobal {
   // null values are if the feature has been disabled
   db: {
     get(name: string): Database | null;
@@ -106,9 +182,6 @@ 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;
 }