miqro 6.1.1 → 6.1.3

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,149 @@
+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: [server.middleware.json()],
+    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,38 @@
+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"
+        });
+    }
+};
+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,45 @@
+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: [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, 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,7 @@
+//import "../../../../.types/browser.globals";
+import { Editor } from "../../../components/editor.js";
+window.addEventListener("load", async (event) => {
+    jsx.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,21 @@
+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/build/esm/src/bin/compile.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Arguments } from "../common/arguments.js";
+export declare function compileSH(args: Arguments): Promise<void>;

package/build/esm/src/bin/compile.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { EXIT_CODES } from "../common/constants.js";
+export async function compileSH(args) {
+    return new Promise((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);
+        }
+    });
+}

package/build/esm/src/bin/doc-md.d.ts

@@ -0,0 +1,17 @@
+import { Logger, ParserMode, RouterJSONDoc, SchemaProperties } from "@miqro/core";
+export declare function getMDDoc(args: {
+    ignore?: string[];
+    showFilePath?: boolean;
+    jsonDoc: RouterJSONDoc;
+}, logger?: Logger): Promise<string>;
+export declare function parserToString(parser: {
+    status?: number | number[];
+    headers?: string | SchemaProperties | SchemaProperties[];
+    headersMode?: ParserMode;
+    query?: string | SchemaProperties | boolean | SchemaProperties[];
+    queryMode?: ParserMode;
+    params?: string | SchemaProperties | boolean | SchemaProperties[];
+    paramsMode?: ParserMode;
+    body?: string | SchemaProperties | boolean | SchemaProperties[];
+    bodyMode?: ParserMode;
+}): string;