miqro 5.0.5 → 6.0.3

package/editor/auth.ts

@@ -0,0 +1,51 @@
+import { AuthConfig, ServerRequest } from "../src/types.js";
+import { AdminRequest } from "./common/admin-interface.js";
+
+export const ADMIN_EDITOR_AUTH_KEY = "$$ADMIN_EDITOR_AUTH_KEY$$";
+
+export const ADMIN_EDITOR_AUTH_QUERY = "key";
+export const ADMIN_EDITOR_AUTH_COOKIE = ADMIN_EDITOR_AUTH_KEY;
+
+export default {
+  authService: {
+    verify: async (args) => {
+
+      const adminInterface = (args.req as AdminRequest).editor;
+      const serverInterface = (args.req as any as ServerRequest).server;
+      const KEY = (adminInterface ? adminInterface.getCache() : serverInterface.cache).get<string>(ADMIN_EDITOR_AUTH_KEY);
+
+      const validSesson = {
+        username: "username",
+        account: "account",
+        groups: [],
+        token: args.token
+      };
+
+      const queryToken = args.req.query[ADMIN_EDITOR_AUTH_QUERY];
+      const cookieToken = args.req.cookies[ADMIN_EDITOR_AUTH_COOKIE];
+
+      //console.log("\n\nqueryToken[%s] cookieToken[%s] KEY[%s]\n\n", queryToken, cookieToken, KEY);
+
+      if (queryToken) {
+        if (queryToken === KEY) {
+          args.res.setCookie(ADMIN_EDITOR_AUTH_COOKIE, KEY, {
+            expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 31 * 12 * 500),
+            httpOnly: true,
+
+            //secure: true,
+            path: "/",
+            //sameSite: "strict"
+          });
+          args.req.searchParams.delete(ADMIN_EDITOR_AUTH_QUERY);
+          const queryString = args.req.searchParams.toString();
+          const redirect = args.req.path + (queryString ? "?" + queryString : "");
+          await args.res.redirect(redirect);
+          return validSesson;
+        }
+      } else if (cookieToken) {
+        return cookieToken === KEY ? validSesson : null;
+      }
+      return null;
+    },
+  }
+} as AuthConfig;

package/editor/common/admin-interface.ts

@@ -0,0 +1,84 @@
+import { RouterHandlerOptions } from "@miqro/core";
+import { CacheInterface, ServerRequest } from "../../src/types.js";
+import { MigrationModule } from "../../src/inflate/setup-db.js";
+
+export interface EditorAdminInterface {
+  getCache: () => CacheInterface;
+  //inflateJSX: (path: string, minify?: boolean) => Promise<string>;
+  getMigrations(): MigrationModule[];
+  stop: () => Promise<void>;
+  reload: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+  restart: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+  getHotReloadHTML(): string;
+  getInflateErrors(): null | {
+    filePath: string;
+    error: Error;
+  }[];
+  getServices(): string[];
+  getRouteFileMap(): {
+    [filePath: string]: {
+      routes: {
+        path?: string;
+        method?: string | null;
+        options?: RouterHandlerOptions;
+        inflatePath?: string;
+      }[];
+      previewMethod: "api" | "html" | null;
+    }
+  };
+}
+
+export interface AdminRequest extends ServerRequest {
+  editor?: EditorAdminInterface;
+}
+
+/*let currentAdminInterface: EditorAdminInterface | null = null;
+function createFakeAdminInterface(server: any): EditorAdminInterface {
+  return {
+    getCache: () => {
+      return server.cache;
+    },
+    stop: async () => {
+
+    },
+    restart: async () => {
+      return null;
+    },
+    reload: async () => {
+      return null;
+    },
+    getHotReloadHTML: () => {
+      return "";
+    },
+    getMigrations: () => {
+      return [];
+    },
+    getServices: () => {
+      return ["."];
+    },
+    getRouteFileMap: () => {
+      return {};
+    },
+    getInflateErrors: () => {
+      return [];
+    },
+    inflateJSX: async function inflateJSX(path, minify: boolean = true) {
+      return "";
+    }
+  }
+}
+
+export function getEditorAdmin(server): EditorAdminInterface {
+  return currentAdminInterface ? currentAdminInterface : createFakeAdminInterface(server);
+}
+
+export function setEditorAdmin(admin: EditorAdminInterface): void {
+  currentAdminInterface = admin;
+}*/
+

package/editor/common/constants.server.ts

