miqro 6.1.4 → 6.2.1

package/src/common/arguments.ts

@@ -12,6 +12,7 @@ import { isSea } from "node:sea";
 import cluster from "node:cluster";
 import { __package_dirname, getVersion } from "./assets.js";
 import { Parser, Schema } from "@miqro/parser";
+import { ServerOptions } from "node:https";
 
 const parser = new Parser();
 
@@ -23,6 +24,9 @@ interface MiqroJSON {
   browser?: string | boolean;
   logFile?: string | boolean;
   editor?: boolean;
+  https?: boolean;
+  serverOptions?: ServerOptions;
+  httpsRedirect?: number;
 }
 
 const MiqroJSONSchema: Schema<MiqroJSON> = {
@@ -34,7 +38,10 @@ const MiqroJSONSchema: Schema<MiqroJSON> = {
     inflateDir: "string?",
     browser: "boolean?|string?",
     logFile: "boolean?|string?",
-    editor: "boolean?"
+    editor: "boolean?",
+    https: "boolean?",
+    serverOptions: "any?",
+    httpsRedirect: "number?"
   }
 }
 
@@ -76,6 +83,9 @@ export interface Arguments {
   services: string[];
   editor: boolean;
   hotreload: boolean;
+  https: boolean;
+  serverOptions: ServerOptions;
+  httpsRedirect?: number;
 }
 
 /**
@@ -87,6 +97,9 @@ export function parseArguments(): Arguments {
 
   const args = cluster.isPrimary ? process.argv.slice(2, process.argv.length) : process.argv.slice(3, process.argv.length);
   const flags: {
+    httpsRedirect: number | null;
+    https: boolean | null;
+    serverOptions: ServerOptions;
     logFile: string | boolean | null;
     browser: string | boolean | null;
     name: string | null;
@@ -110,6 +123,9 @@ export function parseArguments(): Arguments {
     inflateDir?: string | null;
     hotreload?: boolean | null;
   } = {
+    httpsRedirect: null,
+    https: null,
+    serverOptions: {},
     name: null,
     browser: null,
     logFile: null,
@@ -196,6 +212,59 @@ export function parseArguments(): Arguments {
         }
         flags.hotreload = true;
         continue;
+      case "--https":
+        if (flags.https !== null) {
+          console.error("bad arguments.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        flags.https = true;
+        continue;
+      case "--https-redirect":
+        if (flags.httpsRedirect !== null) {
+          console.error("bad arguments.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        const httpsRedirectPort = parseInt(String(args[i + 1]) as any, 10);
+        if (isNaN(httpsRedirectPort)) {
+          console.error("bad arguments. --https-redirect must be a number.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        flags.httpsRedirect = httpsRedirectPort;
+        i++;
+        continue;
+      case "--https-cert":
+        if (flags.serverOptions.cert) {
+          console.error("bad arguments.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        const httpsCertPath = args[i + 1] as any;
+        if (typeof httpsCertPath !== "string") {
+          console.error("bad arguments. --https-cert must be a string.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        flags.serverOptions.cert = readFileSync(httpsCertPath);
+        i++;
+        continue;
+      case "--https-key":
+        if (flags.serverOptions.key) {
+          console.error("bad arguments.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        const httpsKeyPath = args[i + 1] as any;
+        if (typeof httpsKeyPath !== "string") {
+          console.error("bad arguments. --https-key must be a string.");
+          console.error(usage);
+          process.exit(EXIT_CODES.BAD_ARGUMENTS);
+        }
+        flags.serverOptions.key = readFileSync(httpsKeyPath);
+        i++;
+        continue;
       case "--port":
         if (flags.port !== null) {
           console.error("bad arguments.");
@@ -426,6 +495,8 @@ export function parseArguments(): Arguments {
   const miqroJSONPath = !flags.disableMiqroJSON ? flags.miqroJSONPath ? resolve(flags.miqroJSONPath) : getMiqroJSONPath() : false;
   const miqroRC = miqroJSONPath ? importMiqroJSON(miqroJSONPath) : {};
 
+  //console.dir(miqroRC.serverOptions);
+
   // try to load .miqrorc
   if (!flags.disableMiqroJSON && miqroJSONPath) {
     if (services.length === 0) {
@@ -435,6 +506,33 @@ export function parseArguments(): Arguments {
         }
       }
     }
+    if (flags.https === null) {
+      if (miqroRC.https) {
+        flags.https = miqroRC.https;
+      }
+    }
+    if (flags.httpsRedirect === null) {
+      if (miqroRC.httpsRedirect && flags.https) {
+        /*console.log("reading key from " + String(miqroRC.serverOptions?.key));
+        flags.serverOptions.key = readFileSync(String(miqroRC.serverOptions?.key));*/
+        flags.httpsRedirect = miqroRC.httpsRedirect;
+      }
+    }
+    if (!flags.serverOptions.key) {
+      if (miqroRC.serverOptions?.key) {
+        /*console.log("reading key from " + String(miqroRC.serverOptions?.key));
+        flags.serverOptions.key = readFileSync(String(miqroRC.serverOptions?.key));*/
+        flags.serverOptions.key = miqroRC.serverOptions?.key;
+      }
+    }
+
+    if (!flags.serverOptions.cert) {
+      if (miqroRC.serverOptions?.cert) {
+        /*console.log("reading cert from " + String(miqroRC.serverOptions?.cert));
+        flags.serverOptions.cert = readFileSync(String(miqroRC.serverOptions?.cert));*/
+        flags.serverOptions.cert = miqroRC.serverOptions?.cert;
+      }
+    }
     if (flags.port === null) {
       if (miqroRC.port) {
         flags.port = String(miqroRC.port);
@@ -548,6 +646,21 @@ export function parseArguments(): Arguments {
 
   const generateDocType = flags.generateDocType ? flags.generateDocType as any : "MD";
 
+  if (flags.https && (!flags.serverOptions.key)) {
+    console.error("bad arguments. cannot use --https without --https-key. or set values in miqro.json file.");
+    process.exit(EXIT_CODES.BAD_ARGUMENTS);
+  }
+
+  if (flags.https && (!flags.serverOptions.cert)) {
+    console.error("bad arguments. cannot use --https without --https-cert. or set values in miqro.json file.");
+    process.exit(EXIT_CODES.BAD_ARGUMENTS);
+  }
+
+  if (flags.httpsRedirect && !flags.https) {
+    console.error("bad arguments. cannot use --https-redirect without --https. or set values in miqro.json file.");
+    process.exit(EXIT_CODES.BAD_ARGUMENTS);
+  }
+
   return {
     name: flags.name ? flags.name : undefined,
     browser: flags.browser !== null ? flags.browser : undefined,
@@ -571,6 +684,9 @@ export function parseArguments(): Arguments {
     generateDocOut: flags.generateDocOut ? resolve(process.cwd(), flags.generateDocOut) : generateDocType === "MD" ? resolve(process.cwd(), "API.md") : resolve(process.cwd(), "API.json"),
     generateDocType,
     services,
-    editor: flags.editor ? true : false
+    editor: flags.editor ? true : false,
+    https: flags.https ? true : false,
+    httpsRedirect: flags.httpsRedirect ? flags.httpsRedirect : undefined,
+    serverOptions: flags.serverOptions
   }
 }

package/src/common/help.ts

@@ -40,6 +40,10 @@ export const help = `
 --config\n\toverrides the default miqro.json path.
 --port\n\toverrides the default port from PORT.
 --name\n\toverrides the default name of the server.
+--https\n\tserves the server in https instead of http
+--https-key\n\tpoint to a server.key file for https.
+--https-cert\n\tpoint to a server.cert file for https.
+--https-redirect\n\tserves an aditional http server that redirects to https. it needs a port number.
 
 ==environment variables==
 

package/src/common/jwt.ts

@@ -0,0 +1,85 @@
+import { EncryptJWT, EncryptOptions, JWTDecryptOptions, JWTDecryptResult, JWTPayload, JWTVerifyOptions, JWTVerifyResult, ProtectedHeaderParameters, SignJWT, SignOptions, decodeJwt, decodeProtectedHeader, jwtDecrypt as joseJWTDecrypt, jwtVerify } from "jose";
+import { KeyObject } from "node:crypto";
+import { EncryptJWTOptions, JWTSignOptions } from "../types.js";
+
+/**
+ * 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 
+ */
+export async function encryptJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>): Promise<string> {
+  const en = new EncryptJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'dir',
+      enc: options?.enc ? options?.enc : 'A128CBC-HS256'
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+
+  return await en.encrypt(secret, options?.options);
+}
+
+/**
+ * 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 
+ */
+export async function decryptJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>): Promise<JWTDecryptResult<PayloadType>> {
+  return await joseJWTDecrypt(jwt, secret, options)
+}
+
+/**
+ * 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 
+ */
+export async function verifyJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>): Promise<JWTVerifyResult<PayloadType>> {
+  return await jwtVerify(jwt, secret, options)
+}
+
+/**
+ * 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 
+ */
+export async function signJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>): Promise<string> {
+  const sign = new SignJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'HS256',
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+  return sign.sign(secret, options?.options);
+}
+
+/**
+ * decodes a protected header with jose
+ * @param token 
+ * @returns 
+ */
+export function decodeProtectedHeaderJWT(token: string | object): ProtectedHeaderParameters {
+  return decodeProtectedHeader(token);
+}
+
+/**
+ * decodes a jwt token
+ * @param jwt 
+ * @returns 
+ */
+export function decodeJWT<PayloadType = JWTPayload>(jwt: string): PayloadType & JWTPayload {
+  return decodeJwt<PayloadType>(jwt)
+}

package/src/inflate/inflate-sea.ts

@@ -1,6 +1,6 @@
 import { Logger } from "@miqro/core";
 import { chmodSync, constants, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { cwd, platform } from "node:process";
 
 import { RouteFileMap, StaticFileMap } from "./setup-http.js";
@@ -66,22 +66,22 @@ export async function inflateAppForSea(logger: Logger, inflateDir: string, servi
 
   writeFile(logger, join(inflateDir, "sea", "package.json"), `{ "type": "module", "private": true }`);
 
-  writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { ServerInterfaceImpl, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
+  writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
 
 async function main() {
   const PORT = process.env["PORT"] ? process.env["PORT"] : 8080; 
-  const logProvider = new LogProvider();
+  const loggerProvider = new LogProvider();
   const localCache = new LocalCache();
   const cache = new ClusterCache();
   const webSocketManager = new WebSocketManager();
   const dbManager = new DBManager();
   await initGlobals();
-  const serverInterface = new ServerInterfaceImpl({
+  const serverInterface = createServerInterface({
     cache,
     localCache,
-    logProvider,
+    loggerProvider,
     wsManager: webSocketManager,
-    logger: logProvider.getLogger("server"),
+    logger: loggerProvider.getLogger("server"),
     dbManager,
     port: PORT
   });
@@ -133,9 +133,10 @@ ${Object.keys(serviceRouteFileMap)
       .map(filePath => serviceRouteFileMap[filePath])
       .filter(data => data.previewMethod === "api")
       .map(data => data.routes.map(r => {
-        const rPath = r.inflatePath;
+        const rPath = join(relative(cwd(), dirname(data.filePath)), basename(data.filePath));
         if (rPath) {
-          const apiInflatedPath = join("..", "..", service, "http", rPath + ".api.js");
+          const rPathExt = extname(rPath);
+          const apiInflatedPath = join("..", "..", rPath.substring(0, rPath.length - rPathExt.length) + ".js");
           return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await import("./${apiInflatedPath}")).default);`;
         } else {
           return "";

package/src/inflate/setup-http.ts

@@ -27,6 +27,7 @@ export interface RouteFileMap {
       options?: RouterHandlerOptions;
       inflatePath?: string;
     }[];
+    filePath: string;
     service: string;
     previewMethod: "api" | "html" | null;
   }
@@ -93,6 +94,7 @@ function createStaticRoute(service: string, logger: Logger, router: Router, dir:
       path: normalizePath(path)
     }],
     service,
+    filePath: file.filePath,
     previewMethod: "html"
   };
 
