miqro 7.0.1 → 7.0.3

package/src/inflate/setup-log.ts

@@ -0,0 +1,45 @@
+import { Logger } from "@miqro/core";
+import { importLogConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getLogConfigPath } from "../common/paths.js";
+import { dirname, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { LogConfig } from "../types.js";
+
+export interface LogConfigMap {
+  [service: string]: LogConfig | undefined;
+}
+
+export async function setupLogConfig(logger: Logger, servicePath: string, service: string, logConfigMap: LogConfigMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+  const logPath = getLogConfigPath(servicePath); // resolve(process.cwd(), service, "server.ts");
+  if (logPath) {
+    try {
+      //logger.debug("setting up server config from [%s]", join(service, basename(serverPath)));
+
+      const logConfig = await importLogConfigModule(logPath, logger);
+      logConfigMap[service] = logConfig;
+
+      if (inflateDir) {
+        const inflatePath = resolve(inflateDir, service, "log.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(logPath, {
+          // embemedJSX: false,
+          minify: false,
+          useExport: true,
+          platform: "node",
+          logger
+        }));
+      }
+    } catch (e) {
+      errors.push({
+        filePath: logPath,
+        error: e
+      });
+      logger.error("error with " + logPath);
+      logger.error(e);
+    }
+  }
+}

package/src/inflate/setup-middleware.ts

@@ -0,0 +1,47 @@
+import { Logger, Router } from "@miqro/core";
+import { importMiddlewareConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getMiddlewareConfigPath } from "../common/paths.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { MiddlewareConfig } from "../types.js";
+
+export async function setupMiddleware(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<MiddlewareConfig | null> {
+  const middlewarePath = getMiddlewareConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+
+  if (middlewarePath) {
+    try {
+      const middewareModule = await importMiddlewareConfigModule(middlewarePath, logger);
+      logger.debug("setting up middleware from [%s]", join(service, basename(middlewarePath)));
+      if (middewareModule && middewareModule.middleware) {
+        for (const m of middewareModule.middleware) {
+          mainRouter.use(m);
+        }
+      }
+      if (inflateDir && inflateSea) {
+        const inflatePath = resolve(inflateDir, service, "middleware.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(middlewarePath, {
+          // embemedJSX: false,
+          minify: false,
+          platform: "node",
+          useExport: true,
+          logger
+        }));
+      }
+      return middewareModule;
+
+    } catch (e) {
+      errors.push({
+        filePath: middlewarePath,
+        error: e
+      });
+      logger.error("error with " + middlewarePath);
+      logger.error(e);
+    }
+  }
+  return null;
+}

package/src/inflate/setup-server-config.ts

@@ -0,0 +1,48 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { Logger } from "@miqro/core";
+import { dirname, relative, resolve } from "node:path";
+import { cwd } from "node:process";
+
+import { importServerConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getServerConfigPath } from "../common/paths.js";
+import { ServerConfig } from "../types.js";
+
+export interface ServerConfigMap {
+  [service: string]: ServerConfig | undefined;
+}
+
+export async function setupServerConfig(logger: Logger, servicePath: string, service: string, serverConfigMap: ServerConfigMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+
+  const serverPath = getServerConfigPath(servicePath); // resolve(process.cwd(), service, "server.ts");
+  if (serverPath) {
+    try {
+      //logger.debug("setting up server config from [%s]", join(service, basename(serverPath)));
+      
+      const serverConfig = await importServerConfigModule(serverPath, logger);
+      serverConfigMap[service] = serverConfig;
+
+
+      if (inflateDir) {
+        const inflatePath = resolve(inflateDir, service, "server.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(serverPath, {
+          // embemedJSX: false,
+          minify: false,
+          platform: "node",
+          useExport: true,
+          logger
+        }));
+      }
+    } catch (e) {
+      errors.push({
+        filePath: serverPath,
+        error: e
+      });
+      logger.error("error with " + serverPath);
+      logger.error(e);
+    }
+  }
+}

package/src/inflate/setup-test.ts

@@ -0,0 +1,23 @@
+import { importJSXFile } from "../common/jsx.js";
+import { Logger } from "@miqro/core";
+import { scanFiles } from "./setup-http.js";
+import { resolve } from "node:path";
+
+export async function setupTests(logger: Logger, servicePath: string) {
+  logger.debug("setting up tests from [%s]", servicePath);
+  const files = scanFiles(resolve(servicePath));
+  await Promise.allSettled(files.map((file) => {
+    switch (file.ext) {
+      case ".jsx":
+      case ".js":
+      case ".ts":
+      case ".tsx": {
+        switch (file.subExt) {
+          case ".test":
+            return importJSXFile(file.filePath, logger);
+        }
+      }
+    }
+    return Promise.resolve();
+  }));
+}

package/src/inflate/setup-ws.ts

