miqro 6.1.3 → 6.2.0

package/build/esm/src/inflate/setup-ws.d.ts

@@ -1,4 +1,4 @@
 import { Logger } from "@miqro/core";
 import { InflateError } from "../common/jsx.js";
 import { WSConfig } from "../types.js";
-export declare function inflateWSConfig(logger: Logger, servicePath: string, service: string, wsConfigList: WSConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]): Promise<false | WSConfig>;
+export declare function inflateWSConfig(logger: Logger, servicePath: string, service: string, wsConfigList: WSConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]): Promise<void>;

package/build/esm/src/inflate/setup-ws.js

@@ -30,7 +30,7 @@ export async function inflateWSConfig(logger, servicePath, service, wsConfigList
                     logger
                 }));
             }
-            return wsConfig;
+            //return wsConfigList;
         }
         catch (e) {
             errors.push({
@@ -39,7 +39,7 @@ export async function inflateWSConfig(logger, servicePath, service, wsConfigList
             });
             logger.error("error with " + wsPath);
             logger.error(e);
-            return false;
+            //return false;
         }
     }
 }

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

@@ -8,6 +8,6 @@ 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";
-export { ServerInterfaceImpl, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
+export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";

package/build/esm/src/lib.js

@@ -9,8 +9,8 @@ export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider } from "./services/utils/log.js";
 export { Miqro, 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 } from "./services/utils/server-interface.js";
+export { appendAPIModule } from "./inflate/utils/sea-utils.js";
+export { createServerInterface } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";

package/build/esm/src/main.js

@@ -9,7 +9,7 @@ import { Miqro } from "./services/app.js";
 import { TEST_SOCKET } from "./common/paths.js";
 import { Logger } from "@miqro/core";
 async function main(args) {
-    if (args.installTypes || args.installTSConfig) {
+    if (args.installTypes || args.installTSConfig || args.installMiqroJSON) {
         await installTypings(args, new Logger(""));
         process.exit(EXIT_CODES.NORMAL_EXIT);
     }
@@ -19,6 +19,8 @@ async function main(args) {
             name: args.name ? args.name : undefined,
             port: args.test ? TEST_SOCKET : args.port,
             services: args.services,
+            browser: args.browser,
+            logFile: args.logFile,
             hotreload: args.test ? false : args.hotreload
         });
         // check arguments

package/build/esm/src/services/app.d.ts

@@ -18,6 +18,8 @@ export interface MiqroOptions {
     services: string[];
     editor: boolean;
     port: string;
+    browser?: string | boolean;
+    logFile?: string | boolean;
     hotreload?: boolean;
 }
 export interface InflateOptions {

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";
@@ -90,6 +90,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 +101,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,
@@ -183,9 +184,9 @@ export class Miqro {
     async loadDBConfig(options) {
         const errors = [];
         const dbList = [];
-        const dbConfigList = [];
+        const dbConfigListALL = [];
         for (const service of this.options.services) {
-            const dbConfig = await inflateDBConfig(this.logger, service, dbConfigList, options?.inflateSea ? options?.inflateDir : undefined, errors);
+            const dbConfig = await inflateDBConfig(this.logger, service, dbConfigListALL, options?.inflateSea ? options?.inflateDir : undefined, errors);
             if (dbConfig) {
                 const migrations = await inflateDBMigrations(this.logger, service, dbConfig.name, options?.inflateSea ? options?.inflateDir : undefined, errors);
                 dbList.push({

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/log-transport.d.ts

@@ -1,7 +1,7 @@
-import { WriteArgs } from "@miqro/core";
+import { LoggerTransport, WriteArgs } from "@miqro/core";
 import { Miqro } from "../app.js";
 export declare function createLogProviderOptions(app: Miqro): {
     name: string;
-    transports: import("@miqro/core").LoggerTransport[];
+    transports: LoggerTransport[];
     formatter: (args: WriteArgs) => string;
 };

package/build/esm/src/services/utils/log-transport.js

@@ -3,7 +3,12 @@ import { format } from "node:util";
 import { LOG_SOCKET_PATH, LOG_WRITE_EVENT } from "../../../editor/common/constants.js";
 export function createLogProviderOptions(app) {
     const defaultConsole = ConsoleTransport();
-    const defaultFile = FileTransport();
+    //console.log("app.options.logFile [%s]", app.options.logFile);
+    const defaultFile = 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, level) => {
         try {
             const serviceNamesWithLogConfigReplaceConsole = level === undefined && app.inflated ?
@@ -12,9 +17,9 @@ export function createLogProviderOptions(app) {
                 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/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;
-    constructor(options: ServerInterfaceImplOptions);
-    getWorkerNumber(): number;
-    getWorkerCount(): number;
-    isPrimaryWorker(): boolean;
-    openBrowser(path: string): void;
-    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,30 +1,19 @@
-import cluster from "node:cluster";
 import { execSync } from "node:child_process";
-export class ServerInterfaceImpl {
-    cache;
-    localCache;
-    logger;
-    port;
-    db;
-    ws;
-    loggerProvider;
-    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.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,
+        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,
@@ -37,43 +26,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";
-    }
-    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 = 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"]);
-        }
-    }
-    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,9 +159,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;