oox 0.3.2 → 0.3.4

package/modules/socketio/server.js

@@ -3,7 +3,8 @@ import * as https from 'node:https';
 import { Server } from 'socket.io';
 import * as oox from '../../index.js';
 import { Module, ModuleConfig } from '../../index.js';
-import { sockets } from './socket.js';
+import SocketIOAdapter from './adapter.js';
+import { OOXEvent } from './utils.js';
 export class SocketIOConfig extends ModuleConfig {
     // listen port
     port = 0;
@@ -32,30 +33,12 @@ export default class SocketIOServer extends Module {
     #isSelfServer = false;
     server = null;
     socketServer = null;
-    static isWebSocketUrl(url) {
-        return /^wss?:\/\/.+$/.test(url);
-    }
-    static genWebSocketUrl(url) {
-        // :6000
-        if (url.startsWith(':'))
-            url = oox.config.host + url;
-        // 127.0.0.1:6000
-        if (!/^\w+?:\/.+$/.test(url))
-            url = 'ws://' + url;
-        const urlObject = new URL(url);
-        if (urlObject.protocol !== 'wss:') {
-            if (urlObject.port === '443')
-                urlObject.protocol = 'wss:';
-            else
-                urlObject.protocol = 'ws:';
-        }
-        return urlObject.toString();
-    }
-    getUrl() {
+    adapter = new SocketIOAdapter();
+    getURL() {
         const { host } = oox.config;
         const { port, path } = this.config;
         const protocol = this.config.ssl.enabled ? 'wss:' : 'ws:';
-        return `${protocol}//${host}:${port}${path}`;
+        return new URL(`${protocol}//${host}:${port}${path}`);
     }
     setConfig(config) {
         Object.assign(this.config, config);
@@ -70,6 +53,7 @@ export default class SocketIOServer extends Module {
         return this.config;
     }
     async serve() {
+        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
         await this.stop();
         const { port, ssl } = this.config;
         const isSelfServer = this.#isSelfServer = this.server ? true : false;
@@ -149,6 +133,7 @@ export default class SocketIOServer extends Module {
                 this.serverOnSocketConnection(socket);
             }
             catch (error) {
+                console.error(error);
                 socket.send(error.message).disconnect(true);
             }
         });
@@ -159,30 +144,39 @@ export default class SocketIOServer extends Module {
     serverOnSocketConnection(socket) {
         const headers = socket.handshake.headers;
         const callerId = String(headers['x-caller-id'] || '') || socket.id;
-        // 已经存在相同的连接
-        if (sockets.has(callerId))
-            throw new Error('Connection Exists');
         // client ip or caller service ip
         const ip = String(headers['x-real-ip'] || headers['x-ip'] || socket.handshake.address);
         // service name
         const caller = String(headers['x-caller'] || 'anonymous');
-        socket.data = { connected: true, host: ip, name: caller, id: callerId };
-        // 保存 callerId 与 socket 对应关系
-        sockets.set(callerId, socket);
-        socket.on('disconnect', reason => this.serverOnSocketDisconnect(socket, reason));
-        socket.emit('oox_connected', { name: oox.config.name });
-        this.serverOnConnection(socket);
+        const connection = new oox.KeepAliveConnection(this.adapter, socket, {
+            host: ip,
+            name: caller,
+            id: callerId,
+        });
+        oox.addKeepAliveConnection(connection);
+        this.bindServerConnectionEvents(connection);
+        this.adapter.bindCall(connection);
+        connection.enabled = true;
+        socket.emit(OOXEvent.READY, {
+            id: oox.config.id,
+            name: oox.config.name
+        });
     }
-    serverOnConnection(socket) { }
     /**
-     * 服务端Socket断开事件
-     * @param {Socket} socket
-     * @param {Error} reason
+     * 绑定服务器连接事件
+     * @param connection
      */
-    serverOnSocketDisconnect(socket, reason) {
-        socket.data.connected = false;
-        sockets.delete(socket.data.id);
-        this.serverOnDisconnect(socket, reason);
+    bindServerConnectionEvents(connection) {
+        const socket = connection.nativeConnection;
+        socket.on(OOXEvent.SYNC_CONNECTIONS, async (fn) => {
+            if ('function' !== typeof fn)
+                return;
+            oox.registry.onSyncConnections(connection, {}, fn);
+        });
+        socket.on('disconnecting', (reason) => {
+            oox.removeKeepAliveConnection(connection);
+            socket.removeAllListeners();
+            connection.emit('disconnect');
+        });
     }
-    serverOnDisconnect(socket, reason) { }
 }

package/modules/socketio/socket.js

@@ -1 +1 @@
-export const sockets = new Map();
+export {};

package/modules/socketio/utils.js

@@ -0,0 +1,39 @@
+export var OOXEvent;
+(function (OOXEvent) {
+    OOXEvent["READY"] = "oox:ready";
+    OOXEvent["ENABLED"] = "oox:enabled";
+    OOXEvent["DISABLED"] = "oox:disabled";
+    OOXEvent["SYNC_CONNECTIONS"] = "oox:sync_connections";
+})(OOXEvent || (OOXEvent = {}));
+export function isWebSocketURL(url) {
+    if ('string' === typeof url) {
+        return /^wss?:\/\/.+$/.test(url);
+    }
+    else {
+        return url.protocol === 'ws:' || url.protocol === 'wss:';
+    }
+}
+export function genWebSocketURL(url) {
+    // :6000
+    if (url.startsWith(':'))
+        url = 'ws://localhost' + url;
+    // 127.0.0.1:6000
+    if (!/^\w+?:\/.+$/.test(url))
+        url = 'ws://' + url;
+    const urlObject = new URL(url);
+    // :8000 => :8000/socket.io
+    const notSetPath = !urlObject.pathname || (urlObject.pathname === '/'
+        && !url.endsWith('/')
+        && !urlObject.search
+        && !urlObject.hash);
+    if (notSetPath) {
+        urlObject.pathname = '/socket.io';
+    }
+    if (urlObject.protocol !== 'wss:') {
+        if (urlObject.port === '443')
+            urlObject.protocol = 'wss:';
+        else
+            urlObject.protocol = 'ws:';
+    }
+    return urlObject;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.2",
+    "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/app.d.ts

@@ -7,7 +7,7 @@ export interface ReturnsBody {
     body?: any;
     error?: {
         message: string;
-        stack: string;
+        stack?: string;
     };
 }
 export declare class Context {

package/types/index.d.ts

@@ -1,20 +1,18 @@
 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';
-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;
+    connection?: KeepAliveConnection<any>;
     toJSON?(): {} & this;
 }
 export declare class Config {
     [x: string]: any;
+    id: `${string}-${string}-${string}-${string}-${string}`;
     name: string;
     group: string;
     ignore: string[];
@@ -24,8 +22,11 @@ export declare class Config {
     };
     host: string;
     port: number;
-    origin: string;
+    origin: string | string[];
     errorStack: boolean;
+    isRegistry: boolean;
+    registry: string[];
+    registryAdapter: string;
 }
 export declare const config: Config;
 export declare function setGenTraceIdFunction(fn: () => string): void;
@@ -40,39 +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 interface RPCConnectionAdapter {
-    rpc(connection: any, action: string, params: any[], context: Context): Promise<any>;
-}
-export interface RPCKeepAliveConnectionData {
-    /**
-     * 是否连接成功
-     */
-    connected: boolean;
-    /**
-     * 连接主机地址
-     */
-    host: string;
-    /**
-     * 连接服务名称
-     */
-    name: string;
-    /**
-     * 目标服务网络唯一ID
-     */
-    id: string;
-}
-export declare class RPCKeepAliveConnection {
-    data: RPCKeepAliveConnectionData;
-    nativeConnection: any;
-    adapter: RPCConnectionAdapter;
-    constructor(adapter: RPCConnectionAdapter, nativeConnection: any, data?: RPCKeepAliveConnectionData);
-}
-export declare const keepAliveConnections: Map<string, Map<string, RPCKeepAliveConnection>>;
-export declare function getKeepAliveConnections(name: string): Map<string, RPCKeepAliveConnection>;
-export declare function getKeepAliveConnection(name: string, id: string): RPCKeepAliveConnection | null;
-export declare function addKeepAliveConnection(connection: RPCKeepAliveConnection): void;
-export declare function removeKeepAliveConnection(connection: RPCKeepAliveConnection): 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): 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, 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/http/index.d.ts

@@ -5,7 +5,7 @@ import Module, { ModuleConfig } from '../module.js';
 export declare class HTTPConfig extends ModuleConfig {
     port: number;
     path: string;
-    origin: string;
+    origin: string | string[];
     ssl: {
         enabled: boolean;
         cert: string;
@@ -18,7 +18,7 @@ export default class HTTPModule extends Module {
     config: HTTPConfig;
     server: http.Server;
     router: Router;
-    getUrl(): string;
+    getURL(): URL;
     get(path: string, ...args: any[]): this;
     post(path: string, ...args: any[]): this;
     put(path: string, ...args: any[]): this;

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

@@ -0,0 +1,14 @@
+import * as oox from '../../index.js';
+import { Socket } from './socket.js';
+import { OOXEvent } from './utils.js';
+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/index.d.ts

@@ -1,37 +1,4 @@
-import SocketIOClient from './client.js';
-import * as oox from '../../index.js';
-import { RPCKeepAliveConnectionData, RPCConnectionAdapter } from '../../index.js';
-import { Socket, sockets, ServerSocket, ClientSocket } from './socket.js';
-export { Socket, sockets };
-export default class SocketIOModule extends SocketIOClient implements RPCConnectionAdapter {
-    sockets: Map<string, Socket>;
+import SocketINServer from './server.js';
+export default class SocketIOModule extends SocketINServer {
     serve(): Promise<void>;
-    onSyncConnection(socket: Socket): oox.RPCKeepAliveConnectionData[];
-    serverOnDisconnect(socket: ServerSocket, reason: string): void;
-    clientOnDisconnect(socket: ClientSocket, reason: any): void;
-    /**
-     *
-     * @param socket 是由哪个通道发送过来的
-     * @param connectionDatas
-     */
-    clientOnSyncConnection(socket: Socket, connectionDatas: RPCKeepAliveConnectionData[]): void;
-    onFetchActions(socket: Socket, search: string): string[];
-    fetchActions(url: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
-    fetchActions(name: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
-    onConnection(socket: Socket): void;
-    /**
-     *
-     * @param {Socket} socket
-     */
-    serverOnConnection(socket: ServerSocket): void;
-    call(action: string, params: any[], context: oox.Context, callback?: (returns: any) => void): Promise<oox.ReturnsBody>;
-    clientOnConnection(socket: ClientSocket): void;
-    /**
-     * socketio emit
-     */
-    emit(url: string, event: string, params: any[]): Promise<unknown>;
-    /**
-     * RPC
-     */
-    rpc(url: string, action: string, params: [], context?: oox.Context): Promise<any>;
 }

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

@@ -1,12 +1,14 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
 import { Server, ServerOptions } from 'socket.io';
+import * as oox from '../../index.js';
 import { Module, ModuleConfig } from '../../index.js';
-import { ServerSocket as Socket } from './socket.js';
+import { Socket } from './socket.js';
+import SocketIOAdapter from './adapter.js';
 export declare class SocketIOConfig extends ModuleConfig {
     port: number;
     path: string;
-    origin: string;
+    origin: string | string[];
     ssl: {
         enabled: boolean;
         cert: string;
@@ -20,9 +22,8 @@ export default class SocketIOServer extends Module {
     config: SocketIOConfig;
     server: http.Server | https.Server;
     socketServer: Server;
-    static isWebSocketUrl(url: string): boolean;
-    static genWebSocketUrl(url: string): string;
-    getUrl(): string;
+    adapter: SocketIOAdapter;
+    getURL(): URL;
     setConfig(config: SocketIOConfig): void;
     getConfig(): SocketIOConfig;
     serve(): Promise<void>;
@@ -32,13 +33,10 @@ export default class SocketIOServer extends Module {
     /**
      * 服务端Socket连接事件
      */
-    serverOnSocketConnection(socket: Socket): void;
-    serverOnConnection(socket: Socket): void;
+    serverOnSocketConnection(socket: Socket<'server'>): void;
     /**
-     * 服务端Socket断开事件
-     * @param {Socket} socket
-     * @param {Error} reason
+     * 绑定服务器连接事件
+     * @param connection
      */
-    serverOnSocketDisconnect(socket: Socket, reason: string): void;
-    serverOnDisconnect(socket: Socket, reason: string): void;
+    bindServerConnectionEvents(connection: oox.KeepAliveConnection<Socket<'server'>>): void;
 }