@@ -0,0 +1,50 @@
+import { Logger } from "@miqro/core";
+import { dirname, join, relative, resolve } from "node:path";
+import { cwd } from "node:process";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+import { importWSConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getWSConfigPath } from "../common/paths.js";
+import { WSConfig } from "../types.js";
+
+export async function inflateWSConfig(logger: Logger, servicePath: string, service: string, wsConfigList: WSConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]): Promise<void> {
+  const wsPath = getWSConfigPath(servicePath); // resolve(process.cwd(), service, "ws.ts");
+
+  if (wsPath) {
+    try {
+      logger.debug("importing websocket socket for service [%s]", service);
+      const wsConfig = await importWSConfigModule(wsPath, logger);
+      if (wsConfig && wsConfigList.filter(c => c.path === wsConfig.path).length > 0) {
+        throw new Error(`ws path [${wsConfig.path}] already defined! from [${wsPath}]`);
+      } else if (wsConfigList) {
+        logger.debug("importing websocket on path [%s] from [%s]", wsConfig.path, join(service, "ws.ts"));
+        wsConfigList.push(wsConfig);
+        //wsMap[wsConfig.path] = { name: service, options: wsConfig };
+      }
+
+      if (inflateDir) {
+        const inflatePath = resolve(inflateDir, service, "ws.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(wsPath, {
+          // embemedJSX: false,
+          minify: false,
+          platform: "node",
+          useExport: true,
+          logger
+        }));
+      }
+      //return wsConfigList;
+    } catch (e) {
+      errors.push({
+        filePath: wsPath,
+        error: e
+      });
+      logger.error("error with " + wsPath);
+      logger.error(e);
+      //return false;
+    }
+  }
+}

package/src/inflate/setup.doc.ts

@@ -0,0 +1,92 @@
+import { Logger, Router } from "@miqro/core";
+import { importDocConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getDocConfigPath } from "../common/paths.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { getDocOutput } from "../bin/generate-doc.js";
+import { RouteFileMap, StaticFileMap } from "./setup-http.js";
+import { CONTENT_TYPE_MAP } from "../common/content-type.js";
+
+export async function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, staticFileMap: StaticFileMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+  const docPath = getDocConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+
+  if (docPath) {
+    try {
+      const docModule = await importDocConfigModule(docPath, logger);
+      logger.debug("setting up error handling from [%s]", join(service, basename(docPath)));
+      if (docModule && docModule.publish) {
+        const paths = Object.keys(docModule.publish);
+        for (const path of paths) {
+          const config = docModule.publish[path];
+
+          const contentType = config.type === "MD" ? CONTENT_TYPE_MAP[".md"] :
+            config.type === "JSON" ? CONTENT_TYPE_MAP[".json"] : CONTENT_TYPE_MAP[".html"];
+
+          const body = await getDocOutput(mainRouter, fileMap, config.all, config.type);
+          mainRouter.get(path, async (_, res) => {
+            switch (config.type) {
+              case "MD": {
+                return await res.asyncEnd({
+                  headers: {
+                    "content-type": contentType
+                  },
+                  status: 200,
+                  body
+                });
+              }
+              case "JSON": {
+                return await res.json(body);
+              }
+              case "HTML": {
+                return await res.html(body);
+              }
+              default:
+                return true;
+            }
+          });
+
+          if (inflateDir) {
+            const inflatePath = join(inflateDir, service, "static", path);
+            mkdirSync(dirname(inflatePath), {
+              recursive: true
+            });
+            logger.log("writing [%s]", relative(cwd(), inflatePath));
+            writeFileSync(inflatePath, body);
+
+            fileMap[docPath + path] = {
+              routes: [{
+                method: "GET",
+                path
+              }],
+              service,
+              filePath: docPath,
+              previewMethod: "html"
+            };
+
+            if (staticFileMap) {
+              staticFileMap[docPath + path] = {
+                contentType,
+                filePath: docPath,
+                previewMethod: "html",
+                method: "GET",
+                path,
+                body: Buffer.from(body),
+                inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+              }
+            }
+          }
+        }
+      }
+
+    } catch (e) {
+      errors.push({
+        filePath: docPath,
+        error: e
+      });
+      logger.error("error with " + docPath);
+      logger.error(e);
+    }
+  }
+  return null;
+}

package/src/inflate/utils/sea-utils.ts

@@ -0,0 +1,14 @@
+import { Router } from "@miqro/core";
+import { describeFilePath } from "../../common/fs.js";
+import { getRoutes } from "../../services/utils/get-route.js";
+// import { assertGlobalTampered } from "../../services/globals.js";
+import { dirname, join, relative } from "node:path";
+
+export async function appendAPIModule(router: Router, dir: string, filePath: string, module: any) {
+  const file = describeFilePath(filePath);
+  const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName, module);
+  for (const r of routes) {
+    // router.use(assertGlobalTampered);
+    router.use(module.handler, r.path, r.method as any, r.options);
+  }
+}

package/src/lib.ts

