miqro 6.1.1 → 6.1.3

package/editor/http/admin/editor/api/fs/scan.api.tsx

@@ -0,0 +1,181 @@
+import { APIRoute } from "@miqro/core";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.js";
+import { AdminRequest } from "../../../../../common/admin-interface.js";
+
+export interface ScannedFile {
+  filePath: string;
+  ext: string;
+  fileName: string;
+  name: string;
+  subExt: string;
+  subName: string;
+  language: string;
+  previewPath?: string;
+  dirs: string[];
+  apiPreview?: {
+    path: string;
+    method: string;
+  }[];
+}
+
+export default {
+  method: "GET",
+  path: "/scan",
+  description: "admin editor file scan endpoint",
+  middleware: [server.middleware.json()],
+  request: {
+    body: false
+  },
+  response: {
+    status: [200, 400]
+  },
+  handler: async (req: AdminRequest, res) => {
+    const admin = req.editor;
+    const services = admin ? admin.getServices() : ["."];
+    return res.json({
+      files: scanDir(req),
+      services
+    });
+  },
+} as APIRoute;
+
+export function scanDir(req: AdminRequest, basePath: string = BASE_PATH, ret: ScannedFile[] = []): ScannedFile[] {
+  const admin = req.editor;
+  const services = admin ? admin.getServices() : ["."];
+  services.forEach(service => {
+    scanDirInternal(req, resolve(basePath, service), ret);
+  });
+  return ret;
+}
+
+function scanDirInternal(req, path: string = BASE_PATH, ret: ScannedFile[] = []): ScannedFile[] {
+  if (!existsSync(path)) {
+    return ret;
+  }
+  const files = readdirSync(path);
+  for (const file of files) {
+    if (shouldIgnoreFile(file)) {
+      continue;
+    }
+    const filePath = resolve(path, file);
+    if (statSync(filePath).isDirectory()) {
+      scanDirInternal(req, filePath, ret);
+      continue;
+    } else {
+      const ext = extname(filePath);
+      const fileName = basename(filePath);
+      const name = fileName.substring(0, fileName.length - ext.length);
+      const subExt = extname(name);
+      const subName = name.substring(0, name.length - subExt.length);
+
+      ret.push({
+        dirs: getFileDirs(relative(BASE_PATH, filePath)),
+        language: getLanguage(filePath),
+        filePath: relative(BASE_PATH, filePath),
+        ext,
+        fileName,
+        name,
+        subExt,
+        subName,
+        previewPath: getPreview(req, filePath),
+        apiPreview: getAPIPreview(req, filePath)
+      });
+    }
+  }
+  return ret;
+}
+
+function shouldIgnoreFile(file) {
+  return file === ".git" || file === ".types" || file === ".DS_Store" || file === "node_modules";
+}
+
+function getFileDirs(filePath: string): string[] {
+  const dirs: string[] = [];
+  let dir = dirname(filePath);
+  while (dir !== sep && dir !== "" && dir !== "." && dir !== BASE_PATH) {
+
+    dirs.push(dir);
+    dir = dirname(dir);
+
+  }
+  return dirs.reverse().map(d => basename(d));
+
+}
+
+export function getLanguage(filePath: string): string {
+  const ext = extname(filePath);
+  const fileName = basename(filePath);
+  switch (ext.toLocaleLowerCase()) {
+    case ".py":
+      return "python";
+    case ".sh":
+      return "bash";
+    case ".webmanifest":
+    case ".json":
+      return "json";
+    case ".xml":
+      return "xml";
+    case ".jsx":
+    case ".js":
+      return "javascript";
+    case ".tsx":
+    case ".ts":
+    case "d.ts":
+      return "typescript";
+    case ".htm":
+    case ".html":
+      return "html";
+    case ".scss":
+    case ".css":
+      return "css";
+    case ".md":
+      return "markdown";
+    case ".c":
+      return "c";
+    case ".h":
+    case ".cpp":
+      return "cpp";
+    case ".yml":
+    case ".yaml":
+      return "yaml";
+    case ".txt":
+    case ".log":
+      return "text";
+    default:
+      switch (fileName) {
+        case "dockerfile":
+          return "dockerfile";
+        case ".gitignore":
+          return "text";
+      }
+      return "text";
+  }
+}
+
+export function getPreview(req: AdminRequest, filePath: string): undefined | string {
+  const admin = req.editor;
+  const inflateData = admin ? admin.getRouteFileMap()[filePath] : undefined;
+  if (inflateData) {
+    return inflateData.previewMethod === "html" ? inflateData.routes[0].path : undefined;
+  }
+  return undefined;
+}
+
+export function getAPIPreview(req, filePath: string): undefined | {
+  path: string;
+  method: string;
+}[] {
+  const admin = req.editor;
+  const inflateData = admin ? admin.getRouteFileMap()[filePath] : undefined;
+  if (inflateData) {
+    return inflateData.previewMethod === "api" ? inflateData.routes.map(r => {
+      return {
+        path: r.path,
+        method: r.method ? r.method : "GET"
+      };
+    }) : undefined;
+  }
+  return undefined;
+}

