Merge branch 'main' into v2/json-codegen

Author: glbrntt

Sources/GRPCCore/Call/Server/ServerContext.swift

@@ -19,23 +19,6 @@ public struct ServerContext: Sendable {
   /// A description of the method being called.
   public var descriptor: MethodDescriptor
 
-  /// A description of the remote peer.
-  ///
-  /// The format of the description should follow the pattern "<transport>:<address>" where
-  /// "<transport>" indicates the underlying network transport (such as "ipv4", "unix", or
-  /// "in-process"). This is a guideline for how descriptions should be formatted; different
-  /// implementations may not follow this format so you shouldn't make assumptions based on it.
-  ///
-  /// Some examples include:
-  /// - "ipv4:127.0.0.1:31415",
-  /// - "ipv6:[::1]:443",
-  /// - "in-process:27182".
-  @available(*, deprecated, renamed: "remotePeer")
-  public var peer: String {
-    get { remotePeer }
-    set { remotePeer = newValue }
-  }
-
   /// A description of the remote peer.
   ///
   /// The format of the description should follow the pattern "<transport>:<address>" where

Sources/GRPCCore/Documentation.docc/Development/Design.md

@@ -173,12 +173,12 @@ concurrency.
 Most users won't use ``GRPCClient`` to execute RPCs directly, instead they will
 use the generated client stubs which wrap the ``GRPCClient``. Users are
 responsible for creating the client and running it (which starts and runs the
-underlying transport). This is done by calling ``GRPCClient/run()``. The client
+underlying transport). This is done by calling ``GRPCClient/runConnections()``. The client
 can be shutdown gracefully by calling ``GRPCClient/beginGracefulShutdown()``
 which will stop new RPCs from starting (by failing them with
 ``RPCError/Code-swift.struct/unavailable``) but allow existing ones to continue.
 Existing work can be stopped more abruptly by cancelling the task where
-``GRPCClient/run()`` is executing.
+``GRPCClient/runConnections()`` is executing.
 
 #### Server
 

Sources/GRPCCore/GRPCClient.swift

@@ -227,16 +227,11 @@ public final class GRPCClient<Transport: ClientTransport>: Sendable {
     }
   }
 
-  @available(*, deprecated, renamed: "runConnections", message: "It'll be removed before v2.")
-  public func run() async throws {
-    try await self.runConnections()
-  }
-
   /// Close the client.
   ///
   /// The transport will be closed: this means that it will be given enough time to wait for
   /// in-flight RPCs to finish executing, but no new RPCs will be accepted. You can cancel the task
-  /// executing ``run()`` if you want to abruptly stop in-flight RPCs.
+  /// executing ``runConnections()`` if you want to abruptly stop in-flight RPCs.
   public func beginGracefulShutdown() {
     let wasRunning = self.stateMachine.withLock { $0.state.beginGracefulShutdown() }
     if wasRunning {

Sources/GRPCCore/MethodDescriptor.swift

@@ -51,17 +51,6 @@ public struct MethodDescriptor: Sendable, Hashable {
     self.service = ServiceDescriptor(fullyQualifiedService: fullyQualifiedService)
     self.method = method
   }
-
-  @available(*, deprecated, renamed: "init(fullyQualifiedService:method:)")
-  /// Creates a new method descriptor.
-  ///
-  /// - Parameters:
-  ///   - service: The fully qualified name of the service, including the package
-  ///       name. For example, "helloworld.Greeter".
-  ///   - method: The name of the method. For example, "SayHello".
-  public init(service: String, method: String) {
-    self.init(fullyQualifiedService: service, method: method)
-  }
 }
 
 extension MethodDescriptor: CustomStringConvertible {

Tests/GRPCCoreTests/Test Utilities/Coding+JSON.swift

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import GRPCCore
 
 import struct Foundation.Data

Tests/GRPCInProcessTransportTests/InProcessTransportTests.swift

@@ -80,7 +80,7 @@ struct InProcessTransportTests {
         request: ClientRequest(message: ()),
         descriptor: .peerInfo,
         serializer: VoidSerializer(),
-        deserializer: PeerInfoDeserializer(),
+        deserializer: JSONDeserializer<PeerInfo>(),
         options: .defaults
       ) {
         try $0.message
@@ -142,7 +142,7 @@ private struct TestService: RegistrableRPCService {
     router.registerHandler(
       forMethod: .peerInfo,
       deserializer: VoidDeserializer(),
-      serializer: PeerInfoSerializer(),
+      serializer: JSONSerializer<PeerInfo>(),
       handler: {
         let response = try await self.peerInfo(
           request: ServerRequest<Void>(stream: $0),
@@ -171,22 +171,6 @@ private struct PeerInfo: Codable {
   var remote: String
 }
 
-private struct PeerInfoSerializer: MessageSerializer {
-  func serialize<Bytes: GRPCContiguousBytes>(_ message: PeerInfo) throws -> Bytes {
-    Bytes("\(message.local) \(message.remote)".utf8)
-  }
-}
-
-private struct PeerInfoDeserializer: MessageDeserializer {
-  func deserialize<Bytes: GRPCContiguousBytes>(_ serializedMessageBytes: Bytes) throws -> PeerInfo {
-    let stringPeerInfo = serializedMessageBytes.withUnsafeBytes {
-      String(decoding: $0, as: UTF8.self)
-    }
-    let peerInfoComponents = stringPeerInfo.split(separator: " ")
-    return PeerInfo(local: String(peerInfoComponents[0]), remote: String(peerInfoComponents[1]))
-  }
-}
-
 private struct UTF8Serializer: MessageSerializer {
   func serialize<Bytes: GRPCContiguousBytes>(_ message: String) throws -> Bytes {
     Bytes(message.utf8)

Tests/GRPCInProcessTransportTests/Test Utilities/JSONSerializing.swift

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2025, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import GRPCCore
+
+import struct Foundation.Data
+import class Foundation.JSONDecoder
+import class Foundation.JSONEncoder
+
+struct JSONSerializer<Message: Codable>: MessageSerializer {
+  func serialize<Bytes: GRPCContiguousBytes>(_ message: Message) throws -> Bytes {
+    do {
+      let jsonEncoder = JSONEncoder()
+      let data = try jsonEncoder.encode(message)
+      return Bytes(data)
+    } catch {
+      throw RPCError(code: .internalError, message: "Can't serialize message to JSON. \(error)")
+    }
+  }
+}
+
+struct JSONDeserializer<Message: Codable>: MessageDeserializer {
+  func deserialize<Bytes: GRPCContiguousBytes>(_ serializedMessageBytes: Bytes) throws -> Message {
+    do {
+      let jsonDecoder = JSONDecoder()
+      let data = serializedMessageBytes.withUnsafeBytes { Data($0) }
+      return try jsonDecoder.decode(Message.self, from: data)
+    } catch {
+      throw RPCError(code: .internalError, message: "Can't deserialze message from JSON. \(error)")
+    }
+  }
+}