@@ -0,0 +1,34 @@
+import { Component, enableDebugLog, Fragment, Props, createElement as realCreateElement } from "@miqro/jsx";
+import { jsx2HTML } from "./common/jsx.js";
+
+/*export * from "@miqro/core";
+export * from "@miqro/query";*/
+export * from "./types.js";
+
+export { ClusterWebSocketServer2 } from "./services/utils/cluster-ws.js";
+export { ClusterCache } from "./services/utils/cluster-cache.js";
+export { LocalCache } from "./services/utils/cache.js";
+export { WebSocketManager, WebSocketManagerOptions } from "./services/utils/websocketmanager.js";
+export { DBManager } from "./services/utils/db-manager.js";
+export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
+export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
+// export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+export { jsx2HTML } from "./common/jsx.js";
+
+//exported for --inflate-sea
+export { appendAPIModule } from "./inflate/utils/sea-utils.js";
+export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
+export { App, LoggerHandler, Router } from "@miqro/core";
+export { migration } from "@miqro/query";
+export { middleware } from "./services/utils/middleware.js";
+export { jwt } from "./services/utils/jwt.js";
+export const JSX = {
+  createElement: (...args: [tag: string | Component | typeof Fragment, attributes: Props | null | undefined, ...children: Array<any>]) => {
+    const ret = realCreateElement(...args);
+    ret.toString = () => jsx2HTML(ret)
+    return ret;
+  },
+  Fragment,
+  enableDebugLog
+}
+export * as jsx from "@miqro/jsx";

package/src/main.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { Arguments, parseArguments } from "./common/arguments.js";
+import { EXIT_CODES } from "./common/constants.js";
+import { testMain } from "./bin/test.js";
+import { compileSH } from "./bin/compile.js";
+import { installTypings } from "./bin/types.js";
+import { generateDocs } from "./bin/generate-doc.js";
+import { Miqro } from "./services/app.js";
+import { TEST_SOCKET } from "./common/paths.js";
+import { Logger } from "@miqro/core";
+
+async function main(args: Arguments) {
+  if (args.install || args.installTSConfig || args.installMiqroJSON) {
+    await installTypings(args, new Logger(""));
+    process.exit(EXIT_CODES.NORMAL_EXIT);
+  } else {
+    const app = new Miqro({
+      editor: args.editor,
+      name: args.name ? args.name : undefined,
+      port: args.test ? TEST_SOCKET : args.port,
+      services: args.services,
+      browser: args.browser,
+      logFile: args.logFile,
+      hotreload: args.test ? false : args.hotreload,
+      watch: args.test ? false : args.watch,
+      https: args.test ? false : args.https,
+      serverOptions: args.serverOptions,
+      httpRedirect: args.test ? undefined : args.httpsRedirect
+    });
+    // check arguments
+    if (args.generateDoc) {
+      // --generate-doc
+      const inflated = await app.inflate({
+        inflateParallel: args.inflateParallel
+      });
+      await generateDocs(args, app.logger, inflated);
+      process.exit(EXIT_CODES.NORMAL_EXIT);
+    } else if (args.migrateUp || args.migrateDown) {
+      // --migration-up and --migradtion-down
+      await app.migrate({
+        direction: args.migrateUp ? "up" : "down"
+      });
+      await app.dbManager.closeAll();
+      await app.dbManager.deleteAll();
+      await app.webSocketManager.disconnectAll();
+      process.exit(EXIT_CODES.NORMAL_EXIT);
+    } else if (args.test) {
+      // --test
+      await app.inflate({
+        inflateParallel: args.inflateParallel
+      });
+      await app.start();
+      await testMain(app);
+      await app.stop();
+      await app.dbManager.closeAll();
+      await app.webSocketManager.disconnectAll();
+      process.exit(EXIT_CODES.NORMAL_EXIT);
+    } else if (args.compile) {
+      // --compile
+      await app.inflate({
+        inflateDir: args.inflateDir,
+        inflateSea: true,
+        inflateParallel: args.inflateParallel
+      });
+      await app.dbManager.closeAll();
+      await app.webSocketManager.disconnectAll();
+      await compileSH(args);
+      process.exit(EXIT_CODES.NORMAL_EXIT);
+    } else if (args.inflate) {
+      // --inflate and --inflate-sea
+      // loadApp with inflateDir arg to inflate inflatable files
+      await app.inflate({
+        inflateDir: args.inflateDir,
+        inflateSea: args.inflateSEA,
+        inflateParallel: args.inflateParallel
+      });
+      await app.dbManager.closeAll();
+      await app.webSocketManager.disconnectAll();
+      process.exit(EXIT_CODES.NORMAL_EXIT);
+    } else {
+      // server
+      await app.inflate({
+        inflateParallel: args.inflateParallel
+      });
+      await app.start();
+    }
+  }
+}
+
+try {
+  // parse args
+  main(parseArguments()).catch(e => {
+    console.error(e);
+    process.exit(EXIT_CODES.ABNORMAL);
+  });
+} catch (e) {
+  console.error(e);
+  console.error(e.message);
+  process.exit(EXIT_CODES.ABNORMAL);
+}