miqro 6.1.2 → 6.1.3

package/src/services/utils/log.ts

@@ -0,0 +1,92 @@
+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()],
+      name: options?.name
+    };
+    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, "_").replace(/\./ig, "_").replace(/-/ig, "_").toUpperCase();
+    const WORKER_IDENTIFIER = process.env["CLUSTER_NODE_NUMBER"] ? `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}_` : "";
+    const identifier = `${pathToEnv === "_" ? "" : `${pathToEnv.substring(1)}`}${pathToEnv.charAt(pathToEnv.length - 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,172 @@
+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 ? 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: 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 getWorkerNumber(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+  }
+  public getWorkerCount(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+  }
+  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);
+  }
+}

package/src/services/utils/websocketmanager.ts

@@ -0,0 +1,149 @@
+import { Logger } from "@miqro/core";
+import { LOG_SOCKET_PATH } from "../../../editor/common/constants.js";
+import { ClusterWebSocketServer2 } from "./cluster-ws.js";
+import { WSConfig } from "../../types.js";
+
+export interface WebSocketManagerOptions {
+  logger?: Logger | Console;
+  name?: string;
+  avoidLogSocket?: boolean;
+}
+
+export class WebSocketManager {
+  public runningGlobalWSMap = new Map<string, ClusterWebSocketServer2>();
+  public logger?: Logger | Console | null = null;
+  public name: string;
+  public avoidLogSocket: boolean;
+  constructor(options?: WebSocketManagerOptions) {
+    this.onUpgrade = this.onUpgrade.bind(this);
+    this.logger = options && options.logger ? options.logger : null;
+    this.name = options && options.name ? options.name : "WebSocketManager";
+    this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
+  }
+
+  public deleteWS(path: string) {
+    const ws = this.runningGlobalWSMap.get(path);
+    this.disconnectAllFrom(path);
+    ws.dispose();
+    this.runningGlobalWSMap.delete(path);
+  }
+
+  public deleteAllWS() {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      this.deleteWS(path);
+    }
+  }
+
+  public getWS(path: string): ClusterWebSocketServer2 | undefined {
+    return this.runningGlobalWSMap.get(path);
+  }
+
+  public replaceALLWS(list: WSConfig[]) {
+    this.deleteAllWS();
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (this.runningGlobalWSMap.has(wsConfig.path)) {
+          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);
+        this.runningGlobalWSMap.set(wsConfig.path, server);
+      }
+    }
+  }
+
+  public replaceALLWSBuLOGSocket(list: WSConfig[]) {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      if (path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+        this.deleteWS(path);
+      }
+    }
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (wsConfig.path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          if (this.runningGlobalWSMap.has(wsConfig.path)) {
+            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);
+          this.runningGlobalWSMap.set(wsConfig.path, server);
+        }
+      }
+    }
+  }
+
+  /*public setupWS(path: string, server: ClusterWebSocketServer2) {
+    if (this.runningGlobalWSMap.has(path)) {
+      throw new Error(`ws on path ${path} already setup!`);
+    }
+    this.runningGlobalWSMap.set(path, server);
+  }*/
+
+  public disconnectAllFrom(path: string) {
+    try {
+      this.logger?.debug("disconnect all from [%s]", path);
+      const ws = this.getWS(path);
+      if (ws) {
+        const clients = ws.clients.values();
+        if (clients) {
+          for (const client of clients) {
+            try {
+              client.socket.destroy();
+            } catch (e2) {
+              this.logger?.error("error disconnecting web socket client");
+              this.logger?.error(e2);
+            }
+          }
+        }
+        //ws.dispose();
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public disconnectAllButLOGSocket() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        if (wsPath !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          this.disconnectAllFrom(wsPath);
+        }
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public disconnectAll() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        this.disconnectAllFrom(wsPath);
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+
+  public onUpgrade(req, socket, head) {
+    try {
+      const wsServer = this.getWS(req.path);
+      if (wsServer) {
+        return wsServer.onUpgrade(req, socket, head);
+      } else {
+        socket.destroy();
+      }
+    } catch (e) {
+      this.logger?.error(e);
+    }
+  }
+}
+
+/*export interface WSMapConfig {
+  [path: string]: {
+    name: string;
+    options: WSConfig;
+  } | undefined;
+}*/

package/src/types/@esbuild.d.ts

@@ -0,0 +1 @@
+import "../globals.js";

package/src/types/@miqro/core.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/core/lib.js";

package/src/types/@miqro/jsx.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/jsx/esm/lib.js";

package/src/types/@miqro/parser.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/parser/lib.js";

package/src/types/@miqro/query.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/query/lib.js";

package/src/types/@miqro/request.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/request/lib.js";

package/src/types/@miqro/test.d.ts

@@ -0,0 +1,2 @@
+import "../globals.js";
+export * from "@miqro/test/dist/index.js";

package/src/types/@miqro.d.ts

@@ -0,0 +1 @@
+import "../globals.js";

package/src/types/@types.d.ts

@@ -0,0 +1 @@
+import "../globals.js";

package/src/types/browser.globals.d.ts

@@ -0,0 +1,9 @@
+import "./jsx.globals.js";
+import { RuntimeElementDefinitionOptions, Component } from "@miqro/jsx/esm/lib.js";
+
+declare global {
+  // only available browser side
+  var jsx: {
+    define: (tagName: string, component: Component, options?: RuntimeElementDefinitionOptions) => void;
+  }
+}

package/src/types/globals.d.ts

@@ -0,0 +1,2 @@
+import "./browser.globals.js";
+import "./server.globals.js";

package/src/types/jsx.globals.d.ts

@@ -0,0 +1,37 @@
+import * as jsxLib from "@miqro/jsx/esm/lib.js";
+
+declare global {
+  // jsx only for the default value of tsconfig.json
+  var React: {};
+  var jsx: {
+    useRuntime: typeof jsxLib.useRuntime;
+    usePathname: typeof jsxLib.usePathname;
+    Link: typeof jsxLib.Link;
+    Router: typeof jsxLib.Router;
+    createContext: typeof jsxLib.createContext;
+    useContext: typeof jsxLib.useContext;
+    useState: typeof jsxLib.useState;
+    useEffect: typeof jsxLib.useEffect;
+    useQuery: typeof jsxLib.useQuery;
+    useRef: typeof jsxLib.useRef;
+    useElement: typeof jsxLib.useElement;
+    useRefresh: typeof jsxLib.useRefresh;
+  }
+  /*var useRuntime: typeof jsxLib.useRuntime;
+  var usePathname: typeof jsxLib.usePathname;
+  var Link: typeof jsxLib.Link;
+  var Router: typeof jsxLib.Router;
+  var createContext: typeof jsxLib.createContext;
+  var useContext: typeof jsxLib.useContext;
+  var useState: typeof jsxLib.useState;
+  var useEffect: typeof jsxLib.useEffect;
+  var useQuery: typeof jsxLib.useQuery;
+  var useRef: typeof jsxLib.useRef;
+  var useElement: typeof jsxLib.useElement;
+  var useRefresh: typeof jsxLib.useRefresh;*/
+  var JSX: {
+    createElement: typeof jsxLib.createElement;
+    Fragment: typeof jsxLib.Fragment;
+    enableDebugLog: typeof jsxLib.enableDebugLog;
+  }
+}

package/src/types/miqro.d.ts

@@ -0,0 +1,129 @@
+import "./globals.js";
+import { Database, Migration } from "@miqro/query/lib.js";
+import { ErrorHandler, HandlerWithOptions, CORSOptions, LogLevel, LoggerTransportWriteArgs, Request, Response, WebSocketServer, Logger, WebSocketServerOptions, SessionHandlerOptions, RouteOptions, Handler } from "@miqro/core/lib.js";
+import { ParserInterface } from "@miqro/parser/lib.js";
+
+/*export * from "@miqro/core/lib.js";
+export * from "@miqro/query/lib.js";*/
+
+export interface AuthConfig extends SessionHandlerOptions {
+
+}
+
+export interface MiddlewareConfig {
+  middleware?: Array<HandlerWithOptions | Handler>;
+  post?: Array<HandlerWithOptions | Handler>;
+}
+
+export interface CORSConfig extends CORSOptions {
+
+}
+
+export interface ErrorConfig {
+  catch?: Array<ErrorHandler>;
+}
+
+export interface WSConfig extends WebSocketServerOptions {
+  path: string;
+  disabled?: boolean;
+}
+
+export interface DocConfig {
+  publish: {
+    [path: string]: {
+      type?: "HTML" | "MD" | "JSON",
+      all?: boolean;
+    }
+  }
+}
+
+export interface ServerConfig {
+  start?: (server: ServerInterface) => Promise<void> | void;
+  preload?: (server: ServerInterface) => Promise<void> | void;
+  load?: (server: ServerInterface) => Promise<void> | void;
+  unload?: (server: ServerInterface) => void;
+  stop?: (server: ServerInterface) => void;
+}
+
+export interface DBConfig {
+  dialect?: string;
+  storage?: string;
+  url?: string;
+  disabled?: boolean;
+  name: string;
+}
+
+export interface CacheInterface {
+  get<T = any>(key: string): T | undefined;
+  set: (key: string, value: unknown) => void;
+  unset: (key: string) => void;
+  has: (key: string) => boolean;
+
+  set_add: (key: string, value: unknown) => void;
+  set_delete: (key: string, value: unknown) => void;
+  set_has: (key: string, value: unknown) => boolean;
+  set_clear: (key: string) => void;
+
+  array_push: (key: string, value: unknown) => void;
+  array_clear: (key: string) => void;
+}
+
+export interface APIOptions extends Partial<RouteOptions> {
+  basePath?: string;
+  path?: string | string[];
+  method?: string | string[];
+  parser?: ParserInterface;
+  middleware?: Handler | Handler[];
+  session?: SessionHandlerOptions | Handler;
+}
+
+export interface NamedMigration {
+  name: string;
+  service: string;
+  dbName: string;
+}
+
+export interface LogConfig {
+  level?: LogLevel;
+  replaceConsoleTransport?: boolean;
+  replaceFileTransport?: boolean;
+  write: (args: LoggerTransportWriteArgs) => Promise<void> | void;
+}
+
+export interface MigrateOptions {
+  direction: "up" | "down";
+  service?: string;
+  dbName?: string;
+  name?: string;
+}
+
+export interface ServerInterface {
+  // null values are if the feature has been disabled
+  db: {
+    get(name: string): Database | null;
+    getMigrations(): NamedMigration[];
+    migrate(options?: MigrateOptions): Promise<void>;
+  },
+  ws: {
+    get(path: string): WebSocketServer | undefined;
+    disconnectAll(path: string): void;
+  };
+  cache: CacheInterface;
+  localCache: CacheInterface;
+  logger: Logger;
+  isPrimaryWorker: () => boolean;
+  getWorkerNumber: () => number;
+  getWorkerCount: () => number;
+  openBrowser: (path: string) => void;
+  getLogger: (identifier: string, options?: { level?: any; transports?: any[]; formatter?: any; }) => Logger;
+}
+
+export interface ServerRequest extends Request {
+  server?: ServerInterface;
+}
+
+export interface ServerResponse extends Response {
+}
+
+export { App, LoggerHandler, Router, APIRoute } from "@miqro/core/lib.js";
+export { migration, Migration } from "@miqro/query/lib.js";

package/src/types/postject.d.ts

@@ -0,0 +1 @@
+import "../globals.js";