oox 0.3.5 → 0.3.6

package/app.js

@@ -1,12 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { genKVMethods } from './utils.js';
-export * as logger from './logger.js';
-export class AppContext {
-    // 请求溯源ID
-    traceId = '';
-}
-export const asyncStore = new AsyncLocalStorage();
+import { asyncStore } from './context.js';
 export const eventHub = new EventEmitter();
 /**
  * sourceMethods => methods

package/bin/proxy-require.js

@@ -4,10 +4,6 @@ import * as path from 'node:path';
 import * as oox from '../index.js';
 import { Module } from 'node:module';
 const require = createRequire(import.meta.url);
-/**
- * 为了不重复创建Proxy，这个对象用于保存各个RPC服务的各个属性Proxy
- */
-const rpcServiceAttrMap = Object.create(null);
 /**
  * 重写 require 缓存
  */
@@ -24,24 +20,6 @@ function rewriteModuleCache(id, exports) {
     m.paths = paths;
     require.cache[id] = m;
 }
-function dotCall(name, action) {
-    return new Proxy(function () { }, {
-        get(target, key) {
-            const attrKey = name + '.' + (action ? action + '.' + key : key);
-            if (rpcServiceAttrMap) {
-                // 不重复创建Proxy
-                return rpcServiceAttrMap[attrKey];
-            }
-            const attrProxy = dotCall(name, attrKey);
-            rpcServiceAttrMap[attrKey] = attrProxy;
-            return attrProxy;
-        },
-        has(target, key) { return true; },
-        apply(target, thisArg, args) {
-            return oox.rpc(name, action, args);
-        }
-    });
-}
 export function proxyGroup(groupDirectory, excludes = []) {
     if (!groupDirectory)
         return;
@@ -70,7 +48,7 @@ export function proxyGroup(groupDirectory, excludes = []) {
             name = scriptMatch[1];
         }
         if (!excludes.includes(name))
-            rewriteModuleCache(id, dotCall(name, ''));
+            rewriteModuleCache(id, oox.proxy(name));
     }
 }
 /**

package/bin/starter.js

@@ -1,6 +1,6 @@
 import * as path from 'node:path';
 import chalk from 'chalk';
-import { formatters as configFormatters } from '../config.js';
+import { configFormatters } from '../config.js';
 import * as oox from '../index.js';
 import { buildConfig } from './configurer.js';
 import { registry } from './register.js';

package/config.js

@@ -43,7 +43,7 @@ export class Config {
         caller: [],
     };
 }
-export const formatters = {
+export const configFormatters = {
     id: function (value) {
         return String(value || randomUUID());
     },
@@ -114,3 +114,32 @@ export const formatters = {
         return value;
     }
 };
+/**
+ * 检查连接是否被允许
+ * @param ip 连接主机 IP
+ * @param caller 连接服务名称
+ * @param token 令牌
+ * @returns 是否被允许
+ */
+export function checkAllow(ip, caller, token) {
+    // check trusted token
+    const trusted = !config.token || token === config.token;
+    if (!trusted) {
+        const { allow } = config;
+        if (!allow.untrusted) {
+            return { allow: false, reason: 'untrusted' };
+        }
+        if (Array.isArray(allow.ip) && allow.ip.length) {
+            let allowed = allow.ip.some(item => item === '*' || new RegExp(item).test(ip));
+            if (!allowed)
+                return { allow: false, reason: 'not allow ip=' + ip };
+        }
+        if (Array.isArray(allow.caller) && allow.caller.length) {
+            let allowed = allow.caller.some(item => item === '*' || new RegExp(item).test(caller));
+            if (!allowed)
+                return { allow: false, reason: 'not allow caller=' + caller };
+        }
+    }
+    return { allow: true };
+}
+export const config = new Config();

package/context.js

