oox 0.3.4 → 0.3.5

package/registry.js

@@ -1,5 +1,71 @@
 import { config } from './index.js';
 import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConnections } from './keepalive-connection.js';
+const unsubscribeListeners = new Map();
+const subscribes = new Map();
+let broadcastTimer = null;
+/**
+ * 取消订阅连接列表
+ * @param connection
+ */
+export function unsubscribe(connection) {
+    subscribes.delete(connection);
+}
+/**
+ * 订阅连接列表
+ * @param connection
+ * @param query
+ * @returns
+ */
+export function subscribe(connection, query) {
+    if (!config.isRegistry)
+        return;
+    if (!unsubscribeListeners.has(connection)) {
+        const listener = () => {
+            unsubscribe(connection);
+        };
+        unsubscribeListeners.set(connection, listener);
+        connection.once('disconnect', listener);
+    }
+    subscribes.set(connection, query);
+}
+/**
+ * 停止广播连接列表
+ */
+export function stopBroadcastTimer() {
+    if (!broadcastTimer)
+        return;
+    clearInterval(broadcastTimer);
+    broadcastTimer = null;
+}
+/**
+ * 开始广播连接列表
+ */
+export function startBroadcastTimer() {
+    if (!config.isRegistry)
+        return;
+    if (broadcastTimer)
+        clearInterval(broadcastTimer);
+    broadcastTimer = setInterval(broadcast, 1000);
+}
+/**
+ * 广播连接列表
+ */
+export function broadcast() {
+    if (!config.isRegistry)
+        return;
+    for (const [connection, query] of subscribes.entries()) {
+        try {
+            onSyncConnections(connection, query, returns => {
+                if (!returns.success)
+                    return;
+                connection.adapter['registry:notify'](connection, returns.body || []);
+            });
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+}
 /**
  * 服务器发送连接列表
  * @param connection
@@ -8,8 +74,16 @@ import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConn
  */
 export function onSyncConnections(connection, query, callback) {
     // 检查是否开启服务注册功能
-    if (!config.isRegistry)
-        return callback([]);
+    if (!config.isRegistry) {
+        const returns = {
+            success: false,
+            error: {
+                message: 'Service registration is not enabled',
+            }
+        };
+        callback(returns);
+        return;
+    }
     const datas = [];
     if (query.name) {
         const names = Array.isArray(query.name) ? query.name : [query.name];
@@ -34,14 +108,24 @@ export function onSyncConnections(connection, query, callback) {
             }
         }
     }
-    callback(datas);
+    const returns = {
+        success: true,
+        body: datas,
+    };
+    callback(returns);
 }
 /**
  * 同步连接列表
  * @param datas 连接参数列表
  */
-export function syncConnections(datas) {
-    for (const data of datas) {
+export function syncConnections(returns) {
+    if (!returns.success) {
+        if (returns.error) {
+            console.error(new Error(returns.error.message || 'Sync connections failed'));
+        }
+        return;
+    }
+    for (const data of returns.body || []) {
         // 获取适配器
         const adapter = keepAliveConnectionAdapters.get(data.adapter);
         if (!adapter)
@@ -56,6 +140,6 @@ export function syncConnections(datas) {
         if (keepAliveConnections.has(data.name, data.id))
             continue;
         // 建立连接
-        adapter.open(data.url).catch((error) => console.error(error));
+        adapter.open(data).catch((error) => console.error(error));
     }
 }

package/samples/keepalive-connection-sample.js

@@ -1,22 +1,41 @@
 import * as oox from '../index.js';
 export class SampleKeepAliveConnectionAdapter {
-    name;
     OOXEvent = {
         READY: 'oox:ready',
         ENABLED: 'oox:enabled',
         DISABLED: 'oox:disabled',
-        SYNC_CONNECTIONS: 'oox:sync_connections',
+        REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+        REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+        REGISTRY_NOTIFY: 'oox:registry:notify',
     };
     nativeEvent = {
         CONNECT: 'connect',
         DISCONNECT: 'disconnect',
         ERROR: 'error',
     };
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection, datas) {
+        connection.nativeConnection.emit(this.OOXEvent.REGISTRY_NOTIFY, datas);
+    }
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection, query) {
+        connection.nativeConnection.emit(this.OOXEvent.REGISTRY_SUBSCRIBE, query);
+    }
     bindConnectionEvents(connection) {
         const socket = connection.nativeConnection;
         socket.on(this.OOXEvent.READY, (params) => {
             connection.ready(params);
-            socket.emit(this.OOXEvent.SYNC_CONNECTIONS, oox.registry.syncConnections);
+            socket.emit(this.OOXEvent.REGISTRY_SYNC_CONNECTIONS, oox.registry.syncConnections);
+        });
+        socket.on(this.OOXEvent.REGISTRY_NOTIFY, (datas) => {
+            oox.registry.syncConnections({
+                success: true,
+                body: datas,
+            });
         });
         socket.on(this.OOXEvent.ENABLED, () => {
             connection.enabled = true;
@@ -25,23 +44,21 @@ export class SampleKeepAliveConnectionAdapter {
             connection.enabled = false;
         });
         socket.on(this.nativeEvent.DISCONNECT, (reason) => {
-            connection.emit('disconnect');
             oox.removeKeepAliveConnection(connection);
             socket.removeAllListeners();
-            socket.disconnect();
+            connection.emit('disconnect');
         });
         socket.on(this.nativeEvent.CONNECT, () => {
             connection.emit('connect');
         });
         socket.on(this.nativeEvent.ERROR, (error) => {
-            connection.emit('error', error);
             oox.removeKeepAliveConnection(connection);
             socket.removeAllListeners();
-            socket.disconnect();
+            connection.emit('error', new oox.KeepAliveConnectionError(error.message, connection));
         });
     }
-    async open(url) {
-        const connection = this.newConnection(url);
+    async open(identify) {
+        const connection = this.newConnection(identify);
         oox.addKeepAliveConnection(connection);
         this.bindConnectionEvents(connection);
         this.bindCall(connection);
@@ -89,7 +106,11 @@ export class SampleKeepAliveConnectionAdapter {
     async rpc(connection, action, params, context) {
         if (!context)
             context = oox.getContext();
-        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, context]);
+        const miniContext = {
+            sourceIP: context.sourceIP,
+            traceId: context.traceId,
+        };
+        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, miniContext]);
         if (success)
             return body;
         else if (error)
@@ -102,20 +123,16 @@ export class SampleKeepAliveConnectionAdapter {
      * @param connection
      */
     bindCall(connection) {
-        const { id, name, host } = connection.data;
-        const connectionContext = {
-            sourceIP: '',
-            ip: host,
-            caller: name,
-            callerId: id,
-            connection
-        };
+        const { id, name, ip } = connection.data;
         connection.nativeConnection.on('call', async (action, params, context, callback) => {
-            if ('object' !== typeof context)
-                context = oox.genContext(connectionContext);
-            else
-                context = oox.genContext(Object.assign(context, connectionContext));
-            this.call(action, params, context, callback);
+            const validContext = new oox.Context({
+                ...context,
+                ip: ip,
+                caller: name,
+                callerId: id,
+                connection
+            });
+            this.call(action, params, validContext, callback);
         });
     }
     async call(action, params, context, callback) {

package/types/app.d.ts

@@ -1,20 +1,20 @@
 import { EventEmitter } from 'node:events';
 import { AsyncLocalStorage } from 'node:async_hooks';
 export * as logger from './logger.js';
-export interface ReturnsBody {
-    traceId: string;
+export interface ReturnsBody<T = any> {
+    traceId?: string;
     success: boolean;
-    body?: any;
+    body?: T;
     error?: {
         message: string;
         stack?: string;
     };
 }
-export declare class Context {
+export declare class AppContext {
     [x: string]: any;
-    traceId?: string;
+    traceId?: string | undefined;
 }
-export declare const asyncStore: AsyncLocalStorage<Context>;
+export declare const asyncStore: AsyncLocalStorage<AppContext>;
 export declare const eventHub: EventEmitter<[never]>;
 /**
  * the kvMethods is all actions refs [has bind this]
@@ -24,21 +24,21 @@ export declare const sourceKVMethods: Map<string, Function>;
 export declare function setMethods(methods: any): void;
 export declare function getMethods(): any;
 export declare function on(event: 'app:configured' | 'app:served' | 'app:stopped', listener: () => void): void;
-export declare function on(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: Context) => void): void;
-export declare function on(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
-export declare function on(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: Context, error: Error) => void): void;
-export declare function on(event: 'log', listener: (timestamp: number, context: Context | null, level: string, msgs: any[]) => void): void;
+export declare function on(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: AppContext) => void): void;
+export declare function on(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody) => void): void;
+export declare function on(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: AppContext, error: Error) => void): void;
+export declare function on(event: 'log', listener: (timestamp: number, context: AppContext | null, level: string, msgs: any[]) => void): void;
 export declare function once(event: 'app:configured' | 'app:served' | 'app:stopped', listener: (...args: any[]) => void): void;
-export declare function once(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: Context) => void): void;
-export declare function once(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
-export declare function once(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: Context, error: Error) => void): void;
-export declare function once(event: 'log', listener: (timestamp: number, context: Context | null, level: string, msgs: any[]) => void): void;
+export declare function once(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: AppContext) => void): void;
+export declare function once(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody) => void): void;
+export declare function once(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: AppContext, error: Error) => void): void;
+export declare function once(event: 'log', listener: (timestamp: number, context: AppContext | null, level: string, msgs: any[]) => void): void;
 export declare function off(event: 'app:configured' | 'app:served' | 'app:stopped' | 'call:start' | 'call:success' | 'call:fail' | 'log', listener: (...args: any[]) => void): void;
 export declare function emit(event: 'app:configured' | 'app:served' | 'app:stopped'): boolean;
-export declare function emit(event: 'call:start', timestamp: number, action: string, params: any[], context: Context): boolean;
-export declare function emit(event: 'call:success', timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody): boolean;
-export declare function emit(event: 'call:fail', timestamp: number, action: string, params: any[], context: Context, error: Error): boolean;
-export declare function emit(event: 'log', timestamp: number, context: Context | null, level: string, content: any): boolean;
+export declare function emit(event: 'call:start', timestamp: number, action: string, params: any[], context: AppContext): boolean;
+export declare function emit(event: 'call:success', timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody): boolean;
+export declare function emit(event: 'call:fail', timestamp: number, action: string, params: any[], context: AppContext, error: Error): boolean;
+export declare function emit(event: 'log', timestamp: number, context: AppContext | null, level: string, content: any): boolean;
 /**
  * Call an Function on RPC server
  * @param action
@@ -46,5 +46,5 @@ export declare function emit(event: 'log', timestamp: number, context: Context |
  * @param context
  * @returns
  */
-export declare function call(action: string, params: any[], context: Context): Promise<ReturnsBody>;
-export declare function execute(action: string, params: Array<any>, context: Context): Promise<any>;
+export declare function call(action: string, params: any[] | undefined, context: AppContext): Promise<ReturnsBody>;
+export declare function execute(action: string, params: Array<any>, context: AppContext): Promise<any>;

package/types/bin/configurer.d.ts

@@ -1,3 +1,5 @@
 export declare function buildConfig(mergeEnv?: {
     [x: string]: any;
-}): Promise<any>;
+}): Promise<{
+    [x: string]: any;
+}>;

package/types/bin/register.d.ts

@@ -1 +1,2 @@
-export declare function registry(urls: string | string[]): Promise<void>;
+import * as oox from '../index.js';
+export declare function registry(identifies: string[] | oox.KeepAliveConnectionData[]): Promise<void>;

package/types/bin/starter.d.ts

@@ -1,5 +1,4 @@
-import * as oox from '../index.js';
 export declare function configure(env?: {
     [x: string]: any;
-}, entryFilename?: string): Promise<oox.Config>;
+}, entryFilename?: string): Promise<import("../config.js").Config>;
 export declare function startup(): Promise<void>;

package/types/config.d.ts

@@ -0,0 +1,54 @@
+import { KeepAliveConnectionData } from "./keepalive-connection.js";
+export interface ConfigAllow {
+    untrusted: boolean;
+    ip: string[];
+    caller: string[];
+}
+interface ConfigInterface {
+    id: string;
+    name: string;
+    group: string;
+    ignore: string[];
+    entryInfo: {
+        path: string;
+        group: string;
+    };
+    host: string;
+    port: number;
+    origin: string | string[];
+    errorStack: boolean;
+    isRegistry: boolean;
+    registry: string[] | KeepAliveConnectionData[];
+    registryToken: string;
+    registryAdapter: string;
+    token: string;
+    allow: ConfigAllow;
+}
+export declare class Config implements ConfigInterface {
+    [x: string]: any;
+    id: string;
+    name: string;
+    group: string;
+    ignore: string[];
+    entryInfo: {
+        path: string;
+        group: string;
+    };
+    host: string;
+    port: number;
+    origin: string | string[];
+    errorStack: boolean;
+    isRegistry: boolean;
+    registry: string[] | KeepAliveConnectionData[];
+    registryToken: string;
+    registryAdapter: string;
+    token: string;
+    allow: ConfigAllow;
+}
+type StrictFormatter<T> = {
+    [K in keyof T]: (value: any) => T[K];
+};
+export declare const formatters: StrictFormatter<ConfigInterface> & {
+    [x: string]: (v: any) => any;
+};
+export {};

package/types/index.d.ts

@@ -1,33 +1,21 @@
-import * as app from './app.js';
+import { AppContext } from './app.js';
 import * as registry from './registry.js';
+import { Config } from './config.js';
 import Module, { ModuleConfig } from './modules/module.js';
-import { KeepAliveConnectionReadyParams, KeepAliveConnectionAdapter, KeepAliveConnection, KeepAliveConnectionData, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './keepalive-connection.js';
-export declare class Context extends app.Context {
+import { KeepAliveConnection, KeepAliveNativeConnection } from './keepalive-connection.js';
+export interface KeepAliveRPCContext {
+    traceId?: string;
+    sourceIP?: string;
+}
+export declare class Context extends AppContext {
     sourceIP: string;
     ip: string;
     caller: string;
     callerId: string;
-    connection?: KeepAliveConnection<any>;
+    connection?: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(context?: Partial<Context>);
     toJSON?(): {} & this;
 }
-export declare class Config {
-    [x: string]: any;
-    id: `${string}-${string}-${string}-${string}-${string}`;
-    name: string;
-    group: string;
-    ignore: string[];
-    entryInfo: {
-        path: string;
-        group: string;
-    };
-    host: string;
-    port: number;
-    origin: string | string[];
-    errorStack: boolean;
-    isRegistry: boolean;
-    registry: string[];
-    registryAdapter: string;
-}
 export declare const config: Config;
 export declare function setGenTraceIdFunction(fn: () => string): void;
 /**
@@ -41,16 +29,31 @@ export declare function genContext(context?: Context): Context;
 export declare function getContext(): Context;
 export declare function serve(): Promise<void>;
 export declare function stop(): Promise<void>;
-export declare function addKeepAliveConnection(connection: KeepAliveConnection<any>): void;
-export declare function removeKeepAliveConnection(connection: KeepAliveConnection<any>): void;
+/**
+ * 检查连接是否被允许
+ * @param ip 连接主机 IP
+ * @param caller 连接服务名称
+ * @param token 令牌
+ * @returns 是否被允许
+ */
+export declare function checkAllow(ip: string, caller: string, token: string): {
+    allow: boolean;
+    reason?: string;
+};
+/**
+ * 添加长连接
+ * @throws {KeepAliveConnectionError} 连接已存在
+ * @param connection
+ */
+export declare function addKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
+export declare function removeKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
 export declare function removeKeepAliveConnection(name: string, id: string): void;
-export declare function setLoadBalancePolicy(policy: (name: string) => KeepAliveConnection<any>): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => KeepAliveConnection<KeepAliveNativeConnection>): void;
 export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
-export declare function rpc(connection: KeepAliveConnection<any>, action: string, params: any[], context?: Context): Promise<any>;
-export { KeepAliveConnectionReadyParams, KeepAliveConnectionAdapter, KeepAliveConnection, KeepAliveConnectionData, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
-export { ReturnsBody } from './app.js';
+export declare function rpc(connection: KeepAliveConnection<KeepAliveNativeConnection>, action: string, params: any[], context?: Context): Promise<any>;
+export * from './app.js';
+export * from './keepalive-connection.js';
 export { Module, ModuleConfig };
 export { registry };
-export declare const asyncStore: import("async_hooks").AsyncLocalStorage<app.Context>, setMethods: typeof app.setMethods, getMethods: typeof app.getMethods, kvMethods: Map<string, Function>, sourceKVMethods: Map<string, Function>, call: typeof app.call, execute: typeof app.execute, logger: typeof app.logger, on: typeof app.on, once: typeof app.once, off: typeof app.off, emit: typeof app.emit;
-import Modules from './modules/index.js';
-export declare const modules: Modules;
+import * as modules from './modules/index.js';
+export { modules };

package/types/keepalive-connection.d.ts

@@ -1,14 +1,33 @@
 import EventEmitter from 'node:events';
 import { Context } from './index.js';
 type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-export interface KeepAliveConnectionAdapter<T> {
+export declare class KeepAliveConnectionError extends Error {
+    connection: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(message: string, connection: KeepAliveConnection<KeepAliveNativeConnection>);
+}
+export interface KeepAliveNativeConnection {
+    disconnect(): void;
+}
+export interface KeepAliveSyncConnectionsQuery {
+    [x: string]: any;
+    name?: string | string[];
+}
+export interface KeepAliveConnectionAdapter<T extends KeepAliveNativeConnection> {
     /**
      * 连接适配器名称
      */
     name: string;
-    open(url: string | URL): Promise<KeepAliveConnection<T>>;
+    open(identify: string | URL | KeepAliveConnectionData): Promise<KeepAliveConnection<T>>;
     close(connection: KeepAliveConnection<T>): Promise<void>;
     rpc(connection: KeepAliveConnection<T>, action: string, params: any[], context: Context): Promise<any>;
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection: KeepAliveConnection<T>, datas: KeepAliveConnectionData[]): void;
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection: KeepAliveConnection<T>, query: KeepAliveSyncConnectionsQuery): void;
 }
 export interface KeepAliveConnectionData {
     /**
@@ -18,7 +37,7 @@ export interface KeepAliveConnectionData {
     /**
      * 连接主机地址
      */
-    host: string;
+    ip: string;
     /**
      * 连接服务名称
      */
@@ -31,21 +50,26 @@ export interface KeepAliveConnectionData {
      * 目标服务网络唯一ID
      */
     id: string;
+    /**
+     * 验证令牌
+     */
+    token: string;
 }
 export interface KeepAliveConnectionReadyParams {
     [x: string]: any;
     id: KeepAliveConnectionData['id'];
     name: KeepAliveConnectionData['name'];
 }
-export type KeepAliveConnectionEventMap = Record<keyof {
-    "enabled": any;
-    "disabled": any;
-    "connect": any;
-    "disconnect": any;
-    'error': any;
-}, any[]>;
-export declare class KeepAliveConnection<T> extends EventEmitter<KeepAliveConnectionEventMap> {
+interface KeepAliveConnectionEventMap<T> {
+    "enabled": [];
+    "disabled": [];
+    "connect": [];
+    "disconnect": [];
+    'error': [KeepAliveConnectionError];
+}
+export declare class KeepAliveConnection<T extends KeepAliveNativeConnection> extends EventEmitter<KeepAliveConnectionEventMap<KeepAliveConnection<T>>> {
     #private;
+    isRegistry: boolean;
     data: KeepAliveConnectionData;
     nativeConnection: T;
     adapter: KeepAliveConnectionAdapter<T>;
@@ -62,8 +86,9 @@ export declare class KeepAliveConnection<T> extends EventEmitter<KeepAliveConnec
      * @returns
      */
     ready(params: KeepAliveConnectionReadyParams): void;
+    disconnect(): void;
 }
-export declare class KeepAliveConnectionStore<T> {
+export declare class KeepAliveConnectionStore<T extends KeepAliveNativeConnection> {
     #private;
     entries(): MapIterator<[string, Map<string, KeepAliveConnection<T>>]>;
     getConnectionsOfService(name: string): Map<string, KeepAliveConnection<T>>;
@@ -73,7 +98,7 @@ export declare class KeepAliveConnectionStore<T> {
     remove(connection: KeepAliveConnection<T>): void;
     remove(name: string, id: string): void;
 }
-export declare const keepAliveConnectionAdapters: Map<string, KeepAliveConnectionAdapter<any>>;
-export declare const keepAliveConnections: KeepAliveConnectionStore<any>;
-export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<any>;
+export declare const keepAliveConnectionAdapters: Map<string, KeepAliveConnectionAdapter<KeepAliveNativeConnection>>;
+export declare const keepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
+export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
 export {};

package/types/modules/http/index.d.ts

@@ -1,8 +1,9 @@
 import * as http from 'node:http';
+import * as https from 'node:https';
 import Router, { Middleware } from './router.js';
-import * as oox from '../../index.js';
 import Module, { ModuleConfig } from '../module.js';
-export declare class HTTPConfig extends ModuleConfig {
+export declare class HTTPConfig implements ModuleConfig {
+    enabled: boolean;
     port: number;
     path: string;
     origin: string | string[];
@@ -16,7 +17,7 @@ export declare class HTTPConfig extends ModuleConfig {
 export default class HTTPModule extends Module {
     name: string;
     config: HTTPConfig;
-    server: http.Server;
+    server: http.Server | https.Server | null;
     router: Router;
     getURL(): URL;
     get(path: string, ...args: any[]): this;
@@ -58,8 +59,4 @@ export default class HTTPModule extends Module {
             stack?: any;
         };
     }): void;
-    /**
-     * HTTP RPC
-     */
-    rpc(url: string | URL, action: string, params: Array<any>, context?: oox.Context): Promise<any>;
 }

package/types/modules/index.d.ts

@@ -1,24 +1,39 @@
 import Module from './module.js';
 import HTTP from './http/index.js';
 import SocketIO from './socketio/index.js';
-export default class Modules extends Module {
-    #private;
-    /**
-     * the module unique name
-     */
-    name: string;
-    /**
-     * all builtin modules
-     */
-    builtins: {
-        http: HTTP;
-        socketio: SocketIO;
-    };
-    constructor();
-    add(module: Module): this;
-    get(name: string): Module;
-    remove(name: string): Promise<void>;
-    setConfig(config: any): void;
-    serve(): Promise<void>;
-    stop(): Promise<void>;
-}
+/**
+ * FIFO queue for modules starting
+ */
+export declare const queue: Module[];
+/**
+ * all modules map
+ */
+export declare const map: Map<string, Module>;
+/**
+ * add module to modules queue
+ */
+export declare function add(module: Module): void;
+/**
+ * get module by name
+ */
+export declare function get(name: string): Module | null;
+export declare function remove(name: string): Promise<void>;
+/**
+ * set modules config
+ */
+export declare function setConfig(config: any): void;
+/**
+ * serve modules
+ */
+export declare function serve(): Promise<void>;
+/**
+ * stop all modules
+ */
+export declare function stop(): Promise<void>;
+/**
+ * all builtin modules
+ */
+export declare const builtins: {
+    http: HTTP;
+    socketio: SocketIO;
+};