I have loads of structs defined via typed_struct and would like to serialize and deserialize these structs to and from JSON. I am currently using Jason, but I am not tied to that at all. Serializing any of my structs into JSON is simple, deriving Jason.Encoder works. An example structure that (hopefully) contains everything I need could look like this:

require Protocol

defmodule Example do
  use TypedStruct
  @type id :: Ecto.UUID.t()

  typedstruct module: Presence do
    field :joined_since, DateTime.t(), enforce: false
    field :reason, String.t()
  end

  typedstruct enforce: true do
    field :id, id
    field :name, String.t()
    field :presences, %{optional(Presence.id) => Presence.t()}
  end

  def build() do
    %__MODULE__{
      id: Ecto.UUID.generate(),
      name: "Some Guest",
      presences: %{
        "#{Ecto.UUID.generate()}": %Presence{
          joined_since: DateTime.utc_now,
          reason: "Creation"
        }
      }
    }
  end
end

Protocol.derive(Jason.Encoder, Example)
Protocol.derive(Jason.Encoder, Example.Presence)

Implementing serialization and deserialization for this however comes with two problems:

1. By default I am losing the type when serializing as JSON: From my point of view the easiest thing would be to tag each JSON object with the type. As far as I understand it, this is also the way a “normal” map is differentiated from a struct: By having a :__struct__ field present in the map. If I could just serialize this field alongside the normal data, the resulting map would be properly treated as a struct. I am already using the :__struct__ field to know on which module I want to call functions, so to me this seems like a natural thing to do. But it at least doesn’t seem to be encouraged by Jason: I didn’t stumble over any way of doing this except for repeating all keys as part of the only option to the protocol or providing a manual implementation.

   Protocol.derive(Jason.Encoder, Example, only: [:__struct__, :id, :name, :presences])
   Protocol.derive(Jason.Encoder, Example.Presence, only: [:__struct__, :id, :joined_since, :reason])
   

2. I do fear however that whatever I am doing is misguided. Because when serializing and deserializing such a struct (using the derived protocol from 1.) I made some observations:

   iex(14)> Example.build |> Jason.encode!() |> Jason.decode!(keys: :atoms)
   %{
       id: "21be5f01-eef1-4ff1-afd5-a09919a9f26f",
       name: "Some Guest",
       __struct__: "Elixir.Example",
       presences: %{
         "bfa4f256-d1d9-416c-a08f-8a04e3b7cc06": %{
           id: "b0e55b2f-1541-4987-8b99-b57563584558",
           reason: "Creation",
           __struct__: "Elixir.Example.Presence",
           joined_since: "2025-03-27T12:08:18.791171Z"
         }
       }
     }
   

   1. At first I was pleasently surprised to discover, that the keys: :atoms option did not turn the UUID that is part of the presences key into an atom. That saves me from a self-inflicted atom exhaustion I guess, but I don’t understand why the UUID wasn’t converted.
   2. It however also didn’t “recover” the DateTime, but left it as a string. I guess this is to be expected, as there is no “proper” JSON representation for date and time.
   3. The resulting map suddenly has the :__struct__ “visible” as part of my iex representation. So something about the map I recovered is not quite a “proper” struct.

This leaves me with the following questions:

1. What is a better way to tell Jason to include the __struct__ when serializing? So far I would probably write a manual implementation and re-use that. Or is there a reason I really should not do this?
2. What is different from a “proper” struct about the map I get from calling encode! and decode!?
3. Should I just abandon the idea of serializing to JSON and “simply” write the binary representation into my PostgreSQL database?