miqro 7.2.6 → 7.2.8

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

@@ -1,255 +0,0 @@
-import { Logger } from "@miqro/core";
-import { CacheInterface } from "../../types.js";
-
-const ClusterCacheType = "$$$$$$$$$$$ClusterCacheType$$$$$$$$$$$";
-
-interface ClusterCacheMessage {
-  type: typeof ClusterCacheType;
-  target: string;
-  action: "set" | "unset" | "set_add" | "set_delete" | "array_push" | "set_clear" | "array_clear";
-  fromPID: number;
-  key: string;
-  value?: string;
-}
-
-export class ClusterCache implements CacheInterface {
-  private localCache = new Map<string, unknown>();
-  //private logger: Logger;
-  listener: (data: any) => Promise<void>;
-
-  constructor(public name: string, public logger?: Logger) {
-    this.listener = async (data) => {
-      try {
-        const msg = (data as ClusterCacheMessage);
-
-        //console.dir(msg);
-        if (
-          msg &&
-          msg.key &&
-          msg.action &&
-          msg.type === ClusterCacheType &&
-          msg.fromPID !== process.pid &&
-          (msg.action === "set_clear" || msg.action === "array_clear" || msg.action === "set_add" || msg.action === "set" || msg.action === "unset" || msg.action === "set_delete" || msg.action === "array_push") &&
-          msg.target === this.name) {
-          this.logger?.debug("remote cluster cache message from [%s] [%s] [%s] [%s]", msg.fromPID, msg.target, msg.action, msg.key);
-          switch (msg.action) {
-            case "set_clear": {
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
-              if (!(list instanceof Set)) {
-                throw new Error("cannot apply clear on non set");
-              }
-              list.clear();
-              this.localCache.set(msg.key, list);
-              break;
-            }
-            case "array_clear": {
-              //this.localCache.set(msg.key, msg.value);
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : [];
-              if (!(list instanceof Array)) {
-                throw new Error("cannot apply clear on non array");
-              }
-              this.localCache.set(msg.key, []);
-              break;
-            }
-            case "unset":
-              this.localCache.delete(msg.key);
-              break;
-            case "set":
-              this.localCache.set(msg.key, msg.value);
-              break;
-            case "set_add": {
-              //this.localCache.set(msg.key, msg.value);
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
-              if (!(list instanceof Set)) {
-                throw new Error("cannot apply add on non set");
-              }
-              if (!list.has(msg.value)) {
-                list.add(msg.value);
-              }
-              this.localCache.set(msg.key, list);
-              break;
-            }
-            case "set_delete": {
-              //this.localCache.set(msg.key, msg.value);
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
-              if (!(list instanceof Set)) {
-                throw new Error("cannot apply delete on non set");
-              }
-              if (list.has(msg.value)) {
-                list.delete(msg.value);
-              }
-              this.localCache.set(msg.key, list);
-              break;
-            }
-            case "array_push": {
-              //this.localCache.set(msg.key, msg.value);
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : [];
-              if (!(list instanceof Array)) {
-                throw new Error("cannot apply push on non array");
-              }
-              list.push(msg.value);
-              this.localCache.set(msg.key, list);
-              break;
-            }
-          }
-        }
-      } catch (e) {
-        this.logger?.error(e);
-      }
-    };
-    this.connect();
-  }
-
-  connect() {
-    if (process.send) {
-      process.removeListener("message", this.listener);
-      process.on("message", this.listener);
-    }
-  }
-
-  disconnect() {
-    process.removeListener("message", this.listener);
-  }
-
-  get<T = any>(key: string): T | undefined {
-    this.logger?.trace("get(%s)", key);
-    return this.localCache.get(key) as T;
-  }
-  set(key: string, value: unknown): void {
-    this.localCache.set(key, value);
-    this.logger?.trace("set(%s, ...)", key);
-    sendTimeout({
-      type: ClusterCacheType,
-      action: "set",
-      target: this.name,
-      fromPID: process.pid,
-      key,
-      value
-    } as ClusterCacheMessage);
-  }
-  unset(key: string): void {
-    this.logger?.trace("unset(%s)", key);
-    this.localCache.delete(key);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "unset",
-      fromPID: process.pid,
-      key
-    } as ClusterCacheMessage);
-  }
-  has(key: string): boolean {
-    this.logger?.trace("has(%s)", key);
-    return this.localCache.has(key);
-  }
-
-  set_add(key: string, value: unknown): void {
-    this.logger?.trace("push(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : new Set<string>();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (!list.has(value)) {
-      list.add(value);
-    }
-    this.localCache.set(key, list);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "set_add",
-      fromPID: process.pid,
-      key,
-      value
-    } as ClusterCacheMessage);
-  }
-  set_delete(key: string, value: unknown): void {
-    this.logger?.trace("delete(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : new Set<string>();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (list.has(value)) {
-      list.delete(value);
-    }
-    this.localCache.set(key, list);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "set_delete",
-      fromPID: process.pid,
-      key,
-      value
-    } as ClusterCacheMessage);
-  }
-  set_has(key: string, value: unknown): boolean {
-    this.logger?.trace("set_has(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : new Set<string>();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    const ret = list.has(value);
-    this.localCache.set(key, list);
-    return ret;
-  }
-  set_clear(key: string): void {
-    this.logger?.trace("set_clear(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : new Set<string>();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    list.clear();
-    this.localCache.set(key, list);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "set_clear",
-      fromPID: process.pid,
-      key
-    } as ClusterCacheMessage);
-  }
-  array_push(key: string, value: unknown): void {
-    this.logger?.trace("array_push(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : [];
-    if (!(list instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    list.push(value);
-    this.localCache.set(key, list);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "array_push",
-      fromPID: process.pid,
-      key,
-      value
-    } as ClusterCacheMessage);
-  }
-  array_clear(key: string): void {
-    this.logger?.trace("array_clear(%s)", key);
-    if (this.localCache.has(key) && !(this.localCache.get(key) instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    this.localCache.set(key, []);
-    sendTimeout({
-      type: ClusterCacheType,
-      target: this.name,
-      action: "array_clear",
-      fromPID: process.pid,
-      key
-    } as ClusterCacheMessage);
-  }
-}
-
-function sendTimeout(msg: ClusterCacheMessage) {
-  if (process.send) {
-    setTimeout(() => {
-      try {
-        if (process.send) {
-          process.send(msg);
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    }, 10);
-  }
-}

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

@@ -1,202 +0,0 @@
-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, public path: string, public logger: Logger | Console, options: WebSocketServerOptions) {
-    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 {
-          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);
-        }
-        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);
-        }
-      },
-      onConnection: (req) => {
-        if (process.send) {
-          process.send({
-            type: ClusterWebSocketServer2MessageType,
-            action: "connection",
-            target: this.name,
-            fromPID: String(process.pid),
-            clientUUID: req.uuid
-          } as ClusterWebSocketServer2Message);
-        }
-        this.logger?.debug("[%s] new web socket connection from (%s)", req.uuid, req.req.socket.remoteAddress);
-        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);
-        }
-        this.logger?.debug("[%s] [%s] web socket disconnection from (%s)", req.uuid, this.path, req.req.socket.remoteAddress);
-        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);
-      }
-    };
-
-    this.connect();
-  }
-
-  public connect() {
-    if (process.send) {
-      process.removeListener("message", this.listener);
-      process.on("message", this.listener);
-      process.send({
-        type: ClusterWebSocketServer2MessageType,
-        action: "sync",
-        fromPID: String(process.pid),
-        target: this.name
-      } as ClusterWebSocketServer2Message);
-    }
-  }
-
-  public 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

@@ -1,92 +0,0 @@
-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 connectAll() {
-    this.options?.logger?.debug("connection all db connections");
-    const tR = [];
-    for (const name of this.map.keys()) {
-      const db = this.map.get(name);
-      if (db && db.status === "disconnected") {
-        this.options?.logger?.debug("connecting db connection [%s]", name);
-        tR.push(db.connect());
-      }
-    }
-    await Promise.all(tR);
-  }
-
-  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

@@ -1,70 +0,0 @@
-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/jwt.ts

@@ -1,25 +0,0 @@
-import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../../common/jwt.js";
-import { JWTInterface } from "../../types.js";
-import { createSecretKey } from "node:crypto";
-
-export const jwt: JWTInterface = {
-  createSecretKey,
-  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);
-  }
-};