feat: add RPC middleware and reconnect strategies

Author: imba97

packages/core/src/bridge/initializer.ts

@@ -201,7 +201,6 @@ export class FrpBridgeInitializer {
       result.rpcClient = new RpcClient({
         url: urlWithToken,
         nodeId: rpcOptions.clientNodeId,
-        reconnectInterval: rpcOptions.clientReconnectInterval,
         getRegisterPayload: rpcOptions.getRegisterPayload ?? (async () => {
           throw new Error('rpc getRegisterPayload is required in client mode')
         }),

packages/core/src/rpc/index.ts

@@ -1,2 +1,5 @@
+export * from './message-types'
+export * from './middleware'
+export * from './reconnect-strategy'
 export { RpcClient, type RpcClientOptions } from './rpc-client'
 export { RpcServer, type RpcServerOptions } from './rpc-server'

packages/core/src/rpc/message-types.ts

@@ -0,0 +1,111 @@
+/**
+ * RPC 消息类型定义
+ * 提供类型安全的消息结构和类型守卫
+ */
+
+/**
+ * RPC 消息类型枚举
+ */
+export enum RpcMessageType {
+  REGISTER = 'register',
+  COMMAND = 'command',
+  RESPONSE = 'response',
+  PING = 'ping',
+  PONG = 'pong'
+}
+
+/**
+ * 节点注册消息
+ */
+export interface RegisterMessage {
+  type: RpcMessageType.REGISTER
+  nodeId: string
+  payload: Record<string, unknown>
+}
+
+/**
+ * RPC 请求
+ */
+export interface RpcRequest {
+  id: string
+  method: string
+  params: Record<string, unknown>
+  timeout?: number
+}
+
+/**
+ * RPC 响应状态
+ */
+export type RpcResponseStatus = 'success' | 'error'
+
+/**
+ * RPC 响应
+ */
+export interface RpcResponse {
+  id: string
+  status: RpcResponseStatus
+  result?: unknown
+  error?: { code: string, message: string }
+}
+
+/**
+ * Ping 消息
+ */
+export interface PingMessage {
+  type: RpcMessageType.PING
+  timestamp: number
+}
+
+/**
+ * Pong 消息
+ */
+export interface PongMessage {
+  type: RpcMessageType.PONG
+  timestamp: number
+}
+
+/**
+ * 所有 RPC 消息类型
+ */
+export type RpcMessage = RegisterMessage | RpcRequest | RpcResponse | PingMessage | PongMessage
+
+/**
+ * 类型守卫：检查是否为注册消息
+ */
+export function isRegisterMessage(msg: unknown): msg is RegisterMessage {
+  return typeof msg === 'object' && msg !== null && (msg as any).type === RpcMessageType.REGISTER
+}
+
+/**
+ * 类型守卫：检查是否为 RPC 请求
+ */
+export function isRpcRequest(msg: unknown): msg is RpcRequest {
+  return typeof msg === 'object' && msg !== null
+    && typeof (msg as any).id === 'string'
+    && typeof (msg as any).method === 'string'
+}
+
+/**
+ * 类型守卫：检查是否为 RPC 响应
+ */
+export function isRpcResponse(msg: unknown): msg is RpcResponse {
+  return typeof msg === 'object' && msg !== null
+    && typeof (msg as any).id === 'string'
+    && typeof (msg as any).status === 'string'
+}
+
+/**
+ * 类型守卫：检查是否为 Ping 消息
+ */
+export function isPingMessage(msg: unknown): msg is PingMessage {
+  return typeof msg === 'object' && msg !== null
+    && (msg as any).type === RpcMessageType.PING
+}
+
+/**
+ * 类型守卫：检查是否为 Pong 消息
+ */
+export function isPongMessage(msg: unknown): msg is PongMessage {
+  return typeof msg === 'object' && msg !== null
+    && (msg as any).type === RpcMessageType.PONG
+}

packages/core/src/rpc/middleware.ts

@@ -0,0 +1,195 @@
+/**
+ * RPC 中间件系统
+ * 提供可扩展的请求处理管道
+ */
+
+import type { RpcRequest, RpcResponse } from './message-types'
+
+/**
+ * 中间件上下文
+ */
+export interface MiddlewareContext {
+  request: RpcRequest
+  response: Partial<RpcResponse>
+  startTime: number
+}
+
+/**
+ * 中间件函数类型
+ */
+export type MiddlewareFn = (
+  context: MiddlewareContext,
+  next: () => Promise<void>
+) => Promise<void>
+
+/**
+ * 中间件选项
+ */
+export interface MiddlewareOptions {
+  preHooks?: MiddlewareFn[]
+  postHooks?: MiddlewareFn[]
+}
+
+/**
+ * 日志中间件
+ */
+export function loggingMiddleware(
+  logger?: {
+    info?: (msg: string, data?: unknown) => void
+    warn?: (msg: string, data?: unknown) => void
+    error?: (msg: string, data?: unknown) => void
+  }
+): MiddlewareFn {
+  return async (context, next) => {
+    const { request } = context
+    logger?.info?.('RPC request', { method: request.method, params: request.params })
+
+    try {
+      await next()
+      logger?.info?.('RPC response', {
+        method: request.method,
+        duration: Date.now() - context.startTime,
+        status: context.response.status
+      })
+    }
+    catch (error) {
+      logger?.error?.('RPC error', {
+        method: request.method,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      })
+      throw error
+    }
+  }
+}
+
+/**
+ * 认证中间件
+ */
+export function authMiddleware(
+  validateToken: (token: string | undefined) => boolean | Promise<boolean>
+): MiddlewareFn {
+  return async (context, next) => {
+    const { request, response } = context
+    const token = request.params.token as string | undefined
+
+    const isValid = await validateToken(token)
+    if (!isValid) {
+      response.status = 'error'
+      response.error = { code: 'UNAUTHORIZED', message: 'Invalid or missing token' }
+      return
+    }
+
+    await next()
+  }
+}
+
+/**
+ * 超时中间件
+ */
+export function timeoutMiddleware(timeoutMs: number): MiddlewareFn {
+  return async (context, next) => {
+    const { request } = context
+
+    // 使用请求指定的超时或默认超时
+    const timeout = request.timeout ?? timeoutMs
+
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`RPC timeout: ${request.method}`))
+      }, timeout)
+    })
+
+    try {
+      await Promise.race([next(), timeoutPromise])
+    }
+    catch (error) {
+      context.response.status = 'error'
+      context.response.error = {
+        code: 'TIMEOUT',
+        message: error instanceof Error ? error.message : 'Request timeout'
+      }
+      throw error
+    }
+  }
+}
+
+/**
+ * 错误处理中间件
+ */
+export function errorHandlerMiddleware(
+  logger?: { error?: (msg: string, data?: unknown) => void }
+): MiddlewareFn {
+  return async (context, next) => {
+    try {
+      await next()
+    }
+    catch (error) {
+      context.response.status = 'error'
+      context.response.error = {
+        code: error instanceof Error ? error.name : 'UNKNOWN_ERROR',
+        message: error instanceof Error ? error.message : 'Unknown error'
+      }
+      logger?.error?.('RPC middleware error', error)
+    }
+  }
+}
+
+/**
+ * 中间件管道
+ */
+export class MiddlewarePipeline {
+  private middlewares: MiddlewareFn[] = []
+
+  /**
+   * 添加中间件
+   */
+  use(middleware: MiddlewareFn): this {
+    this.middlewares.push(middleware)
+    return this
+  }
+
+  /**
+   * 执行中间件管道
+   */
+  async execute(
+    request: RpcRequest,
+    handler: () => Promise<unknown>
+  ): Promise<Partial<RpcResponse>> {
+    const context: MiddlewareContext = {
+      request,
+      response: { id: request.id },
+      startTime: Date.now()
+    }
+
+    // 构建中间件链
+    let next: () => Promise<void> = async () => this.executeHandler(context, handler)
+    for (let i = this.middlewares.length - 1; i >= 0; i--) {
+      const middleware = this.middlewares[i]
+      const prevNext = next
+      next = async () => middleware(context, prevNext)
+    }
+
+    await next()
+
+    return context.response
+  }
+
+  /**
+   * 执行处理器
+   */
+  private async executeHandler(
+    context: MiddlewareContext,
+    handler: () => Promise<unknown>
+  ): Promise<void> {
+    const result = await handler()
+    context.response.result = result
+    context.response.status = 'success'
+  }
+
+  /**
+   * 清空中间件
+   */
+  clear(): void {
+    this.middlewares = []
+  }
+}