miqro 6.0.14 → 6.1.1

package/src/inflate/setup-http.ts

@@ -1,643 +0,0 @@
-import { Router, newURL, Response, Request, RouterHandlerOptions, Logger, APIRoute, normalizePath } from "@miqro/core";
-import { existsSync, mkdirSync, readFile, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve as pathResolve } from "node:path";
-
-import { CONTENT_TYPE_MAP, DEFAULT_CONTENT_TYPE } from "../common/content-type.js";
-import { InflateError, importHTMLModule, importAPIRoute, inflateJSX, importJSONModule, JSONModuleValue, jsx2HTML } from "../common/jsx.js";
-import { createNodeRuntime } from "@miqro/jsx-node";
-import { getHotReloadScript } from "../services/hot-reload.js";
-import { RuntimeURL } from "@miqro/jsx";
-import { cwd } from "node:process";
-import { assertGlobalTampered } from "../services/globals.js";
-import { getHTTPRouterPath, getStaticFilesPath } from "../common/paths.js";
-import { setupCORS } from "./setup-cors.js";
-import { setupAUTH } from "./setup-auth.js";
-import { getRoutes } from "../services/utils/get-route.js";
-import { describeFilePath } from "../common/fs.js";
-import { inflateMD2HTML } from "./md.js";
-import { ServerInterface, ServerRequest } from "../types.js";
-
-export interface RouteFileMap {
-  [filePath: string]: {
-    routes: {
-      path?: string;
-      method?: string;
-      options?: RouterHandlerOptions;
-      inflatePath?: string;
-    }[];
-    service: string;
-    previewMethod: "api" | "html" | null;
-  }
-}
-
-export interface StaticFileMap {
-  [filePathKey: string]: {
-    path: string;
-    filePath: string;
-    method: string | null;
-    inflatePath?: string;
-    contentType: string;
-    previewMethod: "html" | null;
-    body: Buffer;
-  }
-}
-
-export async function setupHTTPRouter(server: ServerInterface, logger: Logger, hotreload: boolean, servicePath: string, service: string, routeFileMap: RouteFileMap, staticFileMap: StaticFileMap | null, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]) {
-  const mainRouter = new Router();
-  const apiRouterPath = getHTTPRouterPath(servicePath); //resolve(process.cwd(), service, "http");
-  if (apiRouterPath) {
-
-    await setupCORS(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
-
-    await setupAUTH(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
-    logger.trace("setting up http routes from [%s]", service);
-    const { router: httpRouter } = await createRouterFromDirectory(server, hotreload, service, logger, apiRouterPath, errors, routeFileMap, staticFileMap, inflateDir, inflateSea);
-
-    mainRouter.use(httpRouter);
-  }
-
-  const staticFilesPath = getStaticFilesPath(servicePath); //resolve(process.cwd(), service, "static");
-  if (staticFilesPath) {
-    logger.trace("setting up static file routes from [%s]", service);
-    const staticRouter = createStaticRouterFromDirectory(service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap);
-    mainRouter.use(staticRouter);
-  }
-  return mainRouter;
-}
-
-function createStaticRoute(service: string, logger: Logger, router: Router, dir: string, file: ScannedFile, inflateDir?: string | undefined | false, routeFileMap?: RouteFileMap, staticFileMap?: StaticFileMap) {
-  logger.trace("creating static route for [%s]", file.filePath);
-  logger.trace("[%o]", {
-    file,
-    dir
-  });
-  const contentType = CONTENT_TYPE_MAP[String(file.ext).toLocaleLowerCase()];
-  const path = join("/", relative(dir, file.filePath));
-
-
-  routeFileMap[file.filePath] = {
-    routes: [{
-      method: "GET",
-      path: normalizePath(path)
-    }],
-    service,
-    previewMethod: "html"
-  };
-
-  if (inflateDir) {
-    const inflatePath = join(inflateDir, service, "static", path);
-    mkdirSync(dirname(inflatePath), {
-      recursive: true
-    });
-    logger.log("writing [%s]", relative(cwd(), inflatePath));
-    const body = readFileSync(file.filePath);
-    writeFileSync(inflatePath, body);
-    if (staticFileMap) {
-      staticFileMap[file.filePath] = {
-        contentType,
-        filePath: file.filePath,
-        previewMethod: "html",
-        method: "GET",
-        path: normalizePath(path),
-        body: Buffer.from(body),
-        inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
-      }
-    }
-  }
-
-
-
-  router.use(assertGlobalTampered);
-  router.get(path, async function (_req, res) {
-    await new Promise<void>((resolve, reject) => {
-      try {
-        readFile(file.filePath, async (err, body) => {
-          if (err) {
-            reject(err);
-          } else {
-            try {
-              await res.asyncEnd({
-                status: 200,
-                headers: {
-                  ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                },
-                body
-              });
-              resolve();
-            } catch (e) {
-              reject(e);
-            }
-          }
-        })
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}
-
-function createStaticRouterFromDirectory(service: string, logger: Logger, dir: string, inflateDir: string | false | undefined, routeFileMap: RouteFileMap | undefined, staticFileMap: StaticFileMap | null): Router {
-  const router = new Router();
-  scanFiles(dir).forEach(file => {
-    createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
-  });
-  return router;
-}
-
-async function createRouterFromDirectory(server: ServerInterface, hotreload: boolean, service: string, logger: Logger, dir: string, errors: InflateError[] = [], routeFileMap: RouteFileMap = {}, staticFileMap: StaticFileMap | null = null, inflateDir: string | undefined | false, inflateSea: boolean): Promise<{
-  router: Router;
-  errors: InflateError[];
-  routeFileMap: RouteFileMap;
-}> {
-  const router = new Router();
-  router.use(assertGlobalTampered);
-  await Promise.all(scanFiles(dir).map(file => new Promise<void>(async (resolve) => {
-    try {
-      switch (file.ext) {
-        case ".jsx":
-        case ".js":
-        case ".ts":
-        case ".tsx": {
-          switch (file.subExt) {
-            case ".test":
-              return resolve();
-            case ".ignore":
-              logger.warn("ignoring [%s]", file.filePath);
-              return resolve();
-            case ".api": {
-
-              const module = await importAPIRoute(file.filePath, logger);
-
-              const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName, module);
-
-              routeFileMap[file.filePath] = {
-                routes,
-                service,
-                previewMethod: "api"
-              };
-
-              const inflatedCode = inflateDir ? await inflateJSX(file.filePath, {
-                embemedJSX: false,
-                minify: false,
-                useExport: true,
-                logger
-              }) : "";
-
-              for (const r of routes) {
-
-                /*if (inflateDir && r.inflatePath) {
-                  const rPath = r.inflatePath;
-                  const inflatePath = join(inflateDir, service, "http", rPath + ".api.js");
-                  mkdirSync(dirname(inflatePath), {
-                    recursive: true
-                  });
-                  logger.log("writing [%s]", relative(cwd(), inflatePath));
-                  writeFileSync(inflatePath, inflatedCode);
-                }*/
-
-                if (inflateDir && r.defaultInflatePath && inflateSea) {
-                  const rPath = r.defaultInflatePath;
-                  const inflatePath = join(inflateDir, service, "http", rPath + ".api.js");
-                  mkdirSync(dirname(inflatePath), {
-                    recursive: true
-                  });
-                  logger.log("writing [%s]", relative(cwd(), inflatePath));
-                  writeFileSync(inflatePath, inflatedCode);
-                }
-
-
-                router.use(assertGlobalTampered);
-                router.use(module.handler, r.path, r.method as any, r.options);
-              }
-              return resolve();
-            }
-            case ".json": {
-              const module = await importJSONModule(file.filePath, logger);
-              const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName + ".json", module.apiOptions as Partial<APIRoute>);
-
-              routeFileMap[file.filePath] = {
-                routes,
-                service,
-                previewMethod: "html"
-              };
-
-              for (const r of routes) {
-
-                const contentType = CONTENT_TYPE_MAP[".json"] ? CONTENT_TYPE_MAP[".json"] : DEFAULT_CONTENT_TYPE;
-
-
-
-                if (inflateDir) {
-
-                  if (r.inflatePath) {
-                    //if (r.method === "GET" || r.method === "get") {
-                    const rPath = r.inflatePath;
-                    const inflatePath = join(inflateDir, service, "static", rPath);
-                    mkdirSync(dirname(inflatePath), {
-                      recursive: true
-                    });
-                    if (existsSync(inflatePath) && statSync(inflatePath).isDirectory()) {
-                      logger.trace("ignoring writing over directory [%s] for file [%s]", relative(cwd(), inflatePath), file.filePath);
-                      continue;
-                    }
-                    const JSON_STATIC = await getJSON({ server } as ServerRequest, null, newURL(r.path), module.apiOptions?.basePath, module.default);
-                    //const JSON = await getJSON({ server } as ServerRequest, null, newURL(r.path), module.apiOptions?.basePath, module.default);
-                    logger.log("writing [%s]", relative(cwd(), inflatePath));
-                    writeFileSync(inflatePath, JSON_STATIC);
-                    //}
-
-                    if (staticFileMap && inflateSea) {
-                      staticFileMap[file.filePath] = {
-                        contentType,
-                        filePath: file.filePath,
-                        method: r.method,
-                        previewMethod: "html",
-                        path: r.path,
-                        body: Buffer.from(JSON_STATIC),
-                        inflatePath: inflateDir ? join(inflateDir, service, "static", r.inflatePath) : undefined
-                      }
-                    }
-                  }
-                }
-
-                router.use(assertGlobalTampered);
-                router.use(async function (req: Request, res: Response) {
-
-                  const JSON = await getJSON(req, res, newURL(req.path), module.apiOptions?.basePath, module.default);
-
-                  return res.asyncEnd({
-                    status: 200,
-                    headers: {
-                      ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                    },
-                    body: JSON
-                  });
-                }, r.path, r.method as any, r.options)
-              }
-
-              return resolve();
-            }
-            case ".html": {
-
-              const module = await importHTMLModule(file.filePath, logger);
-
-              const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName + ".html", module.apiOptions as Partial<APIRoute>);
-
-              routeFileMap[file.filePath] = {
-                routes,
-                service,
-                previewMethod: "html"
-              };
-
-              for (const r of routes) {
-
-                const contentType = CONTENT_TYPE_MAP[".html"] ? CONTENT_TYPE_MAP[".html"] : DEFAULT_CONTENT_TYPE;
-
-                if (inflateDir) {
-
-                  if (r.inflatePath) {
-                    //if (r.method === "GET" || r.method === "get") {
-                    const rPath = r.inflatePath;
-                    const inflatePath = join(inflateDir, service, "static", rPath);
-                    mkdirSync(dirname(inflatePath), {
-                      recursive: true
-                    });
-                    if (existsSync(inflatePath) && statSync(inflatePath).isDirectory()) {
-                      logger.trace("ignoring writing over directory [%s] for file [%s]", relative(cwd(), inflatePath), file.filePath);
-                      continue;
-                    }
-                    const toRender = typeof module.default === "function" ? module.default({ server } as ServerRequest, null) : module.default;
-                    const HTML_STATIC = await getHTML(hotreload, { server } as ServerRequest, null, newURL(r.path), module.apiOptions?.basePath, await toRender);
-
-                    logger.log("writing [%s]", relative(cwd(), inflatePath));
-                    writeFileSync(inflatePath, HTML_STATIC);
-                    //}
-
-
-                    if (staticFileMap && inflateSea) {
-                      staticFileMap[file.filePath + r.method + r.path] = {
-                        filePath: file.filePath,
-                        contentType,
-                        method: r.method,
-                        previewMethod: "html",
-                        path: r.path,
-                        body: Buffer.from(HTML_STATIC),
-                        inflatePath: inflateDir ? join(inflateDir, service, "static", r.inflatePath) : undefined
-                      }
-                    }
-                  }
-                }
-
-                router.use(assertGlobalTampered);
-                router.use(async function (req: Request, res: Response) {
-                  const toRender = typeof module.default === "function" ? module.default(req, res) : module.default;
-                  const HTML = await getHTML(hotreload, req, res, newURL(req.path), module.apiOptions?.basePath, await toRender);
-
-                  return res.asyncEnd({
-                    status: 200,
-                    headers: {
-                      ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                    },
-                    body: HTML
-                  });
-                }, r.path, r.method as any, r.options)
-              }
-              return resolve();
-            }
-            case ".min":
-            case ".js":
-            default: {
-              // allow fall-through when extension is .js and .ts because is a static route without embemedJSX
-              if (file.ext !== ".js" && file.ext !== ".ts") {
-                const code = await inflateJSX(file.filePath, {
-                  embemedJSX: true,
-                  minify: file.subExt === ".min" ? true : false,
-                  useExport: false,
-                  logger
-                });
-                const contentType = CONTENT_TYPE_MAP[".js"];
-                const path = join("/", dirname(relative(dir, file.filePath)), file.name + ".js");
-
-                routeFileMap[file.filePath] = {
-                  routes: [{
-                    method: "GET",
-                    path
-                  }],
-                  service,
-                  previewMethod: "html"
-                };
-
-                if (inflateDir) {
-                  const inflatePath = join(inflateDir, service, "static", path);
-                  mkdirSync(dirname(inflatePath), {
-                    recursive: true
-                  });
-                  logger.log("writing [%s]", relative(cwd(), inflatePath));
-                  writeFileSync(inflatePath, code);
-
-
-                  if (staticFileMap && inflateSea) {
-                    staticFileMap[file.filePath] = {
-                      contentType,
-                      filePath: file.filePath,
-                      method: "GET",
-                      previewMethod: "html",
-                      path,
-                      body: Buffer.from(code),
-                      inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
-                    }
-                  }
-                }
-
-                router.use(assertGlobalTampered);
-                router.get(path, async function (req, res) {
-                  return res.asyncEnd({
-                    status: 200,
-                    headers: {
-                      ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                    },
-                    body: code
-                  });
-                });
-                return resolve();
-              }
-            }
-          }
-        }
-        case ".md": {
-          switch (file.subExt) {
-            case ".html": {
-              const code = await inflateMD2HTML(file.filePath, logger);
-              const contentType = CONTENT_TYPE_MAP[".html"];
-              const path = join("/", dirname(relative(dir, file.filePath)), file.name);
-              routeFileMap[file.filePath] = {
-                routes: [{
-                  method: "GET",
-                  path
-                }],
-                service,
-                previewMethod: "html"
-              };
-
-              if (inflateDir) {
-                const inflatePath = join(inflateDir, service, "static", path);
-                mkdirSync(dirname(inflatePath), {
-                  recursive: true
-                });
-                logger.log("writing [%s]", relative(cwd(), inflatePath));
-                writeFileSync(inflatePath, code);
-                if (staticFileMap && inflateSea) {
-                  staticFileMap[file.filePath] = {
-                    contentType,
-                    method: "GET",
-                    filePath: file.filePath,
-                    previewMethod: "html",
-                    path,
-                    body: Buffer.from(code),
-                    inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
-                  }
-                }
-              }
-
-              router.use(assertGlobalTampered);
-              router.get(path, async function (_req, res) {
-                res.asyncEnd({
-                  status: 200,
-                  headers: {
-                    ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                  },
-                  body: code
-                });
-              });
-              return resolve();
-            }
-          }
-        }
-        default:
-          if (file.ext === ".js" || file.ext === ".ts") {
-            switch (file.subExt) {
-              case ".ignore": {
-                logger.warn("ignoring [%s]", file.filePath);
-                return resolve();
-              }
-              case ".bundle":
-              case ".min": {
-                const code = await inflateJSX(file.filePath, {
-                  embemedJSX: false,
-                  minify: file.subExt === ".min" ? true : false,
-                  useExport: false,
-                  logger
-                });
-                const contentType = CONTENT_TYPE_MAP[".js"];
-                const path = join("/", dirname(relative(dir, file.filePath)), file.name + ".js");
-                routeFileMap[file.filePath] = {
-                  routes: [{
-                    method: "GET",
-                    path
-                  }],
-                  service,
-                  previewMethod: "html"
-                };
-
-                if (inflateDir) {
-                  const inflatePath = join(inflateDir, service, "static", path);
-                  mkdirSync(dirname(inflatePath), {
-                    recursive: true
-                  });
-                  logger.log("writing [%s]", relative(cwd(), inflatePath));
-                  writeFileSync(inflatePath, code);
-                  if (staticFileMap && inflateSea) {
-                    staticFileMap[file.filePath] = {
-                      contentType,
-                      method: "GET",
-                      filePath: file.filePath,
-                      previewMethod: "html",
-                      path,
-                      body: Buffer.from(code),
-                      inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
-                    }
-                  }
-                }
-
-                router.use(assertGlobalTampered);
-                router.get(path, async function (_req, res) {
-                  res.asyncEnd({
-                    status: 200,
-                    headers: {
-                      ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                    },
-                    body: code
-                  });
-                });
-                return resolve();
-              }
-            }
-          } else if (file.ext === ".bundle") {
-            switch (file.subExt) {
-              case ".ignore": {
-                logger.warn("ignoring [%s]", file.filePath);
-                return resolve();
-              }
-              case ".css": {
-                const code = readFileSync(file.filePath).toString()
-                  .split("\n")
-                  .filter(c => c)
-                  .filter(c => c.charAt(0) !== "#")
-                  .map(cssPath => readFileSync(pathResolve(dirname(file.filePath), cssPath)).toString())
-                  .join("\n");
-                const contentType = CONTENT_TYPE_MAP[".css"];
-                const path = join("/", dirname(relative(dir, file.filePath)), file.name);
-                routeFileMap[file.filePath] = {
-                  routes: [{
-                    method: "GET",
-                    path
-                  }],
-                  service,
-                  previewMethod: "html"
-                };
-
-                if (inflateDir) {
-                  const inflatePath = join(inflateDir, service, "static", path);
-                  mkdirSync(dirname(inflatePath), {
-                    recursive: true
-                  });
-                  logger.log("writing [%s]", relative(cwd(), inflatePath));
-                  writeFileSync(inflatePath, code);
-                  if (staticFileMap && inflateSea) {
-                    staticFileMap[file.filePath] = {
-                      contentType,
-                      method: "GET",
-                      filePath: file.filePath,
-                      previewMethod: "html",
-                      path,
-                      body: Buffer.from(code),
-                      inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
-                    }
-                  }
-                }
-
-                router.use(assertGlobalTampered);
-                router.get(path, async function (_req, res) {
-                  res.asyncEnd({
-                    status: 200,
-                    headers: {
-                      ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                    },
-                    body: code
-                  });
-                });
-                return resolve();
-              }
-            }
-          }
-          createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
-          return resolve();
-
-      }
-    } catch (e) {
-      logger.error("error with " + file.filePath);
-      logger.error(e);
-      errors.push({
-        filePath: file.filePath,
-        error: e
-      });
-    } finally {
-      return resolve();
-    }
-  })));
-  router.use(assertGlobalTampered);
-  return {
-    routeFileMap,
-    router,
-    errors
-  };
-}
-
-interface ScannedFile {
-  filePath: string;
-  ext: string;
-  fileName: string;
-  name: string;
-  subExt: string;
-  subName: string;
-}
-
-export function scanFiles(path: string, ret: ScannedFile[] = []): ScannedFile[] {
-  const files = readdirSync(path);
-  for (const file of files) {
-    const filePath = pathResolve(path, file);
-    if (statSync(filePath).isDirectory()) {
-      scanFiles(filePath, ret);
-      continue;
-    } else {
-      const description = describeFilePath(filePath);
-      if (description.fileName === ".DS_Store") {
-        continue;
-      }
-      ret.push(description);
-    }
-  }
-  return ret;
-}
-
-
-
-function getHTML(hotreload: boolean, req: ServerRequest, res: Response | null, url: RuntimeURL, basePath: string | undefined, out: JSX.Element): string {
-  let HTML = `<!DOCTYPE html>\n${jsx2HTML(out, createNodeRuntime({
-    url,
-    basePath
-  }))}`;
-
-  //console.log("GET_HTML[%s] [%o]", HTML, out);
-
-  if (hotreload) {
-    HTML += getHotReloadScript()
-  }
-  return HTML;
-}
-
-async function getJSON(req: ServerRequest, res: Response | null, url: RuntimeURL, basePath: string | undefined, out: JSONModuleValue | Promise<JSONModuleValue> | ((req: Request | null, res: Response | null) => JSONModuleValue | Promise<JSONModuleValue>)) {
-
-  const toRender = await (typeof out === "function" ? out(req, res) : out);
-  return JSON.stringify(toRender, undefined, 2);
-}

package/src/inflate/setup-log.ts

@@ -1,44 +0,0 @@
-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.js");
-        mkdirSync(dirname(inflatePath), {
-          recursive: true
-        });
-        logger.log("writing [%s]", relative(cwd(), inflatePath));
-        writeFileSync(inflatePath, await inflateJSX(logPath, {
-          embemedJSX: false,
-          minify: false,
-          useExport: true,
-          logger
-        }));
-      }
-    } catch (e) {
-      errors.push({
-        filePath: logPath,
-        error: e
-      });
-      logger.error("error with " + logPath);
-      logger.error(e);
-    }
-  }
-}