Hi! I’m continuing my battle (1, 2) against transitive compile-time dependencies on a large code base

This time I am facing an issue with getting rid of a comp. time dependency coming from a custom Ecto type. The source code repo depicting the issue is available here.

Basically, I have 3 modules: Ecto schema, custom type and a module with helper functions. Heavily simplified versions of them look like this:

defmodule MySchema do
  use Ecto.Schema

  schema "my_table" do
    field :my_field, MyType
  end
end

defmodule MyType do
  use Ecto.Type

  def type, do: :binary

  def cast(value), do: {:ok, MyHelperModule.heavy_casting_work(value)}
  def load(value), do: {:ok, MyHelperModule.heavy_loading_work(value)}
  def dump(value), do: {:ok, MyHelperModule.heavy_dumping_work(value)}
end

defmodule MyHelperModule do
  def heavy_casting_work(value), do: value
  def heavy_loading_work(value), do: value
  def heavy_dumping_work(value), do: value
end

The problem here is that, in case implementation of MyHelperModule changes, both MyType and MySchema modules need to be re-compiled. It can be seen by calling mix xref graph:

mix xref graph --source lib/my_schema.ex

Output:

lib/my_schema.ex
└── lib/my_type.ex (compile)
    └── lib/my_helper_module.ex

The rationale for MyHelperModule’s existence is that it can be quite complicated, and best for it is to exist & be tested on its own. Additionally, it is sometimes used in other contexts in the application, such that don’t really require an Ecto.Type interface.

What would be a strategy to get rid of a transitive dependency here?

It seems to me that Ecto absolutely needs to compile all custom types ahead of compiling the schema, so the only way to ensure there’s no transitive com.-time dependency is to have MyType be absolutely free of dependencies on any other module in the app