PR changes

Author: gjcairo

Sources/GRPCCore/Call/Server/RPCRouter.swift

@@ -22,6 +22,8 @@
 /// the router has a handler for a method with ``hasHandler(forMethod:)`` or get a list of all
 /// methods with handlers registered by calling ``methods``. You can also remove the handler for a
 /// given method by calling ``removeHandler(forMethod:)``.
+/// You can also register any interceptors that you want applied to registered handlers via the
+/// ``registerInterceptors(pipeline:)`` method.
 ///
 /// In most cases you won't need to interact with the router directly. Instead you should register
 /// your services with ``GRPCServer/init(transport:services:interceptors:)`` which will in turn
@@ -145,10 +147,19 @@ public struct RPCRouter: Sendable {
     return self.handlers.removeValue(forKey: descriptor) != nil
   }
 
+  /// Registers applicable interceptors to all currently-registered handlers.
+  ///
+  /// - Important: Calling this method will apply the interceptors only to existing handlers. Any handlers registered via
+  ///  ``registerHandler(forMethod:deserializer:serializer:handler:)`` _after_ calling this method will not have
+  ///    any interceptors applied to them. If you want to make sure all registered methods have any applicable interceptors applied,
+  ///    only call this method _after_ you have registered all handlers.
+  /// - Parameter pipeline: The interceptor pipeline operations to register to all currently-registered handlers. The order of the
+  ///  interceptors matters.
+  /// - SeeAlso: ``ServerInterceptorPipelineOperation``.
   @inlinable
