miqro 6.1.4 → 6.2.0

package/build/editor.bundle.js

@@ -8835,8 +8835,8 @@ function HighlightTextArea({ content, language, oncontentchange, tabChar, disabl
         ev.preventDefault();
         if (elementRef.current) {
           if (content !== elementRef.current.textContent) {
-            elementRef.current.innerHTML = runHighlight(elementRef.current.textContent, language);
           }
+          elementRef.current.innerHTML = runHighlight(elementRef.current.textContent, language);
         }
       },
       onkeydown: (ev) => {
@@ -9272,7 +9272,7 @@ function FileEditor({ disableLog, disablePreview, disableReload, togglePanel, is
         apiPreview
       }
     ) : /* @__PURE__ */ JSX.createElement(JSX.Fragment, null),
-    previewPath ? /* @__PURE__ */ JSX.createElement(
+    previewPath && isPanelVisible("right") ? /* @__PURE__ */ JSX.createElement(
       "div",
       {
         class: `file-editor-preview`,
@@ -10521,6 +10521,14 @@ function Editor(props) {
       const { files: files2, services: services2 } = await r.json();
       setfiles(files2);
       setservices(services2);
+      for (const file of files2) {
+        if (opened[file.filePath]) {
+          opened[file.filePath] = {
+            content: opened[file.filePath].content,
+            ...file
+          };
+        }
+      }
     }
   }
   function isDirCollapsed(dir) {

package/build/esm/editor/components/editor.js

@@ -147,6 +147,14 @@ export function Editor(props) {
             const { files, services } = await r.json();
             setfiles(files);
             setservices(services);
+            for (const file of files) {
+                if (opened[file.filePath]) {
+                    opened[file.filePath] = {
+                        content: opened[file.filePath].content,
+                        ...file
+                    };
+                }
+            }
         }
     }
     function isDirCollapsed(dir) {

package/build/esm/editor/components/file-editor.js

@@ -50,7 +50,7 @@ export function FileEditor({ disableLog, disablePreview, disableReload, togglePa
                             }
                         }, content: content, language: language }) : JSX.createElement("p", null, "binary data not supported")),
             apiPreview && apiPreview.length > 0 ? JSX.createElement(APIPReview, { isPanelVisible: isPanelVisible, apiPreview: apiPreview }) : JSX.createElement(JSX.Fragment, null),
-            previewPath ? JSX.createElement("div", { class: `file-editor-preview`, style: `${!isPanelVisible("right") ? "display: none;" : ""}` },
+            previewPath && isPanelVisible("right") ? JSX.createElement("div", { class: `file-editor-preview`, style: `${!isPanelVisible("right") ? "display: none;" : ""}` },
                 JSX.createElement("div", { class: "file-editor-preview-path" },
                     JSX.createElement("a", { href: previewPath, target: "_blank" }, "open in new window")),
                 JSX.createElement("iframe", { ref: iFrameRef, src: previewPath, sandbox: "allow-scripts allow-same-origin" })) : JSX.createElement(JSX.Fragment, null))));

package/build/esm/editor/components/highlight-text-area.js

