miqro 5.0.5 → 6.0.3

package/src/common/paths.ts

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

@@ -0,0 +1,80 @@
+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();
+}

package/src/inflate/inflate-sea.ts

@@ -0,0 +1,193 @@
+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,
+    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}].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}].map(config=>config.load(serverInterface)));\n` : ""}
+  
+
+  await app.listen(PORT);
+  ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].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

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

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

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

@@ -0,0 +1,40 @@
+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);
+    }
+  }
+}