Schemas with common fields

van-mronov · January 31, 2018, 7:03am

Hi, all! Suppose I have 2 schemas mapping 2 similar external API responses:

defmodule Foo do
  use Ecto.Schema

  embedded_schema do
    belongs_to :common_field_1, CommonField

    field :common_field_2, :integer
    field :common_field_3, :string

    field :foo_specific_field, :integer
  end

  def changeset(params) do
    %Foo{}
    |> cast(...)
    |> validate_common_fields()
    |> validate_foo_specific_fields()
  end

  def validate_common_fields(%Ecto.Changeset{} = changeset) do
    # Uses only common fields
  end

  def validate_foo_specific_fields(%Ecto.Changeset{} = changeset) do
    # Uses common and specific fields
  end
end

defmodule Bar do
  use Ecto.Schema

  embedded_schema do
    belongs_to :common_field_1, CommonField

    field :common_field_2, :integer
    field :common_field_3, :string

    field :bar_specific_field1, :integer
    field :bar_specific_field2, :string
  end

  def changeset(params) do
    %Bar{}
    |> cast(...)
    |> validate_common_fields()
    |> validate_bar_specific_fields()
  end

  def validate_common_fields(%Ecto.Changeset{} = changeset) do
    # Uses only common fields
  end

  def validate_bar_specific_fields(%Ecto.Changeset{} = changeset) do
    # Uses common and specific fields
  end
end

What is the best way to avoid dup code in that case? I can move common validations in another module. But how to deal with common fields in schema definitions?

NobbZ · January 31, 2018, 7:37am

In theory you can do it exactly like it is done in ecto itself with the timestamps/1 and implement it as a macro.

But for only two schemas, I do not think its worth the effort…

Implementation:

github.com

elixir-ecto/ecto/blob/v2.2.8/lib/ecto/schema.ex#L485-L508


      
          defmacro timestamps(opts \\ []) do
            quote bind_quoted: binding() do
              timestamps =
                [inserted_at: :inserted_at, updated_at: :updated_at,
                 type: :naive_datetime, usec: true]
                |> Keyword.merge(@timestamps_opts)
                |> Keyword.merge(opts)
          
              type      = Keyword.fetch!(timestamps, :type)
              precision = if Keyword.fetch!(timestamps, :usec), do: :microseconds, else: :seconds
              autogen   = timestamps[:autogenerate] || {Ecto.Schema, :__timestamps__, [type, precision]}
          
              if inserted_at = Keyword.fetch!(timestamps, :inserted_at) do
                Ecto.Schema.field(inserted_at, type, [])
                Module.put_attribute(__MODULE__, :ecto_autogenerate, {inserted_at, autogen})
              end
          
              if updated_at = Keyword.fetch!(timestamps, :updated_at) do
                Ecto.Schema.field(updated_at, type, [])
                Module.put_attribute(__MODULE__, :ecto_autogenerate, {updated_at, autogen})

This file has been truncated. show original

LostKobrakai · January 31, 2018, 8:07am

I would expect this to be a case of driving DRYness to far. Those API resonses are currently similar, but will they stay that way in the future? Will changes happen in both responses at the same time? Having common validation is a nice option to prevent having to fix business rules in two places, but the schema is just a static representation without many moving parts.

van-mronov · January 31, 2018, 9:05am

@NobbZ @LostKobrakai Thank both of you, guys. I understand your concerns on overDRYing schema definitions. In our case we have not 2 but 5 such schemas. Perhaps, we will consider requesting external API refactoring.