miqro 5.0.5 → 6.0.3

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

@@ -0,0 +1,192 @@
+import { Logger, WebSocketServer, WebSocketServerOptions } from "@miqro/core";
+import { Serializable } from "node:child_process";
+
+const ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
+
+export interface ClusterWebSocketServer2Message {
+  type: typeof ClusterWebSocketServer2MessageType;
+  target: string;
+  action: "connection" | "disconnection" | "sendMessage" | "error" | "sync";
+  clientUUID?: string;
+  errorMessage?: string;
+  fromUUID?: string;
+  fromPID: string,
+  payload?: Serializable;
+}
+
+export class ClusterWebSocketServer2 extends WebSocketServer {
+  public remoteClients: Set<string> = new Set();
+  listener: (data: any) => Promise<void>;
+  public constructor(protected name: string, options: WebSocketServerOptions) {
+    super({
+      ...options,
+      validate: (req) => {
+        if (
+          this.options.maxConnections !== undefined &&
+          this.clients.size + this.remoteClients.size >= this.options.maxConnections
+        ) {
+          return false;
+        } else {
+          return options.validate ? options.validate(req) : true;
+        }
+      },
+      onError: (req, error) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "error",
+            target: this.name,
+            clientUUID: req.uuid,
+            fromPID: String(process.pid),
+            errorMessage: error.message
+          } as ClusterWebSocketServer2Message);
+        }
+        if (options.onError) {
+          options.onError(req, error);
+        }
+      },
+      onConnection: (req) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "connection",
+            target: this.name,
+            fromPID: String(process.pid),
+            clientUUID: req.uuid
+          } as ClusterWebSocketServer2Message);
+        }
+        if (options.onConnection) {
+          options.onConnection(req);
+        }
+      },
+      onDisconnect: (req) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "disconnection",
+            target: this.name,
+            fromPID: String(process.pid),
+            clientUUID: req.uuid
+          } as ClusterWebSocketServer2Message);
+        }
+        if (options.onDisconnect) {
+          options.onDisconnect(req);
+        }
+      }
+    });
+    this.listener = async (data) => {
+      try {
+        const msg = (data as ClusterWebSocketServer2Message);
+        if (
+          msg &&
+          msg.type === ClusterWebSocketServer2MessageType &&
+          msg.target === this.name &&
+          msg.action) {
+          // receive message from cluster workers
+          //console.dir(data);
+          //this.logger?.debug("remote web socket server message from [%s] [%s] [%s]", msg.fromPID, msg.target, msg.action);
+          switch (msg.action) {
+            case "sync":
+              if (process.send) {
+                for (const clientUUID of this.clients.keys()) {
+                  process.send({
+                    type: ClusterWebSocketServer2MessageType,
+                    action: "connection",
+                    target: this.name,
+                    fromPID: String(process.pid),
+                    clientUUID
+                  } as ClusterWebSocketServer2Message);
+                }
+              }
+              break;
+            case "connection":
+              if (!msg.clientUUID) {
+                throw new Error(`action [${msg.action}] without clientUUID`);
+              }
+              if (!this.remoteClients.has(msg.clientUUID)) {
+                this.remoteClients.add(msg.clientUUID);
+              }
+              break;
+            case "disconnection":
+              if (!msg.clientUUID) {
+                throw new Error(`action [${msg.action}] without clientUUID`);
+              }
+              if (this.remoteClients.has(msg.clientUUID)) {
+                this.remoteClients.delete(msg.clientUUID);
+              }
+              break;
+            case "sendMessage": {
+              const payload = String(msg.payload);
+              if (!msg.clientUUID) {
+                // broadcast to local clients
+                await super.broadcast(payload, msg.fromUUID);
+              } else if (this.isConnected(msg.clientUUID)) {
+                // write if local client
+                await super.writeTo(msg.clientUUID, payload);
+              }
+              break;
+            }
+            default:
+              throw new Error(`action [${msg.action}] not supported`);
+          }
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    };
+
+    if (process.send) {
+      process.on("message", this.listener);
+      process.send({
+        type: ClusterWebSocketServer2MessageType,
+        action: "sync",
+        fromPID: String(process.pid),
+        target: this.name
+      } as ClusterWebSocketServer2Message);
+    }
+  }
+
+  dispose() {
+    process.removeListener("message", this.listener);
+  }
+
+  public async broadcast(payload: string, fromUUID?: string): Promise<void> {
+    if (process.send) {
+      process.send({
+        type: ClusterWebSocketServer2MessageType,
+        action: "sendMessage",
+        payload,
+        target: this.name,
+        fromPID: String(process.pid),
+        fromUUID
+      } as ClusterWebSocketServer2Message);
+    }
+    return super.broadcast(payload, fromUUID);
+  }
+
+  public async writeTo(clientUUID: string, payload: string): Promise<void> {
+    if (this.remoteClients.has(clientUUID)) {
+      // write to remote client via IPC
+      if (process.send) {
+        process.send({
+          type: ClusterWebSocketServer2MessageType,
+          action: "sendMessage",
+          clientUUID,
+          target: this.name,
+          fromPID: String(process.pid),
+          payload
+        } as ClusterWebSocketServer2Message);
+        return;
+      }
+    }
+    // due to the implementation of isUUIDValid depends on this.remoteClients to be sync there can be two clients registered with the same UUID in the cluster
+    if (this.clients.has(clientUUID)) {
+      // write to local client
+      return super.writeTo(clientUUID, payload);
+    }
+  }
+
+  public isUUIDValid(uuid: string) {
+    return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
+  }
+}

