miqro 7.0.1 → 7.0.2

package/build/esm/editor/http/admin/editor/api/fs/rename.api.js

@@ -0,0 +1,40 @@
+import { JSONParser } from "@miqro/core";
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { getPath } from "./read.api.js";
+import { dirname } from "node:path";
+export default {
+    middleware: [JSONParser()],
+    method: "POST",
+    description: "admin editor file rename endpoint",
+    path: "/rename",
+    request: {
+        body: {
+            path: "string",
+            newName: "string"
+        }
+    },
+    response: {
+        status: [200, 400],
+        body: {
+            message: "string"
+        }
+    },
+    handler: async (req, res) => {
+        const { path, newName } = req.body;
+        await rename(path, newName);
+        return res?.json({
+            message: "OK"
+        });
+    }
+};
+export async function rename(path, newName) {
+    if (existsSync(path) && !existsSync(newName)) {
+        mkdirSync(dirname(getPath(newName)), {
+            recursive: true
+        });
+        renameSync(getPath(path), getPath(newName));
+    }
+    else {
+        throw new Error("invalid paths");
+    }
+}

package/build/esm/editor/http/admin/editor/api/fs/scan.api.d.ts

@@ -0,0 +1,26 @@
+import { APIRoute } from "@miqro/core";
+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;
+    }[];
+}
+declare const _default: APIRoute;
+export default _default;
+export declare function scanDir(req: AdminRequest, basePath?: string, ret?: ScannedFile[]): ScannedFile[];
+export declare function getLanguage(filePath: string): string;
+export declare function getPreview(req: AdminRequest, filePath: string): undefined | string;
+export declare function getAPIPreview(req: any, filePath: string): undefined | {
+    path: string;
+    method: string;
+}[];

package/build/esm/editor/http/admin/editor/api/fs/scan.api.js

@@ -0,0 +1,150 @@
+import { JSONParser } from "@miqro/core";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, relative, resolve, sep } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.js";
+export default {
+    method: "GET",
+    path: "/scan",
+    description: "admin editor file scan endpoint",
+    middleware: [JSONParser()],
+    request: {
+        body: false
+    },
+    response: {
+        status: [200, 400]
+    },
+    handler: async (req, res) => {
+        const admin = req.editor;
+        const services = admin ? admin.getServices() : ["."];
+        return res.json({
+            files: scanDir(req),
+            services
+        });
+    },
+};
+export function scanDir(req, basePath = BASE_PATH, ret = []) {
+    const admin = req.editor;
+    const services = admin ? admin.getServices() : ["."];
+    services.forEach(service => {
+        scanDirInternal(req, resolve(basePath, service), ret);
+    });
+    return ret;
+}
+function scanDirInternal(req, path = BASE_PATH, ret = []) {
+    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) {
+    const dirs = [];
+    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) {
+    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, filePath) {
+    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) {
+    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/build/esm/editor/http/admin/editor/api/fs/write.api.d.ts

@@ -0,0 +1,3 @@
+import { APIRoute } from "@miqro/core";
+declare const _default: APIRoute;
+export default _default;

package/build/esm/editor/http/admin/editor/api/fs/write.api.js

@@ -0,0 +1,39 @@
+import { JSONParser } from "@miqro/core";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { getPath } from "./read.api.js";
+import { dirname } from "node:path";
+export default {
+    middleware: [JSONParser()],
+    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"
+        });
+    }
+};
+async function writeFile(path, contents, override) {
+    if (existsSync(getPath(path)) && !override) {
+        throw new Error("file already exists!");
+    }
+    mkdirSync(dirname(getPath(path)), {
+        recursive: true
+    });
+    writeFileSync(getPath(path), contents);
+}

package/build/esm/editor/http/admin/editor/api/server/reload.api.d.ts