@@ -0,0 +1,5 @@
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+
+export const PORT = process.env["PORT"] ? process.env["PORT"] : "8080";
+export const BASE_PATH = resolve(cwd());

package/editor/common/constants.ts

@@ -0,0 +1,21 @@
+export const BASEEDITOR_PATH = "/admin/editor";
+export const LOG_SOCKET_PATH = "/admin/socket/";
+export const LOG_WRITE_EVENT = "LogWrite";
+
+export const SUPPORTED_LANGUAGES = [
+  "text",
+  "json",
+  "javascript",
+  "typescript",
+  "dockerfile",
+  "yaml",
+  "xml",
+  "html",
+  "css",
+  "scss",
+  "markdown",
+  "c",
+  "cpp",
+  "bash",
+  "python"
+];

package/editor/common/editor-index.tsx

@@ -0,0 +1,17 @@
+import { scanDir } from "../http/admin/editor/api/fs/scan.api.js";
+import { parseInflateErrors } from "../http/admin/editor/api/server/restart.api.js";
+import { AdminRequest } from "./admin-interface.js";
+import { HTMLEncode } from "./html-encode.js";
+
+export function EditorIndex(editorCSS: string, editorJS: string, enableHotReload: boolean) {
+  return async function editorIndex(req: AdminRequest, res) {
+    const admin = req.editor;
+
+    const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
+    const files = scanDir(req);
+    const migrations = admin ? admin.getMigrations().map(m => m.name) : [];
+    const services = admin ? admin.getServices() : ["."];
+    const hotReload = enableHotReload ? (admin ? admin.getHotReloadHTML() : "") : "";
+    res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode(JSON.stringify(migrations))}" services="${HTMLEncode(JSON.stringify(services))}" errors="${HTMLEncode(JSON.stringify(errors))}" files="${HTMLEncode(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`)
+  }
+}

package/editor/common/html-encode.ts

@@ -0,0 +1,14 @@
+export function HTMLEncode(str: string): string {
+  let i = str.length;
+  const aRet: string[] = [];
+
+  while (i--) {
+    const iC = str[i].charCodeAt(0);
+    if (iC < 65 || iC > 127 || (iC > 90 && iC < 97)) {
+      aRet[i] = '&#' + iC + ';';
+    } else {
+      aRet[i] = str[i];
+    }
+  }
+  return aRet.join('');
+}

package/editor/common/log-socket.tsx

@@ -0,0 +1,82 @@
+interface LogLine { out: string; identifier: string; level: "error" | "warn" | "debug" | "trace" | "info" }
+
+export interface LogSocket {
+  lines: LogLine[];
+  clearLog: () => void;
+  getMaxlogsize: () => number | "unlimited";
+  setMaxLogSize: (val: number | "unlimited") => void;
+}
+
+export function useLogSocket(): LogSocket {
+
+  const [_, setmaxLogSize, getMaxlogsize] = jsx.useState<number | "unlimited">(1000000);
+
+  const [__, setlines, getLines] = jsx.useState<LogLine[]>([]);
+  const refresh = jsx.useRefresh();
+
+  jsx.useEffect(() => {
+
+    let timeout;
+
+    function setupSocket() {
+      try {
+        console.log("setting up log socket");
+        const socket = new WebSocket("/admin/socket");
+        socket.addEventListener("error", (err) => {
+          console.error(err);
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+        socket.addEventListener("open", () => {
+          console.log("log socket open");
+          clearTimeout(timeout);
+          socket.addEventListener("message", (msg) => {
+            const lines = getLines();
+            const data = JSON.parse(msg.data);
+            //console.log(data.out);
+            const maxLogSize = getMaxlogsize();
+            if (maxLogSize !== "unlimited" && lines.length >= maxLogSize) {
+              lines.splice(0, (lines.length - maxLogSize) + 1);
+            }
+            lines.push(data);
+            setlines(lines);
+            refresh();
+          });
+        });
+        socket.addEventListener("close", () => {
+          console.log("log socket close");
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+      } catch (e) {
+        console.error(e);
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          setupSocket();
+        }, 1000);
+      }
+    }
+
+    setupSocket();
+  }, []);
+
+  return {
+    lines: getLines(),
+    clearLog: () => {
+      setlines([]);
+    },
+    getMaxlogsize,
+    setMaxLogSize: (newValue: number | "unlimited") => {
+      if (newValue === "unlimited") {
+        setmaxLogSize(newValue);
+      } else {
+        setmaxLogSize(newValue);
+      }
+
+    }
+  }
+}