package/src/services/utils/db-manager.ts

@@ -0,0 +1,79 @@
+import cluster from "node:cluster";
+import { Database } from "@miqro/query";
+import { DBConfig } from "../../types.js";
+import { LogProvider } from "./log.js";
+import { Logger } from "@miqro/core";
+
+export class DBManager {
+  private map = new Map<string, Database>();
+  public options: {
+    loggerProvider?: LogProvider;
+    logger?: Logger;
+  };
+
+  constructor(options?: {
+    loggerProvider?: LogProvider;
+    logger?: Logger;
+  }) {
+    this.options = options ? options : {};
+  }
+
+  async setupDB(config: DBConfig) {
+    if (this.getDB(config.name)) {
+      throw new Error("cannot override db");
+    }
+    if (!config.disabled) {
+      const DB_IDENTIFIER = cluster.isPrimary ? "DATABASE" : process.env["CLUSTER_NODE_NUMBER"] ? `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}_DATABASE` : "WORKER_DATABASE";
+      this.options?.logger?.debug("setting up db connection [%s]", config.name);
+      this.options?.logger?.trace("creating db connection [%s]", config.name);
+      const db = new Database({
+        dialect: config.dialect ? config.dialect as any : "node:sqlite",
+        storage: config.storage ? config.storage : "./db.sqlite3",
+        connectionString: config.url,
+        logger: this.options?.loggerProvider?.getLogger(`${DB_IDENTIFIER}_${config.name}`)
+      });
+
+      this.options?.logger?.trace("connecting db connection [%s]", config.name);
+      await db.connect();
+      this.options?.logger?.trace("db connection [%s] connected", config.name);
+
+      /*if (config.name && config.name !== name) {
+        this.setDB(config.name, db);
+      }*/
+
+      this.setDB(config.name, db);
+
+      return db;
+    }
+  }
+
+  async closeAll() {
+    this.options?.logger?.debug("closing all db connections");
+    for (const name of this.map.keys()) {
+      const db = this.map.get(name);
+      if (db && db.status === "connected") {
+        this.options?.logger?.debug("disconnecting db connection [%s]", name);
+        await db.disconnect();
+      }
+    }
+  }
+
+  async deleteAll() {
+    await this.closeAll();
+    this.options?.logger?.debug("clear all db connections");
+    this.map.clear();
+  }
+
+  getDB(name: string): Database | null {
+    const db = this.map.get(name);
+    return db ? db : null;
+  }
+
+  setDB(name: string, db: Database): void {
+    if (this.getDB(name)) {
+      throw new Error("cannot override db connection [" + name + "]");
+    }
+    this.map.set(name, db);
+  }
+
+}

