miqro 7.0.1 → 7.0.2

package/src/common/paths.ts

@@ -0,0 +1,107 @@
+import { checkEnvVariable } from "@miqro/core";
+import { randomUUID } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { cwd, platform } from "node:process";
+
+export const JSX_TMP_DIR = checkEnvVariable(`JSX_TMP`, resolve(tmpdir(), "jsx_tmp"));
+
+export const TEST_SOCKET = resolve(JSX_TMP_DIR, `test.${randomUUID()}.sock`);
+
+export function getServicePath(service: string) {
+  return resolve(cwd(), service);
+}
+
+const EXTENSIONS = [".ts", ".js", ".cjs"];
+
+function getFilePath(dirname: string, name: string, extensions: string[]) {
+  for (const ex of extensions) {
+    const path = resolve(dirname, name + ex);
+    if (existsSync(path) && !statSync(path).isDirectory()) {
+      return path;
+    }
+  }
+  return false;
+}
+
+export function getLogConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "log", EXTENSIONS);
+}
+
+export function getCORSConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "cors", EXTENSIONS);
+}
+
+export function getServerConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "server", EXTENSIONS);
+}
+
+export function getWSConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "ws", EXTENSIONS);
+}
+
+export function getDBConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "db", EXTENSIONS);
+}
+
+export function getStaticFilesPath(servicePath: string) {
+  const staticFilesPath = resolve(servicePath, "static");
+  if (existsSync(staticFilesPath) && statSync(staticFilesPath).isDirectory()) {
+    return staticFilesPath;
+  }
+  return false;
+}
+
+export function getMiddlewareConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "middleware", EXTENSIONS);
+}
+
+export function getErrorConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "catch", EXTENSIONS);
+}
+
+export function getDocConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "doc", EXTENSIONS);
+}
+
+export function getMiqroJSONPath() {
+  const miqroRCPath = resolve(cwd(), "miqro.json");
+  if (existsSync(miqroRCPath) && !statSync(miqroRCPath).isDirectory()) {
+    return miqroRCPath;
+  }
+  return false;
+}
+
+export function getAuthConfigPath(servicePath: string) {
+  return getFilePath(servicePath, "auth", EXTENSIONS);
+}
+
+export function getHTTPRouterPath(servicePath: string) {
+  const apiRouterPath = resolve(servicePath, "http");
+  if (existsSync(apiRouterPath) && statSync(apiRouterPath).isDirectory()) {
+    return apiRouterPath;
+  }
+  return false;
+}
+
+export function getMigrationsPath(servicePath: string) {
+  const migrationsFolderPath = resolve(servicePath, "migration");
+  if (existsSync(migrationsFolderPath) && statSync(migrationsFolderPath).isDirectory()) {
+    return migrationsFolderPath;
+  }
+  return false;
+}
+
+export function getESBuildBinaryPath() {
+  if (platform === "win32") {
+    return resolve(JSX_TMP_DIR, String(process.pid), "esbuild.exe");
+  } else {
+    return resolve(JSX_TMP_DIR, String(process.pid), "esbuild");
+  }
+}
+
+/*export function getJSXJSPath() {
+  return resolve(JSX_TMP_DIR, String(process.pid), "jsx.js");
+}*/
+

package/src/common/watch.ts