-  mutating func registerInterceptors(pipeline: [ServerInterceptorOperation]) {
+  public mutating func registerInterceptors(pipeline: [ServerInterceptorPipelineOperation]) {
     for descriptor in self.handlers.keys {
-      let applicableOperations = pipeline.filter { $0._applies(to: descriptor) }
+      let applicableOperations = pipeline.filter { $0.applies(to: descriptor) }
       if !applicableOperations.isEmpty {
         self.handlers[descriptor]?.interceptors = applicableOperations.map { $0.interceptor }
       }

Sources/GRPCCore/Call/Server/ServerInterceptor.swift

@@ -21,7 +21,7 @@
 /// been returned from a service. They are typically used for cross-cutting concerns like filtering
 /// requests, validating messages, logging additional data, and tracing.
 ///
-/// Interceptors can be registered with the server either directly or  via ``ServerInterceptorOperation``s.
+/// Interceptors can be registered with the server either directly or  via ``ServerInterceptorPipelineOperation``s.
 /// You may register them for all services registered with a server, for RPCs directed to specific services, or
 /// for RPCs directed to specific methods. If you need to modify the behavior of an interceptor on a
 /// per-RPC basis in more detail, then you can use the ``ServerContext/descriptor`` to determine

Sources/GRPCCore/Call/Server/ServerInterceptorOperation.swift renamed to Sources/GRPCCore/Call/Server/ServerInterceptorPipelineOperation.swift

@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-/// A `ServerInterceptorOperation` describes to which RPCs a server interceptor should be applied.
+/// A `ServerInterceptorPipelineOperation` describes to which RPCs a server interceptor should be applied.
 ///  
 /// You can configure a server interceptor to be applied to:
 /// - all RPCs and services;
 /// - requests directed only to specific services registered with your server; or
 /// - requests directed only to specific methods (of a specific service).
 ///  
 /// - SeeAlso: ``ServerInterceptor`` for more information on server interceptors, and
-///  ``ClientInterceptorOperation`` for the client-side version of this type.
-public struct ServerInterceptorOperation: Sendable {
-  /// The subject of a ``ServerInterceptorOperation``.
+///  ``ClientInterceptorPipelineOperation`` for the client-side version of this type.
+public struct ServerInterceptorPipelineOperation: Sendable {
+  /// The subject of a ``ServerInterceptorPipelineOperation``.
   /// The subject of an interceptor can either be all services and methods, only specific services, or only specific methods.
   public struct Subject: Sendable {
     internal enum Wrapped: Sendable {
       case all
-      case services([ServiceDescriptor])
-      case methods([MethodDescriptor])
+      case services(Set<ServiceDescriptor>)
+      case methods(Set<MethodDescriptor>)
     }
 
     private let wrapped: Wrapped
@@ -41,19 +41,20 @@ public struct ServerInterceptorOperation: Sendable {
     /// An operation subject specifying an interceptor that will be applied only to RPCs directed to the specified services.
     /// - Parameters:
     ///   - services: The list of service names for which this interceptor should intercept RPCs.
-    /// - Returns: A ``ServerInterceptorOperation``.
-    public static func services(_ services: [ServiceDescriptor]) -> Self {
+    /// - Returns: A ``ServerInterceptorPipelineOperation``.
+    public static func services(_ services: Set<ServiceDescriptor>) -> Self {
       Self(wrapped: .services(services))
     }
 
     /// An operation subject specifying an interceptor that will be applied only to RPCs directed to the specified service methods.
     /// - Parameters:
     ///   - methods: The list of method descriptors for which this interceptor should intercept RPCs.
-    /// - Returns: A ``ServerInterceptorOperation``.
-    public static func methods(_ methods: [MethodDescriptor]) -> Self {
+    /// - Returns: A ``ServerInterceptorPipelineOperation``.
+    public static func methods(_ methods: Set<MethodDescriptor>) -> Self {
       Self(wrapped: .methods(methods))
     }
 
+    @usableFromInline
     internal func applies(to descriptor: MethodDescriptor) -> Bool {
       switch self.wrapped {
       case .all:
@@ -71,7 +72,8 @@ public struct ServerInterceptorOperation: Sendable {
   /// The interceptor specified for this operation.
   public let interceptor: any ServerInterceptor
 
-  private let subject: Subject
+  @usableFromInline
+  internal let subject: Subject
 
   private init(interceptor: any ServerInterceptor, appliesTo: Subject) {
     self.interceptor = interceptor
@@ -82,15 +84,16 @@ public struct ServerInterceptorOperation: Sendable {
   /// - Parameters:
   ///   - interceptor: The ``ServerInterceptor`` to register with the server.
   ///   - subject: The ``Subject`` to which the `interceptor` applies.
-  /// - Returns: A ``ServerInterceptorOperation``.
+  /// - Returns: A ``ServerInterceptorPipelineOperation``.
   public static func apply(_ interceptor: any ServerInterceptor, to subject: Subject) -> Self {
     Self(interceptor: interceptor, appliesTo: subject)
   }
 
-  /// Returns whether this ``ServerInterceptorOperation`` applies to the given `descriptor`.
+  /// Returns whether this ``ServerInterceptorPipelineOperation`` applies to the given `descriptor`.
   /// - Parameter descriptor: A ``MethodDescriptor`` for which to test whether this interceptor applies.
   /// - Returns: `true` if this interceptor applies to the given `descriptor`, or `false` otherwise.
-  public func _applies(to descriptor: MethodDescriptor) -> Bool {
+  @inlinable
+  internal func applies(to descriptor: MethodDescriptor) -> Bool {
     self.subject.applies(to: descriptor)
   }
 }

Sources/GRPCCore/GRPCServer.swift

@@ -166,7 +166,7 @@ public final class GRPCServer: Sendable {
   public convenience init(
     transport: any ServerTransport,
     services: [any RegistrableRPCService],
-    interceptorPipeline: [ServerInterceptorOperation]
+    interceptorPipeline: [ServerInterceptorPipelineOperation]
   ) {
     var router = RPCRouter()
     for service in services {

Tests/GRPCCoreTests/GRPCServerTests.swift

@@ -22,7 +22,7 @@ import XCTest
 final class GRPCServerTests: XCTestCase {
   func withInProcessClientConnectedToServer(
     services: [any RegistrableRPCService],
-    interceptorPipeline: [ServerInterceptorOperation] = [],
+    interceptorPipeline: [ServerInterceptorPipelineOperation] = [],
     _ body: (InProcessTransport.Client, GRPCServer) async throws -> Void
   ) async throws {
     let inProcess = InProcessTransport()
@@ -554,7 +554,7 @@ struct ServerTests {
 
   func withInProcessClientConnectedToServer(
     services: [any RegistrableRPCService],
-    interceptorPipeline: [ServerInterceptorOperation] = [],
+    interceptorPipeline: [ServerInterceptorPipelineOperation] = [],
     _ body: (InProcessTransport.Client, GRPCServer) async throws -> Void
   ) async throws {
     let inProcess = InProcessTransport()