miqro 6.1.2 → 6.1.3

package/src/common/watch.ts

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

@@ -0,0 +1,206 @@
+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, getErrorConfigPath, getMiddlewareConfigPath, 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 => `app.use(await (await import("./${join(service, "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, "router.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
+export async function setupRouter() {
+  const router = new Router();
+${getErrorConfigPath(servicePath) ? `
+  const errorConfig = (await import("../../${service}/catch.js")).default;
+  if(errorConfig && errorConfig.catch) {
+    for(const m of errorConfig.catch) {
+      router.catch(m);
+    }
+  }` : ""}
+${getCORSConfigPath(servicePath) ? `  router.use(server.middleware.cors((await import("../../${service}/cors.js")).default));` : ""}
+${getAuthConfigPath(servicePath) ? `  router.use(server.middleware.session((await import("../../${service}/auth.js")).default));` : ""}
+${getMiddlewareConfigPath(servicePath) ? `
+  const middlewareConfig = (await import("../../${service}/middleware.js")).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 = 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")}
+  router.use(await (await import("./static-router.js")).setupRouter())
+
+${getMiddlewareConfigPath(servicePath) ? `
+  if(middlewareConfig && middlewareConfig.post) {
+    for(const m of middlewareConfig.post) {
+      router.use(m);
+    }
+  }` : ""}
+      
+  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,99 @@
+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;
+  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 setupDoc(logger, servicePath, service, router, routeFileMap, 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);
+  }
+
+  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,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);
+    }
+  }
+}

package/src/inflate/setup-db.ts

@@ -0,0 +1,113 @@
+import { Logger } from "@miqro/core";
+import { Migration, migration } from "@miqro/query";
+import { importDBConfigModule, importMigrationModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getDBConfigPath, getMigrationsPath, getServicePath } from "../common/paths.js";
+import { dirname, extname, relative, resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { DBConfig, NamedMigration } from "../types.js";
+
+export interface MigrationModule extends Migration, NamedMigration {
+  
+}
+
+export async function inflateDBConfig(logger: Logger, service: string, dbConfigList: DBConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]) {
+  const servicePath = getServicePath(service);
+  const dbConfigPath = getDBConfigPath(servicePath);
+  if (dbConfigPath) {
+    try {
+      //logger.debug("loading DBConfig for service[%s]", service);
+      const config = await importDBConfigModule(dbConfigPath, logger);
+      if (config && dbConfigList && dbConfigList.filter(c => c.name === config.name).length > 0) {
+        throw new Error(`ws path [${config.name}] already defined! error from [${dbConfigPath}]`);
+      } else if (config) {
+        //logger.debug("DBConfig [%s] loaded from service [%s]", config.name, service);
+        if (dbConfigList) {
+          dbConfigList.push(config);
+        }
+      }
+      if (config) {
+        if (inflateDir) {
+          const inflatePath = resolve(inflateDir, service, "db.js");
+          mkdirSync(dirname(inflatePath), {
+            recursive: true
+          });
+          logger.log("writing [%s]", relative(cwd(), inflatePath));
+          writeFileSync(inflatePath, await inflateJSX(dbConfigPath, {
+            embemedJSX: false,
+            minify: false,
+            useExport: true,
+            logger
+          }));
+        }
+
+        //const db = await dbManager.setupDB(service, config);
+
+        //return db;
+        return config;
+      }
+    } catch (e) {
+      errors.push({
+        filePath: dbConfigPath,
+        error: e
+      });
+      logger.error("error with " + dbConfigPath);
+      logger.error(e);
+      return false;
+    }
+  }
+  return false;
+}
+
+export async function inflateDBMigrations(logger: Logger, service: string, dbName: string, inflateDir: string | undefined | false, errors: InflateError[]) {
+  const servicePath = getServicePath(service);
+  const migrationsFolderPath = getMigrationsPath(servicePath);
+  if (migrationsFolderPath) {
+
+    logger?.trace("loading migrations from service [%s]", service);
+
+    const serviceMigrations = migration.getSortedMigrations(migrationsFolderPath);
+
+    const migrationModules: MigrationModule[] = [];
+
+    for (const migrationName of serviceMigrations) {
+      const migrationPath = resolve(migrationsFolderPath, migrationName);
+      try {
+        const migrationModule = await importMigrationModule(migrationPath);
+        migrationModules.push({
+          name: migrationName,
+          service,
+          dbName,
+          ...migrationModule
+        });
+
+        if (inflateDir) {
+          const inflatePath = resolve(inflateDir, service, "migration", migrationName.substring(0, migrationName.length - extname(migrationName).length) + ".js");
+          mkdirSync(dirname(inflatePath), {
+            recursive: true
+          });
+          logger?.log("writing [%s]", relative(cwd(), inflatePath));
+          writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migrationName), {
+            embemedJSX: false,
+            minify: false,
+            useExport: true,
+            logger
+          }));
+        }
+
+      } catch (e) {
+        errors.push({
+          filePath: migrationPath,
+          error: e
+        });
+        logger.error("error with " + migrationPath);
+        logger.error(e);
+        return false;
+      }
+    }
+
+    return migrationModules;
+
+  }
+  return false;
+}

package/src/inflate/setup-error.ts

@@ -0,0 +1,43 @@
+import { Logger, Router } from "@miqro/core";
+import { importErrorConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { getErrorConfigPath } 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 setupError(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<void> {
+  const errorPath = getErrorConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+
+  if (errorPath) {
+    try {
+      const errorModule = await importErrorConfigModule(errorPath, logger);
+      logger.debug("setting up error handling from [%s]", join(service, basename(errorPath)));
+      if (errorModule && errorModule.catch) {
+        for (const m of errorModule.catch) {
+          mainRouter.catch(m);
+        }
+      }
+      if (inflateDir && inflateSea) {
+        const inflatePath = resolve(inflateDir, service, "catch.js");
+        mkdirSync(dirname(inflatePath), {
+          recursive: true
+        });
+        logger.log("writing [%s]", relative(cwd(), inflatePath));
+        writeFileSync(inflatePath, await inflateJSX(errorPath, {
+          embemedJSX: false,
+          minify: false,
+          useExport: true,
+          logger
+        }));
+      }
+
+    } catch (e) {
+      errors.push({
+        filePath: errorPath,
+        error: e
+      });
+      logger.error("error with " + errorPath);
+      logger.error(e);
+    }
+  }
+}