@@ -94,8 +94,9 @@ export function HighlightTextArea({ content, language, oncontentchange, tabChar,
                 if (elementRef.current) {
                     if (content !== elementRef.current.textContent) {
                         //setlastContent(String(elementRef.current.textContent));
-                        elementRef.current.innerHTML = runHighlight(elementRef.current.textContent, language);
+                        //elementRef.current.innerHTML = runHighlight(elementRef.current.textContent, language);
                     }
+                    elementRef.current.innerHTML = runHighlight(elementRef.current.textContent, language);
                 }
             }, onkeydown: ev => {
                 if (ev.keyCode === 9) {

package/build/esm/src/common/jwt.d.ts

@@ -0,0 +1,49 @@
+import { JWTDecryptOptions, JWTDecryptResult, JWTPayload, JWTVerifyOptions, JWTVerifyResult, ProtectedHeaderParameters } from "jose";
+import { KeyObject } from "node:crypto";
+import { EncryptJWTOptions, JWTSignOptions } from "../types.js";
+/**
+ * creates a JWT encrypted token with jose
+ *
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns
+ */
+export declare function encryptJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>): Promise<string>;
+/**
+ * decrypts a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns
+ */
+export declare function decryptJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>): Promise<JWTDecryptResult<PayloadType>>;
+/**
+ * verify a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns
+ */
+export declare function verifyJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>): Promise<JWTVerifyResult<PayloadType>>;
+/**
+ * creates a signed JWT with jose
+ *
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns
+ */
+export declare function signJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>): Promise<string>;
+/**
+ * decodes a protected header with jose
+ * @param token
+ * @returns
+ */
+export declare function decodeProtectedHeaderJWT(token: string | object): ProtectedHeaderParameters;
+/**
+ * decodes a jwt token
+ * @param jwt
+ * @returns
+ */
+export declare function decodeJWT<PayloadType = JWTPayload>(jwt: string): PayloadType & JWTPayload;

package/build/esm/src/common/jwt.js

@@ -0,0 +1,76 @@
+import { EncryptJWT, SignJWT, decodeJwt, decodeProtectedHeader, jwtDecrypt as joseJWTDecrypt, jwtVerify } from "jose";
+/**
+ * creates a JWT encrypted token with jose
+ *
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns
+ */
+export async function encryptJWT(payload, secret, options) {
+    const en = new EncryptJWT(payload)
+        .setProtectedHeader({
+        alg: options?.alg ? options?.alg : 'dir',
+        enc: options?.enc ? options?.enc : 'A128CBC-HS256'
+    })
+        .setIssuedAt(options?.iat)
+        .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+        .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+        .setExpirationTime(options?.exp ? options?.exp : '2h');
+    return await en.encrypt(secret, options?.options);
+}
+/**
+ * decrypts a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns
+ */
+export async function decryptJWT(jwt, secret, options) {
+    return await joseJWTDecrypt(jwt, secret, options);
+}
+/**
+ * verify a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns
+ */
+export async function verifyJWT(jwt, secret, options) {
+    return await jwtVerify(jwt, secret, options);
+}
+/**
+ * creates a signed JWT with jose
+ *
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns
+ */
+export async function signJWT(payload, secret, options) {
+    const sign = new SignJWT(payload)
+        .setProtectedHeader({
+        alg: options?.alg ? options?.alg : 'HS256',
+    })
+        .setIssuedAt(options?.iat)
+        .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+        .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+        .setExpirationTime(options?.exp ? options?.exp : '2h');
+    return sign.sign(secret, options?.options);
+}
+/**
+ * decodes a protected header with jose
+ * @param token
+ * @returns
+ */
+export function decodeProtectedHeaderJWT(token) {
+    return decodeProtectedHeader(token);
+}
+/**
+ * decodes a jwt token
+ * @param jwt
+ * @returns
+ */
+export function decodeJWT(jwt) {
+    return decodeJwt(jwt);
+}

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

