Serializing Ash Structs with Jason

Ash Forum Ash Questions / Help
, ,
1

So I am using live_svelte which lets you use svelte in your live_views. You pass in the props to the svelte component in a h_sigil and live_svelte serializer them using Jason. Is it possible to derive the encoder for ash resource structs?

2

I am currently manually implementing Jason.Encoder. Is there a means to derive the encoder for ash resources?

defimpl Jason.Encoder, for: Flame.App.Reactant do
  def encode(value, opts) do
    Jason.Encode.map(Map.take(value, [:id, :identity, :spec]), opts)
  end
end
3

I think I’d actually suggest not using a protocol-based encoder, primarily because with Ash resources you can have calculations/aggregates/metadata that you may want to display along with the resource. For instance, if you wanted to show related data, or if you wanted to show computed properties, you might want something like this:

def encode(resources, opts \\ []) do
  Jason.encode!(sanitize(resources, opts))
end

defp sanitize(records, opts) when is_list(resources) do
  Enum.map(records, &sanitize(&1, opts))
end

defp sanitize(%resource{} = record, opts) do
  if Ash.Resource.Info.resource?(resource) do
    fields = opts[:fields] || public_attributes(record)

    Map.new(fields, fn
      {field, further} ->
        {field, sanitize(Map.get(record, field), further)} 
      field -> 
        {field, sanitize(Map.get(record, field), [])} 
      end)
  else
    record
  end
end

defp sanitize(value, _), do: value

defp public_attributes(%resource{}), do: resource |> Ash.Resource.Info.public_attributes() |> Enum.map(&(&1.name))

Something like the above would let you call encode(record, fields: [:field1, :field2, relationship: [fields: [:field3]]).

This lets you load data and serialize it, i.e

MyResource
|> Ash.Query.load([:field1, :field2, relationship: [:field3]])
|> MyApi.read!()
|> Encoder.encode(fields: [:field1, :field2, relationship: [fields: [:field3]])
6 Likes
4

Wow. This is great. I’m guessing the names are a little wrong. They should be.

def encode(records, opts \\ []) do
  Jason.encode!(sanitize(records, opts))
end

defp sanitize(records, opts) when is_list(records) do
  Enum.map(records, &sanitize(&1, opts))
end

Cheers!

1 Like
5

Alternative solution for those who stumble upon this thread:

Had the same use case with live_svelte and decided to go with more automatic approach by writing an Ash extension that defines customizable Jason implementation for a resource based on its fields - ash_jason.

To get some reasonable default behavior just include AshJason.Extension into extensions in use Ash.Resource call. To customize use optional jason section.

It is also possible to write your own extension using ash_jason as a reference point - the library is small, just around hundred lines between two files.

5 Likes