@@ -185,6 +187,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               routeFileMap[file.filePath] = {
                 routes,
                 service,
+                filePath: file.filePath,
                 previewMethod: "api"
               };
 
@@ -230,6 +233,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               routeFileMap[file.filePath] = {
                 routes,
                 service,
+                filePath: file.filePath,
                 previewMethod: "html"
               };
 
@@ -297,6 +301,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
 
               routeFileMap[file.filePath] = {
                 routes,
+                filePath: file.filePath,
                 service,
                 previewMethod: "html"
               };
@@ -375,6 +380,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     method: "GET",
                     path
                   }],
+                  filePath: file.filePath,
                   service,
                   previewMethod: "html"
                 };
@@ -428,6 +434,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                   path
                 }],
                 service,
+                filePath: file.filePath,
                 previewMethod: "html"
               };
 
@@ -487,6 +494,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     method: "GET",
                     path
                   }],
+                  filePath: file.filePath,
                   service,
                   previewMethod: "html"
                 };
@@ -545,6 +553,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     path
                   }],
                   service,
+                  filePath: file.filePath,
                   previewMethod: "html"
                 };
 

package/src/lib.ts

@@ -10,10 +10,10 @@ export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
 export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
 export { initGlobals, assertGlobalTampered } from "./services/globals.js";