@@ -1,5 +1,5 @@
 import { chmodSync, constants, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { cwd, platform } from "node:process";
 import { getAuthConfigPath, getCORSConfigPath, getDBConfigPath, getErrorConfigPath, getMiddlewareConfigPath, getMigrationsPath, getServerConfigPath, getWSConfigPath } from "../common/paths.js";
 import { getAsset } from "../common/assets.js";
@@ -54,22 +54,22 @@ export async function inflateAppForSea(logger, inflateDir, services) {
   })`;
     }).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");
+    writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, 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 loggerProvider = new LogProvider();
   const localCache = new LocalCache();
   const cache = new ClusterCache();
   const webSocketManager = new WebSocketManager();
   const dbManager = new DBManager();
   await initGlobals();
-  const serverInterface = new ServerInterfaceImpl({
+  const serverInterface = createServerInterface({
     cache,
     localCache,
-    logProvider,
+    loggerProvider,
     wsManager: webSocketManager,
-    logger: logProvider.getLogger("server"),
+    logger: loggerProvider.getLogger("server"),
     dbManager,
     port: PORT
   });
@@ -118,9 +118,10 @@ ${Object.keys(serviceRouteFileMap)
         .map(filePath => serviceRouteFileMap[filePath])
         .filter(data => data.previewMethod === "api")
         .map(data => data.routes.map(r => {
-        const rPath = r.inflatePath;
+        const rPath = join(relative(cwd(), dirname(data.filePath)), basename(data.filePath));
         if (rPath) {
-            const apiInflatedPath = join("..", "..", service, "http", rPath + ".api.js");
+            const rPathExt = extname(rPath);
+            const apiInflatedPath = join("..", "..", rPath.substring(0, rPath.length - rPathExt.length) + ".js");
             return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await import("./${apiInflatedPath}")).default);`;
         }
         else {

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

@@ -9,6 +9,7 @@ export interface RouteFileMap {
             options?: RouterHandlerOptions;
             inflatePath?: string;
         }[];
+        filePath: string;
         service: string;
         previewMethod: "api" | "html" | null;
     };

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

@@ -55,6 +55,7 @@ function createStaticRoute(service, logger, router, dir, file, inflateDir, route
                 path: normalizePath(path)
             }],
         service,
+        filePath: file.filePath,
         previewMethod: "html"
     };
     if (inflateDir) {
@@ -137,6 +138,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                             routeFileMap[file.filePath] = {
                                 routes,
                                 service,
+                                filePath: file.filePath,
                                 previewMethod: "api"
                             };
                             const inflatedCode = inflateDir ? await inflateJSX(file.filePath, {
@@ -175,6 +177,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                             routeFileMap[file.filePath] = {
                                 routes,
                                 service,
+                                filePath: file.filePath,
                                 previewMethod: "html"
                             };
                             for (const r of routes) {
@@ -228,6 +231,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                             const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName + ".html", module.apiOptions);
                             routeFileMap[file.filePath] = {
                                 routes,
+                                filePath: file.filePath,
                                 service,
                                 previewMethod: "html"
                             };
@@ -296,6 +300,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             method: "GET",
                                             path
                                         }],
+                                    filePath: file.filePath,
                                     service,
                                     previewMethod: "html"
                                 };
@@ -345,6 +350,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                         path
                                     }],
                                 service,
+                                filePath: file.filePath,
                                 previewMethod: "html"
                             };
                             if (inflateDir) {
@@ -402,6 +408,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             method: "GET",
                                             path
                                         }],
+                                    filePath: file.filePath,
                                     service,
                                     previewMethod: "html"
                                 };
@@ -459,6 +466,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             path
                                         }],
                                     service,
