oox 0.3.3 → 0.3.5

package/types/index.d.ts

@@ -1,37 +1,21 @@
-import * as app from './app.js';
+import { AppContext } from './app.js';
+import * as registry from './registry.js';
+import { Config } from './config.js';
 import Module, { ModuleConfig } from './modules/module.js';
-import 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;
-export declare class Context extends app.Context {
+import { KeepAliveConnection, KeepAliveNativeConnection } from './keepalive-connection.js';
+export interface KeepAliveRPCContext {
+    traceId?: string;
+    sourceIP?: string;
+}
+export declare class Context extends AppContext {
     sourceIP: string;
     ip: string;
     caller: string;
     callerId: string;
-    connection?: RPCKeepAliveConnection<any>;
+    connection?: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(context?: Partial<Context>);
     toJSON?(): {} & this;
 }
-export declare class Config {
-    [x: string]: any;
-    id: `${string}-${string}-${string}-${string}-${string}`;
-    name: string;
-    group: string;
-    ignore: string[];
-    entryInfo: {
-        path: string;
-        group: string;
-    };
-    host: string;
-    port: number;
-    origin: string | string[];
-    errorStack: boolean;
-    registry: string[];
-    registryAdapter: string;
-}
 export declare const config: Config;
 export declare function setGenTraceIdFunction(fn: () => string): void;
 /**
@@ -45,9 +29,31 @@ export declare function genContext(context?: Context): Context;
 export declare function getContext(): Context;
 export declare function serve(): Promise<void>;
 export declare function stop(): Promise<void>;
-export declare function addKeepAliveConnection(connection: RPCKeepAliveConnection<any>): void;
-export declare function removeKeepAliveConnection(connection: RPCKeepAliveConnection<any>): void;
+/**
+ * 检查连接是否被允许
+ * @param ip 连接主机 IP
+ * @param caller 连接服务名称
+ * @param token 令牌
+ * @returns 是否被允许
+ */
+export declare function checkAllow(ip: string, caller: string, token: string): {
+    allow: boolean;
+    reason?: string;
+};
+/**
+ * 添加长连接
+ * @throws {KeepAliveConnectionError} 连接已存在
+ * @param connection
+ */
+export declare function addKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
+export declare function removeKeepAliveConnection(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
 export declare function removeKeepAliveConnection(name: string, id: string): void;
-export declare function setLoadBalancePolicy(policy: (name: string) => RPCKeepAliveConnection<any>): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => KeepAliveConnection<KeepAliveNativeConnection>): void;
 export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
-export declare function rpc(connection: RPCKeepAliveConnection<any>, 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 './keepalive-connection.js';
+export { Module, ModuleConfig };
+export { registry };
+import * as modules from './modules/index.js';
+export { modules };

package/types/keepalive-connection.d.ts

@@ -0,0 +1,104 @@
+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 declare class KeepAliveConnectionError extends Error {
+    connection: KeepAliveConnection<KeepAliveNativeConnection>;
+    constructor(message: string, connection: KeepAliveConnection<KeepAliveNativeConnection>);
+}
+export interface KeepAliveNativeConnection {
+    disconnect(): void;
+}
+export interface KeepAliveSyncConnectionsQuery {
+    [x: string]: any;
+    name?: string | string[];
+}
+export interface KeepAliveConnectionAdapter<T extends KeepAliveNativeConnection> {
+    /**
+     * 连接适配器名称
+     */
+    name: string;
+    open(identify: string | URL | KeepAliveConnectionData): Promise<KeepAliveConnection<T>>;
+    close(connection: KeepAliveConnection<T>): Promise<void>;
+    rpc(connection: KeepAliveConnection<T>, action: string, params: any[], context: Context): Promise<any>;
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection: KeepAliveConnection<T>, datas: KeepAliveConnectionData[]): void;
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection: KeepAliveConnection<T>, query: KeepAliveSyncConnectionsQuery): void;
+}
+export interface KeepAliveConnectionData {
+    /**
+     * 连接适配器名称
+     */
+    adapter: string;
+    /**
+     * 连接主机地址
+     */
+    ip: string;
+    /**
+     * 连接服务名称
+     */
+    name: string;
+    /**
+     * 连接URL
+     */
+    url?: string | URL;
+    /**
+     * 目标服务网络唯一ID
+     */
+    id: string;
+    /**
+     * 验证令牌
+     */
+    token: string;
+}
+export interface KeepAliveConnectionReadyParams {
+    [x: string]: any;
+    id: KeepAliveConnectionData['id'];
+    name: KeepAliveConnectionData['name'];
+}
+interface KeepAliveConnectionEventMap<T> {
+    "enabled": [];
+    "disabled": [];
+    "connect": [];
+    "disconnect": [];
+    'error': [KeepAliveConnectionError];
+}
+export declare class KeepAliveConnection<T extends KeepAliveNativeConnection> extends EventEmitter<KeepAliveConnectionEventMap<KeepAliveConnection<T>>> {
+    #private;
+    isRegistry: boolean;
+    data: KeepAliveConnectionData;
+    nativeConnection: T;
+    adapter: KeepAliveConnectionAdapter<T>;
+    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;
+    disconnect(): void;
+}
+export declare class KeepAliveConnectionStore<T extends KeepAliveNativeConnection> {
+    #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<KeepAliveNativeConnection>>;
+export declare const keepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
+export declare const enabledKeepAliveConnections: KeepAliveConnectionStore<KeepAliveNativeConnection>;
+export {};

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

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

package/types/modules/index.d.ts

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

package/types/modules/module.d.ts

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

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(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<Socket>;
 }

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

@@ -5,8 +5,8 @@ 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 {
+export declare class SocketIOConfig implements ModuleConfig {
+    enabled: boolean;
     port: number;
     path: string;
     origin: string | string[];
@@ -21,9 +21,10 @@ export default class SocketIOServer extends Module {
     #private;
     name: string;
     config: SocketIOConfig;
-    server: http.Server | https.Server;
-    socketServer: Server;
+    server: http.Server | https.Server | null;
+    socketServer: Server | null;
     adapter: SocketIOAdapter;
+    constructor();
     getURL(): URL;
     setConfig(config: SocketIOConfig): void;
     getConfig(): SocketIOConfig;
@@ -35,14 +36,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,7 +1,10 @@
 export declare enum OOXEvent {
-    CONNECTED = "oox:connected",
+    READY = "oox:ready",
+    ENABLED = "oox:enabled",
     DISABLED = "oox:disabled",
-    SYNC_CONNECTIONS = "oox:sync_connections"
+    REGISTRY_SYNC_CONNECTIONS = "oox:registry:sync_connections",
+    REGISTRY_SUBSCRIBE = "oox:registry:subscribe",
+    REGISTRY_NOTIFY = "oox:registry:notify"
 }
 export declare function isWebSocketURL(url: string | URL): boolean;
 export declare function genWebSocketURL(url: string): URL;

package/types/registry.d.ts

@@ -0,0 +1,41 @@
+import { ReturnsBody } from './index.js';
+import { KeepAliveConnection, KeepAliveConnectionData, KeepAliveNativeConnection } from './keepalive-connection.js';
+export interface SyncConnectionsQuery {
+    name?: string | string[];
+}
+/**
+ * 取消订阅连接列表
+ * @param connection
+ */
+export declare function unsubscribe(connection: KeepAliveConnection<KeepAliveNativeConnection>): void;
+/**
+ * 订阅连接列表
+ * @param connection
+ * @param query
+ * @returns
+ */
+export declare function subscribe(connection: KeepAliveConnection<KeepAliveNativeConnection>, query: SyncConnectionsQuery): void;
+/**
+ * 停止广播连接列表
+ */
+export declare function stopBroadcastTimer(): void;
+/**
+ * 开始广播连接列表
+ */
+export declare function startBroadcastTimer(): void;
+/**
+ * 广播连接列表
+ */
+export declare function broadcast(): void;
+/**
+ * 服务器发送连接列表
+ * @param connection
+ * @param query
+ * @param callback
+ */
+export declare function onSyncConnections(connection: KeepAliveConnection<KeepAliveNativeConnection>, query: SyncConnectionsQuery, callback: (returns: ReturnsBody<KeepAliveConnectionData[]>) => void): void;
+/**
+ * 同步连接列表
+ * @param datas 连接参数列表
+ */
+export declare function syncConnections(returns: ReturnsBody<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,55 @@
+import * as oox from '../index.js';
+export interface SampleKeepAliveNativeConnection extends oox.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;
+}
+export declare abstract class SampleKeepAliveConnectionAdapter<NativeConnection extends SampleKeepAliveNativeConnection> implements oox.KeepAliveConnectionAdapter<NativeConnection> {
+    abstract name: string;
+    OOXEvent: {
+        READY: string;
+        ENABLED: string;
+        DISABLED: string;
+        REGISTRY_SYNC_CONNECTIONS: string;
+        REGISTRY_SUBSCRIBE: string;
+        REGISTRY_NOTIFY: string;
+    };
+    nativeEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+    };
+    abstract newConnection(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<NativeConnection>;
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection: oox.KeepAliveConnection<NativeConnection>, datas: oox.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>;
+    /**
+     * 发送事件
+     * @param socket
+     * @param event
+     * @param params
+     */
+    emit(socket: NativeConnection, event: string, params: any[]): Promise<unknown>;
+    /**
+     * RPC
+     */
+    rpc(connection: oox.KeepAliveConnection<NativeConnection>, action: string, params: any[], context?: oox.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>>;
+}

package/utils.js

@@ -3,7 +3,7 @@ export function getIPAddress(version = 4) {
     const interfaces = networkInterfaces();
     const ip = [];
     for (const name of Object.keys(interfaces))
-        for (const intf of interfaces[name])
+        for (const intf of interfaces[name] || [])
             if (intf.mac !== '00:00:00:00:00:00')
                 if ((version !== 4 && version !== 6) || 'IPv' + version === intf.family)
                     ip.push(intf.address);

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>;