@@ -0,0 +1,88 @@
+//import "../services/globals.js";
+import { FSWatcher, existsSync, readdirSync, statSync, watch } from "node:fs";
+import { resolve } from "node:path";
+import { Miqro } from "../services/app.js";
+
+export async function watchAndServer(app: Miqro) {
+  let timeout: any;
+  const watchLogger = app.logger;
+  const watchers: FSWatcher[] = [];
+
+  /*await start({
+    logger,
+    webSocketManager,
+    dbManager,
+    services,
+    editor,
+    inflateTests: false,
+    inflateDir: false,
+    inflateSea: false,
+    runOnTestPort: false
+  });*/
+
+  //await app.start();
+
+  function watchHandler(eventType: any, filename: any) {
+    stopWatch();
+    watchLogger?.debug(`event type is: ${eventType}`);
+    if (filename) {
+      watchLogger?.debug(`filename provided: ${filename}`);
+    } else {
+      watchLogger?.debug('filename not provided');
+    }
+    watchLogger?.info(`${eventType} on ${filename}`);
+    clearTimeout(timeout);
+    timeout = setTimeout(async () => {
+      try {
+        stopWatch();
+        setTimeout(async () => {
+          watchLogger?.debug("closed");
+          await app.reload();
+          reWatch();
+        }, 500);
+      } catch (e) {
+        watchLogger?.error(e);
+      }
+    }, 2000);
+  }
+
+  function watchDir(toWatch: string) {
+    clearTimeout(timeout);
+    const files = existsSync(toWatch) ? readdirSync(toWatch) : [];
+    for (const file of files) {
+      const filePath = resolve(toWatch, file);
+      if (statSync(filePath).isDirectory()) {
+        watchDir(filePath);
+      } else {
+        //console.log("toWatch=" + filePath);
+        watchers.push(watch(filePath, watchHandler));
+      }
+    }
+  }
+
+  function stopWatch() {
+    clearTimeout(timeout);
+    const toClose = watchers.splice(0, watchers.length);
+    for (const watcher of toClose) {
+      watcher.close();
+    }
+  }
+
+
+  function reWatch() {
+    stopWatch();
+    clearTimeout(timeout);
+    for (const service of app.options.services) {
+      const toWatch = resolve(process.cwd(), service);
+      watchDir(toWatch);
+    }
+  }
+
+  watchLogger?.info("watching for changes on [%s]", app.options.services.join(","));
+  reWatch();
+  return {
+    stopWatch: () => {
+      stopWatch();
+    }
+  };
+}

package/src/inflate/inflate-sea.ts