package/src/services/utils/get-route.ts

@@ -0,0 +1,70 @@
+import { APIRoute, normalizePath, RouterHandlerOptions } from "@miqro/core";
+import { join } from "node:path";
+
+export interface RouterUseCall {
+  path?: string;
+  method?: string;
+  inflatePath: string;
+  defaultInflatePath: string;
+  options?: RouterHandlerOptions;
+}
+
+export function getRoutes(prePath: string, defaultPath: string, apiOptions?: Partial<APIRoute>): RouterUseCall[] {
+  const ret: RouterUseCall[] = [];
+  const path = apiOptions && apiOptions.path ? apiOptions.path : defaultPath;
+  const defaultInflatePath = join(prePath, defaultPath);
+  const method = apiOptions && apiOptions.method ? apiOptions.method : "GET";
+
+  const methods = method instanceof Array ? method : [method];
+  const paths = path instanceof Array ? path : [path];
+
+  if (apiOptions && apiOptions.path === null) {
+    for (const m of methods) {
+      ret.push({
+        options: {
+          apiName: apiOptions?.apiName,
+          description: apiOptions?.description,
+          identifier: apiOptions?.identifier,
+          middleware: apiOptions?.middleware,
+          name: apiOptions?.name,
+          parser: apiOptions?.parser,
+          policy: apiOptions?.policy,
+          request: apiOptions?.request,
+          response: apiOptions?.response,
+          session: apiOptions?.session
+        },
+        inflatePath: defaultInflatePath,
+        defaultInflatePath, 
+        method: m.toLocaleLowerCase() !== "use" ? m.toUpperCase() : undefined,
+        path: undefined
+      });
+    }
+  } else {
+    for (const p of paths) {
+      for (const m of methods) {
+        ret.push({
+          options: {
+            apiName: apiOptions?.apiName,
+            description: apiOptions?.description,
+            identifier: apiOptions?.identifier,
+            middleware: apiOptions?.middleware,
+            name: apiOptions?.name,
+            parser: apiOptions?.parser,
+            policy: apiOptions?.policy,
+            request: apiOptions?.request,
+            response: apiOptions?.response,
+            session: apiOptions?.session
+          },
+          inflatePath: p !== "/" ? join(prePath, p) : defaultInflatePath,
+          defaultInflatePath,
+          method: m.toLocaleLowerCase() !== "use" ? m.toUpperCase() : undefined,
+          path: normalizePath(join(prePath, p))
+        });
+      }
+    }
+  }
+
+
+
+  return ret;
+}

package/src/services/utils/log.ts

