miqro 5.0.4 → 6.0.3

package/src/services/utils/websocketmanager.ts

@@ -0,0 +1,139 @@
+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 deleteAllWS() {
+    this.runningGlobalWSMap.clear();
+  }
+
+  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.runningGlobalWSMap.delete(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,109 @@
+import "./globals.js";
+import { Database, Migration } from "@miqro/query/lib.js";
+import { 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 CORSConfig extends CORSOptions {
+
+}
+
+export interface WSConfig extends WebSocketServerOptions {
+  path: string;
+  disabled?: 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;
+  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 } from "@miqro/core/lib.js";
+export { migration } from "@miqro/query/lib.js";

package/src/types/postject.d.ts

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

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

@@ -0,0 +1,72 @@
+import "./jsx.globals.js";
+
+import { Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core/lib.js";
+import { request } from "./@miqro/request.js";
+import { RuntimeHTMLElement, Runtime, RuntimeContainer, RuntimeURL, RuntimeOptions, RuntimeShadowRootInit } from "./@miqro/jsx.js";
+
+declare global {
+  // only available server side
+  var server: {
+    /*// null values are if the feature has been disabled
+    db: {
+      get(name: string): Database | null;
+    },
+    ws: {
+      get(path: string): WebSocketServer | undefined;
+      disconnectAll(path: string): void;
+    };
+    cache: {
+      get: (key: string) => any;
+      set: (key: string, value: unknown) => void;
+      delete: (key: string) => void;
+      has: (key: string) => boolean;
+    };
+    logger: Logger;*/
+    middleware: {
+      buffer: typeof ReadBuffer;
+      url: typeof URLEncodedParser;
+      json: typeof JSONParser;
+      text: typeof TextParser;
+      cors: typeof CORS;
+      session: typeof SessionHandler;
+    }
+    encodeHTML: (str: string) => string;
+    inflateMDtoHTML: (str: string) => string;
+  }
+
+  var test: {
+    PORT: string;
+    request: typeof request,
+    logger: Logger,
+    sleep: (ms: number) => Promise<void>,
+    jsx: {
+      createRuntime: (args?: {
+        basePath?: string | null;
+        url?: RuntimeURL;
+        logger?: {
+          log: Function,
+          error: Function
+        }
+      }) => Runtime;
+      test: (cb: (container: RuntimeContainer, root: RuntimeHTMLElement, runtime: Runtime) => (Promise<void> | void), args?: {
+        runtimeOptions?: {
+          basePath?: string | null;
+          url?: RuntimeURL;
+          logger?: {
+            log: Function;
+            error: Function;
+          };
+        },
+        containerOptions?: {
+          runtimeOptions?: RuntimeOptions;
+          shadowInit?: boolean | RuntimeShadowRootInit;
+        };
+      }) => () => Promise<void>;
+    }
+  }
+
+  var it: Function;
+  var describe: Function;
+  var before: Function;
+  var after: Function;
+}

package/src/types.ts

@@ -0,0 +1,199 @@
+import { Database } from "@miqro/query";
+import { WebSocketServerOptions, SessionHandlerOptions, Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler, RouteOptions, Handler, Request, Response, LogLevel, LoggerTransportWriteArgs, CORSOptions } from "@miqro/core";
+import { request } from "@miqro/request";
+import { 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";
+
+declare global {
+  // jsx only for the default value of tsconfig.json
+  //var React: {};
+  var JSX: {
+    createElement: typeof createElement;
+    Fragment: typeof Fragment;
+    enableDebugLog: typeof enableDebugLog;
+  }
+}
+
+declare global {
+  // only available browser side
+  var jsx: {
+    define: (tagName: string, component: Component, options?: RuntimeElementDefinitionOptions) => void;
+    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;
+  }
+}
+
+export interface ServerGlobal {
+  encodeHTML: (str: string) => string;
+  inflateMDtoHTML: (str: string) => string;
+  middleware: {
+    buffer: typeof ReadBuffer;
+    url: typeof URLEncodedParser;
+    json: typeof JSONParser;
+    text: typeof TextParser;
+    cors: typeof CORS;
+    session: typeof SessionHandler;
+  };
+}
+
+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 NamedMigration {
+  name: string;
+  service: string;
+  dbName: string;
+}
+
+export interface MigrateOptions {
+  direction: "up" | "down";
+  service?: string;
+  dbName?: string;
+  name?: string;
+}
+
+export interface LogConfig {
+  level?: LogLevel;
+  replaceConsoleTransport?: boolean;
+  replaceFileTransport?: boolean;
+  write: (args: LoggerTransportWriteArgs) => Promise<void> | void;
+}
+
+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;
+  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 interface TestHelperGlobal {
+  PORT: string;
+  request: typeof request,
+  logger: Logger,
+  sleep: (ms: number) => Promise<void>,
+  jsx: {
+    createRuntime: (args?: {
+      basePath?: string | null;
+      url?: RuntimeURL;
+      logger?: {
+        log: Function,
+        error: Function
+      }
+    }) => Runtime;
+    test: (cb: (container: RuntimeContainer, root: RuntimeHTMLElement, runtime: Runtime) => (Promise<void> | void), args?: {
+      runtimeOptions?: {
+        basePath?: string | null;
+        url?: RuntimeURL;
+        logger?: {
+          log: Function;
+          error: Function;
+        };
+      },
+      containerOptions?: {
+        runtimeOptions?: RuntimeOptions;
+        shadowInit?: boolean | RuntimeShadowRootInit;
+      };
+    }) => () => Promise<void>;
+  }
+}
+
+declare global {
+  // only available server side
+  var server: ServerGlobal;
+
+  //var utils: UtilsGlobal;
+
+  var test: TestHelperGlobal;
+
+  var it: Function;
+  var describe: Function;
+  var before: Function;
+  var after: Function;
+}
+
+export interface AuthConfig extends SessionHandlerOptions {
+
+}
+
+export interface WSConfig extends WebSocketServerOptions {
+  path: string;
+  disabled?: boolean;
+}
+
+export interface CORSConfig extends CORSOptions {
+
+}
+
+export interface ServerConfig {
+  preload?: (server: ServerInterface) => Promise<void> | void;
+  start?: (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 APIOptions extends Partial<RouteOptions> {
+  basePath?: string;
+  path?: string | string[];
+  method?: string | string[];
+  parser?: ParserInterface;
+  middleware?: Handler | Handler[];
+  session?: SessionHandlerOptions | Handler;
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "noEmit": false,
+    "sourceMap": true,
+    "declaration": true,
+    "outDir": "./build/esm",
+    "strict": false,
+    "module": "NodeNext",
+    "lib": ["es2021", "dom"],
+    "jsx": "react",
+    "jsxFactory": "JSX.createElement",
+    "jsxFragmentFactory": "JSX.Fragment",
+    "moduleResolution": "nodenext"
+    /*"typeRoots": [
+      "./.types",
+      ".types",
+      "./node_modules/",
+      "./node_modules/@types"
+    ]*/
+  },
+  "include": [
+      "src/**/*",
+      "editor/**/*"
+  ],
+  "exclude": [
+      "node_modules",
+      "sea",
+      "test",
+      ".types",
+      "node_modules/@miqro/jsx/build/esm/jsx.d.ts",
+      ".types/@miqro/jsx/esm/jsx.d.ts",
+      "src/types/"
+  ]
+}

package/build/cli.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { CMD_MAP, usage } from "./cmd-map.js";
-import { mainCMD } from "./utils/exec.js";
-mainCMD(CMD_MAP, usage, console);