Getting rid of a transitive compile dependency with custom Ecto type

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

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
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)}
defmodule MyHelperModule do
  def heavy_casting_work(value), do: value
  def heavy_loading_work(value), do: value
  def heavy_dumping_work(value), do: value

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


└── 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 :frowning:

1 Like

You can always go and change a compile time dependency to a runtime dependency e.g. by using something like Module.concat to build the module name for your helper module in a function body of a function on the type module.

If the compiler cannot know the module at compile time it cannot react in any way.

Another option would be inverting the dependency. Put the implementations for provided functionality into the type module and let the helper delegate to the implementation on the type.

:+1: for this particular bit. In this case, it has to be a compile-time dependency, so minimizing the subgraph makes sense.

1 Like

Thanks! In a few places in the codebase, I ultimately settled on using Module.concat/1, since refactoring using the “reverse dependency” approach was a little more work in my case, and better done separately.