[CodeGen Protobuf support] Message serializer and deserializer (#1764)

Motivation:

In the generated code we are specifying types for a serializer and deserializer. As we want to support SwiftProtobuf, we need to implement the generic serializer and deserializer for Protobuf messages, which will be the default if the user doesn't specify other IDL serializer and deserializer.

Modifications:

Created the serializer and deserializer structs conforming to `GRPCCore.MessageSerializer` and `GRPCCOre.MessageDeserializer` respectively and implemented their serialize and deserialize functions. Added tests for them.

Result:

The generated code can reference protobuf serializer and deserializer types, as they will be supported in GRPC.

Package.swift

@@ -93,6 +93,7 @@ extension Target.Dependency {
   static let protocGenGRPCSwift: Self = .target(name: "protoc-gen-grpc-swift")
   static let reflectionService: Self = .target(name: "GRPCReflectionService")
   static let grpcCodeGen: Self = .target(name: "GRPCCodeGen")
+  static let grpcProtobuf: Self = .target(name: "GRPCProtobuf")
 
   // Target dependencies; internal
   static let grpcSampleData: Self = .target(name: "GRPCSampleData")
@@ -330,6 +331,15 @@ extension Target {
     ]
   )
 
+  static let grpcProtobufTests: Target = .testTarget(
+    name: "GRPCProtobufTests",
+    dependencies: [
+      .grpcCore,
+      .grpcProtobuf,
+      .protobuf
+    ]
+  )
+  
   static let interopTestModels: Target = .target(
     name: "GRPCInteroperabilityTestModels",
     dependencies: [
@@ -579,6 +589,15 @@ extension Target {
     name: "GRPCCodeGen",
     path: "Sources/GRPCCodeGen"
   )
+  
+  static let grpcProtobuf: Target = .target(
+    name: "GRPCProtobuf",
+    dependencies: [
+      .grpcCore,
+      .protobuf
+    ],
+    path: "Sources/GRPCProtobuf"
+  )
 }
 
 // MARK: - Products
@@ -666,6 +685,7 @@ let package = Package(
     .grpcHTTP2Core,
     .grpcHTTP2TransportNIOPosix,
     .grpcHTTP2TransportNIOTransportServices,
+    .grpcProtobuf,
 
     // v2 tests
     .grpcCoreTests,
@@ -674,7 +694,8 @@ let package = Package(
     .grpcInterceptorsTests,
     .grpcHTTP2CoreTests,
     .grpcHTTP2TransportNIOPosixTests,
-    .grpcHTTP2TransportNIOTransportServicesTests
+    .grpcHTTP2TransportNIOTransportServicesTests,
+    .grpcProtobufTests
   ]
 )
 

Sources/GRPCProtobuf/Coding.swift

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024, 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 Foundation
+import GRPCCore
+import SwiftProtobuf
+
+/// Serializes a Protobuf message into a sequence of bytes.
+public struct ProtobufSerializer<Message: SwiftProtobuf.Message>: GRPCCore.MessageSerializer {
+  public init() {}
+
+  /// Serializes a ``Message`` into a sequence of bytes.
+  ///
+  /// - Parameter message: The message to serialize.
+  /// - Returns: An array of serialized bytes representing the message.
+  public func serialize(_ message: Message) throws -> [UInt8] {
+    do {
+      let data = try message.serializedData()
+      return Array(data)
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't serialize message of type \(type(of: message)).",
+        cause: error
+      )
+    }
+  }
+}
+
+/// Deserializes a sequence of bytes into a Protobuf message.
+public struct ProtobufDeserializer<Message: SwiftProtobuf.Message>: GRPCCore.MessageDeserializer {
+  public init() {}
+
+  /// Deserializes a sequence of bytes into a ``Message``.
+  ///
+  /// - Parameter serializedMessageBytes: The array of bytes to deserialize.
+  /// - Returns: The deserialized message.
+  public func deserialize(_ serializedMessageBytes: [UInt8]) throws -> Message {
+    do {
+      let message = try Message(contiguousBytes: serializedMessageBytes)
+      return message
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't deserialize to message of type \(Message.self)",
+        cause: error
+      )
+    }
+  }
+}

Tests/GRPCProtobufTests/ProtobufCodingTests.swift

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2024, 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 GRPCProtobuf
+import SwiftProtobuf
+import XCTest
+
+final class ProtobufCodingTests: XCTestCase {
+  func testSerializeDeserializeRoundtrip() throws {
+    let message = Google_Protobuf_Timestamp.with {
+      $0.seconds = 4
+    }
+
+    let serializer = ProtobufSerializer<Google_Protobuf_Timestamp>()
+    let deserializer = ProtobufDeserializer<Google_Protobuf_Timestamp>()
+
+    let bytes = try serializer.serialize(message)
+    let roundTrip = try deserializer.deserialize(bytes)
+    XCTAssertEqual(roundTrip, message)
+  }
+
+  func testSerializerError() throws {
+    let message = TestMessage()
+    let serializer = ProtobufSerializer<TestMessage>()
+
+    XCTAssertThrowsError(
+      try serializer.serialize(message)
+    ) { error in
+      XCTAssertEqual(
+        error as? RPCError,
+        RPCError(
+          code: .invalidArgument,
+          message:
+            """
+            Can't serialize message of type TestMessage.
+            """
+        )
+      )
+    }
+  }
+
+  func testDeserializerError() throws {
+    let bytes = Array("%%%%%££££".utf8)
+    let deserializer = ProtobufDeserializer<TestMessage>()
+    XCTAssertThrowsError(
+      try deserializer.deserialize(bytes)
+    ) { error in
+      XCTAssertEqual(
+        error as? RPCError,
+        RPCError(
+          code: .invalidArgument,
+          message:
+            """
+            Can't deserialize to message of type TestMessage
+            """
+        )
+      )
+    }
+  }
+}
+
+struct TestMessage: SwiftProtobuf.Message {
+  var text: String = ""
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+  static var protoMessageName: String = "Test" + ".ServiceRequest"
+  init() {}
+
+  mutating func decodeMessage<D>(decoder: inout D) throws where D: SwiftProtobuf.Decoder {
+    throw RPCError(code: .internalError, message: "Decoding error")
+  }
+
+  func traverse<V>(visitor: inout V) throws where V: SwiftProtobuf.Visitor {
+    throw RPCError(code: .internalError, message: "Traversing error")
+  }
+
+  public var isInitialized: Bool {
+    if self.text.isEmpty { return false }
+    return true
+  }
+
+  func isEqualTo(message: SwiftProtobuf.Message) -> Bool {
+    return false
+  }
+}