@@ -0,0 +1,237 @@
+import { Logger } from "@miqro/core";
+import { chmodSync, constants, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { cwd, platform } from "node:process";
+
+import { RouteFileMap, StaticFileMap } from "./setup-http.js";
+import { getAuthConfigPath, getCORSConfigPath, getDBConfigPath, getErrorConfigPath, getMiddlewareConfigPath, getMigrationsPath, getMiqroJSONPath, getServerConfigPath, getServicePath, getWSConfigPath } from "../common/paths.js";
+import { getAsset } from "../common/assets.js";
+import { migration } from "@miqro/query";
+import { esBuild } from "../common/esbuild.js";
+
+//export const libCJSBuffer = Buffer.from(getAsset("lib.cjs"));
+/*export const COMPILESH = Buffer.from(Buffer.from(getAsset("compile.base64.sh")).toString(), "base64");
+export const SIGN_REMOVESH = Buffer.from(getAsset("sign-remove.sh"));
+export const SIGN_ADDSH = Buffer.from(getAsset("sign-add.sh"));
+export const INSTALLNODEJSSH = Buffer.from(getAsset("install-nodejs.sh"));
+export const APPSH = Buffer.from(getAsset("app.sh"));
+export const NODESH = Buffer.from(getAsset("node.sh"));
+export const SEACONFIGJSON = Buffer.from(getAsset("sea.basic.config.json"));
+export const POSTJECTCJS = Buffer.from(Buffer.from(getAsset("postject.base64.cjs")).toString(), "base64");*/
+
+export async function inflateSeaAssets(logger: Logger, inflateDir: string) {
+  const esbuildBinaryBuffer = Buffer.from(getAsset("esbuild-binary"));
+  if (platform === "win32") {
+    writeFile(logger, resolve(inflateDir, "sea", "esbuild.exe"), esbuildBinaryBuffer);
+    chmodSync(resolve(inflateDir, "sea", "esbuild.exe"), constants.S_IXUSR | constants.S_IRUSR | constants.S_IWUSR);
+  } else {
+    writeFile(logger, resolve(inflateDir, "sea", "esbuild"), esbuildBinaryBuffer);
+    chmodSync(resolve(inflateDir, "sea", "esbuild"), constants.S_IXUSR | constants.S_IRUSR | constants.S_IWUSR);
+  }
+  // writeFile(logger, resolve(inflateDir, "sea", "postject.cjs"), Buffer.from(Buffer.from(getAsset("postject.base64.cjs")).toString(), "base64"));
+  writeFile(logger, resolve(inflateDir, "sea", "config.json"), Buffer.from(getAsset("sea.basic.config.json")));
+  writeFile(logger, resolve(inflateDir, "sea", "run.sh"), Buffer.from(getAsset("app.sh")));
+  writeFile(logger, resolve(inflateDir, "sea", "node.sh"), Buffer.from(getAsset("node.sh")));
+  writeFile(logger, resolve(inflateDir, "compile.sh"), Buffer.from(Buffer.from(getAsset("compile.base64.sh")).toString(), "base64"));
+  writeFile(logger, resolve(inflateDir, "sea", "sign-add.sh"), Buffer.from(getAsset("sign-add.sh")));
+  writeFile(logger, resolve(inflateDir, "sea", "sign-remove.sh"), Buffer.from(getAsset("sign-remove.sh")));
+  writeFile(logger, resolve(inflateDir, "install-nodejs.sh"), Buffer.from(getAsset("install-nodejs.sh")));
+}
+
+export async function inflateAppForSea(logger: Logger, inflateDir: string, services: string[], port: string) {
+
+  const PORT = port;
+
+  inflateSeaAssets(logger, inflateDir);
+
+  writeFile(logger, resolve(inflateDir, "sea", "lib.cjs"), Buffer.from(getAsset("lib.cjs")));
+
+  const WSLIST = services.filter(service => getWSConfigPath(resolve(cwd(), service))).map(service => {
+    return `(await require("../${service}/ws.cjs")).default`;
+  }).join(",")
+
+  const SERVERCONFIGLIST = services.filter(service => getServerConfigPath(resolve(cwd(), service))).map(service => {
+    return `(await require("../${service}/server.cjs")).default`;
+  }).join(",\n");
+
+  const DBCONFIGLIST = services.filter(service => getDBConfigPath(resolve(cwd(), service))).map(service => {
+    return `new Promise(async (resolve, reject) => {
+    try {
+      const db = await dbManager.setupDB((await require("../${service}/db.cjs")).default);
+      await (await require("./${service}/migration-up.cjs")).runMigrations(db);
+      resolve();
+    } catch(e) {
+      reject(e);
+    }
+    
+  })`;
+  }).join(",");
+
+  writeFile(logger, join(inflateDir, "sea", "package.json"), `{ "type": "module", "private": true }`);
+
+  writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, ServerRequestHandler, WebSocketManager, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
+
+async function main() {
+  const PORT = "${PORT}"; 
+  const loggerProvider = new LogProvider();
+  const localCache = new LocalCache();
+  const cache = new ClusterCache();
+  const webSocketManager = new WebSocketManager();
+  const dbManager = new DBManager();
+  const serverInterface = createServerInterface({
+    cache,
+    localCache,
+    loggerProvider,
+    wsManager: webSocketManager,
+    logger: loggerProvider.getLogger("server"),
+    dbManager,
+    port: PORT
+  });
+
+  await Promise.all([${DBCONFIGLIST}]);
+
+  ${!WSLIST ? "" : `\n  webSocketManager.replaceALLWS(await Promise.all([${WSLIST}]))`}
+  const app = new App({
+    onUpgrade: webSocketManager.onUpgrade
+  });
+  ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.preload).map(config=>config.preload(serverInterface)));\n` : ""}
+  app.use(ServerRequestHandler(serverInterface));
+  app.use(LoggerHandler());
+  ${services.map(service => `app.use(await (await require("./${join(service, "router.cjs")}")).setupRouter());`).join("\n")}
+  ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.load).map(config=>config.load(serverInterface)));\n` : ""}
+  
+  await app.listen(PORT);
+  ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.start).map(config=>config.start(serverInterface)));` : ""}
+  loggerProvider.getLogger("server").info("listening on [%s]", PORT);
+}
+main().catch(e=>console.error(e));
+`
+  );
+
+  logger.log("writing [%s]", relative(cwd(), join(inflateDir, "sea", "app.bundle.cjs")));
+  await esBuild({
+    entryPoints: [join(inflateDir, "sea", "app.cjs")],
+    bundle: true,
+    minify: true,
+    jsxFactory: "JSX.createElement",
+    jsxFragment: "JSX.Fragment",
+    platform: "node",
+    outfile: join(inflateDir, "sea", "app.bundle.cjs")
+  });
+  const miqroRCPath = getMiqroJSONPath();
+  if (miqroRCPath) {
+    writeFile(logger, join(inflateDir, "miqro.json"), readFileSync(miqroRCPath));
+  }
+}
+
+export async function inflateServiceForSea(logger: Logger, inflateDir: string, service: string, servicePath: string/*, serviceMigrations: string[]*/, serviceRouteFileMap: RouteFileMap, serviceStaticFileMap: StaticFileMap) {
+  const migrationsFolderPath = getMigrationsPath(servicePath);
+
+  const serviceMigrations: string[] = migrationsFolderPath ? migration.getSortedMigrations(migrationsFolderPath) : [];
+  writeFile(logger, join(inflateDir, "sea", service, "router.cjs"), `const { appendAPIModule, Router, middleware } = require("./../lib.cjs");\n
+async function setupRouter() {
+  const router = new Router();
+${getErrorConfigPath(servicePath) ? `
+  const errorConfig = (await require("../../${service}/catch.cjs")).default;
+  if(errorConfig && errorConfig.catch) {
+    for(const m of errorConfig.catch) {
+      router.catch(m);
+    }
+  }` : ""}
+${getCORSConfigPath(servicePath) ? `  router.use(middleware.cors((await require("../../${service}/cors.cjs")).default));` : ""}
+${getAuthConfigPath(servicePath) ? `  router.use(middleware.session((await require("../../${service}/auth.cjs")).default));` : ""}
+${getMiddlewareConfigPath(servicePath) ? `
+  const middlewareConfig = (await require("../../${service}/middleware.cjs")).default;
+  if(middlewareConfig && middlewareConfig.middleware) {
+    for(const m of middlewareConfig.middleware) {
+      router.use(m);
+    }
+  }` : ""}
+${Object.keys(serviceRouteFileMap)
+      .map(filePath => serviceRouteFileMap[filePath])
+      .filter(data => data.previewMethod === "api")
+      .map(data => data.routes.map(r => {
+        const rPath = join(relative(cwd(), dirname(data.filePath)), basename(data.filePath));
+        if (rPath) {
+          const rPathExt = extname(rPath);
+          const apiInflatedPath = join("..", "..", rPath.substring(0, rPath.length - rPathExt.length) + ".cjs");
+          return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await require("./${apiInflatedPath}")).default);`;
+        } else {
+          return "";
+        }
+      }).filter(l => l)[0])
+      .join("\n")}
+  router.use(await (await require("./static-router.cjs")).setupRouter())
+
+${getMiddlewareConfigPath(servicePath) ? `
+  if(middlewareConfig && middlewareConfig.post) {
+    for(const m of middlewareConfig.post) {
+      router.use(m);
+    }
+  }` : ""}
+      
+  return router;
+}
+module.exports = {
+  setupRouter
+}`);
+
+  writeFile(logger, join(inflateDir, "sea", service, "migration-up.cjs"), `const { migration } = require("./../lib.cjs");\n
+async function runMigrations(db) {
+  await migration.init(db);
+${serviceMigrations.map(file => {
+    const name = `${file.substring(0, file.length - extname(file).length)}`;
+    return `  await migration.up.module(db, "${file}", (await require("../../${service}/migration/${name}.cjs")).default)`;
+  }).join("\n")}
+}
+module.exports = {
+  runMigrations
+}`);
+
+  writeFile(logger, join(inflateDir, "sea", service, "migration-down.cjs"), `const { migration } = require("./../lib.cjs");\n
+async function runMigrations(db) {
+  await migration.init(db);
+${serviceMigrations.reverse().map(file => {
+    const name = `${file.substring(0, file.length - extname(file).length)}`;
+    return `  await migration.down.module(db, "${file}", (await require("../../${service}/migration/${name}.cjs")).default)`;
+  }).join("\n")}
+}
+module.exports = {
+  runMigrations
+}`);
+
+  const staticFiles = Object.keys(serviceStaticFileMap);
+  /*if (staticFiles.length !== 0) {
+    writeFile(logger, join(inflateDir, "sea", service, "static.base64.json"), JSON.stringify(serviceStaticFileMap));
+  }*/
+  writeFile(logger, join(inflateDir, "sea", service, "static-router.cjs"), `const { appendAPIModule, Router } = require("./../lib.cjs");\n
+async function setupRouter() {
+  const router = new Router();
+  ${staticFiles.length === 0 ? "" : `
+${staticFiles.map((filePath) => {
+    return `  router.get("${serviceStaticFileMap[filePath].path}", async (_, res) => {
+    return res.asyncEnd({
+      status: 200,
+      headers: {
+        ["Content-Type"]: "${serviceStaticFileMap[filePath].contentType}"
+      },
+      body: Buffer.from("${serviceStaticFileMap[filePath].body.toString("base64")}", "base64")
+    });
+  });`;
+  }).join("\n")}
+`}
+  return router;
+}
+module.exports = {
+  setupRouter
+}`);
+
+}
+
+function writeFile(logger: Logger, path: string, buffer: Buffer | string) {
+  logger.log("writing [%s]", relative(cwd(), path));
+  mkdirSync(dirname(path), {
+    recursive: true
+  });
+  writeFileSync(path, buffer);
+}

package/src/inflate/inflate.ts

@@ -0,0 +1,101 @@
+import { InflateError } from "../common/jsx.js";
+import { Logger, Router } from "@miqro/core";
+import { RouteFileMap, setupHTTPRouter, StaticFileMap } from "./setup-http.js";
+//import { WSMapConfig } from "./utils/websocketmanager.js";
+//import { ServerConfigMap, setupServerConfig } from "./setup-server-config.js";
+// import { assertGlobalTampered } from "../services/globals.js";
+import { getServicePath } from "../common/paths.js";
+import { inflateWSConfig } from "./setup-ws.js";
+import { inflateAppForSea, inflateServiceForSea } from "./inflate-sea.js";
+import { ServerInterface, WSConfig } from "../types.js";
+import { LogConfigMap, setupLogConfig } from "./setup-log.js";
+import { setupDoc } from "./setup.doc.js";
+
+export interface InflateAppOptions {
+  logger?: Logger;
+  services: string[];
+  //dbManager: DBManager;
+  inflateDir: string | undefined | false;
+  inflateSea: boolean;
+  //editor: boolean;
+  //inflateTests: boolean;
+  hotreload?: boolean;
+  port: string;
+  serverInterface: ServerInterface;
+  inflateParallel?: number;
+}
+
+export async function inflateApp({ inflateParallel, serverInterface, logger, hotreload, services/*, dbManager*/, inflateDir, inflateSea/*, editor, inflateTests*/, port }: InflateAppOptions): Promise<[Router, InflateError[] | null, RouteFileMap, WSConfig[]/*, ServerConfigMap*/, LogConfigMap]> {
+  logger.trace("inflateApp");
+  const errors: InflateError[] = [];
+  //const migrations: string[] = [];
+  let routeFileMap: RouteFileMap = {};
+  const wsConfigList: WSConfig[] = [];
+  const router = new Router();
+  const logConfigMap: LogConfigMap = {};
+  //const serverConfigMap: ServerConfigMap = {};
+
+  // router.use(assertGlobalTampered);
+
+  /*if (editor) {
+    logger.info("setting up editor on %s", BASEEDITOR_PATH);
+    const editorRouter = await createEditorRouter();
+    router.use(editorRouter);
+    logger.info("setting up ws on [%s]", LOG_SOCKET_PATH);
+    wsConfigList.push(editorWSConfig);
+    serverConfigMap[EDITOR_CONFIG_KEY] = editorServerConfig;
+  }*/
+
+
+
+  for (const service of services) {
+    const serviceRouteFileMap: RouteFileMap = {};
+    const serviceStaticFileMap: StaticFileMap | null = inflateSea ? {} : null;
+    const servicePath = getServicePath(service);
+
+    /*const migrationsFolderPath = getMigrationsPath(servicePath);
+
+    const serviceMigrations: string[] = migrationsFolderPath ? migration.getSortedMigrations(migrationsFolderPath) : [];*/
+
+    /*const db = dbManager.getDB(service) ? dbManager.getDB(service) : await setupDB(logger, service, dbManager, inflateDir);;
+
+    if (db && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+      await runMigrations(logger, db, servicePath, service, inflateDir, serviceMigrations);
+    }
+    if (db) {
+      migrations.push(...serviceMigrations);
+    }*/
+
+    //await setupDB(logger, service, dbConfigList, inflateDir);
+
+    await setupLogConfig(logger, servicePath, service, logConfigMap, inflateSea ? inflateDir : false, errors);
+
+    router.use(await setupHTTPRouter(serverInterface, logger, hotreload ? hotreload : false, servicePath, service, serviceRouteFileMap, serviceStaticFileMap, inflateDir, inflateSea, errors, inflateParallel));
+    routeFileMap = {
+      ...routeFileMap,
+      ...serviceRouteFileMap
+    };
+
+    await setupDoc(logger, servicePath, service, router, routeFileMap, serviceStaticFileMap, inflateDir, errors);
+
+    await inflateWSConfig(logger, servicePath, service, wsConfigList, inflateSea ? inflateDir : undefined, errors);
+
+    //await setupServerConfig(logger, servicePath, service, serverConfigMap, inflateSea ? inflateDir : undefined, errors);
+
+    if (inflateDir && inflateSea) {
+      await inflateServiceForSea(logger, inflateDir, service, servicePath /*, serviceMigrations*/, serviceRouteFileMap, serviceStaticFileMap);
+    }
+
+    /*if (inflateTests) {
+      await setupTests(logger, servicePath);
+    }*/
+  }
+
+  if (inflateDir && inflateSea) {
+    await inflateAppForSea(logger, inflateDir, services, port);
+  }
+
+  // router.use(assertGlobalTampered);
+
+  return errors.length === 0 ? [router, null, routeFileMap/*, migrations*/, wsConfigList/*, serverConfigMap*/, logConfigMap] : [router, errors, routeFileMap/*, migrations*/, wsConfigList/*, serverConfigMap*/, logConfigMap];
+}

package/src/inflate/md.ts

@@ -0,0 +1,25 @@
+
+import * as showdown from "showdown";
+import { readFileSync } from "node:fs";
+import { Logger } from "@miqro/core";
+
+export function inflateMD2HTML(inFile: string, logger?: Logger): string {
+  try {
+    const text = readFileSync(inFile).toString();
+    const html = inflateMDString2HTML(text);
+    return html;
+  } catch (e) {
+    logger?.error("error with: " + inFile);
+    logger?.error(e);
+    throw e;
+  }
+}
+
+export function inflateMDString2HTML(text: string, logger?: Logger): string {
+  const converter = new (showdown as any).default.Converter();
+  converter.setFlavor('github');
+  /*converter.setOption("tables", true);
+  converter.setOption("rawHeaderId", true);*/
+  const html = converter.makeHtml(text);
+  return html;
+}

package/src/inflate/setup-auth.ts

@@ -0,0 +1,41 @@
+import { Logger, Router, SessionHandler } from "@miqro/core";
+import { importAuthModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getAuthConfigPath } from "../common/paths.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+
+export async function setupAUTH(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]) {
+  const authPath = getAuthConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+
+  if (authPath) {
+    try {
+      const authModule = await importAuthModule(authPath, logger);
+      logger.debug("setting up authentication from [%s]", join(service, basename(authPath)));
+      mainRouter.use(SessionHandler(authModule));
+
+      if (inflateDir && inflateSea) {
+        const inflatePath = resolve(inflateDir, service, "auth.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(authPath, {
+          // embemedJSX: false,
+          minify: false,
+          useExport: true,
+          platform: "node",
+          logger
+        }));
+      }
+
+    } catch (e) {
+      errors.push({
+        filePath: authPath,
+        error: e
+      });
+      logger.error("error with " + authPath);
+      logger.error(e);
+    }
+  }
+}

package/src/inflate/setup-cors.ts

@@ -0,0 +1,41 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { importCORSModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getCORSConfigPath } from "../common/paths.js";
+import { CORS, Logger, Router } from "@miqro/core";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { cwd } from "node:process";
+
+export async function setupCORS(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]) {
+  const corsPath = getCORSConfigPath(servicePath);
+
+  if (corsPath) {
+    try {
+      const corsOptions = await importCORSModule(corsPath, logger);
+      logger.debug("setting up cors from [%s]", join(service, basename(corsPath)));
+      mainRouter.use(CORS(corsOptions));
+
+      if (inflateDir && inflateSea) {
+        const inflatePath = resolve(inflateDir, service, "cors.cjs");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(corsPath, {
+          // embemedJSX: false,
+          minify: false,
+          useExport: true,
+          platform: "node",
+          logger
+        }));
+      }
+
+    } catch (e) {
+      errors.push({
+        filePath: corsPath,
+        error: e
+      });
+      logger.error("error with " + corsPath);
+      logger.error(e);
+    }
+  }
+}