oox 0.3.3 → 0.3.4

package/bin/cli.js

@@ -27,23 +27,26 @@ if (execFilename.endsWith('oox') || fileURLToPath(import.meta.url) === execFilen
         console.log();
         console.log('  oox entry.js port=8080');
         console.log();
-        console.log('  oox app/entry/index.js group=app/ env=envs/entry.js ignore=core');
+        console.log('  oox entry.js group=app/ registry=:6000');
+        console.log('  oox app/entry/index.js group=app/ env=envs/prod.js ignore=core');
         console.log();
         console.log(chalk.bold('Params:'));
         const params = [
-            ['  default-env  [ file ]  ', '.js or .json file, merge to oox.config'],
-            ['  env          [ file ]  ', '.js or .json file, merge to oox.config', chalk.bold('(after default-env)')],
-            ['  port         [ int  ]  ', 'set', chalk.bold('0'), 'for random port, or any integer > 0'],
-            ['  group        [ dir  ]  ', 'service group directory, all LocalCall transform to RPC'],
-            ['  ignore       [ name ]  ', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
-            ['  http         [ json ]  ', 'HTTP server options, support flat name, ex: http.path=/api'],
-            ['  socketio     [ json ]  ', 'SocketIO server options, support flat name'],
-            ['  registry     [ urls ]  ', 'registry service url, support string | array<string>'],
-            ['  origin       [ urls ]  ', 'set', chalk.bold('*'), 'allow any connections <Access-Control-Allow-Origin>'],
-            ['  errorStack  [ bool ]  ', 'set no to hidden error stack return'],
-            ['  ...                    ', 'set params as', chalk.bold('foo=bar') + ',', 'usage as', chalk.bold('oox.config.foo')]
+            ['default-env', 'file', '.js or .json file, merge to oox.config'],
+            ['env', 'file', `${chalk.bold.red('default-env')}.js or .json file, merge to oox.config, ${chalk.bold('(after default-env)')}`],
+            ['port', 'int', `default is ${chalk.bold('0')}, for random port, or any integer > 0`],
+            ['group', 'dir', 'service group directory, all LocalCall transform to RPC'],
+            ['ignore', 'name', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
+            ['http', 'json', 'HTTP server options, support flat name, ex: http.path=/api'],
+            ['socketio', 'json', 'SocketIO server options, support flat name'],
+            ['isRegistry', 'bool', `default is ${chalk.bold.red('true')}, set no to disable service registry`],
+            ['registryAdapter', 'name', 'set service registry adapter name'],
+            ['registry', 'urls', 'registry service url, support string | array<string>'],
+            ['origin', 'urls', `set ${chalk.bold('*')}, allow any connections <Access-Control-Allow-Origin>`],
+            ['errorStack', 'bool', 'set no to hidden error stack return'],
         ];
-        params.forEach(row => console.log(...row, '\n'));
+        console.log(mergeCommandParams(params));
+        console.log('  ...', 'set params as', chalk.bold('foo=bar') + ',', 'usage as', chalk.bold('oox.config.foo'));
         console.log();
     }
     if (isStartup) {
@@ -55,3 +58,27 @@ if (execFilename.endsWith('oox') || fileURLToPath(import.meta.url) === execFilen
         await startup();
     }
 }
+function mergeCommandParams(params) {
+    let result = '';
+    const perLinePrefix = ' '.repeat(2);
+    const nameMaxLength = 12;
+    const typeMaxLength = 6;
+    for (const param of params) {
+        const name = param[0];
+        const type = param[1];
+        const desc = param.slice(2).join(' ');
+        result += perLinePrefix + name;
+        if (name.length > nameMaxLength) {
+            result += '\n' + perLinePrefix;
+            result += ' '.repeat(nameMaxLength);
+        }
+        else {
+            result += ' '.repeat(nameMaxLength - name.length);
+        }
+        result += '[' + type + ']';
+        result += ' '.repeat(typeMaxLength - type.length);
+        result += desc;
+        result += '\n';
+    }
+    return result;
+}

package/bin/register.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import * as oox from '../index.js';
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 async function connect(url, prevError = null) {
-    const adapter = oox.rpcKeepAliveConnectionAdapters.get(oox.config.registryAdapter);
+    const adapter = oox.keepAliveConnectionAdapters.get(oox.config.registryAdapter);
     try {
         const connection = await adapter.open(url);
         onConnection(connection, url);

package/index.js

@@ -1,13 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import * as app from './app.js';
 import { getIPAddress } from './utils.js';
+import * as registry from './registry.js';
 import Module, { ModuleConfig } from './modules/module.js';
-import Modules from './modules/index.js';
-import { RPCKeepAliveConnection, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './rpc-keepalive-connection.js';
-export { RPCKeepAliveConnection, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
-export { Module, ModuleConfig };
-export const modules = new Modules;
-export const { asyncStore, setMethods, getMethods, kvMethods, sourceKVMethods, call, execute, logger, on, once, off, emit, } = app;
+import { KeepAliveConnection, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './keepalive-connection.js';
 export class Context extends app.Context {
     // 请求溯源IP
     sourceIP = '';
@@ -49,6 +45,8 @@ export class Config {
     origin = '';
     // 默认返回错误调用栈信息信息
     errorStack = true;
+    // 是否开启服务注册功能
+    isRegistry = true;
     // 服务注册列表
     registry = [];
     // 服务注册适配器
@@ -120,7 +118,7 @@ export async function rpc(arg1, action, params, context) {
         context = getContext();
     }
     let connection;
-    if (arg1 instanceof RPCKeepAliveConnection) {
+    if (arg1 instanceof KeepAliveConnection) {
         connection = arg1;
     }
     else if ('string' === typeof arg1) {
@@ -132,3 +130,10 @@ export async function rpc(arg1, action, params, context) {
         throw new Error(`Unknown rpc arg1<${arg1}>`);
     return connection.adapter.rpc(connection, action, params, context);
 }
+export { KeepAliveConnection, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
+export { Module, ModuleConfig };
+export { registry };
+export const { asyncStore, setMethods, getMethods, kvMethods, sourceKVMethods, call, execute, logger, on, once, off, emit, } = app;
+// 放在最后导入，解决循环依赖问题
+import Modules from './modules/index.js';
+export const modules = new Modules;

package/{rpc-keepalive-connection.js → keepalive-connection.js}

@@ -1,5 +1,5 @@
 import EventEmitter from 'node:events';
-export class RPCKeepAliveConnection extends EventEmitter {
+export class KeepAliveConnection extends EventEmitter {
     // 连接是否可用
     #enabled = false;
     data;
@@ -9,8 +9,14 @@ export class RPCKeepAliveConnection extends EventEmitter {
         super();
         this.adapter = adapter;
         this.nativeConnection = nativeConnection;
-        this.data = data;
+        this.data = Object.assign(data, {
+            adapter: adapter.name,
+        });
     }
+    /**
+     * 设置连接是否可用，并自动触发enabled或disabled事件
+     * @param enabled 是否可用
+     */
     set enabled(enabled) {
         if (enabled !== this.#enabled) {
             this.#enabled = enabled;
@@ -26,21 +32,22 @@ export class RPCKeepAliveConnection extends EventEmitter {
     get enabled() {
         return this.#enabled;
     }
-    updateId(newId) {
+    /**
+     * enable & mount connection
+     * @param params
+     * @returns
+     */
+    ready(params) {
+        // 连接已就绪，不允许重复就绪
+        if (this.enabled)
+            return;
+        const { id, name } = params;
         keepAliveConnections.remove(this);
-        this.data.id = newId;
-        keepAliveConnections.add(this);
-    }
-    updateName(newName) {
-        keepAliveConnections.remove(this);
-        this.data.name = newName;
-        keepAliveConnections.add(this);
-    }
-    updateIdAndName(newId, newName) {
-        keepAliveConnections.remove(this);
-        this.data.id = newId;
-        this.data.name = newName;
+        // 更新连接数据
+        this.data.id = id;
+        this.data.name = name;
         keepAliveConnections.add(this);
+        this.enabled = true;
     }
 }
 export class KeepAliveConnectionStore {
@@ -74,7 +81,7 @@ export class KeepAliveConnectionStore {
         }
     }
     remove(name, id) {
-        if (name instanceof RPCKeepAliveConnection) {
+        if (name instanceof KeepAliveConnection) {
             id = name.data.id;
             name = name.data.name;
         }
@@ -84,6 +91,6 @@ export class KeepAliveConnectionStore {
         }
     }
 }
-export const rpcKeepAliveConnectionAdapters = new Map();
+export const keepAliveConnectionAdapters = new Map();
 export const keepAliveConnections = new KeepAliveConnectionStore();
 export const enabledKeepAliveConnections = new KeepAliveConnectionStore();

package/modules/socketio/adapter.js

@@ -1,50 +1,12 @@
 import * as SocketIOClient from 'socket.io-client';
 import * as oox from '../../index.js';
-import { OOXEvent, genWebSocketURL, isWebSocketURL } from './utils.js';
+import { OOXEvent, genWebSocketURL } from './utils.js';
 import { randomUUID } from 'node:crypto';
-export default class SocketIOAdapter {
-    /**
-     * 客户端发送连接列表
-     * @param datas
-     */
-    [OOXEvent.SYNC_CONNECTIONS](datas) {
-        for (const data of datas) {
-            if (data.name === oox.config.name)
-                continue;
-            if (!data.url || !isWebSocketURL(data.url))
-                continue;
-            const has = oox.keepAliveConnections.has(data.name, data.id);
-            if (has)
-                continue;
-            this.open(data.url).catch((error) => console.error(error));
-        }
-    }
-    bindClientConnectionEvents(connection) {
-        const socket = connection.nativeConnection;
-        socket.on(OOXEvent.CONNECTED, ({ id, name }) => {
-            connection.updateIdAndName(id, name);
-            connection.enabled = true;
-            socket.emit(OOXEvent.SYNC_CONNECTIONS, this[OOXEvent.SYNC_CONNECTIONS].bind(this));
-        });
-        socket.on(OOXEvent.DISABLED, () => {
-            connection.enabled = false;
-        });
-        socket.on('disconnect', (reason) => {
-            connection.emit('disconnect');
-            oox.removeKeepAliveConnection(connection);
-            socket.removeAllListeners();
-            socket.disconnect();
-        });
-        socket.on('connect', () => {
-            connection.emit('connect');
-        });
-        socket.on('connect_error', (error) => {
-            connection.emit('error', error);
-            oox.removeKeepAliveConnection(connection);
-            socket.removeAllListeners();
-            socket.disconnect();
-        });
-    }
+import { SampleKeepAliveConnectionAdapter } from '../../samples/index.js';
+export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter {
+    name = 'socketio';
+    OOXEvent = OOXEvent;
+    nativeEvent = { CONNECT: 'connect', DISCONNECT: 'disconnect', ERROR: 'connect_error' };
     newConnection(url) {
         const { id, host, name } = oox.config;
         const headers = {
@@ -64,95 +26,12 @@ export default class SocketIOAdapter {
             path: mURL.pathname,
             autoConnect: false,
         });
-        const data = {
+        const connection = new oox.KeepAliveConnection(this, socket, {
             name: 'anonymous',
             id: randomUUID(),
             host: mURL.host,
             url: mURL
-        };
-        const connection = new oox.RPCKeepAliveConnection(this, socket, data);
-        return connection;
-    }
-    async open(url) {
-        const connection = this.newConnection(url);
-        oox.addKeepAliveConnection(connection);
-        this.bindClientConnectionEvents(connection);
-        this.bindCall(connection);
-        await new Promise((resolve, reject) => {
-            connection.once('enabled', resolve);
-            connection.once('error', reject);
-            connection.once('disconnect', () => {
-                reject(new Error('disconnect'));
-            });
-            connection.nativeConnection.connect();
         });
         return connection;
     }
-    async close(connection) {
-        connection.nativeConnection.disconnect();
-        return Promise.resolve();
-    }
-    /**
-     * socketio emit
-     */
-    async emit(socket, event, params) {
-        if (!socket.connected)
-            throw new Error('Socket not connected');
-        return await new Promise((resolve, reject) => {
-            const onError = (reason) => {
-                const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
-                reject(new Error(message));
-            };
-            // RPC 执行时中断连接
-            socket.once('disconnect', onError);
-            socket.emit(event, ...params, (returns) => {
-                socket.offAny(onError);
-                resolve(returns);
-            });
-        });
-    }
-    /**
-     * RPC
-     */
-    async rpc(connection, action, params, context) {
-        if (!context)
-            context = oox.getContext();
-        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, context]);
-        if (success)
-            return body;
-        else if (error)
-            throw new Error(error.message);
-        else
-            throw new Error('[RPC] Unknown Error');
-    }
-    /**
-     * 绑定 call 事件
-     * @param connection
-     */
-    bindCall(connection) {
-        const { id, name, host } = connection.data;
-        const connectionContext = {
-            sourceIP: '',
-            ip: host,
-            caller: name,
-            callerId: id,
-            connection
-        };
-        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);
-        });
-    }
-    async call(action, params, context, callback) {
-        const returns = await oox.call(action, params, context);
-        if (returns.error && !oox.config.errorStack) {
-            // 不返回错误调用栈信息
-            delete returns.error.stack;
-        }
-        'function' === typeof callback && callback(returns);
-        return returns;
-    }
 }

package/modules/socketio/server.js

@@ -4,7 +4,7 @@ import { Server } from 'socket.io';
 import * as oox from '../../index.js';
 import { Module, ModuleConfig } from '../../index.js';
 import SocketIOAdapter from './adapter.js';
-import { isWebSocketURL, OOXEvent } from './utils.js';
+import { OOXEvent } from './utils.js';
 export class SocketIOConfig extends ModuleConfig {
     // listen port
     port = 0;
@@ -53,7 +53,7 @@ export default class SocketIOServer extends Module {
         return this.config;
     }
     async serve() {
-        oox.rpcKeepAliveConnectionAdapters.set(this.name, this.adapter);
+        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
         await this.stop();
         const { port, ssl } = this.config;
         const isSelfServer = this.#isSelfServer = this.server ? true : false;
@@ -148,7 +148,7 @@ export default class SocketIOServer extends Module {
         const ip = String(headers['x-real-ip'] || headers['x-ip'] || socket.handshake.address);
         // service name
         const caller = String(headers['x-caller'] || 'anonymous');
-        const connection = new oox.RPCKeepAliveConnection(this.adapter, socket, {
+        const connection = new oox.KeepAliveConnection(this.adapter, socket, {
             host: ip,
             name: caller,
             id: callerId,
@@ -157,29 +157,11 @@ export default class SocketIOServer extends Module {
         this.bindServerConnectionEvents(connection);
         this.adapter.bindCall(connection);
         connection.enabled = true;
-        socket.emit(OOXEvent.CONNECTED, {
+        socket.emit(OOXEvent.READY, {
             id: oox.config.id,
             name: oox.config.name
         });
     }
-    /**
-    * 服务器发送连接列表
-    * @param connection
-    */
-    [OOXEvent.SYNC_CONNECTIONS](connection) {
-        const socket = connection.nativeConnection;
-        const datas = [];
-        for (const [name, connections] of oox.enabledKeepAliveConnections.entries()) {
-            if (name === connection.data.name)
-                continue;
-            for (const conn of Array.from(connections.values())) {
-                if (!conn.data.url || !isWebSocketURL(conn.data.url))
-                    continue;
-                datas.push(conn.data);
-            }
-        }
-        return datas;
-    }
     /**
      * 绑定服务器连接事件
      * @param connection
@@ -189,8 +171,7 @@ export default class SocketIOServer extends Module {
         socket.on(OOXEvent.SYNC_CONNECTIONS, async (fn) => {
             if ('function' !== typeof fn)
                 return;
-            const datas = this[OOXEvent.SYNC_CONNECTIONS](connection);
-            fn(datas);
+            oox.registry.onSyncConnections(connection, {}, fn);
         });
         socket.on('disconnecting', (reason) => {
             oox.removeKeepAliveConnection(connection);

package/modules/socketio/utils.js

@@ -1,6 +1,7 @@
 export var OOXEvent;
 (function (OOXEvent) {
-    OOXEvent["CONNECTED"] = "oox:connected";
+    OOXEvent["READY"] = "oox:ready";
+    OOXEvent["ENABLED"] = "oox:enabled";
     OOXEvent["DISABLED"] = "oox:disabled";
     OOXEvent["SYNC_CONNECTIONS"] = "oox:sync_connections";
 })(OOXEvent || (OOXEvent = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.3",
+    "version": "0.3.4",
     "description": "OOX Service Engine",
     "keywords": [
         "http",
@@ -22,7 +22,9 @@
             "types": "./types/index.d.ts"
         },
         "./loader": "./bin/loader.mjs",
-        "./cli": "./bin/cli.js"
+        "./cli": "./bin/cli.js",
+        "./samples": "./samples/index.js",
+        "./samples/types": "./types/samples/index.d.ts"
     },
     "bin": {
         "oox": "./bin/cli.js"

package/registry.js

@@ -0,0 +1,61 @@
+import { config } from './index.js';
+import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConnections } from './keepalive-connection.js';
+/**
+ * 服务器发送连接列表
+ * @param connection
+ * @param query
+ * @param callback
+ */
+export function onSyncConnections(connection, query, callback) {
+    // 检查是否开启服务注册功能
+    if (!config.isRegistry)
+        return callback([]);
+    const datas = [];
+    if (query.name) {
+        const names = Array.isArray(query.name) ? query.name : [query.name];
+        for (const [name, connections] of enabledKeepAliveConnections.entries()) {
+            if (names.includes(name))
+                continue;
+            for (const conn of Array.from(connections.values())) {
+                if (!conn.data.url)
+                    continue;
+                datas.push(conn.data);
+            }
+        }
+    }
+    else {
+        for (const [name, connections] of enabledKeepAliveConnections.entries()) {
+            if (name === connection.data.name)
+                continue;
+            for (const conn of Array.from(connections.values())) {
+                if (!conn.data.url)
+                    continue;
+                datas.push(conn.data);
+            }
+        }
+    }
+    callback(datas);
+}
+/**
+ * 同步连接列表
+ * @param datas 连接参数列表
+ */
+export function syncConnections(datas) {
+    for (const data of datas) {
+        // 获取适配器
+        const adapter = keepAliveConnectionAdapters.get(data.adapter);
+        if (!adapter)
+            continue;
+        // 忽略自己
+        if (data.name === config.name)
+            continue;
+        // 忽略无效URL
+        if (!data.url)
+            continue;
+        // 忽略已存在连接
+        if (keepAliveConnections.has(data.name, data.id))
+            continue;
+        // 建立连接
+        adapter.open(data.url).catch((error) => console.error(error));
+    }
+}

package/samples/index.js

@@ -0,0 +1 @@
+export { SampleKeepAliveConnectionAdapter } from './keepalive-connection-sample.js';

package/samples/keepalive-connection-sample.js

@@ -0,0 +1,130 @@
+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',
+    };
+    nativeEvent = {
+        CONNECT: 'connect',
+        DISCONNECT: 'disconnect',
+        ERROR: 'error',
+    };
+    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.on(this.OOXEvent.ENABLED, () => {
+            connection.enabled = true;
+        });
+        socket.on(this.OOXEvent.DISABLED, () => {
+            connection.enabled = false;
+        });
+        socket.on(this.nativeEvent.DISCONNECT, (reason) => {
+            connection.emit('disconnect');
+            oox.removeKeepAliveConnection(connection);
+            socket.removeAllListeners();
+            socket.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();
+        });
+    }
+    async open(url) {
+        const connection = this.newConnection(url);
+        oox.addKeepAliveConnection(connection);
+        this.bindConnectionEvents(connection);
+        this.bindCall(connection);
+        await new Promise((resolve, reject) => {
+            connection.once('enabled', resolve);
+            connection.once('error', reject);
+            connection.once('disconnect', () => {
+                reject(new Error('disconnect'));
+            });
+            if (connection.nativeConnection.connect) {
+                connection.nativeConnection.connect();
+            }
+        });
+        return connection;
+    }
+    async close(connection) {
+        connection.nativeConnection.disconnect();
+        return Promise.resolve();
+    }
+    /**
+     * 发送事件
+     * @param socket
+     * @param event
+     * @param params
+     */
+    async emit(socket, event, params) {
+        if (!socket.connected)
+            throw new Error('Socket not connected');
+        return await new Promise((resolve, reject) => {
+            const onError = (reason) => {
+                const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
+                reject(new Error(message));
+            };
+            // RPC 执行时中断连接
+            socket.once(this.nativeEvent.DISCONNECT, onError);
+            socket.emit(event, ...params, (returns) => {
+                socket.off(this.nativeEvent.DISCONNECT, onError);
+                resolve(returns);
+            });
+        });
+    }
+    /**
+     * RPC
+     */
+    async rpc(connection, action, params, context) {
+        if (!context)
+            context = oox.getContext();
+        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, context]);
+        if (success)
+            return body;
+        else if (error)
+            throw new Error(error.message);
+        else
+            throw new Error('[RPC] Unknown Error');
+    }
+    /**
+     * 绑定 call 事件
+     * @param connection
+     */
+    bindCall(connection) {
+        const { id, name, host } = connection.data;
+        const connectionContext = {
+            sourceIP: '',
+            ip: host,
+            caller: name,
+            callerId: id,
+            connection
+        };
+        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);
+        });
+    }
+    async call(action, params, context, callback) {
+        const returns = await oox.call(action, params, context);
+        if (returns.error && !oox.config.errorStack) {
+            // 不返回错误调用栈信息
+            delete returns.error.stack;
+        }
+        'function' === typeof callback && callback(returns);
+        return returns;
+    }
+}

package/types/index.d.ts

@@ -1,18 +1,13 @@
 import * as app from './app.js';
+import * as registry from './registry.js';
 import Module, { ModuleConfig } from './modules/module.js';
-import Modules from './modules/index.js';
-import { RPCKeepAliveConnectionAdapter, RPCKeepAliveConnection, RPCKeepAliveConnectionData, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './rpc-keepalive-connection.js';
-export { RPCKeepAliveConnectionAdapter, RPCKeepAliveConnection, RPCKeepAliveConnectionData, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
-export { ReturnsBody } from './app.js';
-export { Module, ModuleConfig };
-export declare const modules: Modules;
-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 { KeepAliveConnectionReadyParams, KeepAliveConnectionAdapter, KeepAliveConnection, KeepAliveConnectionData, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './keepalive-connection.js';
 export declare class Context extends app.Context {
     sourceIP: string;
     ip: string;
     caller: string;
     callerId: string;
-    connection?: RPCKeepAliveConnection<any>;
+    connection?: KeepAliveConnection<any>;
     toJSON?(): {} & this;
 }
 export declare class Config {
@@ -29,6 +24,7 @@ export declare class Config {
     port: number;
     origin: string | string[];
     errorStack: boolean;
+    isRegistry: boolean;
     registry: string[];
     registryAdapter: string;
 }
@@ -45,9 +41,16 @@ 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: RPCKeepAliveConnection<any>): void;
-export declare function removeKeepAliveConnection(connection: RPCKeepAliveConnection<any>): void;
+export declare function addKeepAliveConnection(connection: KeepAliveConnection<any>): void;
+export declare function removeKeepAliveConnection(connection: KeepAliveConnection<any>): void;
 export declare function removeKeepAliveConnection(name: string, id: string): void;
-export declare function setLoadBalancePolicy(policy: (name: string) => RPCKeepAliveConnection<any>): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => KeepAliveConnection<any>): void;
 export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
-export declare function rpc(connection: RPCKeepAliveConnection<any>, 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 { 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;

package/types/keepalive-connection.d.ts

@@ -0,0 +1,79 @@
+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> {
+    /**
+     * 连接适配器名称
+     */
+    name: string;
+    open(url: string | URL): Promise<KeepAliveConnection<T>>;
+    close(connection: KeepAliveConnection<T>): Promise<void>;
+    rpc(connection: KeepAliveConnection<T>, action: string, params: any[], context: Context): Promise<any>;
+}
+export interface KeepAliveConnectionData {
+    /**
+     * 连接适配器名称
+     */
+    adapter: string;
+    /**
+     * 连接主机地址
+     */
+    host: string;
+    /**
+     * 连接服务名称
+     */
+    name: string;
+    /**
+     * 连接URL
+     */
+    url?: string | URL;
+    /**
+     * 目标服务网络唯一ID
+     */
+    id: 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> {
+    #private;
+    data: KeepAliveConnectionData;
+    nativeConnection: T;
+    adapter: KeepAliveConnectionAdapter<T>;
+    constructor(adapter: KeepAliveConnectionAdapter<T>, nativeConnection: T, data: MakeOptional<KeepAliveConnectionData, 'adapter'>);
+    /**
+     * 设置连接是否可用，并自动触发enabled或disabled事件
+     * @param enabled 是否可用
+     */
+    set enabled(enabled: boolean);
+    get enabled(): boolean;
+    /**
+     * enable & mount connection
+     * @param params
+     * @returns
+     */
+    ready(params: KeepAliveConnectionReadyParams): void;
+}
+export declare class KeepAliveConnectionStore<T> {
+    #private;
+    entries(): MapIterator<[string, Map<string, KeepAliveConnection<T>>]>;
+    getConnectionsOfService(name: string): Map<string, KeepAliveConnection<T>>;
+    has(name: string, id: string): boolean;
+    get(name: string, id: string): KeepAliveConnection<T> | null;
+    add(connection: KeepAliveConnection<T>): void;
+    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 {};

package/types/modules/socketio/adapter.d.ts

@@ -1,28 +1,14 @@
 import * as oox from '../../index.js';
 import { Socket } from './socket.js';
 import { OOXEvent } from './utils.js';
-export default class SocketIOAdapter implements oox.RPCKeepAliveConnectionAdapter<Socket> {
-    /**
-     * 客户端发送连接列表
-     * @param datas
-     */
-    [OOXEvent.SYNC_CONNECTIONS](datas: oox.RPCKeepAliveConnectionData[]): void;
-    bindClientConnectionEvents(connection: oox.RPCKeepAliveConnection<Socket<'client'>>): void;
-    newConnection(url: string | URL): oox.RPCKeepAliveConnection<Socket>;
-    open(url: string | URL): Promise<oox.RPCKeepAliveConnection<Socket>>;
-    close(connection: oox.RPCKeepAliveConnection<Socket>): Promise<void>;
-    /**
-     * socketio emit
-     */
-    emit(socket: Socket, event: string, params: any[]): Promise<unknown>;
-    /**
-     * RPC
-     */
-    rpc(connection: oox.RPCKeepAliveConnection<Socket>, action: string, params: [], context?: oox.Context): Promise<any>;
-    /**
-     * 绑定 call 事件
-     * @param connection
-     */
-    bindCall(connection: oox.RPCKeepAliveConnection<Socket>): void;
-    call(action: string, params: any[], context: oox.Context, callback?: (returns: any) => void): Promise<oox.ReturnsBody>;
+import { SampleKeepAliveConnectionAdapter } from '../../samples/index.js';
+export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter<Socket> {
+    name: string;
+    OOXEvent: typeof OOXEvent;
+    nativeEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+    };
+    newConnection(url: string | URL): oox.KeepAliveConnection<Socket>;
 }

package/types/modules/socketio/server.d.ts

@@ -5,7 +5,6 @@ import * as oox from '../../index.js';
 import { Module, ModuleConfig } from '../../index.js';
 import { Socket } from './socket.js';
 import SocketIOAdapter from './adapter.js';
-import { OOXEvent } from './utils.js';
 export declare class SocketIOConfig extends ModuleConfig {
     port: number;
     path: string;
@@ -35,14 +34,9 @@ export default class SocketIOServer extends Module {
      * 服务端Socket连接事件
      */
     serverOnSocketConnection(socket: Socket<'server'>): void;
-    /**
-    * 服务器发送连接列表
-    * @param connection
-    */
-    [OOXEvent.SYNC_CONNECTIONS](connection: oox.RPCKeepAliveConnection<Socket<'server'>>): oox.RPCKeepAliveConnectionData[];
     /**
      * 绑定服务器连接事件
      * @param connection
      */
-    bindServerConnectionEvents(connection: oox.RPCKeepAliveConnection<Socket<'server'>>): void;
+    bindServerConnectionEvents(connection: oox.KeepAliveConnection<Socket<'server'>>): void;
 }

package/types/modules/socketio/utils.d.ts

@@ -1,5 +1,6 @@
 export declare enum OOXEvent {
-    CONNECTED = "oox:connected",
+    READY = "oox:ready",
+    ENABLED = "oox:enabled",
     DISABLED = "oox:disabled",
     SYNC_CONNECTIONS = "oox:sync_connections"
 }

package/types/registry.d.ts

@@ -0,0 +1,16 @@
+import { KeepAliveConnection, KeepAliveConnectionData } from './keepalive-connection.js';
+export interface SyncConnectionsQuery {
+    name?: string | string[];
+}
+/**
+ * 服务器发送连接列表
+ * @param connection
+ * @param query
+ * @param callback
+ */
+export declare function onSyncConnections(connection: KeepAliveConnection<any>, query: SyncConnectionsQuery, callback: (datas: KeepAliveConnectionData[]) => void): void;
+/**
+ * 同步连接列表
+ * @param datas 连接参数列表
+ */
+export declare function syncConnections(datas: KeepAliveConnectionData[]): void;

package/types/samples/index.d.ts

@@ -0,0 +1 @@
+export { SampleKeepAliveConnectionAdapter, SampleKeepAliveNativeConnection } from './keepalive-connection-sample.js';

package/types/samples/keepalive-connection-sample.d.ts

@@ -0,0 +1,46 @@
+import * as oox from '../index.js';
+export interface SampleKeepAliveNativeConnection {
+    connected: boolean;
+    connect?(): void;
+    disconnect(): void;
+    on(event: string | symbol, listener: (...args: any[]) => void): any;
+    once(event: string | symbol, listener: (...args: any[]) => void): any;
+    off(event: string | symbol, listener?: (...args: any[]) => void): any;
+    emit(event: string | symbol, ...args: any[]): any;
+    removeAllListeners(event?: string | symbol): any;
+}
+export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection extends SampleKeepAliveNativeConnection> implements oox.KeepAliveConnectionAdapter<NativeConnection> {
+    name: string;
+    OOXEvent: {
+        READY: string;
+        ENABLED: string;
+        DISABLED: string;
+        SYNC_CONNECTIONS: string;
+    };
+    nativeEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+    };
+    abstract newConnection(url: string | URL): oox.KeepAliveConnection<NativeConnection>;
+    bindConnectionEvents(connection: oox.KeepAliveConnection<NativeConnection>): void;
+    open(url: string | URL): Promise<oox.KeepAliveConnection<NativeConnection>>;
+    close(connection: oox.KeepAliveConnection<NativeConnection>): Promise<void>;
+    /**
+     * 发送事件
+     * @param socket
+     * @param event
+     * @param params
+     */
+    emit(socket: NativeConnection, event: string, params: any[]): Promise<unknown>;
+    /**
+     * RPC
+     */
+    rpc(connection: oox.KeepAliveConnection<NativeConnection>, action: string, params: [], context?: oox.Context): Promise<any>;
+    /**
+     * 绑定 call 事件
+     * @param connection
+     */
+    bindCall(connection: oox.KeepAliveConnection<NativeConnection>): void;
+    call(action: string, params: any[], context: oox.Context, callback?: (returns: any) => void): Promise<oox.ReturnsBody>;
+}

package/types/rpc-keepalive-connection.d.ts

@@ -1,57 +0,0 @@
-import EventEmitter from 'node:events';
-import { Context } from './index.js';
-export interface RPCKeepAliveConnectionAdapter<T> {
-    open(url: string | URL): Promise<RPCKeepAliveConnection<T>>;
-    close(connection: RPCKeepAliveConnection<T>): Promise<void>;
-    rpc(connection: RPCKeepAliveConnection<T>, action: string, params: any[], context: Context): Promise<any>;
-}
-export interface RPCKeepAliveConnectionData {
-    /**
-     * 连接主机地址
-     */
-    host: string;
-    /**
-     * 连接服务名称
-     */
-    name: string;
-    /**
-     * 连接URL
-     */
-    url?: string | URL;
-    /**
-     * 目标服务网络唯一ID
-     */
-    id: string;
-}
-export type RPCKeepAliveConnectionEventMap = Record<keyof {
-    "enabled": any;
-    "disabled": any;
-    "connect": any;
-    "disconnect": any;
-    'error': any;
-}, any[]>;
-export declare class RPCKeepAliveConnection<T> extends EventEmitter<RPCKeepAliveConnectionEventMap> {
-    #private;
-    data: RPCKeepAliveConnectionData;
-    nativeConnection: T;
-    adapter: RPCKeepAliveConnectionAdapter<T>;
-    constructor(adapter: RPCKeepAliveConnectionAdapter<T>, nativeConnection: T, data: RPCKeepAliveConnectionData);
-    set enabled(enabled: boolean);
-    get enabled(): boolean;
-    updateId(newId: string): void;
-    updateName(newName: string): void;
-    updateIdAndName(newId: string, newName: string): void;
-}
-export declare class KeepAliveConnectionStore<T> {
-    #private;
-    entries(): MapIterator<[string, Map<string, RPCKeepAliveConnection<T>>]>;
-    getConnectionsOfService(name: string): Map<string, RPCKeepAliveConnection<T>>;
-    has(name: string, id: string): boolean;
-    get(name: string, id: string): RPCKeepAliveConnection<T> | null;
-    add(connection: RPCKeepAliveConnection<T>): void;
-    remove(connection: RPCKeepAliveConnection<T>): void;
-    remove(name: string, id: string): void;
-}
-export declare const rpcKeepAliveConnectionAdapters: Map<string, RPCKeepAliveConnectionAdapter<any>>;
-export declare const keepAliveConnections: KeepAliveConnectionStore<any>;
-export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<any>;