@@ -0,0 +1,91 @@
+import { ConsoleTransport, getEnvVariable, Logger, LoggerTransport, MinimalLogger, newURL, normalizePath, Request, WriteArgs } from "@miqro/core";
+import { format } from "node:util";
+
+const DEFAULT_ENV_NAME = "LOG_LEVEL";
+
+export interface LogProviderOptions {
+  name?: string;
+  transports: LoggerTransport[];
+  formatter: (args: WriteArgs) => string;
+}
+
+export const DEFAULT_FORMATTER = ({ identifier, level, message, optionalParams }: WriteArgs) => format(`${new Date().toISOString()} PID[${process.pid}] ` +
+  `${identifier ? `[${identifier}] ` : ""}` +
+  `${level !== "info" ? (level === "error" || level === "warn" ? `[${level.toUpperCase()}] ` : `[${level}] `) : ""}` +
+  `${message}`, ...optionalParams)
+
+export class LogProvider {
+
+  public options: LogProviderOptions;
+  public constructor(options?: LogProviderOptions) {
+    this.options = {
+      formatter: options && options.formatter ? options.formatter : DEFAULT_FORMATTER,
+      transports: options && options.transports ? options.transports : [ConsoleTransport()]
+    };
+    this.requestLoggerFactory = this.requestLoggerFactory.bind(this);
+  }
+
+  public requestLoggerFactory(uuid: string, req: Request): MinimalLogger {
+    let path = "";
+    let query = "";
+    let urlParsingError;
+    let method = "GET";
+    let remoteAddress: string | undefined = "";
+    try {
+      const url = newURL(req.url ? req.url : "/") as URL;
+      query = url.searchParams.toString();
+      path = normalizePath(url.pathname); // normalized path
+      method = req.method ? req.method.toUpperCase() as string : "GET";
+      remoteAddress = req.socket.remoteAddress;
+    } catch (e) {
+      urlParsingError = e;
+    }
+    const pathToEnv = path.replace(/\//ig, "_").toUpperCase();
+    const WORKER_IDENTIFIER = process.env["CLUSTER_NODE_NUMBER"] ? `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}_` : "";
+    const identifier = `${pathToEnv === "_" ? "" : `${pathToEnv.substring(1)}`}${method.toUpperCase()}`;
+    const upgrade = req.headers.connection?.indexOf("Upgrade") !== -1;
+
+    const logger = this.getLogger(
+      `${WORKER_IDENTIFIER}${identifier}`, {
+      formatter: (args: WriteArgs) => {
+        args.message = `%s${upgrade ? " UPGRADE" : ""} %s%s [%s] (%s) ${args.message}`;
+        args.optionalParams = [method, path, query ? `?${query}` : "", uuid, remoteAddress].concat(args.optionalParams);
+        args.meta.push(req);
+        args.meta.push(uuid);
+        return this.options.formatter(args);
+      }
+    });
+
+
+    if (urlParsingError) {
+      logger.error(urlParsingError);
+    }
+
+    return logger;
+  };
+
+  public getLogger(identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }): Logger {
+
+    identifier = this.options.name ?
+      `${this.options.name}${identifier ?
+        `_${identifier}` : ""}`.toUpperCase() :
+      identifier ? identifier.toUpperCase() : "";
+
+    const envVarName = `LOG_LEVEL_${identifier}`;
+    const level = options && options.level ? options.level : getEnvVariable(envVarName) ? getEnvVariable(envVarName) : getEnvVariable(DEFAULT_ENV_NAME, "info");
+
+    const logger = new Logger(identifier, level, {
+      transports: [],
+      formatter: options && options.formatter ? options.formatter : this.options.formatter
+    });
+    for (const t of this.options.transports) {
+      logger.addTransport(t);
+    }
+    if (options && options.transports) {
+      for (const t of options.transports) {
+        logger.addTransport(t);
+      }
+    }
+    return logger;
+  }
+}

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

@@ -0,0 +1,166 @@
+import { WebSocketServer, Logger } from "@miqro/core";
+import { Database } from "@miqro/query";
+import cluster from "node:cluster";
+import { CacheInterface, MigrateOptions, NamedMigration, ServerInterface } from "../../types.js";
+import { DBManager } from "./db-manager.js";
+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);
+      }
+    }*/
+
+export interface ServerInterfaceImplOptions {
+  cache: CacheInterface;
+  localCache: CacheInterface;
+  dbManager: DBManager;
+  wsManager: 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;
+    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);
+      },
+      getMigrations: () => {
+        if (app?.inflated) {
+          const ret: NamedMigration[] = [];
+          for (const d of app?.inflated.dbList) {
+            ret.push(...(d.migrations.map(m => {
+              return {
+                name: m.name,
+                service: m.service,
+                dbName: m.dbName
+              }
+            })));
+          }
+          return ret;
+        }
+        return [];
+      },
+      migrate: (options: MigrateOptions) => {
+        return app?.migrate(options);
+      }
+    });
+    this.ws = Object.freeze({
+      get: (name: string) => {
+        return wsManager?.getWS(name);
+      },
+      disconnectAll: (path: string) => {
+        return wsManager?.disconnectAllButLOGSocket();
+      }
+    });
+  }
+  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);
+  }
+}