miqro 7.0.1 → 7.0.3

package/src/bin/doc-md.ts

@@ -0,0 +1,210 @@
+import { GroupPolicy, Logger, ParserMode, RouteJSONDoc, RouterJSONDoc, SchemaProperties } from "@miqro/core";
+import { Schema } from "@miqro/parser";
+
+/*interface SchemaProperties {
+  [key: string]: Schema | string;
+}
+
+type ParserMode = "add_extra" | "no_extra" | "remove_extra"*/
+
+export async function getMDDoc(args: { ignore?: string[], showFilePath?: boolean; jsonDoc: RouterJSONDoc }, logger?: Logger) {
+
+  const pathList = Object.keys(args.jsonDoc).sort();
+
+  let outMD = "";
+
+  const tableIndexItems = [];
+
+  for (const path of pathList) {
+    const pathData = args.jsonDoc[path];
+    const methods = Object.keys(pathData);
+    for (const method of methods) {
+      if (method) {
+        const apiDataList: RouteJSONDoc[] = pathData[method];
+        for (const apiData of apiDataList) {
+          tableIndexItems.push({
+            apiData
+          });
+          outMD += `## ${apiData.identifier/*.replaceAll("_", "-")*/}\n\n`;
+          outMD += `${args.showFilePath && (apiData as any).___filePath ? (apiData as any).___filePath + "\n\n" : ""}`;
+
+          if (apiData.name) {
+            outMD += `${apiData.name}\n\n`;
+          }
+          if (apiData.description) {
+            outMD += `${apiData.description}\n\n`;
+          }
+          outMD += `[${method}] ${path}\n\n`;
+
+          outMD += `[${path}](${path}) \n\n`;
+
+          if (apiData.policy) {
+            outMD += `### policy\n\n`;
+            outMD += policyToString(apiData.policy);
+          }
+          if (apiData.request) {
+            const requestOutMD = parserToString(apiData.request);
+            outMD += requestOutMD !== "" ? `### request\n\n${requestOutMD}` : "";
+          }
+          if (apiData.response && typeof apiData.response !== "boolean") {
+            const responseOutMD = parserToString(apiData.response);
+            outMD += responseOutMD !== "" ? `### response\n\n${responseOutMD}` : "";
+          }
+        }
+      }
+    }
+  }
+
+  const indexTable = getIndexTable(tableIndexItems);
+
+  return `${indexTable}\n\n${outMD}`;
+}
+
+function getIndexTable(data: {
+  apiData: RouteJSONDoc;
+}[]): string {
+  return `${data.map(api => `[${api.apiData.identifier/*.replaceAll("_", "-")*/}](#${api.apiData.identifier/*.replaceAll("_", "-")*/.toLocaleLowerCase()})${api.apiData.name || api.apiData.description ? `\n\n\t${api.apiData.name ? api.apiData.name + " " : ""}${api.apiData.description ? api.apiData.description : ""}` : ""}`).join("\n\n")}`;
+}
+
+function policyToString(policy: GroupPolicy): string {
+  let outMD = "| groups | policy |\n";
+  outMD += "|--------|--------|\n";
+  outMD += `| ${(policy.groups instanceof Array ? policy.groups : [policy.groups]).join(",")} | ${policy.groupPolicy} |\n\n`;
+  return outMD;
+}
+
+export 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 {
+  let outMD = "";
+  if (parser.status) {
+    outMD += `#### status\n\n${parser.status instanceof Array ? parser.status.join(",") : parser.status}\n\n`;
+  }
+  if (parser.params && typeof parser.params !== "boolean") {
+    outMD += `#### path params\n\n`;
+    outMD += parserPartToString(parser.params, parser.paramsMode);
+  }
+  if (parser.headers) {
+    outMD += `#### headers\n\n`;
+    outMD += parserPartToString(parser.headers, parser.headersMode);
+  }
+  if (parser.query && parser.query !== true) {
+    outMD += `#### query\n\n`;
+    outMD += parserPartToString(parser.query, parser.queryMode);
+  }
+  if (parser.body && parser.body !== true) {
+    outMD += `#### body\n\n`;
+    outMD += parserPartToString(parser.body, parser.bodyMode);
+  }
+  return outMD;
+}
+
+function parserPartToString(arg: string | SchemaProperties | false | SchemaProperties[], mode?: ParserMode): string {
+  if (arg === false) {
+    return "not allowed";
+  }
+  let outMD = "";
+  let maxTabulation = 1;
+  const parsers: Array<SchemaProperties | string> | string = arg instanceof Array ? arg : typeof arg === "string" ? [arg] : [arg];
+  for (const parser of parsers) {
+    const ret = internalParserToString(parser);
+    if (ret.maxTabulation > maxTabulation) {
+      maxTabulation = ret.maxTabulation;
+    }
+    outMD += `| | | | ${getTabulation(ret.maxTabulation * 2)}\n`;
+    outMD += `|--------|-------|-------|${getTabulation(ret.maxTabulation * 2, true)}\n`;
+    outMD += `${ret.out}\n\n`;
+  }
+  return outMD
+}
+
+function internalParserToString(parser: string | SchemaProperties, tabulation = 1): { out: string, maxTabulation: number } {
+  let outMD = "";
+  let maxTabulation = tabulation;
+  if (typeof parser === "string") {
+    outMD += `${getTabulation(tabulation)}${parser}|\n`;
+  } else {
+    const attrNames = Object.keys(parser);
+    for (const name of attrNames) {
+      const p = parser[name];
+      const description = typeof p === "string" ? "" : p.description ? p.description : "";
+
+      if (typeof p === "string") {
+        outMD += `${getTabulation(tabulation)}${name} | ${p}|\n`;
+      } else if (p.type.toLocaleLowerCase() === "object" || p.type.toLocaleLowerCase() === "object?") {
+        const rString = p.required === false || p.type.toLocaleLowerCase() === "object?" ? "?" : "";
+        outMD += `${getTabulation(tabulation)}${name} | object${rString}| ${description}|\n`;
+        const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+        if (maxTabulation < ret.maxTabulation) {
+          maxTabulation = ret.maxTabulation;
+        }
+        outMD += `${ret.out}`;
+      } else if (p.type.toLocaleLowerCase() === "dict" || p.type.toLocaleLowerCase() === "dict?") {
+        const rString = p.required === false || p.type.toLocaleLowerCase() === "dict?" ? "?" : "";
+        outMD += `${getTabulation(tabulation)}${name} | Dict\\<${p.dictType}\>${rString}| ${description}|\n`;
+        if (p.dictType === "object") {
+          const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+          if (maxTabulation < ret.maxTabulation) {
+            maxTabulation = ret.maxTabulation;
+          }
+          outMD += `${ret.out}`;
+        }
+      } else if (p.type.toLocaleLowerCase() === "array" || p.type.toLocaleLowerCase() === "array?") {
+        const rString = p.required === false || p.type.toLocaleLowerCase() === "array?" ? "?" : "";
+        outMD += `${getTabulation(tabulation)}${name} | Array\\<${p.arrayType}\>${rString}| ${description}|\n`;
+        if (p.arrayType.toLocaleLowerCase() === "object") {
+          const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+          if (maxTabulation < ret.maxTabulation) {
+            maxTabulation = ret.maxTabulation;
+          }
+          outMD += `${ret.out}`;
+        }
+      } else if (p.type.toLocaleLowerCase() === "regex") {
+        outMD += `${getTabulation(tabulation)}${name} | ${p.regex}| ${description}|\n`;
+      } else if (p.type.toLocaleLowerCase() === "regex?") {
+        outMD += `${getTabulation(tabulation)}${name} | ${p.regex}?| ${description}|\n`;
+      } else if (p.type.toLocaleLowerCase() === "enum") {
+        outMD += `${getTabulation(tabulation)}${name} | ${p.type}| ${description}|\n`;
+        outMD += `${getTabulation(tabulation + 1)}| ${p.enumValues?.join(",")}|\n`;
+        if (maxTabulation < tabulation + 1) {
+          maxTabulation = tabulation + 1;
+        }
+      } else if (p.type.toLocaleLowerCase() === "enum?") {
+        outMD += `${getTabulation(tabulation)}${name} | ${p.type}?| ${description}|\n`;
+        outMD += `${getTabulation(tabulation + 1)}| ${p.enumValues?.join(",")}|\n`;
+        if (maxTabulation < tabulation + 1) {
+          maxTabulation = tabulation + 1;
+        }
+      } else {
+        const rString = p.required === false ? "?" : "";
+        outMD += `${getTabulation(tabulation)}${name} | ${p.type}${rString}| ${description}|\n`;
+      }
+    }
+  }
+  return {
+    out: outMD,
+    maxTabulation
+  };
+}
+
+function parserBaseObjectTypeToString(arg: Schema, tabulation: number): { out: string; maxTabulation: number } {
+  const options: SchemaProperties = arg.properties ? arg.properties : {};
+  //const outMD = `${getTabulation(tabulation)}name | type |\n${getTabulation(tabulation)}--------|--------|\n`;
+  return internalParserToString(options, tabulation + 1);
+}
+
+function getTabulation(n: number, header = false) {
+  let out = "";
+  for (let i = 0; i < n; i++) {
+    out += header ? "-|" : "| ";
+  }
+  return out;
+}

package/src/bin/generate-doc.ts

@@ -0,0 +1,64 @@
+import { Logger, Router } from "@miqro/core";
+import { Arguments } from "../common/arguments.js";
+import { writeFileSync } from "node:fs";
+import { getMDDoc } from "./doc-md.js";
+import { EXIT_CODES } from "../common/constants.js";
+import { InflatedResult } from "../services/app.js";
+import { RouteFileMap } from "../inflate/setup-http.js";
+import { inflateMD2HTML, inflateMDString2HTML } from "../inflate/md.js";
+
+export async function generateDocs(args: Arguments, logger: Logger, result: InflatedResult) {
+  logger.info("writing [%s]", args.generateDocOut);
+  writeFileSync(args.generateDocOut, await getDocOutput(result.router, result.fileMap, args.generateDocAll, args.generateDocType));
+}
+
+export async function getDocOutput(router: Router, fileMap: RouteFileMap, generateDocAll: boolean, generateDocType: "MD" | "JSON" | "HTML") {
+  /*
+    ** TODO FIX THIS MESS
+    */
+
+  const fileMapAPIRouteList = Object.keys(fileMap).map(f => fileMap[f]).filter(fMap => fMap.previewMethod === "api").map(fMap => fMap.routes);
+
+  const jsonDoc = router.getJSONDoc();
+
+  if (!generateDocAll) {
+    Object.keys(jsonDoc).forEach(path => {
+      const methods = Object.keys(jsonDoc[path]);
+      methods.forEach(method => {
+        const data = jsonDoc[path][method];
+        //console.log("[%s] [%s]", path, method);
+
+        if (fileMapAPIRouteList.filter(f => {
+          for (const r of f) {
+            if (r.method === String(method).toUpperCase() && r.path === path) {
+              return true;
+            }
+          }
+          return false;
+        }).length === 0) {
+          //console.log("DELETE [%s] [%s]", path, method);
+          delete jsonDoc[path][method];
+        } else {
+          //console.log("KEEP [%s] [%s]", path, method);
+        }
+
+      });
+    });
+  }
+
+  switch (generateDocType) {
+    case "JSON":
+      return JSON.stringify(jsonDoc, undefined, 2);
+      break;
+    case "MD":
+      return await getMDDoc({ showFilePath: true, jsonDoc });
+      break;
+    case "HTML":
+      const md = await getMDDoc({ showFilePath: true, jsonDoc });
+      const html = inflateMDString2HTML(md);
+      return html;
+      break;
+    default:
+      process.exit(EXIT_CODES.BAD_ARGUMENTS);
+  }
+}

package/src/bin/test.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { RequestOptions, request as reqlRequest } from "@miqro/request";
+import { resetGlobals, runTests } from "@miqro/test/dist/runner/common.js";
+import { getServicePath, TEST_SOCKET } from "../common/paths.js";
+import { createNodeRuntime } from "@miqro/jsx-node";
+import { RuntimeOptions, RuntimeShadowRootInit, RuntimeURL } from "@miqro/jsx";
+import { EXIT_CODES } from "../common/constants.js";
+import { Miqro } from "../services/app.js";
+import { setupTests } from "../inflate/setup-test.js";
+
+export async function testMain(app: Miqro) {
+  const startMS = Date.now();
+  //resetTests();
+  resetGlobals();
+  //const testLogger = getLogger("test");
+  globalThis.test = {
+    PORT: TEST_SOCKET,
+    request: (request: RequestOptions) => reqlRequest({
+      ...request,
+      socketPath: TEST_SOCKET
+    }),
+    logger: app.logger,
+    sleep: async (ms: number) => new Promise(resolve => setTimeout(resolve, ms)),
+    jsx: {
+      createRuntime: createNodeRuntime,
+      test: (cb, args: {
+        runtimeOptions?: {
+          basePath?: string | null;
+          url?: RuntimeURL;
+          logger?: {
+            log: Function;
+            error: Function;
+          };
+        },
+        containerOptions?: {
+          runtimeOptions?: RuntimeOptions;
+          shadowInit?: boolean | RuntimeShadowRootInit;
+        };
+      }) => {
+        return async () => {
+          const runtime = createNodeRuntime(args.runtimeOptions);
+          const root = runtime.createElement("root");
+          const container = runtime.createContainer(root, args.containerOptions);
+          await cb(container, root, runtime);
+          container.disconnect();
+        }
+      }
+    }
+  }
+
+  for (const service of app.options.services) {
+    const servicePath = getServicePath(service);
+    await setupTests(app.logger, servicePath);
+  }
+
+  console.log("");
+  app.logger.log("===starting tests===");
+  console.log("");
+
+  const ret = await runTests(undefined, app.logger);
+
+  console.log("");
+  app.logger.log("===tests ended===");
+  if (ret.failed.length > 0) {
+    console.log("");
+    app.logger.error("===failed tests===");
+    console.log("");
+  }
+
+  const took = Date.now() - startMS;
+  ret.failed.forEach(e => {
+    app.logger.error("\x1b[31m%s\x1b[0m", e.fullName);
+    app.logger.error(e.error);
+  });
+
+
+  console.log("");
+  app.logger.log(ret.passed + " tests passed");
+  if (ret.failed.length > 0) {
+    app.logger.error(ret.failed.length + " failed");
+  } else {
+    app.logger.log(ret.failed.length + " failed");
+  }
+
+  app.logger.log("took " + took + "ms");
+
+  if (ret.failed.length > 0) {
+    process.exit(EXIT_CODES.TEST_FAILED);
+  }
+  await app.dbManager.closeAll();
+}

package/src/bin/types.ts

@@ -0,0 +1,34 @@
+import { MinimalLogger } from "@miqro/core";
+import { Arguments } from "../common/arguments.js";
+// import { initTypes } from "../common/assets.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { TEMPLATES } from "../../editor/common/templates.js";
+import { EXIT_CODES } from "../common/constants.js";
+import { installAsset } from "../common/assets.js";
+
+export async function installTypings(args: Arguments, logger: MinimalLogger) {
+  /*if (args.installTypes) {
+    logger.debug("writing types");
+    // install typing for typescript only if argument --install-types is set
+    await initTypes(logger);
+  }*/
+  if (args.install) {
+    logger.debug("writing node_modules");
+    await installAsset(logger, ["node_modules/"]);
+  }
+  if (args.installTSConfig && !existsSync("tsconfig.json")) {
+    logger.info("writing tsconfig.json");
+    writeFileSync("tsconfig.json", TEMPLATES["TSCONFIGJSON"].template("", ""));
+  } else if (args.installTSConfig) {
+    logger.error("tsconfig.json already exists!");
+    process.exit(EXIT_CODES.ABNORMAL);
+  }
+  if (args.installMiqroJSON && !existsSync("miqro.json")) {
+    logger.info("writing miqro.json");
+    writeFileSync("miqro.json", TEMPLATES["MIQROJSON"].template("", ""));
+  } else if (args.installMiqroJSON) {
+    logger.error("miqro.json already exists!");
+    process.exit(EXIT_CODES.ABNORMAL);
+  }
+  process.exit(EXIT_CODES.NORMAL_EXIT);
+}

package/src/cluster.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { mainPath } from "@miqro/runner";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { parseArguments } from "./common/arguments.js";
+import { checkEnvVariable } from "@miqro/core";
+import { cpus } from "node:os";
+
+const __package_dirname = import.meta.url ? resolve(dirname(fileURLToPath(import.meta.url))) : null;
+
+//const usage = "CLUSTER_COUNT=os.cpus().length [CLUSTER_AUTO_BROADCAST=true|false] [CLUSTER_DISABLE_RESTART=true|false]";
+
+const CLUSTER_COUNT = checkEnvVariable("CLUSTER_COUNT", String(cpus().length));
+
+const args = parseArguments();
+
+if (args.inflate || args.test || args.compile || args.installTSConfig/* || args.installTypes */ || args.migrateDown || args.migrateUp) {
+  await import("./main.js");
+} else {
+  const CMD = `CLUSTER_COUNT=${CLUSTER_COUNT} CLUSTER_AUTO_BROADCAST=true ${process.argv[0]} ${mainPath()} ${resolve(__package_dirname, "main.js")} ${process.argv.slice(2).join(" ")}`;
+
+  console.log(CMD);
+
+  execSync(CMD, { stdio: 'inherit' });
+}