package/editor/http/admin/editor/api/fs/write.api.tsx

@@ -0,0 +1,41 @@
+import { APIRoute } from "@miqro/core";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { getPath } from "./read.api.js";
+import { dirname } from "node:path";
+
+export default {
+  middleware: [server.middleware.json()],
+  method: "POST",
+  path: "/write",
+  description: "admin editor file write endpoint",
+  request: {
+    body: {
+      path: "string",
+      contents: "string",
+      override: "boolean?"
+    }
+  },
+  response: {
+    status: [200, 400],
+    body: {
+      message: "string"
+    }
+  },
+  handler: async (req, res) => {
+    const { path, contents, override } = req.body;
+    await writeFile(path, contents, override);
+    return res.json({
+      message: "OK"
+    });
+  }
+} as APIRoute;
+
+async function writeFile(path: string, contents: string, override?: boolean) {
+  if (existsSync(getPath(path)) && !override) {
+    throw new Error("file already exists!");
+  }
+  mkdirSync(dirname(getPath(path)), {
+    recursive: true
+  });
+  writeFileSync(getPath(path), contents);
+}

package/editor/http/admin/editor/api/server/reload.api.ts

@@ -0,0 +1,53 @@
+import { APIRoute } from "@miqro/core";
+import { relative } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.js";
+import { AdminRequest } from "../../../../../common/admin-interface.js";
+
+export default {
+  method: "POST",
+  path: "/reload",
+  description: "admin editor server reload endpoint. reloads the server without closing the port",
+  middleware: [],
+  request: {
+    body: false
+  },
+  response: {
+    status: [200, 400],
+    body: {
+      message: "string",
+      reloadString: "string",
+      migrations: "string[]",
+      errors: {
+        allowNull: true,
+        type: "array",
+        arrayType: "object",
+        properties: {
+          filePath: "string",
+          error: "string"
+        }
+      }
+    }
+  },
+  handler: async (req: AdminRequest, res) => {
+    const errors = await req?.editor?.reload();
+    const parsedErrors = parseInflateErrors(errors);
+    return res.json({
+      message: "OK",
+      reloadString: req.uuid,
+      migrations: req?.editor?.getMigrations().map(m => m.name),
+      errors: parsedErrors ? parsedErrors : []
+    });
+  },
+} as APIRoute;
+
+export function parseInflateErrors(errors: {
+  filePath: string;
+  error: Error;
+}[] | null) {
+  return errors?.map(error => {
+    return {
+      filePath: relative(BASE_PATH, error.filePath),
+      error: error.error.message
+    }
+  });
+}

package/editor/http/admin/editor/api/server/restart.api.tsx

@@ -0,0 +1,52 @@
+import { APIRoute } from "@miqro/core";
+import { relative } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.js";
+import { AdminRequest } from "../../../../../common/admin-interface.js";
+
+export default {
+  method: "POST",
+  path: "/restart",
+  description: "admin editor server restart endpoint",
+  middleware: [server.middleware.json()],
+  request: {
+    body: false
+  },
+  response: {
+    status: [200, 400],
+    body: {
+      message: "string",
+      reloadString: "string",
+      migrations: "string[]",
+      errors: {
+        allowNull: true,
+        type: "array",
+        arrayType: "object",
+        properties: {
+          filePath: "string",
+          error: "string"
+        }
+      }
+    }
+  },
+  handler: async (req: AdminRequest, res) => {
+    const errors = await req?.editor?.restart();
+    return res.json({
+      message: "OK",
+      reloadString: req.uuid,
+      migrations: req?.editor?.getMigrations().map(m => m.name),
+      errors: parseInflateErrors(errors)
+    });
+  },
+} as APIRoute;
+
+export function parseInflateErrors(errors: {
+  filePath: string;
+  error: Error;
+}[] | null) {
+  return errors?.map(error => {
+    return {
+      filePath: relative(BASE_PATH, error.filePath),
+      error: error.error.message
+    }
+  });
+}

package/editor/http/admin/editor/editor.tsx

@@ -0,0 +1,8 @@
+//import "../../../../.types/browser.globals";
+import { Editor } from "../../../components/editor.js";
+
+window.addEventListener("load", async (event) => {
+  jsx.define("editor-component", Editor, {
+    shadowInit: false
+  });
+});

package/editor/http/admin/editor/index.api.tsx