@@ -0,0 +1,10 @@
+import { APIRoute } from "@miqro/core";
+declare const _default: APIRoute;
+export default _default;
+export declare function parseInflateErrors(errors: {
+    filePath: string;
+    error: Error;
+}[] | null): {
+    filePath: string;
+    error: string;
+}[];

package/build/esm/editor/http/admin/editor/api/server/reload.api.js

@@ -0,0 +1,46 @@
+import { relative } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.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, 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 : []
+        });
+    },
+};
+export function parseInflateErrors(errors) {
+    return errors?.map(error => {
+        return {
+            filePath: relative(BASE_PATH, error.filePath),
+            error: error.error.message
+        };
+    });
+}

package/build/esm/editor/http/admin/editor/api/server/restart.api.d.ts

@@ -0,0 +1,10 @@
+import { APIRoute } from "@miqro/core";
+declare const _default: APIRoute;
+export default _default;
+export declare function parseInflateErrors(errors: {
+    filePath: string;
+    error: Error;
+}[] | null): {
+    filePath: string;
+    error: string;
+}[];

package/build/esm/editor/http/admin/editor/api/server/restart.api.js

@@ -0,0 +1,46 @@
+import { JSONParser } from "@miqro/core";
+import { relative } from "node:path";
+import { BASE_PATH } from "../../../../../common/constants.server.js";
+export default {
+    method: "POST",
+    path: "/restart",
+    description: "admin editor server restart endpoint",
+    middleware: [JSONParser()],
+    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, 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)
+        });
+    },
+};
+export function parseInflateErrors(errors) {
+    return errors?.map(error => {
+        return {
+            filePath: relative(BASE_PATH, error.filePath),
+            error: error.error.message
+        };
+    });
+}

package/build/esm/editor/http/admin/editor/editor.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/editor/http/admin/editor/editor.js

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

package/build/esm/editor/http/admin/editor/index.api.d.ts

@@ -0,0 +1,3 @@
+import { APIRoute } from "@miqro/core";
+declare const _default: APIRoute;
+export default _default;

package/build/esm/editor/http/admin/editor/index.api.js

@@ -0,0 +1,22 @@
+import JSX from "@miqro/jsx";
+import { scanDir } from "./api/fs/scan.api.js";
+import { HTMLEncode } from "../../../common/html-encode.js";
+export default {
+    description: "ADMIN EDITOR GUI",
+    path: "/",
+    method: "GET",
+    handler: async (req, res) => {
+        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(JSX.createElement("html", null,
+            JSX.createElement("head", null,
+                JSX.createElement("link", { rel: "stylesheet", href: "/admin/editor/style.css" })),
+            JSX.createElement("body", null,
+                JSX.createElement("script", { type: "module", src: "/admin/editor/editor.js" }),
+                JSX.createElement("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))}` },
+                    JSX.createElement("noscript", null, "Enable JavaScript"))))));
+    }
+};

package/build/esm/editor/server.d.ts

@@ -0,0 +1,3 @@
+import { ServerConfig } from "../src/types.js";
+declare const _default: ServerConfig;
+export default _default;

package/build/esm/editor/server.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "node:crypto";
+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 { getEditorAdmin } from "./common/admin-interface.js";
+const ADMIN_EDITOR_BROWSER_OPEN_KEY = "ADMIN_EDITOR_BROWSER_OPEN_KEY$$";
+export default {
+    preload: (serverInterface, adminInterface) => {
+        //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, adminInterface) => {
+        //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);
+                }
+            }
+        }
+    }
+};

package/build/esm/editor/ws.d.ts

@@ -0,0 +1,3 @@
+import { WSConfig } from "../src/types.js";
+declare const _default: WSConfig;
+export default _default;

package/build/esm/editor/ws.js

@@ -0,0 +1,11 @@
+import { LOG_SOCKET_PATH } from "./common/constants.js";
+export default {
+    path: LOG_SOCKET_PATH,
+    validate(req) {
+        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;
+    },
+};

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>`)
+  }
+}