miqro 5.0.5 → 6.0.4

package/src/services/editor.tsx

@@ -0,0 +1,93 @@
+import { APIRoute, Handler, Router, RouterHandlerOptions, SessionHandler } from "@miqro/core";
+import { getAsset } from "../common/assets.js";
+
+import { BASEEDITOR_PATH } from "../../editor/common/constants.js";
+import EDITOR_AUTH from "../../editor/auth.js";
+
+/*import writeAPI from "../../editor/http/admin/editor/api/fs/write.api.js";
+import renameAPI from "../../editor/http/admin/editor/api/fs/rename.api.js";
+import deleteAPI from "../../editor/http/admin/editor/api/fs/delete.api.js";
+import readAPI from "../../editor/http/admin/editor/api/fs/read.api.js";
+import scanAPI from "../../editor/http/admin/editor/api/fs/scan.api.js";
+import restartAPI from "../../editor/http/admin/editor/api/server/restart.api.js";
+import reloadAPI from "../../editor/http/admin/editor/api/server/reload.api.js";*/
+
+import { AdminRequest, EditorAdminInterface } from "../../editor/common/admin-interface.js";
+import { CONTENT_TYPE_MAP } from "../common/content-type.js";
+
+export async function createEditorRouter(adminInterface: EditorAdminInterface): Promise<Router> {
+  const router = new Router();
+
+  router.use(async (req: AdminRequest, res) => {
+    res.setHeader("x-uuid", req.uuid);
+    req.editor = adminInterface;
+  });
+
+  const editorFont = Buffer.from(getAsset("editor-assets/font.ttf"));
+  const editorJS = Buffer.from(getAsset("editor-assets/editor.bundle.js")).toString().trim();
+  const editorCSS = Buffer.from(getAsset("editor-assets/style.css")).toString().trim().split("\n").map(l => l.trim()).filter(l => l).join("");
+
+  const writeAPI = (await import("../../editor/http/admin/editor/api/fs/write.api.js")).default;
+  const renameAPI = (await import("../../editor/http/admin/editor/api/fs/rename.api.js")).default;
+  const deleteAPI = (await import("../../editor/http/admin/editor/api/fs/delete.api.js")).default;
+  const readAPI = (await import("../../editor/http/admin/editor/api/fs/read.api.js")).default;
+  const scanAPI = (await import("../../editor/http/admin/editor/api/fs/scan.api.js")).default;
+  const restartAPI = (await import("../../editor/http/admin/editor/api/server/restart.api.js")).default;
+  const reloadAPI = (await import("../../editor/http/admin/editor/api/server/reload.api.js")).default;
+
+  const authHandler = SessionHandler(EDITOR_AUTH);
+
+  const { EditorIndex } = await import("../../editor/common/editor-index.js");
+
+  router.post(`${BASEEDITOR_PATH}/api/fs/write`, getHandler(authHandler, writeAPI));
+
+  router.post(`${BASEEDITOR_PATH}/api/fs/rename`, getHandler(authHandler, renameAPI));
+
+  router.post(`${BASEEDITOR_PATH}/api/fs/read`, getHandler(authHandler, readAPI));
+
+  router.post(`${BASEEDITOR_PATH}/api/fs/delete`, getHandler(authHandler, deleteAPI));
+
+  router.get(`${BASEEDITOR_PATH}/api/fs/scan`, getHandler(authHandler, scanAPI));
+
+  router.post(`${BASEEDITOR_PATH}/api/server/restart`, getHandler(authHandler, restartAPI));
+
+  router.post(`${BASEEDITOR_PATH}/api/server/reload`, getHandler(authHandler, reloadAPI));
+
+  router.get(`${BASEEDITOR_PATH}/font.ttf`, async (_req, res) => {
+    return await res.asyncEnd({
+      status: 200,
+      headers: {
+        ["Content-Type"]: CONTENT_TYPE_MAP[".ttf"]
+      },
+      body: editorFont
+    })
+  });
+
+  router.get(BASEEDITOR_PATH, [authHandler, EditorIndex(editorCSS, editorJS, false)]);
+
+
+
+  router.use(async (req: AdminRequest, res) => {
+    delete req.editor;
+  });
+
+  return router;
+}
+
+function getHandlerOptions(router: APIRoute): RouterHandlerOptions {
+  return {
+    description: router.description,
+    //handler: router,
+    middleware: router.middleware,
+    request: router.request,
+    response: router.response,
+  };
+}
+
+function getHandler(auth: Handler, router: APIRoute): Router {
+  const ret = new Router();
+  ret.use(auth);
+  ret.use(router.handler, undefined, undefined, getHandlerOptions(router));
+  return ret;
+
+}

