oox 0.3.5 → 0.3.7

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,35 +46,42 @@ 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, () => {
             socket.removeAllListeners();
+            removeKeepAliveConnection(connection);
             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) => {
             socket.removeAllListeners();
-            connection.emit('error', new oox.KeepAliveConnectionError(error.message, connection));
+            removeKeepAliveConnection(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) => {
-            connection.once('enabled', resolve);
-            connection.once('error', reject);
-            connection.once('disconnect', () => {
-                reject(new Error('disconnect'));
+        try {
+            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();
+                }
             });
-            if (connection.nativeConnection.connect) {
-                connection.nativeConnection.connect();
-            }
-        });
+        }
+        catch (error) {
+            connection.removeAllListeners();
+            removeKeepAliveConnection(connection);
+            throw error;
+        }
+        this.bindCall(connection);
         return connection;
     }
     async close(connection) {
@@ -93,9 +103,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 +115,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)
@@ -123,9 +133,12 @@ export class SampleKeepAliveConnectionAdapter {
      * @param connection
      */
     bindCall(connection) {
+        if (!connection.enabled)
+            throw new Error('Connection not enabled');
         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 +149,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;
@@ -27,6 +27,7 @@ export default class HTTPModule extends Module {
     use(middleware: Middleware): this;
     setConfig(config: HTTPConfig): void;
     getConfig(): HTTPConfig;
+    get serviceURL(): URL;
     /**
      * start http service
      */

package/types/modules/index.d.ts

@@ -1,6 +1,5 @@
-import Module from './module.js';
+import { Module } from './module.js';
 import HTTP from './http/index.js';
-import SocketIO from './socketio/index.js';
 /**
  * FIFO queue for modules starting
  */
@@ -35,5 +34,4 @@ export declare function stop(): Promise<void>;
  */
 export declare const builtins: {
     http: HTTP;
-    socketio: SocketIO;
 };

package/types/modules/module.d.ts

@@ -1,9 +1,10 @@
 export interface ModuleConfig {
     enabled?: boolean;
 }
-export default abstract class Module {
+export declare abstract class Module {
     abstract config: ModuleConfig;
     abstract name: string;
+    abstract serviceURL?: URL;
     abstract setConfig(config: any): void;
     abstract getConfig(): ModuleConfig;
     abstract serve(): Promise<void>;

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 = [];

package/modules/socketio/adapter.js

@@ -1,49 +0,0 @@
-import * as SocketIOClient from 'socket.io-client';
-import * as oox from '../../index.js';
-import { OOXEvent, genWebSocketURL } from './utils.js';
-import { randomUUID } from 'node:crypto';
-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 = {
-            'x-caller': name,
-            'x-caller-id': id,
-        };
-        let mURL;
-        const connectionData = {
-            name: 'anonymous',
-            id: randomUUID(),
-            adapter: this.name,
-            ip: '',
-            token: ''
-        };
-        if ('string' === typeof identify) {
-            mURL = genWebSocketURL(identify);
-        }
-        else if (identify instanceof URL) {
-            mURL = identify;
-        }
-        else if (identify.url) {
-            // KeepAliveConnectionData
-            Object.assign(connectionData, identify);
-            mURL = new URL(identify.url);
-            if (identify.token) {
-                headers['x-token'] = identify.token;
-            }
-        }
-        else {
-            throw new Error('identify must be string, URL, or KeepAliveConnectionData');
-        }
-        const socket = SocketIOClient.io(mURL.origin, {
-            extraHeaders: headers,
-            path: mURL.pathname,
-            autoConnect: false,
-        });
-        const connection = new oox.KeepAliveConnection(this, socket, connectionData);
-        return connection;
-    }
-}

package/modules/socketio/index.js

@@ -1,23 +0,0 @@
-import * as PATH from 'node:path';
-import * as oox from '../../index.js';
-import SocketINServer from './server.js';
-export default class SocketIOModule extends SocketINServer {
-    async serve() {
-        await this.stop();
-        const _http = oox.modules.builtins.http;
-        const httpConfig = _http.getConfig(), config = this.getConfig();
-        let isShareServer = false;
-        // 都没设置端口
-        isShareServer = !httpConfig.port && !config.port;
-        // 都设置相同端口
-        isShareServer ||= httpConfig.port === config.port;
-        // http 模块未被禁用
-        isShareServer &&= httpConfig.enabled;
-        if (isShareServer) {
-            config.path = PATH.posix.join(httpConfig.path, config.path);
-            this.server = _http.server;
-            this.config.ssl = _http.config.ssl;
-        }
-        await super.serve();
-    }
-}