+                                    filePath: file.filePath,
                                     previewMethod: "html"
                                 };
                                 if (inflateDir) {

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

@@ -8,6 +8,6 @@ export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
 export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
 export { initGlobals, assertGlobalTampered } from "./services/globals.js";
 export { appendAPIModule } from "./inflate/utils/sea-utils.js";
-export { ServerInterfaceImpl, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
+export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";

package/build/esm/src/lib.js

@@ -9,8 +9,8 @@ export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider } from "./services/utils/log.js";
 export { Miqro, ServerRequestHandler } from "./services/app.js";
 export { initGlobals, assertGlobalTampered } from "./services/globals.js";
-export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 //exported for --inflate-sea
-export { ServerInterfaceImpl } from "./services/utils/server-interface.js";
+export { appendAPIModule } from "./inflate/utils/sea-utils.js";
+export { createServerInterface } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";

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

@@ -19,7 +19,7 @@ import { initAssets } from "../common/assets.js";
 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 { createServerInterface } from "./utils/server-interface.js";
 import { getPORT, importMiqroJSON } from "../common/arguments.js";
 import { createLogProviderOptions } from "./utils/log-transport.js";
 import { createAdminInterface } from "./utils/admin-interface.js";
@@ -90,6 +90,7 @@ export class Miqro {
         this.localCache = new LocalCache(`MiqroApplicationLocalCache[${this.options.name}]`, this.logger);
         this.webSocketManager = new WebSocketManager({
             logger: this.logger,
+            loggerProvider: this.loggerProvider,
             name: `MiqroApplicationWebsocketManager[${this.options.name}]`,
             avoidLogSocket: this.options.editor
         });
@@ -100,11 +101,11 @@ export class Miqro {
             loggerProvider: this.loggerProvider,
             logger: this.logger
         });
-        this.serverInterface = new ServerInterfaceImpl({
+        this.serverInterface = createServerInterface({
             cache: this.cache,
-            localCache: this.localCache,
             dbManager: this.dbManager,
-            wsManager: this.webSocketManager,
+            localCache: this.localCache,
+            webSocketManager: this.webSocketManager,
             app: this,
             logger: this.logger,
             loggerProvider: this.loggerProvider,

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

@@ -1,11 +1,16 @@
 //@ts-ignore
 import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
+import cluster from "node:cluster";
 import { strictEqual } from "node:assert";
 import { HTMLEncode } from "@miqro/jsx-node";
 import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, Router, usePathname, Fragment, useEffect, useRef, useState, useQuery, useRefresh, useElement, createContext, useContext } from "@miqro/jsx";
 import { jsx2HTML } from "../common/jsx.js";
 import { inflateMD2HTML } from "../inflate/md.js";
 import { EXIT_CODES } from "../common/constants.js";
+import { ClusterCache, LocalCache } from "../lib.js";
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../common/jwt.js";
+import { createSecretKey } from "node:crypto";
+import { Parser } from "@miqro/parser";
 /*const globaljsx: any = Object.freeze({
   useContext,
   useRuntime,
@@ -80,7 +85,46 @@ const globalServer = Object.freeze({
         session: SessionHandler
     }),
     encodeHTML: HTMLEncode,
-    inflateMDtoHTML: inflateMD2HTML
+    inflateMDtoHTML: inflateMD2HTML,
+    createSecretKey,
+    newParser() {
+        return new Parser();
+    },
+    newClusterCache(name, logger) {
+        return new ClusterCache(name, logger);
+    },
+    newLocalCache(name, logger) {
+        return new LocalCache(name, logger);
+    },
+    getWorkerNumber() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+    },
+    getWorkerCount() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+    },
+    isPrimaryWorker() {
+        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+    },
+    jwt: {
+        decode(jwt) {
+            return decodeJWT(jwt);
+        },
+        decodeProtectedHeader(token) {
+            return decodeProtectedHeaderJWT(token);
+        },
+        decrypt(jwt, secret, options) {
+            return decryptJWT(jwt, secret, options);
+        },
+        encrypt(payload, secret, options) {
+            return encryptJWT(payload, secret, options);
+        },
+        sign(payload, secret, options) {
+            return signJWT(payload, secret, options);
+        },
+        verify(jwt, secret, options) {
+            return verifyJWT(jwt, secret, options);
+        }
+    }
 });
 export function browserJSXGlobals(inFile, jsxPath = false, useExport = true) {
     const PRE = `import { enableDebugLog, useRuntime, Link, usePathname, createContext, useContext, useElement, useRefresh, useQuery, define, Router, useState, useEffect, useRef, createElement, Fragment } from "${jsxPath}";

package/build/esm/src/services/utils/cluster-ws.d.ts

@@ -1,4 +1,4 @@
-import { WebSocketServer, WebSocketServerOptions } from "@miqro/core";
+import { Logger, WebSocketServer, WebSocketServerOptions } from "@miqro/core";
 import { Serializable } from "node:child_process";
 declare const ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
 export interface ClusterWebSocketServer2Message {
@@ -13,9 +13,11 @@ export interface ClusterWebSocketServer2Message {
 }
 export declare class ClusterWebSocketServer2 extends WebSocketServer {
     protected name: string;
+    path: string;
+    logger: Logger | Console;
     remoteClients: Set<string>;
     listener: (data: any) => Promise<void>;
-    constructor(name: string, options: WebSocketServerOptions);
+    constructor(name: string, path: string, logger: Logger | Console, options: WebSocketServerOptions);
     connect(): void;
     dispose(): void;
     broadcast(payload: string, fromUUID?: string): Promise<void>;

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

@@ -2,14 +2,17 @@ import { WebSocketServer } from "@miqro/core";
 const ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
 export class ClusterWebSocketServer2 extends WebSocketServer {
     name;
+    path;
+    logger;
     remoteClients = new Set();
     listener;
-    constructor(name, options) {
+    constructor(name, path, logger, options) {
         super({
             ...options,
             validate: (req) => {
                 if (this.options.maxConnections !== undefined &&
                     this.clients.size + this.remoteClients.size >= this.options.maxConnections) {
+                    this.logger?.warn("[%s] max web socket connection reached! connection refused from [%s]", req.uuid, req.socket.remoteAddress);
                     return false;
                 }
                 else {
@@ -27,6 +30,8 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         errorMessage: error.message
                     });
                 }
+                this.logger?.error("[%s] error from (%s) error [%s]", req.uuid, req.req.socket.remoteAddress, error);
+                this.logger?.error(error);
                 if (options.onError) {
                     options.onError(req, error);
                 }
@@ -41,6 +46,7 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         clientUUID: req.uuid
                     });
                 }
+                this.logger?.log("[%s] new web socket connection from (%s)", req.uuid, req.req.socket.remoteAddress);
                 if (options.onConnection) {
                     options.onConnection(req);
                 }
@@ -55,12 +61,15 @@ export class ClusterWebSocketServer2 extends WebSocketServer {
                         clientUUID: req.uuid
                     });
                 }
+                this.logger?.log("[%s] [%s] web socket disconnection from (%s)", req.uuid, this.path, req.req.socket.remoteAddress);
                 if (options.onDisconnect) {
                     options.onDisconnect(req);
                 }
             }
         });
         this.name = name;
+        this.path = path;
+        this.logger = logger;
         this.listener = async (data) => {
             try {
                 const msg = data;

package/build/esm/src/services/utils/server-interface.d.ts

@@ -1,6 +1,5 @@
-import { WebSocketServer, Logger } from "@miqro/core";
-import { Database } from "@miqro/query";
-import { CacheInterface, MigrateOptions, NamedMigration, ServerInterface } from "../../types.js";
+import { Logger } from "@miqro/core";
+import { CacheInterface, ServerInterface } from "../../types.js";
 import { DBManager } from "./db-manager.js";
 import { Miqro } from "../app.js";
 import { WebSocketManager } from "./websocketmanager.js";
@@ -9,35 +8,10 @@ export interface ServerInterfaceImplOptions {
     cache: CacheInterface;
     localCache: CacheInterface;
     dbManager: DBManager;
-    wsManager: WebSocketManager;
+    webSocketManager: WebSocketManager;
     logger?: Logger;
     app?: Miqro;
     port?: string;
     loggerProvider?: LogProvider;
 }
-export declare class ServerInterfaceImpl implements ServerInterface {
-    cache: CacheInterface;
-    localCache: CacheInterface;
-    logger?: Logger;
-    port?: string;
-    db: {
-        get(name: string): Database | null;
-        getMigrations(): NamedMigration[];
-        migrate(options: MigrateOptions): Promise<void>;
-    };
-    ws: {
-        get(path: string): WebSocketServer | undefined;
-        disconnectAll(path: string): void;
-    };
-    loggerProvider?: LogProvider;
-    openBrowser: (path: string) => void;
-    constructor(options: ServerInterfaceImplOptions);
-    getWorkerNumber(): number;
-    getWorkerCount(): number;
-    isPrimaryWorker(): boolean;
-    getLogger(identifier: string, options?: {
-        level?: any;
-        transports?: any[];
-        formatter?: any;
-    }): Logger;
-}
+export declare function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface;