miqro 6.0.14 → 6.1.1

package/src/common/paths.ts

@@ -1,117 +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);
-}
-
-export function getLogConfigPath(servicePath: string) {
-  const logConfigPath = resolve(servicePath, "log.ts");
-  const logConfigPathJS = resolve(servicePath, "log.js");
-  if (existsSync(logConfigPath) && !statSync(logConfigPath).isDirectory()) {
-    return logConfigPath;
-  } else if (existsSync(logConfigPathJS) && !statSync(logConfigPathJS).isDirectory()) {
-    return logConfigPathJS;
-  }
-  return false;
-}
-
-export function getCORSConfigPath(servicePath: string) {
-  const corsPath = resolve(servicePath, "cors.ts");
-  const corsPathJS = resolve(servicePath, "cors.js");
-  if (existsSync(corsPath) && !statSync(corsPath).isDirectory()) {
-    return corsPath;
-  } else if (existsSync(corsPathJS) && !statSync(corsPathJS).isDirectory()) {
-    return corsPathJS;
-  }
-  return false;
-}
-
-export function getServerConfigPath(servicePath: string) {
-  const serverPath = resolve(servicePath, "server.ts");
-  const serverPathJS = resolve(servicePath, "server.js");
-  if (existsSync(serverPath)) {
-    return serverPath;
-  } else if (existsSync(serverPathJS)) {
-    return serverPathJS;
-  }
-  return false;
-}
-
-export function getWSConfigPath(servicePath: string) {
-  const wsPath = resolve(servicePath, "ws.ts");
-  const wsPathJS = resolve(servicePath, "ws.js");
-  if (existsSync(wsPath)) {
-    return wsPath;
-  } else if (existsSync(wsPathJS)) {
-    return wsPathJS;
-  }
-  return false;
-}
-
-export function getDBConfigPath(servicePath: string) {
-  const dbPath = resolve(servicePath, "db.ts");
-  const dbPathJS = resolve(servicePath, "db.js");
-  if (existsSync(dbPath)) {
-    return dbPath;
-  } else if (existsSync(dbPathJS)) {
-    return dbPathJS;
-  }
-  return false;
-}
-
-export function getStaticFilesPath(servicePath: string) {
-  const staticFilesPath = resolve(servicePath, "static");
-  if (existsSync(staticFilesPath) && statSync(staticFilesPath).isDirectory()) {
-    return staticFilesPath;
-  }
-  return false;
-}
-
-export function getAuthConfigPath(servicePath: string) {
-  const authPath = resolve(servicePath, "auth.ts");
-  const authPathJS = resolve(servicePath, "auth.js");
-  if (existsSync(authPath) && !statSync(authPath).isDirectory()) {
-    return authPath;
-  } else if (existsSync(authPath) && !statSync(authPath).isDirectory()) {
-    return authPathJS;
-  }
-  return false;
-}
-
-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,85 +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) {
-    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() {
-    const toClose = watchers.splice(0, watchers.length);
-    for (const watcher of toClose) {
-      watcher.close();
-    }
-  }
-
-
-  function reWatch() {
-    stopWatch();
-    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,194 +0,0 @@
-import { Logger } from "@miqro/core";
-import { chmodSync, constants, mkdirSync, writeFileSync } from "node:fs";
-import { 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, getMigrationsPath, getServerConfigPath, getServicePath, getWSConfigPath } from "../common/paths.js";
-import { getAsset } from "../common/assets.js";
-import { migration } from "@miqro/query";
-
-//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[]) {
-
-  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 import("../${service}/ws.js")).default`;
-  }).join(",")
-
-  const SERVERCONFIGLIST = services.filter(service => getServerConfigPath(resolve(cwd(), service))).map(service => {
-    return `(await import("../${service}/server.js")).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 import("../${service}/db.js")).default);
-      await (await import("./${service}/migration-up.js")).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 { ServerInterfaceImpl, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
-
-async function main() {
-  const PORT = process.env["PORT"] ? process.env["PORT"] : 8080; 
-  const logProvider = new LogProvider();
-  const localCache = new LocalCache();
-  const cache = new ClusterCache();
-  const webSocketManager = new WebSocketManager();
-  const dbManager = new DBManager();
-  await initGlobals();
-  const serverInterface = new ServerInterfaceImpl({
-    cache,
-    localCache,
-    logProvider,
-    wsManager: webSocketManager,
-    logger: logProvider.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 => {
-    const servicePath = getServicePath(service);
-    return `${getCORSConfigPath(servicePath) ? `app.use(server.middleware.cors((await import("../${service}/cors.js")).default));` : ""}`
-  })}
-  ${services.map(service => {
-    const servicePath = getServicePath(service);
-    return `${getAuthConfigPath(servicePath) ? `app.use(server.middleware.session((await import("../${service}/auth.js")).default));` : ""}`
-  })}
-  ${services.map(service => `
-  app.use(await (await import("./${join(service, "api-router.js")}")).setupRouter());
-  app.use(await (await import("./${join(service, "static-router.js")}")).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)));` : ""}
-}
-main().catch(e=>console.error(e));
-`
-  );
-}
-
-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, "api-router.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
-export async function setupRouter() {
-  const router = new Router();
-
-${Object.keys(serviceRouteFileMap)
-      .map(filePath => serviceRouteFileMap[filePath])
-      .filter(data => data.previewMethod === "api")
-      .map(data => data.routes.map(r => {
-        const rPath = r.inflatePath;
-        if (rPath) {
-          const apiInflatedPath = join("..", "..", service, "http", rPath + ".api.js");
-          return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await import("./${apiInflatedPath}")).default);`;
-        } else {
-          return "";
-        }
-      }).filter(l => l)[0])
-      .join("\n")}
-
-  return router;
-}`);
-
-  writeFile(logger, join(inflateDir, "sea", service, "migration-up.js"), `import { migration } from "./../lib.cjs";\n
-export 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, "${name}", (await import("../../${service}/migration/${name}.js")).default)`;
-  }).join("\n")}
-}`);
-
-  writeFile(logger, join(inflateDir, "sea", service, "migration-down.js"), `import { migration } from "./../lib.cjs";\n
-export 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, "${name}", (await import("../../${service}/migration/${name}.js")).default)`;
-  }).join("\n")}
-}`);
-
-  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.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
-export 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;
-}`);
-
-}
-
-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,96 +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";
-
-export interface InflateAppOptions {
-  logger?: Logger;
-  services: string[];
-  //dbManager: DBManager;
-  inflateDir: string | undefined | false;
-  inflateSea: boolean;
-  //editor: boolean;
-  //inflateTests: boolean;
-  hotreload?: boolean;
-  serverInterface: ServerInterface;
-}
-
-export async function inflateApp({ serverInterface, logger, hotreload, services/*, dbManager*/, inflateDir, inflateSea/*, editor, inflateTests*/ }: 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));
-    routeFileMap = {
-      ...routeFileMap,
-      ...serviceRouteFileMap
-    };
-
-    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);
-  }
-
-  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,20 +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 converter = new (showdown as any).default.Converter();
-    converter.setFlavor('github');
-    /*converter.setOption("tables", true);
-    converter.setOption("rawHeaderId", true);*/
-    const text = readFileSync(inFile).toString();
-    const html = converter.makeHtml(text);
-    return html;
-  } catch (e) {
-    logger?.error("error with: " + inFile);
-    logger?.error(e);
-    throw e;
-  }
-}

package/src/inflate/setup-auth.ts

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

package/src/inflate/setup-cors.ts

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