miqro 7.0.1 → 7.0.3

package/src/services/editor.tsx

@@ -0,0 +1,101 @@
+import { APIRoute, Handler, HandlerWithOptions, 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();
+  const innerRouter = new Router();
+
+  innerRouter.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");
+
+  innerRouter.use(authHandler);
+
+  innerRouter.post(`/api/fs/write`, getHandler(/*authHandler, */writeAPI));
+
+  innerRouter.post(`/api/fs/rename`, getHandler(/*authHandler, */renameAPI));
+
+  innerRouter.post(`/api/fs/read`, getHandler(/*authHandler, */readAPI));
+
+  innerRouter.post(`/api/fs/delete`, getHandler(/*authHandler, */deleteAPI));
+
+  innerRouter.get(`/api/fs/scan`, getHandler(/*authHandler, */scanAPI));
+
+  innerRouter.post(`/api/server/restart`, getHandler(/*authHandler, */restartAPI));
+
+  innerRouter.post(`/api/server/reload`, getHandler(/*authHandler, */reloadAPI));
+
+  innerRouter.get(`/font.ttf`, async (_req, res) => {
+    return await res.asyncEnd({
+      status: 200,
+      headers: {
+        ["Content-Type"]: CONTENT_TYPE_MAP[".ttf"]
+      },
+      body: editorFont
+    })
+  });
+
+  innerRouter.get("/", EditorIndex(editorCSS, editorJS, false));
+
+
+
+  innerRouter.use(async (req: AdminRequest, res) => {
+    delete req.editor;
+  });
+
+  router.use(innerRouter, BASEEDITOR_PATH);
+
+  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): HandlerWithOptions {
+  /*const ret = new Router();
+  ret.use(auth);
+  ret.use(router.handler, undefined, undefined, getHandlerOptions(router));
+  return ret;*/
+  return {
+    ...getHandlerOptions(router),
+    handler: router.handler as Handler
+  }
+}

package/src/services/globals.ts.ignore

@@ -0,0 +1,186 @@
+//@ts-ignore
+import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
+import cluster from "node:cluster";
+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 { ClusterCache, LocalCache, ServerGlobal } from "../lib.js";
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../common/jwt.js";
+import { createSecretKey } from "node:crypto";
+import { Parser } from "@miqro/parser";
+
+/*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,
+  createSecretKey,
+  newParser() {
+    return new Parser();
+  },
+  newClusterCache(name, logger) {
+    return new ClusterCache(name, logger);
+  },
+  newLocalCache(name, logger) {
+    return new LocalCache(name, logger);
+  },
+  getWorkerNumber(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+  },
+  getWorkerCount(): number {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+  },
+  isPrimaryWorker(): boolean {
+    return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+  },
+  jwt: {
+    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);
+    }
+  }
+}) 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,51 @@
+//import { checkEnvVariable } from "@miqro/core";
+
+import { HOT_RELOAD_PATH } from "../common/constants.js";
+
+export function getHotReloadScript() {
+  const HOT_RELOAD_JS_SCRIPT = `
+// Create WebSocket connection.
+
+function getSocket() {
+    return new WebSocket("${HOT_RELOAD_PATH}");
+}
+
+const socket = getSocket();
+
+let timeout;
+
+function tryConnection() {
+    try {
+        const newSocket = getSocket();
+        newSocket.addEventListener("open", (event) => {
+            console.log("reloading");
+            setTimeout(()=>{
+              window.location.reload();
+            }, 500);
+            
+        });
+        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,68 @@
+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) + ".cjs");
+        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,
+          platform: "node",
+          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) + ".cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger?.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
+          // embemedJSX: false,
+          platform: "node",
+          minify: false,
+          useExport: true,
+          logger
+        }));
+      }
+    }
+  }
+  return migrations;
+}

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

@@ -0,0 +1,37 @@
+import { EditorAdminInterface } from "../../../editor/common/admin-interface.js";
+import { MigrationModule } from "../../inflate/setup-db.js";
+import { Miqro } from "../app.js";
+import { getHotReloadScript } from "../hot-reload.js";
+import { ClusterCache } from "./cluster-cache.js";
+
+export function createAdminInterface(app: Miqro): EditorAdminInterface {
+  const adminCache = new ClusterCache("EditorCache[" + app.options.name + "]");
+  return {
+    getCache: () => adminCache,
+    stop: () => app.stop(),
+    restart: () => app.restart(),
+    reload: () => app.reload(),
+    getHotReloadHTML: getHotReloadScript,
+    getMigrations: () => {
+      if (app.inflated) {
+        const ret: MigrationModule[] = [];
+        for (const db of app.inflated.dbList) {
+          for (const m of db.migrations) {
+            ret.push(m);
+          }
+        }
+        return ret;
+      }
+      return [];
+    },
+    getServices: () => {
+      return app.options.services;
+    },
+    getRouteFileMap: () => {
+      return app.inflated ? app.inflated.fileMap : {};
+    },
+    getInflateErrors: () => {
+      return app.inflated ? app.inflated.errors : [];
+    }
+  }
+}

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, []);
+  }
+}