@@ -0,0 +1,58 @@
+import { randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export const asyncStore = new AsyncLocalStorage();
+export class AppContext {
+    // 请求溯源ID
+    traceId = '';
+}
+export class Context extends AppContext {
+    // 请求溯源IP
+    sourceIP = '';
+    // 请求者IP
+    ip = '';
+    // 请求者名称
+    caller = 'anonymous';
+    // 请求者ID (长连接专用)
+    callerId = '';
+    // 请求者连接把柄
+    connection;
+    constructor(context) {
+        super();
+        if (context) {
+            if ('toJSON' in context && typeof context.toJSON !== 'function') {
+                throw new Error('Context.toJSON must be a function');
+            }
+            Object.assign(this, context);
+        }
+    }
+    toJSON() {
+        const context = Object.assign({}, this);
+        delete context.connection;
+        return context;
+    }
+}
+let genTraceIdFunction = () => randomUUID();
+export function setGenTraceIdFunction(fn) {
+    genTraceIdFunction = fn;
+}
+/**
+ * 生成随机不重复id
+ */
+export function genTraceId() {
+    return genTraceIdFunction();
+}
+/**
+ * 获取链路跟踪上下文
+ */
+export function genContext(context) {
+    const newContext = new Context(context);
+    if (!newContext.traceId)
+        newContext.traceId = genTraceId();
+    if (!newContext.sourceIP)
+        newContext.sourceIP = newContext.ip;
+    return newContext;
+}
+export function getContext() {
+    const context = asyncStore.getStore();
+    return context || genContext();
+}

package/index.js

@@ -1,61 +1,3 @@
-import { randomUUID } from 'node:crypto';
-import { asyncStore, AppContext, } from './app.js';
-import * as registry from './registry.js';
-import { Config } from './config.js';
-import Module from './modules/module.js';
-import { KeepAliveConnection, keepAliveConnections, enabledKeepAliveConnections, KeepAliveConnectionError, } from './keepalive-connection.js';
-export class Context extends AppContext {
-    // 请求溯源IP
-    sourceIP = '';
-    // 请求者IP
-    ip = '';
-    // 请求者名称
-    caller = 'anonymous';
-    // 请求者ID (长连接专用)
-    callerId = '';
-    // 请求者连接把柄
-    connection;
-    constructor(context) {
-        super();
-        if (context) {
-            if ('toJSON' in context && typeof context.toJSON !== 'function') {
-                throw new Error('Context.toJSON must be a function');
-            }
-            Object.assign(this, context);
-        }
-    }
-    toJSON() {
-        const context = Object.assign({}, this);
-        delete context.connection;
-        return context;
-    }
-}
-export const config = new Config();
-let genTraceIdFunction = () => randomUUID();
-export function setGenTraceIdFunction(fn) {
-    genTraceIdFunction = fn;
-}
-/**
- * 生成随机不重复id
- */
-export function genTraceId() {
-    return genTraceIdFunction();
-}
-/**
- * 获取链路跟踪上下文
- */
-export function genContext(context) {
-    const newContext = new Context(context);
-    if (!newContext.traceId)
-        newContext.traceId = genTraceId();
-    if (!newContext.sourceIP)
-        newContext.sourceIP = newContext.ip;
-    return newContext;
-}
-export function getContext() {
-    const context = asyncStore.getStore();
-    return context || genContext();
-}
 export async function serve() {
     await modules.serve();
     registry.startBroadcastTimer();
@@ -64,96 +6,14 @@ export async function stop() {
     await modules.stop();
     registry.stopBroadcastTimer();
 }
-/**
- * 检查连接是否被允许
- * @param ip 连接主机 IP
- * @param caller 连接服务名称
- * @param token 令牌
- * @returns 是否被允许
- */
-export function checkAllow(ip, caller, token) {
-    // check trusted token
-    const trusted = !config.token || token === config.token;
-    if (!trusted) {
-        const { allow } = config;
-        if (!allow.untrusted) {
-            return { allow: false, reason: 'untrusted' };
-        }
-        if (Array.isArray(allow.ip) && allow.ip.length) {
-            let allowed = allow.ip.some(item => item === '*' || new RegExp(item).test(ip));
-            if (!allowed)
-                return { allow: false, reason: 'not allow ip=' + ip };
-        }
-        if (Array.isArray(allow.caller) && allow.caller.length) {
-            let allowed = allow.caller.some(item => item === '*' || new RegExp(item).test(caller));
-            if (!allowed)
-                return { allow: false, reason: 'not allow caller=' + caller };
-        }
-    }
-    return { allow: true };
-}
-/**
- * 添加长连接
- * @throws {KeepAliveConnectionError} 连接已存在
- * @param connection
- */
-export function addKeepAliveConnection(connection) {
-    if (keepAliveConnections.has(connection.data.name, connection.data.id)) {
-        connection.disconnect();
-        throw new KeepAliveConnectionError('Connection already exists', connection);
-    }
-    keepAliveConnections.add(connection);
-}
-export function removeKeepAliveConnection(arg1, arg2) {
-    if (typeof arg1 === 'string') {
-        const connection = keepAliveConnections.get(arg1, arg2);
-        if (connection)
-            connection.disconnect();
-        keepAliveConnections.remove(arg1, arg2);
-        enabledKeepAliveConnections.remove(arg1, arg2);
-    }
-    else {
-        arg1.disconnect();
-        keepAliveConnections.remove(arg1);
-        enabledKeepAliveConnections.remove(arg1);
-    }
-}
-/**
-* random connection select for default load balance policy
-* @param name service name
-* @returns selected connection
-*/
-let loadBalancePolicy = (name) => {
-    const connections = enabledKeepAliveConnections.getConnectionsOfService(name);
-    if (!connections || !connections.size)
-        return null;
-    const arrayConnections = Array.from(connections.values());
-    const index = Math.floor(Math.random() * arrayConnections.length);
-    return arrayConnections[index];
-};
-export function setLoadBalancePolicy(policy) {
-    loadBalancePolicy = policy;
-}
-export async function rpc(arg1, action, params, context) {
-    if (!context || !context.traceId) {
-        context = getContext();
-    }
-    let connection = null;
-    if (arg1 instanceof KeepAliveConnection) {
-        connection = arg1;
-    }
-    else if ('string' === typeof arg1) {
-        connection = loadBalancePolicy(arg1);
-    }
-    else
-        throw new Error(`Unknown rpc arg1<${arg1}>`);
-    if (!connection)
-        throw new Error(`Connection<${arg1}> not found`);
-    return connection.adapter.rpc(connection, action, params, context);
-}
 export * from './app.js';
+export * from './config.js';
+export * from './context.js';
 export * from './keepalive-connection.js';
-export { Module };
+export * from './modules/module.js';
+export * as logger from './logger.js';
+export * from './proxy.js';
+import * as registry from './registry.js';
 export { registry };
 // 放在最后导入，避免循环依赖问题
 import * as modules from './modules/index.js';

package/keepalive-connection.js

@@ -1,4 +1,5 @@
 import EventEmitter from 'node:events';
+import { getContext } from './context.js';
 export class KeepAliveConnectionError extends Error {
     connection;
     constructor(message, connection) {
@@ -104,6 +105,65 @@ export class KeepAliveConnectionStore {
         }
     }
 }
+/**
+ * 添加长连接
+ * @throws {KeepAliveConnectionError} 连接已存在
+ * @param connection
+ */
+export function addKeepAliveConnection(connection) {
+    if (keepAliveConnections.has(connection.data.name, connection.data.id)) {
+        connection.disconnect();
+        throw new KeepAliveConnectionError('Connection already exists', connection);
+    }
+    keepAliveConnections.add(connection);
+}
+export function removeKeepAliveConnection(arg1, arg2) {
+    if (typeof arg1 === 'string') {
+        const connection = keepAliveConnections.get(arg1, arg2);
+        if (connection)
+            connection.disconnect();
+        keepAliveConnections.remove(arg1, arg2);
+        enabledKeepAliveConnections.remove(arg1, arg2);
+    }
+    else {
+        arg1.disconnect();
+        keepAliveConnections.remove(arg1);
+        enabledKeepAliveConnections.remove(arg1);
+    }
+}
+/**
+ * random connection select for default load balance policy
+ * @param name service name
+ * @returns selected connection
+ */
+let loadBalancePolicy = (name) => {
+    const connections = enabledKeepAliveConnections.getConnectionsOfService(name);
+    if (!connections || !connections.size)
+        return null;
+    const arrayConnections = Array.from(connections.values());
+    const index = Math.floor(Math.random() * arrayConnections.length);
+    return arrayConnections[index];
+};
+export function setLoadBalancePolicy(policy) {
+    loadBalancePolicy = policy;
+}
+export async function rpc(arg1, action, params, context) {
+    if (!context || !context.traceId) {
+        context = getContext();
+    }
+    let connection = null;
+    if (arg1 instanceof KeepAliveConnection) {
+        connection = arg1;
+    }
+    else if ('string' === typeof arg1) {
+        connection = loadBalancePolicy(arg1);
+    }
+    else
+        throw new Error(`Unknown rpc arg1<${arg1}>`);
+    if (!connection)
+        throw new Error(`Connection<${arg1}> not found`);
+    return connection.adapter.rpc(connection, action, params, context);
+}
 export const keepAliveConnectionAdapters = new Map();
 export const keepAliveConnections = new KeepAliveConnectionStore();
 export const enabledKeepAliveConnections = new KeepAliveConnectionStore();

package/logger.js

@@ -1,4 +1,5 @@
-import { emit, asyncStore } from './app.js';
+import { emit } from './app.js';
+import { asyncStore } from './context.js';
 export function info(...content) {
     const context = asyncStore.getStore() || null;
     emit('log', Date.now(), context, 'info', content);

package/modules/http/index.js

@@ -3,7 +3,7 @@ import * as https from 'node:https';
 import { parseHTTPBody } from './utils.js';
 import Router from './router.js';
 import * as oox from '../../index.js';
-import Module from '../module.js';
+import { Module } from '../module.js';
 export class HTTPConfig {
     enabled = true;
     // listen port

package/modules/module.js

@@ -1,2 +1,2 @@
-export default class Module {
+export class Module {
 }

package/modules/socketio/adapter.js

@@ -6,7 +6,6 @@ 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(identify) {
         const { id, name } = oox.config;
         const headers = {

package/modules/socketio/server.js

@@ -2,9 +2,10 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { Server } from 'socket.io';
 import * as oox from '../../index.js';
-import { Module } from '../../index.js';
+import { Module } from '../module.js';
 import SocketIOAdapter from './adapter.js';
 import { OOXEvent } from './utils.js';
+import { randomUUID } from 'node:crypto';
 export class SocketIOConfig {
     enabled = true;
     // listen port
@@ -137,7 +138,9 @@ export default class SocketIOServer extends Module {
         const { server } = this;
         if (!server)
             throw new Error('HTTP Server is not created');
-        const socketServer = this.socketServer = new Server(server, this.genSocketIOServerOptions());
+        const socketServer = this.socketServer = new Server(server, {
+            ...this.genSocketIOServerOptions(),
+        });
         socketServer.on('connection', async (socket) => {
             try {
                 this.serverOnSocketConnection(socket);
@@ -153,7 +156,7 @@ export default class SocketIOServer extends Module {
      */
     serverOnSocketConnection(socket) {
         const headers = socket.handshake.headers;
-        const callerId = String(headers['x-caller-id'] || '') || socket.id;
+        const callerId = String(headers['x-caller-id'] || randomUUID());
         // client ip or caller service ip
         const ip = String(headers['x-real-ip'] || socket.handshake.address);
         // service name

package/modules/socketio/utils.js

@@ -1,12 +1,15 @@
-export var OOXEvent;
-(function (OOXEvent) {
-    OOXEvent["READY"] = "oox:ready";
-    OOXEvent["ENABLED"] = "oox:enabled";
-    OOXEvent["DISABLED"] = "oox:disabled";
-    OOXEvent["REGISTRY_SYNC_CONNECTIONS"] = "oox:registry:sync_connections";
-    OOXEvent["REGISTRY_SUBSCRIBE"] = "oox:registry:subscribe";
-    OOXEvent["REGISTRY_NOTIFY"] = "oox:registry:notify";
-})(OOXEvent || (OOXEvent = {}));
+export const OOXEvent = {
+    CONNECT: 'connect',
+    DISCONNECT: 'disconnect',
+    ERROR: 'error',
+    CALL: 'call',
+    READY: 'oox:ready',
+    ENABLED: 'oox:enabled',
+    DISABLED: 'oox:disabled',
+    REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+    REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+    REGISTRY_NOTIFY: 'oox:registry:notify',
+};
 export function isWebSocketURL(url) {
     if ('string' === typeof url) {
         return /^wss?:\/\/.+$/.test(url);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.5",
+    "version": "0.3.6",
     "description": "OOX Service Engine",
     "keywords": [
         "http",
@@ -24,7 +24,10 @@
             "types": "./types/index.d.ts"
         },
         "./loader": "./bin/loader.mjs",
-        "./cli": "./bin/cli.js",
+        "./cli": {
+            "default": "./bin/cli.js",
+            "types": "./types/bin/cli.d.ts"
+        },
         "./samples": {
             "types": "./types/samples/index.d.ts",
             "default": "./samples/index.js"

package/proxy.js

@@ -0,0 +1,30 @@
+import { rpc } from './keepalive-connection.js';
+/**
+ * 为了不重复创建Proxy，这个对象用于保存各个RPC服务的各个属性Proxy
+ */
+const rpcServiceAttrMap = Object.create(null);
+export function proxy(name, action = '') {
+    return new Proxy(function () { }, {
+        get(target, key) {
+            if (typeof key !== 'string')
+                return undefined;
+            const attrKey = action ? action + '.' + key : key;
+            const attrKeyPath = name + '.' + attrKey;
+            if (attrKeyPath in rpcServiceAttrMap) {
+                // 不重复创建Proxy
+                return rpcServiceAttrMap[attrKeyPath];
+            }
+            const attrProxy = proxy(name, attrKey);
+            rpcServiceAttrMap[attrKeyPath] = attrProxy;
+            return attrProxy;
+        },
+        has(target, key) {
+            if (typeof key !== 'string')
+                return false;
+            return true;
+        },
+        apply(target, thisArg, args) {
+            return rpc(name, action, args);
+        }
+    });
+}

package/registry.js

@@ -1,4 +1,4 @@
-import { config } from './index.js';
+import { config } from './config.js';
 import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConnections } from './keepalive-connection.js';
 const unsubscribeListeners = new Map();
 const subscribes = new Map();

package/samples/index.js

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

package/samples/keepalive-connection-sample.js

@@ -1,6 +1,14 @@
-import * as oox from '../index.js';
+import * as registry from '../registry.js';
+import { config } from '../config.js';
+import { getContext, genContext, } from '../context.js';
+import { KeepAliveConnectionError, addKeepAliveConnection, removeKeepAliveConnection, } from '../keepalive-connection.js';
+import { call, } from '../app.js';
 export class SampleKeepAliveConnectionAdapter {
     OOXEvent = {
+        CONNECT: 'connect',
+        DISCONNECT: 'disconnect',
+        ERROR: 'error',
+        CALL: 'call',
         READY: 'oox:ready',
         ENABLED: 'oox:enabled',
         DISABLED: 'oox:disabled',
@@ -8,11 +16,6 @@ export class SampleKeepAliveConnectionAdapter {
         REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
         REGISTRY_NOTIFY: 'oox:registry:notify',
     };
-    nativeEvent = {
-        CONNECT: 'connect',
-        DISCONNECT: 'disconnect',
-        ERROR: 'error',
-    };
     /**
      * 通知连接列表
      */
@@ -29,10 +32,10 @@ export class SampleKeepAliveConnectionAdapter {
         const socket = connection.nativeConnection;
         socket.on(this.OOXEvent.READY, (params) => {
             connection.ready(params);
-            socket.emit(this.OOXEvent.REGISTRY_SYNC_CONNECTIONS, oox.registry.syncConnections);
+            socket.emit(this.OOXEvent.REGISTRY_SYNC_CONNECTIONS, registry.syncConnections);
         });
         socket.on(this.OOXEvent.REGISTRY_NOTIFY, (datas) => {
-            oox.registry.syncConnections({
+            registry.syncConnections({
                 success: true,
                 body: datas,
             });
@@ -43,23 +46,23 @@ export class SampleKeepAliveConnectionAdapter {
         socket.on(this.OOXEvent.DISABLED, () => {
             connection.enabled = false;
         });
-        socket.on(this.nativeEvent.DISCONNECT, (reason) => {
-            oox.removeKeepAliveConnection(connection);
+        socket.on(this.OOXEvent.DISCONNECT, () => {
+            removeKeepAliveConnection(connection);
             socket.removeAllListeners();
             connection.emit('disconnect');
         });
-        socket.on(this.nativeEvent.CONNECT, () => {
+        socket.on(this.OOXEvent.CONNECT, () => {
             connection.emit('connect');
         });
-        socket.on(this.nativeEvent.ERROR, (error) => {
-            oox.removeKeepAliveConnection(connection);
+        socket.on(this.OOXEvent.ERROR, (error) => {
+            removeKeepAliveConnection(connection);
             socket.removeAllListeners();
-            connection.emit('error', new oox.KeepAliveConnectionError(error.message, connection));
+            connection.emit('error', new KeepAliveConnectionError(error.message, connection));
         });
     }
     async open(identify) {
         const connection = this.newConnection(identify);
-        oox.addKeepAliveConnection(connection);
+        addKeepAliveConnection(connection);
         this.bindConnectionEvents(connection);
         this.bindCall(connection);
         await new Promise((resolve, reject) => {
@@ -93,9 +96,9 @@ export class SampleKeepAliveConnectionAdapter {
                 reject(new Error(message));
             };
             // RPC 执行时中断连接
-            socket.once(this.nativeEvent.DISCONNECT, onError);
+            socket.once(this.OOXEvent.DISCONNECT, onError);
             socket.emit(event, ...params, (returns) => {
-                socket.off(this.nativeEvent.DISCONNECT, onError);
+                socket.off(this.OOXEvent.DISCONNECT, onError);
                 resolve(returns);
             });
         });
@@ -105,12 +108,12 @@ export class SampleKeepAliveConnectionAdapter {
      */
     async rpc(connection, action, params, context) {
         if (!context)
-            context = oox.getContext();
+            context = getContext();
         const miniContext = {
             sourceIP: context.sourceIP,
             traceId: context.traceId,
         };
-        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, miniContext]);
+        const { success, error, body } = await this.emit(connection.nativeConnection, this.OOXEvent.CALL, [action, params, miniContext]);
         if (success)
             return body;
         else if (error)
@@ -124,8 +127,9 @@ export class SampleKeepAliveConnectionAdapter {
      */
     bindCall(connection) {
         const { id, name, ip } = connection.data;
-        connection.nativeConnection.on('call', async (action, params, context, callback) => {
-            const validContext = new oox.Context({
+        connection.nativeConnection.on(this.OOXEvent.CALL, async (action, params, context, callback) => {
+            const validContext = genContext({
+                sourceIP: ip,
                 ...context,
                 ip: ip,
                 caller: name,
@@ -136,8 +140,8 @@ export class SampleKeepAliveConnectionAdapter {
         });
     }
     async call(action, params, context, callback) {
-        const returns = await oox.call(action, params, context);
-        if (returns.error && !oox.config.errorStack) {
+        const returns = await call(action, params, context);
+        if (returns.error && !config.errorStack) {
             // 不返回错误调用栈信息
             delete returns.error.stack;
         }

package/types/app.d.ts

@@ -1,6 +1,5 @@
 import { EventEmitter } from 'node:events';
-import { AsyncLocalStorage } from 'node:async_hooks';
-export * as logger from './logger.js';
+import { AppContext } from './context.js';
 export interface ReturnsBody<T = any> {
     traceId?: string;
     success: boolean;
@@ -10,11 +9,6 @@ export interface ReturnsBody<T = any> {
         stack?: string;
     };
 }
-export declare class AppContext {
-    [x: string]: any;
-    traceId?: string | undefined;
-}
-export declare const asyncStore: AsyncLocalStorage<AppContext>;
 export declare const eventHub: EventEmitter<[never]>;
 /**
  * the kvMethods is all actions refs [has bind this]

package/types/bin/starter.d.ts

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

package/types/config.d.ts

@@ -48,7 +48,19 @@ export declare class Config implements ConfigInterface {
 type StrictFormatter<T> = {
     [K in keyof T]: (value: any) => T[K];
 };
-export declare const formatters: StrictFormatter<ConfigInterface> & {
+export declare const configFormatters: StrictFormatter<ConfigInterface> & {
     [x: string]: (v: any) => any;
 };
+/**
+ * 检查连接是否被允许
+ * @param ip 连接主机 IP
+ * @param caller 连接服务名称
+ * @param token 令牌
+ * @returns 是否被允许
+ */
+export declare function checkAllow(ip: string, caller: string, token: string): {
+    allow: boolean;
+    reason?: string;
+};
+export declare const config: Config;
 export {};

package/types/context.d.ts

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { KeepAliveConnection, KeepAliveNativeConnection } from './keepalive-connection.js';
+export declare const asyncStore: AsyncLocalStorage<AppContext>;
+export declare class AppContext {
+    [x: string]: any;
+    traceId?: string | undefined;
+}
+export interface KeepAliveRPCContext {
+    traceId?: string;
+    sourceIP?: string;
+}
+export declare class Context extends AppContext {
+    sourceIP: string;
+    ip: string;
+    caller: string;
+    callerId: string;
+    connection?: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(context?: Partial<Context>);
+    toJSON?(): {} & this;
+}
+export declare function setGenTraceIdFunction(fn: () => string): void;
+/**
+ * 生成随机不重复id
+ */
+export declare function genTraceId(): string;
+/**
+ * 获取链路跟踪上下文
+ */
+export declare function genContext(context?: Context): Context;
+export declare function getContext(): Context;

package/types/index.d.ts

@@ -1,59 +1,13 @@
-import { AppContext } from './app.js';
-import * as registry from './registry.js';
-import { Config } from './config.js';
-import Module, { ModuleConfig } from './modules/module.js';
-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<KeepAliveNativeConnection>;
-    constructor(context?: Partial<Context>);
-    toJSON?(): {} & this;
-}
-export declare const config: Config;
-export declare function setGenTraceIdFunction(fn: () => string): void;
-/**
- * 生成随机不重复id
- */
-export declare function genTraceId(): string;
-/**
- * 获取链路跟踪上下文
- */
-export declare function genContext(context?: Context): Context;
-export declare function getContext(): Context;
 export declare function serve(): Promise<void>;
 export declare function stop(): Promise<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<KeepAliveNativeConnection>): void;
-export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
-export declare function rpc(connection: KeepAliveConnection<KeepAliveNativeConnection>, action: string, params: any[], context?: Context): Promise<any>;
 export * from './app.js';
+export * from './config.js';
+export * from './context.js';
 export * from './keepalive-connection.js';
-export { Module, ModuleConfig };
+export * from './modules/module.js';
+export * as logger from './logger.js';
+export * from './proxy.js';
+import * as registry from './registry.js';
 export { registry };
 import * as modules from './modules/index.js';
 export { modules };

package/types/keepalive-connection.d.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'node:events';
-import { Context } from './index.js';
+import { Context } from './context.js';
 type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export declare class KeepAliveConnectionError extends Error {
     connection: KeepAliveConnection<KeepAliveNativeConnection>;
@@ -98,6 +98,17 @@ export declare class KeepAliveConnectionStore<T extends KeepAliveNativeConnectio
     remove(connection: KeepAliveConnection<T>): void;
     remove(name: string, id: string): void;
 }
+/**
+ * 添加长连接
+ * @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<KeepAliveNativeConnection>): void;
+export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
+export declare function rpc(connection: KeepAliveConnection<KeepAliveNativeConnection>, action: string, params: any[], context?: Context): Promise<any>;
 export declare const keepAliveConnectionAdapters: Map<string, KeepAliveConnectionAdapter<KeepAliveNativeConnection>>;
 export declare const keepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
 export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;

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

@@ -1,7 +1,7 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
 import Router, { Middleware } from './router.js';
-import Module, { ModuleConfig } from '../module.js';
+import { Module, ModuleConfig } from '../module.js';
 export declare class HTTPConfig implements ModuleConfig {
     enabled: boolean;
     port: number;

package/types/modules/index.d.ts

@@ -1,4 +1,4 @@
-import Module from './module.js';
+import { Module } from './module.js';
 import HTTP from './http/index.js';
 import SocketIO from './socketio/index.js';
 /**

package/types/modules/module.d.ts

@@ -1,7 +1,7 @@
 export interface ModuleConfig {
     enabled?: boolean;
 }
-export default abstract class Module {
+export declare abstract class Module {
     abstract config: ModuleConfig;
     abstract name: string;
     abstract setConfig(config: any): void;

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

@@ -1,14 +1,19 @@
 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: {
+    OOXEvent: {
         CONNECT: string;
         DISCONNECT: string;
         ERROR: string;
+        CALL: string;
+        READY: string;
+        ENABLED: string;
+        DISABLED: string;
+        REGISTRY_SYNC_CONNECTIONS: string;
+        REGISTRY_SUBSCRIBE: string;
+        REGISTRY_NOTIFY: string;
     };
     newConnection(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<Socket>;
 }

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

@@ -2,7 +2,7 @@ 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 { Module, ModuleConfig } from '../module.js';
 import { Socket } from './socket.js';
 import SocketIOAdapter from './adapter.js';
 export declare class SocketIOConfig implements ModuleConfig {

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

@@ -1,10 +1,14 @@
-export declare enum OOXEvent {
-    READY = "oox:ready",
-    ENABLED = "oox:enabled",
-    DISABLED = "oox:disabled",
-    REGISTRY_SYNC_CONNECTIONS = "oox:registry:sync_connections",
-    REGISTRY_SUBSCRIBE = "oox:registry:subscribe",
-    REGISTRY_NOTIFY = "oox:registry:notify"
-}
+export declare const OOXEvent: {
+    CONNECT: string;
+    DISCONNECT: string;
+    ERROR: string;
+    CALL: string;
+    READY: string;
+    ENABLED: string;
+    DISABLED: string;
+    REGISTRY_SYNC_CONNECTIONS: string;
+    REGISTRY_SUBSCRIBE: string;
+    REGISTRY_NOTIFY: string;
+};
 export declare function isWebSocketURL(url: string | URL): boolean;
 export declare function genWebSocketURL(url: string): URL;

package/types/proxy.d.ts

@@ -0,0 +1 @@
+export declare function proxy(name: string, action?: string): () => void;

package/types/registry.d.ts

@@ -1,4 +1,4 @@
-import { ReturnsBody } from './index.js';
+import { ReturnsBody } from './app.js';
 import { KeepAliveConnection, KeepAliveConnectionData, KeepAliveNativeConnection } from './keepalive-connection.js';
 export interface SyncConnectionsQuery {
     name?: string | string[];

package/types/samples/index.d.ts

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

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

@@ -1,16 +1,22 @@
-import * as oox from '../index.js';
-export interface SampleKeepAliveNativeConnection extends oox.KeepAliveNativeConnection {
+import { Context, KeepAliveRPCContext } from '../context.js';
+import { KeepAliveConnection, KeepAliveConnectionData, KeepAliveNativeConnection, KeepAliveConnectionAdapter, KeepAliveSyncConnectionsQuery } from '../keepalive-connection.js';
+import { ReturnsBody } from '../app.js';
+export interface SampleKeepAliveNativeConnection extends KeepAliveNativeConnection {
     connected: boolean;
     connect?(): void;
-    on(event: string | symbol, listener: (...args: any[]) => any): any;
-    once(event: string | symbol, listener: (...args: any[]) => any): any;
-    off(event?: string | symbol, listener?: (...args: any[]) => any): any;
-    emit(event: string | symbol, ...args: any[]): any;
-    removeAllListeners(event?: string | symbol): any;
+    on(event: string, listener: (...args: any[]) => any): any;
+    once(event: string, listener: (...args: any[]) => any): any;
+    off(event: string, listener?: (...args: any[]) => any): any;
+    emit(event: string, ...args: any[]): any;
+    removeAllListeners(event?: string): any;
 }
-export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection extends SampleKeepAliveNativeConnection> implements oox.KeepAliveConnectionAdapter<NativeConnection> {
+export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection extends SampleKeepAliveNativeConnection> implements KeepAliveConnectionAdapter<NativeConnection> {
     abstract name: string;
     OOXEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+        CALL: string;
         READY: string;
         ENABLED: string;
         DISABLED: string;
@@ -18,23 +24,18 @@ export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection
         REGISTRY_SUBSCRIBE: string;
         REGISTRY_NOTIFY: string;
     };
-    nativeEvent: {
-        CONNECT: string;
-        DISCONNECT: string;
-        ERROR: string;
-    };
-    abstract newConnection(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<NativeConnection>;
+    abstract newConnection(identify: string | URL | KeepAliveConnectionData): KeepAliveConnection<NativeConnection>;
     /**
      * 通知连接列表
      */
-    ['registry:notify'](connection: oox.KeepAliveConnection<NativeConnection>, datas: oox.KeepAliveConnectionData[]): void;
+    ['registry:notify'](connection: KeepAliveConnection<NativeConnection>, datas: KeepAliveConnectionData[]): void;
     /**
      * 订阅连接列表
      */
-    ['registry:subscribe'](connection: oox.KeepAliveConnection<NativeConnection>, query: oox.KeepAliveSyncConnectionsQuery): void;
-    bindConnectionEvents(connection: oox.KeepAliveConnection<NativeConnection>): void;
-    open(identify: string | URL | oox.KeepAliveConnectionData): Promise<oox.KeepAliveConnection<NativeConnection>>;
-    close(connection: oox.KeepAliveConnection<NativeConnection>): Promise<void>;
+    ['registry:subscribe'](connection: KeepAliveConnection<NativeConnection>, query: KeepAliveSyncConnectionsQuery): void;
+    bindConnectionEvents(connection: KeepAliveConnection<NativeConnection>): void;
+    open(identify: string | URL | KeepAliveConnectionData): Promise<KeepAliveConnection<NativeConnection>>;
+    close(connection: KeepAliveConnection<NativeConnection>): Promise<void>;
     /**
      * 发送事件
      * @param socket
@@ -45,11 +46,11 @@ export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection
     /**
      * RPC
      */
-    rpc(connection: oox.KeepAliveConnection<NativeConnection>, action: string, params: any[], context?: oox.KeepAliveRPCContext): Promise<any>;
+    rpc(connection: KeepAliveConnection<NativeConnection>, action: string, params: any[], context?: KeepAliveRPCContext): 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<any>>;
+    bindCall(connection: KeepAliveConnection<NativeConnection>): void;
+    call(action: string, params: any[], context: Context, callback?: (returns: any) => void): Promise<ReturnsBody<any>>;
 }

package/utils.js

@@ -1,4 +1,4 @@
-import { networkInterfaces } from 'os';
+import { networkInterfaces } from 'node:os';
 export function getIPAddress(version = 4) {
     const interfaces = networkInterfaces();
     const ip = [];