miqro 7.2.6 → 7.2.8

package/src/common/paths.ts

@@ -1,107 +0,0 @@
-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

@@ -1,88 +0,0 @@
-//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

@@ -1,268 +0,0 @@
-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, getLogConfigPath, 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 LOGCONFIGLIST = services.filter(service => getLogConfigPath(resolve(cwd(), service))).map(service => {
-    return `{config: (await require("./../${service}/log.cjs")).default, service: "${service}" }`;
-  }).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 { createLogProviderOptions, createServerInterface, ServerRequestHandler, WebSocketManager, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
-
-async function main() {
-  const PORT = "${PORT}";
-
-  const logConfigList = await Promise.all([${LOGCONFIGLIST}]);
-
-  const loggerProvider = new LogProvider(createLogProviderOptions({
-    inflated: {
-      logConfigMap: logConfigList.reduce((ret, config)=>{
-        ret[config.service] = config.config;
-        return ret;
-      }, {})
-    }
-  }));
-  const logger = loggerProvider.getLogger("SERVER");
-  const localCache = new LocalCache();
-  const cache = new ClusterCache();
-  const webSocketManager = new WebSocketManager({
-    loggerProvider,
-    logger
-  });
-  const dbManager = new DBManager({
-    loggerProvider,
-    logger
-  });
-  const serverInterface = createServerInterface({
-    cache,
-    localCache,
-    loggerProvider,
-    webSocketManager,
-    logger,
-    dbManager,
-    port: PORT
-  });
-
-  await Promise.all([${DBCONFIGLIST}]);
-
-  ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.preload).map(config=>config.preload(serverInterface)));\n` : ""}
-
-  ${!WSLIST ? "" : `\n  webSocketManager.replaceALLWS(await Promise.all([${WSLIST}]))`}
-  const app = new App({
-    loggerFactory: loggerProvider.requestLoggerFactory,
-    onUpgrade: (req, socket, head) => {
-      try {
-        req.server = serverInterface;
-        return webSocketManager.onUpgrade(req, socket, head);
-      } catch(e) {
-       console.error(e);
-      }
-    }
-  });
-
-  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("./${relative(service, "")}/lib.cjs");\n
-async function setupRouter() {
-  const router = new Router();
-${getErrorConfigPath(servicePath) ? `
-  const errorConfig = (await require("../${relative(service, "")}/${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("../${relative(service, "")}/${service}/cors.cjs")).default));` : ""}
-${getAuthConfigPath(servicePath) ? `  router.use(middleware.session((await require("../${relative(service, "")}/${service}/auth.cjs")).default));` : ""}
-${getMiddlewareConfigPath(servicePath) ? `
-  const middlewareConfig = (await require("../${relative(service, "")}/${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("..", relative(service, ""), rPath.substring(0, rPath.length - rPathExt.length) + ".cjs");
-          return `  await appendAPIModule(router, "../${relative(service, "")}/${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("./${relative(service, "")}/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, (await require("../${relative(service, "")}/${service}/migration/${name}.cjs")).default.name ?? "${file}", (await require("../${relative(service, "")}/${service}/migration/${name}.cjs")).default)`;
-  }).join("\n")}
-}
-module.exports = {
-  runMigrations
-}`);
-
-  writeFile(logger, join(inflateDir, "sea", service, "migration-down.cjs"), `const { migration } = require("./${relative(service, "")}/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, (await require("../${relative(service, "")}/${service}/migration/${name}.cjs")).default.name ?? "${file}", (await require("../${relative(service, "")}/${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("./${relative(service, "")}/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

@@ -1,105 +0,0 @@
-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;
-  noBuild?: boolean;
-  noMinify?: boolean;
-  inflateOnlyAssets?: boolean;
-  inflateFlat?: boolean;
-}
-
-export async function inflateApp({ inflateParallel, serverInterface, logger, hotreload, services/*, dbManager*/, inflateDir, inflateSea/*, editor, inflateTests*/, port, noBuild, noMinify, inflateOnlyAssets, inflateFlat }: 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, { noBuild }, errors);
-
-    router.use(await setupHTTPRouter({ noBuild }, { noMinify, inflateOnlyAssets, inflateFlat }, 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, { noBuild }, inflateFlat);
-
-    await inflateWSConfig(logger, servicePath, service, wsConfigList, inflateSea ? inflateDir : undefined, errors, { noBuild });
-
-    //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

@@ -1,25 +0,0 @@
-
-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

@@ -1,41 +0,0 @@
-import { Logger, Router, SessionHandler } from "@miqro/core";
-import { importAuthModule, ImportJSXFileOptions, 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, options: ImportJSXFileOptions, errors: InflateError[]) {
-  const authPath = getAuthConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
-
-  if (authPath) {
-    try {
-      const authModule = await importAuthModule(authPath, options, 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

@@ -1,42 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { importCORSModule, ImportJSXFileOptions, 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, options: ImportJSXFileOptions, errors: InflateError[]) {
-  const corsPath = getCORSConfigPath(servicePath);
-
-  if (corsPath) {
-    try {
-      logger.debug("setting up cors from [%s]", join(service, basename(corsPath)));
-      const corsOptions = await importCORSModule(corsPath, options, logger);
-
-      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);
-    }
-  }
-}