Deduplication interceptor pipeline operation

Motivation:

ClientInterceptorPipelineOperation is the same as
ServerInterceptorPipelineOperation apart from the type of interceptor
being used. The duplication here is unnecessary.

Modifications:

- Add a `ConditionalInterceptor` which is roughly the same as
  `*InterceptorPipelineOperation` but is generic.
- The init is private and can only be initialized via static methods
  when the generic type is appropriate (i.e. client/server interceptor).

Result:

Less duplication, less code

Author: glbrntt

Sources/GRPCCore/Call/Client/ClientInterceptorPipelineOperation.swift renamed to Sources/GRPCCore/Call/ConditionalInterceptor.swift

@@ -14,18 +14,16 @@
  * limitations under the License.
  */
 
-/// A `ClientInterceptorPipelineOperation` describes to which RPCs a client interceptor should be applied.
+/// Describes the conditions under which an interceptor should be applied.
 ///
-/// You can configure a client interceptor to be applied to:
+/// You can configure interceptors to be applied to:
 /// - all RPCs and services;
 /// - requests directed only to specific services; or
 /// - requests directed only to specific methods (of a specific service).
 ///
-/// - SeeAlso: ``ClientInterceptor`` for more information on client interceptors, and
-///  ``ServerInterceptorPipelineOperation`` for the server-side version of this type.
-public struct ClientInterceptorPipelineOperation: Sendable {
-  /// The subject of a ``ClientInterceptorPipelineOperation``.
-  /// The subject of an interceptor can either be all services and methods, only specific services, or only specific methods.
+/// - SeeAlso: ``ClientInterceptor`` and ``ServerInterceptor`` for more information on client and
+///   server interceptors, respectively.
+public struct ConditionalInterceptor<Interceptor: Sendable>: Sendable {
   public struct Subject: Sendable {
     internal enum Wrapped: Sendable {
       case all
@@ -41,21 +39,19 @@ public struct ClientInterceptorPipelineOperation: 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 ``ClientInterceptorPipelineOperation``.
     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 ``ClientInterceptorPipelineOperation``.
     public static func methods(_ methods: Set<MethodDescriptor>) -> Self {
       Self(wrapped: .methods(methods))
     }
 
     @usableFromInline
-    internal func applies(to descriptor: MethodDescriptor) -> Bool {
+    package func applies(to descriptor: MethodDescriptor) -> Bool {
       switch self.wrapped {
       case .all:
         return true
@@ -69,24 +65,15 @@ public struct ClientInterceptorPipelineOperation: Sendable {
     }
   }
 
-  /// The interceptor specified for this operation.
-  public let interceptor: any ClientInterceptor
+  /// The interceptor.
+  public let interceptor: Interceptor
 
   @usableFromInline
   internal let subject: Subject
 
-  private init(interceptor: any ClientInterceptor, appliesTo: Subject) {
+  fileprivate init(interceptor: Interceptor, subject: Subject) {
     self.interceptor = interceptor
-    self.subject = appliesTo
-  }
-
-  /// Create an operation, specifying which ``ClientInterceptor`` to apply and to which ``Subject``.
-  /// - Parameters:
-  ///   - interceptor: The ``ClientInterceptor`` to register with the client.
-  ///   - subject: The ``Subject`` to which the `interceptor` applies.
-  /// - Returns: A ``ClientInterceptorPipelineOperation``.
-  public static func apply(_ interceptor: any ClientInterceptor, to subject: Subject) -> Self {
-    Self(interceptor: interceptor, appliesTo: subject)
+    self.subject = subject
   }
 
   /// Returns whether this ``ClientInterceptorPipelineOperation`` applies to the given `descriptor`.
@@ -97,3 +84,29 @@ public struct ClientInterceptorPipelineOperation: Sendable {
     self.subject.applies(to: descriptor)
   }
 }
+
+extension ConditionalInterceptor where Interceptor == any ClientInterceptor {
+  /// Create an operation, specifying which ``ClientInterceptor`` to apply and to which ``Subject``.
+  /// - Parameters:
+  ///   - interceptor: The ``ClientInterceptor`` to register with the client.
+  ///   - subject: The ``Subject`` to which the `interceptor` applies.
+  public static func apply(
+    _ interceptor: any ClientInterceptor,
+    to subject: Subject
+  ) -> Self {
+    Self(interceptor: interceptor, subject: subject)
+  }
+}
+
+extension ConditionalInterceptor where Interceptor == any ServerInterceptor {
+  /// Create an operation, specifying which ``ServerInterceptor`` to apply and to which ``Subject``.
+  /// - Parameters:
+  ///   - interceptor: The ``ServerInterceptor`` to register with the client.
+  ///   - target: The ``Subject`` to which the `interceptor` applies.
+  public static func apply(
+    _ interceptor: any ServerInterceptor,
+    to subject: Subject
+  ) -> Self {
+    Self(interceptor: interceptor, subject: subject)
+  }
+}

Sources/GRPCCore/Call/Server/RPCRouter.swift

@@ -157,7 +157,9 @@ public struct RPCRouter: Sendable {
   ///  interceptors matters.
   /// - SeeAlso: ``ServerInterceptorPipelineOperation``.
   @inlinable
-  public mutating func registerInterceptors(pipeline: [ServerInterceptorPipelineOperation]) {
+  public mutating func registerInterceptors(
+    pipeline: [ConditionalInterceptor<any ServerInterceptor>]
+  ) {
     for descriptor in self.handlers.keys {
       let applicableOperations = pipeline.filter { $0.applies(to: descriptor) }
       if !applicableOperations.isEmpty {

Sources/GRPCCore/Call/Server/ServerInterceptorPipelineOperation.swift

@@ -129,7 +129,7 @@ public final class GRPCClient: Sendable {
   private struct StateMachine {
     var state: State
 
-    private let interceptorPipeline: [ClientInterceptorPipelineOperation]
+    private let interceptorPipeline: [ConditionalInterceptor<any ClientInterceptor>]
 
     /// A collection of interceptors providing cross-cutting functionality to each accepted RPC, keyed by the method to which they apply.
     ///
@@ -142,7 +142,7 @@ public final class GRPCClient: Sendable {
     /// the appropriate handler.
     var interceptorsPerMethod: [MethodDescriptor: [any ClientInterceptor]]
 
-    init(interceptorPipeline: [ClientInterceptorPipelineOperation]) {
+    init(interceptorPipeline: [ConditionalInterceptor<any ClientInterceptor>]) {
       self.state = .notStarted
       self.interceptorPipeline = interceptorPipeline
       self.interceptorsPerMethod = [:]
@@ -195,7 +195,7 @@ public final class GRPCClient: Sendable {
   ///       The last interceptor added will be the final interceptor to intercept each request before calling the appropriate handler.
   public init(
     transport: some ClientTransport,
-    interceptorPipeline: [ClientInterceptorPipelineOperation]
+    interceptorPipeline: [ConditionalInterceptor<any ClientInterceptor>]
   ) {
     self.transport = transport
     self.stateMachine = Mutex(StateMachine(interceptorPipeline: interceptorPipeline))
@@ -423,7 +423,7 @@ public func withGRPCClient<Result: Sendable>(
 /// - Returns: The result of the `handleClient` closure.
 public func withGRPCClient<Result: Sendable>(
   transport: some ClientTransport,
-  interceptorPipeline: [ClientInterceptorPipelineOperation],
+  interceptorPipeline: [ConditionalInterceptor<any ClientInterceptor>],
   isolation: isolated (any Actor)? = #isolation,
   handleClient: (GRPCClient) async throws -> Result
 ) async throws -> Result {

Sources/GRPCCore/GRPCClient.swift

@@ -171,7 +171,7 @@ public final class GRPCServer: Sendable {
   public convenience init(
     transport: any ServerTransport,
     services: [any RegistrableRPCService],
-    interceptorPipeline: [ServerInterceptorPipelineOperation]
+    interceptorPipeline: [ConditionalInterceptor<any ServerInterceptor>]
   ) {
     var router = RPCRouter()
     for service in services {
@@ -290,7 +290,7 @@ public func withGRPCServer<Result: Sendable>(
 public func withGRPCServer<Result: Sendable>(
   transport: any ServerTransport,
   services: [any RegistrableRPCService],
-  interceptorPipeline: [ServerInterceptorPipelineOperation],
+  interceptorPipeline: [ConditionalInterceptor<any ServerInterceptor>],
   isolation: isolated (any Actor)? = #isolation,
   handleServer: (GRPCServer) async throws -> Result
 ) async throws -> Result {

Sources/GRPCCore/GRPCServer.swift

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
+import GRPCCore
 import Testing
 
-@testable import GRPCCore
-
-@Suite("ClientInterceptorPipelineOperation")
-struct ClientInterceptorPipelineOperationTests {
+@Suite("ConditionalInterceptor")
+struct ConditionalInterceptorTests {
   @Test(
     "Applies to",
     arguments: [
@@ -38,24 +37,19 @@ struct ClientInterceptorPipelineOperationTests {
         [.barFoo],
         [.fooBar, .fooBaz, .barBaz]
       ),
-    ] as [(ClientInterceptorPipelineOperation.Subject, [MethodDescriptor], [MethodDescriptor])]
+    ] as [(ConditionalInterceptor<any Sendable>.Subject, [MethodDescriptor], [MethodDescriptor])]
   )
   func appliesTo(
-    operationSubject: ClientInterceptorPipelineOperation.Subject,
+    target: ConditionalInterceptor<any Sendable>.Subject,
     applicableMethods: [MethodDescriptor],
     notApplicableMethods: [MethodDescriptor]
   ) {
-    let operation = ClientInterceptorPipelineOperation.apply(
-      .requestCounter(.init()),
-      to: operationSubject
-    )
-
     for applicableMethod in applicableMethods {
-      #expect(operation.applies(to: applicableMethod))
+      #expect(target.applies(to: applicableMethod))
     }
 
     for notApplicableMethod in notApplicableMethods {
-      #expect(!operation.applies(to: notApplicableMethod))
+      #expect(!target.applies(to: notApplicableMethod))
     }
   }
 }