@@ -0,0 +1,39 @@
+import { APIRoute, Response } from "@miqro/core";
+import { scanDir } from "./api/fs/scan.api.js";
+import { HTMLEncode } from "../../../common/html-encode.js";
+import { AdminRequest } from "../../../common/admin-interface.js";
+
+export default {
+  description: "ADMIN EDITOR GUI",
+  path: "/",
+  method: "GET",
+  handler: async (req: AdminRequest, res: Response) => {
+    const admin = req.editor;
+    const errors = admin ? admin.getInflateErrors() : [];
+    const files = scanDir(req);
+    const migrations = admin ? admin.getMigrations().map(m => m.name) : [];
+    const services = admin ? admin.getServices() : ["."];
+
+    return res.html("<!DOCTYPE html>" + String(<html>
+      <head>
+        <link rel="stylesheet" href="/admin/editor/style.css" />
+      </head>
+      <body>
+
+        <script type="module" src="/admin/editor/editor.js" />
+        <editor-component
+          disablelog="true"
+          disablepreview="true"
+          disablereload="true"
+          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>
+      </body></html>)
+    );
+  }
+} as APIRoute;

package/editor/server.ts

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import { ServerConfig, ServerInterface } from "../src/types.js";
+import { BASEEDITOR_PATH } from "./common/constants.js";
+import { existsSync, readFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { ADMIN_EDITOR_AUTH_KEY, ADMIN_EDITOR_AUTH_QUERY } from "./auth.js";
+import { EditorAdminInterface } from "./common/admin-interface.js";
+//import { getEditorAdmin } from "./common/admin-interface.js";
+
+const ADMIN_EDITOR_BROWSER_OPEN_KEY = "ADMIN_EDITOR_BROWSER_OPEN_KEY$$";
+
+export default {
+  preload: (serverInterface: ServerInterface, adminInterface: EditorAdminInterface) => {
+    //console.dir(server);
+    if (serverInterface?.isPrimaryWorker()) {
+      const cache = (adminInterface ? adminInterface.getCache() : serverInterface.cache);
+      if (!cache.has(ADMIN_EDITOR_AUTH_KEY)) {
+        const adminKEYPath = resolve(".admin_key");
+        if (existsSync(adminKEYPath)) {
+          serverInterface.logger.warn("loading static ADMIN_KEY from [%s]", relative(process.cwd(), adminKEYPath));
+          cache.set(ADMIN_EDITOR_AUTH_KEY, readFileSync(adminKEYPath).toString().trim());
+        } else {
+          cache.set(ADMIN_EDITOR_AUTH_KEY, randomUUID());
+        }
+      }
+    }
+  },
+  start: (serverInterface: ServerInterface, adminInterface: EditorAdminInterface) => {
+    //console.dir(server);
+    const cache = (adminInterface ? adminInterface.getCache() : serverInterface.cache);
+    if (!cache.has(ADMIN_EDITOR_BROWSER_OPEN_KEY)) {
+
+      const KEY = cache.get(ADMIN_EDITOR_AUTH_KEY);
+
+      const adminPath = `${BASEEDITOR_PATH}?${ADMIN_EDITOR_AUTH_QUERY}=${KEY}`;
+
+      if (serverInterface?.isPrimaryWorker()) {
+        serverInterface.logger.log("\n\n\tADMIN_EDITOR\n\n\t%s\n\n", adminPath);
+      }
+
+      //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 (serverInterface.isPrimaryWorker()) {
+        cache.set(ADMIN_EDITOR_BROWSER_OPEN_KEY, true);
+        try {
+          serverInterface.openBrowser(`${BASEEDITOR_PATH}?${ADMIN_EDITOR_AUTH_QUERY}=${KEY}`);
+          //serverInterface.logger.log(`${OPEN} "${adminPath}"`);
+          //execSync(`${OPEN} "${adminPath}"`);
+        } catch (e) {
+          serverInterface.logger.error(e.message);
+        }
+      }
+    }
+  }
+} as ServerConfig;

package/editor/ws.ts

@@ -0,0 +1,15 @@
+import { WSConfig } from "../src/types.js";
+import { LOG_SOCKET_PATH } from "./common/constants.js";
+import { AdminRequest } from "./common/admin-interface.js";
+
+export default {
+  path: LOG_SOCKET_PATH,
+  validate(req: AdminRequest) {
+    const admin = req.editor;
+    const cache = (admin ? admin.getCache() : req.server.cache);
+    
+    const KEY = cache.get("AUTH_KEY");
+    const cookieToken = req.cookies["auth"];
+    return cookieToken === KEY ? true : false;
+  },
+} as WSConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miqro",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "description": "",
   "type": "module",
   "main": "build/esm/src/lib.js",

package/src/bin/compile.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { Arguments } from "../common/arguments.js";
+import { EXIT_CODES } from "../common/constants.js";
+
+export async function compileSH(args: Arguments) {
+  return new Promise<void>((resolve, reject) => {
+    try {
+      process.chdir(args.inflateDir);
+      const proc = spawn(`sh`, ["./compile.sh"]);
+
+      proc.stdout.on('data', (data) => {
+        console.log(`${data}`);
+      });
+
+      proc.stderr.on('data', (data) => {
+        console.log(`${data}`);
+      });
+
+      proc.on('close', (code) => {
+        console.log(`compilation exited with code ${code}`);
+
+        if (code !== 0) {
+          process.exit(code);
+        } else {
+          process.exit(EXIT_CODES.NORMAL_EXIT);
+        }
+        resolve();
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}