Native implimentations of google.protobuf messages

[btkostner]

First off, thank you for the amazing work on the protobuf library. I know this has been asked a couple of times in the org and made clear that there wouldn't be built in support. So, I'm trying to transparently use DateTime in place of google.protobuf.Timestamp via a transform module like mentioned in this issue. I currently have a functioning implementation that passes very basic tests.

defmodule Transformer do
  @behaviour Protobuf.TransformModule

  alias Google.Protobuf.Timestamp

  @impl true
  def encode(%Timestamp{} = timestamp, Timestamp), do: timestamp

  def encode(%DateTime{} = datetime, Timestamp) do
    seconds = datetime |> DateTime.truncate(:second) |> DateTime.to_unix(:second)
    nanos = datetime |> DateTime.to_unix(:nanosecond) |> Kernel.-(seconds * 1_000_000_000)

    %Timestamp{seconds: seconds, nanos: nanos}
  end

  def encode(value, type), do: type.new(value)

  # Decoding is a bit more tricky because it involves the wrapper message.
  # So we iterate all values and if it matches the Timestamp struct, we
  # rewrite it to a native DateTime struct.
  @impl true
  def decode(value, _type) do
    value
    |> Map.from_struct()
    |> Enum.reduce(value, fn {k, v}, value ->
      case v do
        %Timestamp{seconds: seconds, nanos: nanos} ->
          timestamp = DateTime.from_unix!(seconds * 1_000_000_000 + nanos, :nanosecond)
          Map.put(value, k, timestamp)

        _ ->
          value
      end
    end)
  end
end

It's ugly, but it works (so far).

  describe "json" do
    test "encodes the Timestamp struct as a string" do
      message = %TimestampWrapper{timestamp: %Timestamp{seconds: 946684800, nanos: 0}}

      assert {:ok, %{"timestamp" => "2000-01-01T00:00:00Z"}} = Protobuf.JSON.to_encodable(message)
    end

    test "encodes the DateTime struct as a string" do
      message = %TimestampWrapper{timestamp: ~U[2000-01-01T00:00:00.999999Z]}

      assert {:ok, %{"timestamp" => "2000-01-01T00:00:00.999999Z"}} = Protobuf.JSON.to_encodable(message)
    end

    test "decodes the string as a DateTime struct" do
      message = Jason.encode!(%{"timestamp" => "2000-01-01T00:00:00Z"})

      assert %TimestampWrapper{timestamp: ~U[2000-01-01T00:00:00.000000Z]} = Protobuf.JSON.decode!(message, TimestampWrapper)
    end
  end

My biggest problem is that while the data will be a DateTime struct, all of the generated code still references Google.Protobuf.Timestamp, so typespecs will be incorrect. Is there any way to fix this, or a better way to go about this?

[btkostner]

One idea I had was to set the google.protobuf messages to union types and include native encoding in the library. That way people could use DateTime instead of Google.Protobuf.Timestamp to create messages and make things significantly easier. This wouldn't be a breaking change because everything decoded would still be a Google.Protobuf.Timestamp. At which point, if someone wants to change the decoding, they could use a Protobuf.TransformModule to do it.