package/src/services/globals.ts

@@ -0,0 +1,143 @@
+//@ts-ignore
+import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
+import { strictEqual } from "node:assert";
+import { HTMLEncode } from "@miqro/jsx-node";
+import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, Router, usePathname, Fragment, useEffect, useRef, useState, useQuery, useRefresh, useElement, createContext, useContext, Component, Props } from "@miqro/jsx";
+
+import { jsx2HTML } from "../common/jsx.js";
+import { inflateMD2HTML } from "../inflate/md.js";
+import { EXIT_CODES } from "../common/constants.js";
+import { ServerGlobal } from "../lib.js";
+
+/*const globaljsx: any = Object.freeze({
+  useContext,
+  useRuntime,
+  createContext,
+  useState,
+  useEffect,
+  useQuery,
+  useRef,
+  useElement,
+  useRefresh,
+  Link,
+  Router,
+  usePathname
+});*/
+const globalJSX: any = Object.freeze({
+  createElement: (...args: [tag: string | Component | typeof Fragment, attributes: Props | null | undefined, ...children: Array<any>]) => {
+    const ret = realCreateElement(...args);
+    ret.toString = () => jsx2HTML(ret)
+    return ret;
+  },
+  Fragment,
+  enableDebugLog
+});
+const globaljsx: any = Object.freeze({
+  useContext,
+  useRuntime,
+  createContext,
+  useState,
+  useEffect,
+  useQuery,
+  useRef,
+  useElement,
+  useRefresh,
+  Link,
+  Router,
+  usePathname,
+  define: function define() {
+    /*const callSites = getCallSite();
+    const caller = callSites[2];
+    if (CLEAR_JSX_CACHE) {
+      const scriptName = basename(caller.scriptName);
+      const originalName = scriptName.substring(0, scriptName.length - ".mjs".length);
+      //server.logger.debug("browser.define not available server side!");
+      //server.logger.trace("browser.define not available server side! %s", originalName);
+    } else {
+      //server.logger.debug("browser.define not available server side!");
+      //server.logger.trace("browser.define not available server side! %s:%s:%s", caller.scriptName, caller.lineNumber, caller.column);
+    }*/
+  }
+});
+const globalWindow: any = Object.freeze({
+  addEventListener: function define() {
+    /*const callSites = getCallSite();
+    const caller = callSites[2];
+    if (CLEAR_JSX_CACHE) {
+      const scriptName = basename(caller.scriptName);
+      //server.logger.debug("window.addEventListener not available server side!");
+      server.logger.trace("window.addEventListener not available server side! %s", scriptName.substring(0, scriptName.length - ".mjs".length));
+    } else {
+      //server.logger.debug("window.addEventListener not available server side!");
+      server.logger.trace("window.addEventListener not available server side! %s:%s:%s", caller.scriptName, caller.lineNumber, caller.column);
+    }*/
+  }
+});
+const globalServer: ServerGlobal = Object.freeze<ServerGlobal>({
+  middleware: Object.freeze({
+    buffer: ReadBuffer,
+    url: URLEncodedParser,
+    json: JSONParser,
+    text: TextParser,
+    cors: CORS,
+    session: SessionHandler
+  }),
+  encodeHTML: HTMLEncode,
+  inflateMDtoHTML: inflateMD2HTML
+}) as ServerGlobal;
+
+export function browserJSXGlobals(inFile: string, jsxPath: string | false = false, useExport = true): string {
+  const PRE = `import { enableDebugLog, useRuntime, Link, usePathname, createContext, useContext, useElement, useRefresh, useQuery, define, Router, useState, useEffect, useRef, createElement, Fragment } from "${jsxPath}";
+    globalThis.JSX = Object.freeze({
+      createElement,
+      Fragment,
+      enableDebugLog
+    });
+    
+    globalThis.newParser = () => new Parser();
+    globalThis.jsx = Object.freeze({
+      define,
+      useRuntime,
+      createContext, 
+      useContext, 
+      useState,
+      useEffect,
+      useQuery,
+      useRef,
+      useElement,
+      useRefresh,
+      usePathname,
+      Link,
+      Router
+    });`;
+  return `${jsxPath ? PRE : ""}\n${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
+}
+
+export function initGlobals() {//webSocketManager: WebSocketManager, dbManager: DBManager) {
+  //const logger = getLogger(SERVER_IDENTIFIER);  
+  globalThis.server = globalServer;
+  //globalThis.jsx = globaljsx;
+  /*for (const key of Object.keys(globaljsx)) {
+    globalThis[key] = globaljsx[key];
+  }*/
+  globalThis.JSX = globalJSX;
+  globalThis.jsx = globaljsx;
+  globalThis.window = globalWindow;
+}
+
+export function assertGlobalTampered() {
+  try {
+    //strictEqual(globalThis.utils, globalUtils, "globalThis.utils tamperered");
+    strictEqual(globalThis.JSX, globalJSX, "globalThis.JSX tamperered");
+    //strictEqual(globalThis.jsx, globaljsx, "globalThis.jsx tamperered");
+    /*for (const key of Object.keys(globaljsx)) {
+      strictEqual(globalThis[key], globaljsx[key], "globalThis.jsx tamperered");
+    }*/
+    strictEqual(globalThis.server, globalServer, "globalThis.server tamperered");
+    strictEqual(globalThis.jsx, globaljsx, "globalThis.jsx tamperered");
+    strictEqual(globalThis.window, globalWindow, "globalThis.window tamperered");
+  } catch (e) {
+    console.error(e);
+    process.exit(EXIT_CODES.GLOBALS_ALTERED);
+  }
+}

package/src/services/hot-reload.ts

@@ -0,0 +1,46 @@
+//import { checkEnvVariable } from "@miqro/core";
+
+export function getHotReloadScript() {
+  const HOT_RELOAD_JS_SCRIPT = `
+// Create WebSocket connection.
+
+function getSocket() {
+    return new WebSocket("/hot-reload");
+}
+
+const socket = getSocket();
+
+let timeout;
+
+function tryConnection() {
+    try {
+        const newSocket = getSocket();
+        newSocket.addEventListener("open", (event) => {
+            console.log("reloading");
+            window.location.reload();
+        });
+        newSocket.addEventListener("error", (err) => {
+            console.error(err);
+            timeout = setTimeout(tryConnection, 500);
+        });
+    } catch (e) {
+        console.error(e);
+        timeout = setTimeout(tryConnection, 500);
+    }
+}
+
+// Connection closed
+socket.addEventListener("close", (event) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(tryConnection, 500);
+});
+
+socket.addEventListener("error", (err) => {
+    console.error(err);
+});`;
+  return `<script>${HOT_RELOAD_JS_SCRIPT}</script>`;
+}
+
+/*export function isHotReloadEnabled() {
+  return checkEnvVariable("HOT_RELOAD", "0") === "1";
+}*/

package/src/services/migrations.ts

@@ -0,0 +1,66 @@
+import { Logger } from "@miqro/core";
+import { Database, DatabaseLogger, migration } from "@miqro/query";
+import { dirname, extname, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+
+import { getMigrationsPath } from "../common/paths.js";
+import { importJSXFile, inflateJSX } from "../common/jsx.js";
+
+export async function runMigrations(logger: Logger | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined | false, migrations: string[]) {
+  const migrationsFolderPath = getMigrationsPath(servicePath);
+  if (migrationsFolderPath) {
+    logger?.debug("running migrations from [%s]", service);
+    if (!db) {
+      throw new Error("cannot run migrations with the database disabled!");
+    }
+    const serviceMigrations = await migration.up.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, logger));
+    migrations.push(...serviceMigrations);
+
+    if (inflateDir) {
+      for (const migration of serviceMigrations) {
+        const inflatePath = resolve(inflateDir, service, "migration", migration.substring(0, migration.length - extname(migration).length) + ".js");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger?.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
+          embemedJSX: false,
+          minify: false,
+          useExport: true,
+          logger
+        }));
+      }
+    }
+  }
+  return migrations;
+}
+
+export async function runMigrationsDown(logger: Logger | Console | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined, migrations: string[]) {
+  const migrationsFolderPath = getMigrationsPath(servicePath)
+  if (migrationsFolderPath) {
+    logger?.debug("running migrations from [%s]", service);
+    if (!db) {
+      throw new Error("cannot run migrations with the database disabled!");
+    }
+    const serviceMigrations = await migration.down.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, logger));
+    migrations.push(...serviceMigrations);
+
+    if (inflateDir) {
+      for (const migration of serviceMigrations) {
+        const inflatePath = resolve(inflateDir, service, "migration", migration.substring(0, migration.length - extname(migration).length) + ".js");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger?.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
+          embemedJSX: false,
+          minify: false,
+          useExport: true,
+          logger
+        }));
+      }
+    }
+  }
+  return migrations;
+}

package/src/services/utils/cache.ts

@@ -0,0 +1,88 @@
+import { Logger } from "@miqro/core";
+import { CacheInterface } from "../../types.js";
+
+export class LocalCache implements CacheInterface {
+  private localCache = new Map<string, unknown>();
+
+  constructor(public name: string, public logger?: Logger) {
+  }
+
+  dispose() {
+
+  }
+
+  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);
+  }
+  unset(key: string): void {
+    this.logger?.trace("unset(%s)", key);
+    this.localCache.delete(key);
+  }
+  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("set_add(%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);
+  }
+  set_delete(key: string, value: unknown): void {
+    this.logger?.trace("set_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);
+  }
+  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);
+  }
+  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);
+  }
+  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, []);
+  }
+}

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

@@ -0,0 +1,225 @@
+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";
+  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_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 "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 push on non array");
+              }
+              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 push on non array");
+              }
+              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);
+      }
+    };
+    if (process.send) {
+      process.on("message", this.listener);
+    }
+  }
+
+  dispose() {
+    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);
+    if (process.send) {
+      setTimeout(() => {
+        process.send({
+          type: ClusterCacheType,
+          action: "set",
+          target: this.name,
+          fromPID: process.pid,
+          key,
+          value
+        } as ClusterCacheMessage);
+      }, 10);
+    }
+  }
+  unset(key: string): void {
+    this.logger?.trace("unset(%s)", key);
+    this.localCache.delete(key);
+    if (process.send) {
+      setTimeout(() => {
+        process.send({
+          type: ClusterCacheType,
+          target: this.name,
+          action: "unset",
+          fromPID: process.pid,
+          key
+        } as ClusterCacheMessage);
+      }, 10);
+    }
+  }
+  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);
+
+    if (process.send) {
+      setTimeout(() => {
+        process.send({
+          type: ClusterCacheType,
+          target: this.name,
+          action: "set_add",
+          fromPID: process.pid,
+          key,
+          value
+        } as ClusterCacheMessage);
+      }, 10);
+    }
+  }
+  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);
+    if (process.send) {
+      setTimeout(() => {
+        process.send({
+          type: ClusterCacheType,
+          target: this.name,
+          action: "set_delete",
+          fromPID: process.pid,
+          key,
+          value
+        } as ClusterCacheMessage);
+      }, 10);
+    }
+  }
+  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);
+  }
+  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);
+    if (process.send) {
+      setTimeout(() => {
+        process.send({
+          type: ClusterCacheType,
+          target: this.name,
+          action: "array_push",
+          fromPID: process.pid,
+          key,
+          value
+        } as ClusterCacheMessage);
+      }, 10);
+    }
+  }
+  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, []);
+  }
+}