-export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 
 //exported for --inflate-sea
-export { ServerInterfaceImpl, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
+export { appendAPIModule } from "./inflate/utils/sea-utils.js";
+export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
 

package/src/main.ts

@@ -22,7 +22,10 @@ async function main(args: Arguments) {
       services: args.services,
       browser: args.browser,
       logFile: args.logFile,
-      hotreload: args.test ? false : args.hotreload
+      hotreload: args.test ? false : args.hotreload,
+      https: args.test ? false : args.https,
+      serverOptions: args.serverOptions,
+      httpRedirect: args.test ? undefined : args.httpsRedirect
     });
     // check arguments
     if (args.generateDoc) {

package/src/services/app.ts

@@ -25,12 +25,13 @@ 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 { 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";
 import { dirname, join, relative, resolve } from "node:path";
 import { cwd } from "node:process";
+import { ServerOptions } from "node:https";
 
 export interface MiqroOptions {
   name: string;
@@ -42,6 +43,9 @@ export interface MiqroOptions {
   browser?: string | boolean;
   logFile?: string | boolean;
   hotreload?: boolean;
+  serverOptions?: ServerOptions<any, any>;
+  https?: boolean;
+  httpRedirect?: number;
 }
 
 export interface InflateOptions {
@@ -76,6 +80,7 @@ export class Miqro {
   public status: "stopped" | "starting" | "stopping" | "reloading" | "started" = "stopped";
   public options: MiqroOptions;
   public server?: App | null = null;
+  public httpsRedirectServer?: App | null = null;
   public cache: ClusterCache;
   public localCache: LocalCache;
   public webSocketManager: WebSocketManager;
@@ -139,6 +144,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
     });
@@ -150,16 +156,17 @@ export class Miqro {
       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,
       port: this.options.port
     });
+
     this.serverRequestHandler = ServerRequestHandler(this.serverInterface);
 
     this.adminInterface = createAdminInterface(this);
@@ -422,6 +429,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({
@@ -429,8 +437,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: ServerRequest, 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);
 
@@ -453,11 +470,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");
@@ -482,7 +508,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");
@@ -493,6 +521,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/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);
         }