miqro 6.1.4 → 6.2.0

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

@@ -1,49 +1,19 @@
-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,
+        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 +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";
-    }
-    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;