miqro 6.0.14 → 6.1.2

package/build/esm/src/inflate/inflate-sea.js

@@ -1,7 +1,7 @@
 import { chmodSync, constants, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, relative, resolve } from "node:path";
 import { cwd, platform } from "node:process";
-import { getAuthConfigPath, getCORSConfigPath, getDBConfigPath, getMigrationsPath, getServerConfigPath, getServicePath, getWSConfigPath } from "../common/paths.js";
+import { getAuthConfigPath, getCORSConfigPath, getDBConfigPath, getErrorConfigPath, getMiddlewareConfigPath, getMigrationsPath, getServerConfigPath, getWSConfigPath } from "../common/paths.js";
 import { getAsset } from "../common/assets.js";
 import { migration } from "@miqro/query";
 //export const libCJSBuffer = Buffer.from(getAsset("lib.cjs"));
@@ -83,20 +83,9 @@ async function main() {
   ${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")}
+  ${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)));` : ""}
 }
@@ -106,10 +95,25 @@ main().catch(e=>console.error(e));
 export async function inflateServiceForSea(logger, inflateDir, service, servicePath /*, serviceMigrations: string[]*/, serviceRouteFileMap, serviceStaticFileMap) {
     const migrationsFolderPath = getMigrationsPath(servicePath);
     const serviceMigrations = migrationsFolderPath ? migration.getSortedMigrations(migrationsFolderPath) : [];
-    writeFile(logger, join(inflateDir, "sea", service, "api-router.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
+    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")
@@ -124,7 +128,15 @@ ${Object.keys(serviceRouteFileMap)
         }
     }).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
@@ -173,4 +185,3 @@ function writeFile(logger, path, buffer) {
     });
     writeFileSync(path, buffer);
 }
-//# sourceMappingURL=inflate-sea.js.map

package/build/esm/src/inflate/inflate.js

@@ -7,6 +7,7 @@ import { getServicePath } from "../common/paths.js";
 import { inflateWSConfig } from "./setup-ws.js";
 import { inflateAppForSea, inflateServiceForSea } from "./inflate-sea.js";
 import { setupLogConfig } from "./setup-log.js";
+import { setupDoc } from "./setup.doc.js";
 export async function inflateApp({ serverInterface, logger, hotreload, services /*, dbManager*/, inflateDir, inflateSea /*, editor, inflateTests*/ }) {
     logger.trace("inflateApp");
     const errors = [];
@@ -47,6 +48,7 @@ export async function inflateApp({ serverInterface, logger, hotreload, services
             ...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) {
@@ -62,4 +64,3 @@ export async function inflateApp({ serverInterface, logger, hotreload, services
     router.use(assertGlobalTampered);
     return errors.length === 0 ? [router, null, routeFileMap /*, migrations*/, wsConfigList /*, serverConfigMap*/, logConfigMap] : [router, errors, routeFileMap /*, migrations*/, wsConfigList /*, serverConfigMap*/, logConfigMap];
 }
-//# sourceMappingURL=inflate.js.map

package/build/esm/src/inflate/md.d.ts

@@ -1,2 +1,3 @@
 import { Logger } from "@miqro/core";
 export declare function inflateMD2HTML(inFile: string, logger?: Logger): string;
+export declare function inflateMDString2HTML(text: string, logger?: Logger): string;

package/build/esm/src/inflate/md.js

@@ -2,12 +2,8 @@ import * as showdown from "showdown";
 import { readFileSync } from "node:fs";
 export function inflateMD2HTML(inFile, logger) {
     try {
-        const converter = new showdown.default.Converter();
-        converter.setFlavor('github');
-        /*converter.setOption("tables", true);
-        converter.setOption("rawHeaderId", true);*/
         const text = readFileSync(inFile).toString();
-        const html = converter.makeHtml(text);
+        const html = inflateMDString2HTML(text);
         return html;
     }
     catch (e) {
@@ -16,4 +12,11 @@ export function inflateMD2HTML(inFile, logger) {
         throw e;
     }
 }
-//# sourceMappingURL=md.js.map
+export function inflateMDString2HTML(text, logger) {
+    const converter = new showdown.default.Converter();
+    converter.setFlavor('github');
+    /*converter.setOption("tables", true);
+    converter.setOption("rawHeaderId", true);*/
+    const html = converter.makeHtml(text);
+    return html;
+}

package/build/esm/src/inflate/setup-auth.js

@@ -35,4 +35,3 @@ export async function setupAUTH(logger, servicePath, service, mainRouter, inflat
         }
     }
 }
-//# sourceMappingURL=setup-auth.js.map

package/build/esm/src/inflate/setup-cors.js

@@ -35,4 +35,3 @@ export async function setupCORS(logger, servicePath, service, mainRouter, inflat
         }
     }
 }
-//# sourceMappingURL=setup-cors.js.map

package/build/esm/src/inflate/setup-db.js

@@ -96,4 +96,3 @@ export async function inflateDBMigrations(logger, service, dbName, inflateDir, e
     }
     return false;
 }
-//# sourceMappingURL=setup-db.js.map

package/build/esm/src/inflate/setup-error.d.ts

@@ -0,0 +1,3 @@
+import { Logger, Router } from "@miqro/core";
+import { InflateError } from "../common/jsx.js";
+export declare function setupError(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<void>;

package/build/esm/src/inflate/setup-error.js

@@ -0,0 +1,40 @@
+import { importErrorConfigModule, 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, servicePath, service, mainRouter, inflateDir, inflateSea, errors) {
+    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);
+        }
+    }
+}

package/build/esm/src/inflate/setup-http.js

@@ -13,12 +13,17 @@ import { setupAUTH } from "./setup-auth.js";
 import { getRoutes } from "../services/utils/get-route.js";
 import { describeFilePath } from "../common/fs.js";
 import { inflateMD2HTML } from "./md.js";
+import { setupMiddleware } from "./setup-middleware.js";
+import { setupError } from "./setup-error.js";
 export async function setupHTTPRouter(server, logger, hotreload, servicePath, service, routeFileMap, staticFileMap, inflateDir, inflateSea, errors) {
     const mainRouter = new Router();
     const apiRouterPath = getHTTPRouterPath(servicePath); //resolve(process.cwd(), service, "http");
+    let middlewareConfig = null;
+    await setupError(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
+    await setupCORS(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
+    await setupAUTH(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
+    middlewareConfig = await setupMiddleware(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
     if (apiRouterPath) {
-        await setupCORS(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
-        await setupAUTH(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
         logger.trace("setting up http routes from [%s]", service);
         const { router: httpRouter } = await createRouterFromDirectory(server, hotreload, service, logger, apiRouterPath, errors, routeFileMap, staticFileMap, inflateDir, inflateSea);
         mainRouter.use(httpRouter);
@@ -29,6 +34,11 @@ export async function setupHTTPRouter(server, logger, hotreload, servicePath, se
         const staticRouter = createStaticRouterFromDirectory(service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap);
         mainRouter.use(staticRouter);
     }
+    if (middlewareConfig && middlewareConfig.post) {
+        for (const m of middlewareConfig.post) {
+            mainRouter.use(m);
+        }
+    }
     return mainRouter;
 }
 function createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap) {
@@ -508,7 +518,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
     };
 }
 export function scanFiles(path, ret = []) {
-    const files = readdirSync(path);
+    const files = readdirSync(path).sort();
     for (const file of files) {
         const filePath = pathResolve(path, file);
         if (statSync(filePath).isDirectory()) {
@@ -540,4 +550,3 @@ async function getJSON(req, res, url, basePath, out) {
     const toRender = await (typeof out === "function" ? out(req, res) : out);
     return JSON.stringify(toRender, undefined, 2);
 }
-//# sourceMappingURL=setup-http.js.map

package/build/esm/src/inflate/setup-log.js

@@ -34,4 +34,3 @@ export async function setupLogConfig(logger, servicePath, service, logConfigMap,
         }
     }
 }
-//# sourceMappingURL=setup-log.js.map

package/build/esm/src/inflate/setup-middleware.d.ts

@@ -0,0 +1,4 @@
+import { Logger, Router } from "@miqro/core";
+import { InflateError } from "../common/jsx.js";
+import { MiddlewareConfig } from "../types.js";
+export declare function setupMiddleware(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<MiddlewareConfig | null>;

package/build/esm/src/inflate/setup-middleware.js

@@ -0,0 +1,42 @@
+import { importMiddlewareConfigModule, inflateJSX } from "../common/jsx.js";
+import { getMiddlewareConfigPath } 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 setupMiddleware(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors) {
+    const middlewarePath = getMiddlewareConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+    if (middlewarePath) {
+        try {
+            const middewareModule = await importMiddlewareConfigModule(middlewarePath, logger);
+            logger.debug("setting up middleware from [%s]", join(service, basename(middlewarePath)));
+            if (middewareModule && middewareModule.middleware) {
+                for (const m of middewareModule.middleware) {
+                    mainRouter.use(m);
+                }
+            }
+            if (inflateDir && inflateSea) {
+                const inflatePath = resolve(inflateDir, service, "middleware.js");
+                mkdirSync(dirname(inflatePath), {
+                    recursive: true
+                });
+                logger.log("writing [%s]", relative(cwd(), inflatePath));
+                writeFileSync(inflatePath, await inflateJSX(middlewarePath, {
+                    embemedJSX: false,
+                    minify: false,
+                    useExport: true,
+                    logger
+                }));
+            }
+            return middewareModule;
+        }
+        catch (e) {
+            errors.push({
+                filePath: middlewarePath,
+                error: e
+            });
+            logger.error("error with " + middlewarePath);
+            logger.error(e);
+        }
+    }
+    return null;
+}

package/build/esm/src/inflate/setup-server-config.js

@@ -34,4 +34,3 @@ export async function setupServerConfig(logger, servicePath, service, serverConf
         }
     }
 }
-//# sourceMappingURL=setup-server-config.js.map

package/build/esm/src/inflate/setup-test.js

@@ -19,4 +19,3 @@ export async function setupTests(logger, servicePath) {
         return Promise.resolve();
     }));
 }
-//# sourceMappingURL=setup-test.js.map

package/build/esm/src/inflate/setup-ws.js

@@ -43,4 +43,3 @@ export async function inflateWSConfig(logger, servicePath, service, wsConfigList
         }
     }
 }
-//# sourceMappingURL=setup-ws.js.map

package/build/esm/src/inflate/setup.doc.d.ts

@@ -0,0 +1,4 @@
+import { Logger, Router } from "@miqro/core";
+import { InflateError } from "../common/jsx.js";
+import { RouteFileMap } from "./setup-http.js";
+export declare function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, inflateDir: string | undefined | false, errors: InflateError[]): Promise<any>;

package/build/esm/src/inflate/setup.doc.js

@@ -0,0 +1,62 @@
+import { importDocConfigModule } from "../common/jsx.js";
+import { getDocConfigPath } from "../common/paths.js";
+import { basename, dirname, join, relative } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { getDocOutput } from "../bin/generate-doc.js";
+import { CONTENT_TYPE_MAP } from "../common/content-type.js";
+export async function setupDoc(logger, servicePath, service, mainRouter, fileMap, inflateDir, errors) {
+    const docPath = getDocConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
+    if (docPath) {
+        try {
+            const docModule = await importDocConfigModule(docPath, logger);
+            logger.debug("setting up error handling from [%s]", join(service, basename(docPath)));
+            if (docModule && docModule.publish) {
+                const paths = Object.keys(docModule.publish);
+                for (const path of paths) {
+                    const config = docModule.publish[path];
+                    const body = await getDocOutput(mainRouter, fileMap, config.all, config.type);
+                    mainRouter.get(path, async (_, res) => {
+                        switch (config.type) {
+                            case "MD": {
+                                const contentType = CONTENT_TYPE_MAP[".md"];
+                                return await res.asyncEnd({
+                                    headers: {
+                                        "content-type": contentType
+                                    },
+                                    status: 200,
+                                    body
+                                });
+                            }
+                            case "JSON": {
+                                return await res.json(body);
+                            }
+                            case "HTML": {
+                                return await res.html(body);
+                            }
+                            default:
+                                return true;
+                        }
+                    });
+                    if (inflateDir) {
+                        const inflatePath = join(inflateDir, service, "static", path);
+                        mkdirSync(dirname(inflatePath), {
+                            recursive: true
+                        });
+                        logger.log("writing [%s]", relative(cwd(), inflatePath));
+                        writeFileSync(inflatePath, body);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push({
+                filePath: docPath,
+                error: e
+            });
+            logger.error("error with " + docPath);
+            logger.error(e);
+        }
+    }
+    return null;
+}

package/build/esm/src/inflate/utils/sea-utils.js

@@ -10,4 +10,3 @@ export async function appendAPIModule(router, dir, filePath, module) {
         router.use(module.handler, r.path, r.method, r.options);
     }
 }
-//# sourceMappingURL=sea-utils.js.map

package/build/esm/src/lib.js

@@ -14,4 +14,3 @@ export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 export { ServerInterfaceImpl } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
-//# sourceMappingURL=lib.js.map

package/build/esm/src/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { getPORT, parseArguments } from "./common/arguments.js";
+import { parseArguments } from "./common/arguments.js";
 import { EXIT_CODES } from "./common/constants.js";
 import { testMain } from "./bin/test.js";
 import { compileSH } from "./bin/compile.js";
@@ -16,8 +16,8 @@ async function main(args) {
     else {
         const app = new Miqro({
             editor: args.editor,
-            name: "server",
-            port: args.test ? TEST_SOCKET : getPORT(),
+            name: args.name ? args.name : undefined,
+            port: args.test ? TEST_SOCKET : args.port,
             services: args.services,
             hotreload: args.test ? false : args.hotreload
         });
@@ -89,4 +89,3 @@ catch (e) {
     console.error(e.message);
     process.exit(EXIT_CODES.ABNORMAL);
 }
-//# sourceMappingURL=main.js.map

package/build/esm/src/services/app.d.ts

@@ -64,6 +64,7 @@ export declare class Miqro {
         stopWatch: () => void;
     };
     constructor(options?: Partial<MiqroOptions>);
+    static import(inFile: string, options?: Partial<MiqroOptions>, inflate?: Partial<InflateOptions>): Promise<Miqro>;
     connect(): void;
     disconnect(): void;
     inflateWith(inflated?: Partial<InflatedResult>): Promise<void>;

package/build/esm/src/services/app.js

@@ -20,9 +20,11 @@ import { setupExitHandlers } from "../common/exit.js";
 import { inflateDBConfig, inflateDBMigrations } from "../inflate/setup-db.js";
 import { getServicePath } from "../common/paths.js";
 import { ServerInterfaceImpl } from "./utils/server-interface.js";
-import { getPORT } from "../common/arguments.js";
+import { getPORT, importMiqroJSON } from "../common/arguments.js";
 import { createLogProviderOptions } from "./utils/log-transport.js";
 import { createAdminInterface } from "./utils/admin-interface.js";
+import { dirname, join, relative, resolve } from "node:path";
+import { cwd } from "node:process";
 export const MiqroApplicationMessageType = "$$$MiqroApplicationMessageType$$$";
 export class Miqro {
     status = "stopped";
@@ -112,6 +114,21 @@ export class Miqro {
         this.adminInterface = createAdminInterface(this);
         setupExitHandlers(this);
     }
+    static async import(inFile, options, inflate) {
+        const miqroJSON = importMiqroJSON(resolve(inFile));
+        const miqroJSONDir = dirname(resolve(inFile));
+        const app = new Miqro({
+            name: miqroJSON.name ? miqroJSON.name : undefined,
+            port: miqroJSON.port ? String(miqroJSON.port) : undefined,
+            services: miqroJSON.services ? miqroJSON.services.map(s => join(relative(cwd(), miqroJSONDir), s)) : undefined,
+            ...(options ? options : {}),
+        });
+        await app.inflate({
+            inflateDir: miqroJSON.inflateDir ? String(miqroJSON.inflateDir) : undefined,
+            ...(inflate ? inflate : {}),
+        });
+        return app;
+    }
     connect() {
         if (process.send) {
             process.removeListener("message", this.listener);
@@ -535,4 +552,3 @@ export function notifiyServerConfigSync(app, method) {
         });
     }
 }
-//# sourceMappingURL=app.js.map

package/build/esm/src/services/editor.js

@@ -65,4 +65,3 @@ function getHandler(/*auth: Handler, */ router) {
         handler: router.handler
     };
 }
-//# sourceMappingURL=editor.js.map

package/build/esm/src/services/globals.js

@@ -136,4 +136,3 @@ export function assertGlobalTampered() {
         process.exit(EXIT_CODES.GLOBALS_ALTERED);
     }
 }
-//# sourceMappingURL=globals.js.map

package/build/esm/src/services/hot-reload.js

@@ -43,4 +43,3 @@ socket.addEventListener("error", (err) => {
 /*export function isHotReloadEnabled() {
   return checkEnvVariable("HOT_RELOAD", "0") === "1";
 }*/
-//# sourceMappingURL=hot-reload.js.map

package/build/esm/src/services/migrations.js

@@ -58,4 +58,3 @@ export async function runMigrationsDown(logger, db, servicePath, service, inflat
     }
     return migrations;
 }
-//# sourceMappingURL=migrations.js.map

package/build/esm/src/services/utils/admin-interface.js

@@ -31,4 +31,3 @@ export function createAdminInterface(app) {
         }
     };
 }
-//# sourceMappingURL=admin-interface.js.map

package/build/esm/src/services/utils/cache.js

@@ -82,4 +82,3 @@ export class LocalCache {
         this.localCache.set(key, []);
     }
 }
-//# sourceMappingURL=cache.js.map

package/build/esm/src/services/utils/cluster-cache.js

@@ -212,4 +212,3 @@ export class ClusterCache {
         this.localCache.set(key, []);
     }
 }
-//# sourceMappingURL=cluster-cache.js.map

package/build/esm/src/services/utils/cluster-ws.js

@@ -177,4 +177,3 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
         return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
     }
 }
-//# sourceMappingURL=cluster-ws.js.map

package/build/esm/src/services/utils/db-manager.js

@@ -68,4 +68,3 @@ export class DBManager {
         this.map.set(name, db);
     }
 }
-//# sourceMappingURL=db-manager.js.map

package/build/esm/src/services/utils/get-route.js

@@ -55,4 +55,3 @@ export function getRoutes(prePath, defaultPath, apiOptions) {
     }
     return ret;
 }
-//# sourceMappingURL=get-route.js.map

package/build/esm/src/services/utils/log-transport.js

@@ -72,4 +72,3 @@ export function createLogProviderOptions(app) {
         ...(app.options.logProviderOptions ? app.options.logProviderOptions : {})
     };
 }
-//# sourceMappingURL=log-transport.js.map

package/build/esm/src/services/utils/log.js

@@ -10,7 +10,8 @@ export class LogProvider {
     constructor(options) {
         this.options = {
             formatter: options && options.formatter ? options.formatter : DEFAULT_FORMATTER,
-            transports: options && options.transports ? options.transports : [ConsoleTransport()]
+            transports: options && options.transports ? options.transports : [ConsoleTransport()],
+            name: options?.name
         };
         this.requestLoggerFactory = this.requestLoggerFactory.bind(this);
     }
@@ -71,4 +72,3 @@ export class LogProvider {
         return logger;
     }
 }
-//# sourceMappingURL=log.js.map

package/build/esm/src/services/utils/server-interface.js

@@ -77,4 +77,3 @@ export class ServerInterfaceImpl {
         return this.loggerProvider?.getLogger(identifier, options);
     }
 }
-//# sourceMappingURL=server-interface.js.map

package/build/esm/src/services/utils/websocketmanager.js

@@ -133,4 +133,3 @@ export class WebSocketManager {
     options: WSConfig;
   } | undefined;
 }*/
-//# sourceMappingURL=websocketmanager.js.map

package/build/esm/src/types.d.ts

@@ -1,5 +1,5 @@
 import { Database } from "@miqro/query";
-import { WebSocketServerOptions, SessionHandlerOptions, Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler, RouteOptions, Handler, Request, Response, LogLevel, LoggerTransportWriteArgs, CORSOptions } from "@miqro/core";
+import { WebSocketServerOptions, SessionHandlerOptions, Logger, WebSocketServer, ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler, RouteOptions, Handler, Request, Response, LogLevel, LoggerTransportWriteArgs, CORSOptions, HandlerWithOptions, ErrorHandler } from "@miqro/core";
 import { request } from "@miqro/request";
 import { ParserInterface } from "@miqro/parser";
 import { RuntimeHTMLElement, Runtime, RuntimeContainer, RuntimeURL, RuntimeOptions, RuntimeShadowRootInit } from "@miqro/jsx";
@@ -140,6 +140,21 @@ declare global {
 }
 export interface AuthConfig extends SessionHandlerOptions {
 }
+export interface MiddlewareConfig {
+    middleware?: Array<HandlerWithOptions | Handler>;
+    post?: Array<HandlerWithOptions | Handler>;
+}
+export interface ErrorConfig {
+    catch?: Array<ErrorHandler>;
+}
+export interface DocConfig {
+    publish: {
+        [path: string]: {
+            type?: "HTML" | "MD" | "JSON";
+            all?: boolean;
+        };
+    };
+}
 export interface WSConfig extends WebSocketServerOptions {
     path: string;
     disabled?: boolean;

package/build/esm/src/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map