README.md

# Injectx

<!-- MDOC !-->

**Context Dependency Injection for Elixir**

## Installation

If [available in Hex](https://hex.pm/docs/publish), the package can be installed
by adding `injectx` to your list of dependencies in `mix.exs`:

```elixir
def deps do
  [
    {:injectx, "~> 0.1.0"}
  ]
end
```

`Injectx` module is a entrypoint to CDI.

## Usage:

Define your Behavior module:

```elixir
defmodule FooBehavior do
  @callback greetings(String.t()) :: String.t()
end
```

Implement it:

```elixir
defmodule FooImpl do
  @behavior FooBehavior

  @impl true
  def greetings(_name) do
    "Hello from FooImpl"
  end
end
```

Initialize Injectx Context on Application bootstrap:

```elixir
defmodule App do
  use Application

  alias Injectx.Context

  @impl true
  def start(_type, _args) do
    context = %Context{
      bindings: [
        %Context.Binding{
          behavior: FooBehavior,
          definitions: [
            %Context.BindingDefinition{module: FooImpl, default: true}
          ]
        }
      ]
    }

    Context.from(context)

    children = [
      ...
    ]

    opts = [strategy: :one_for_one, name: App.Supervisor]
    Supervisor.start_link(children, opts)
  end
end
```

### Use your behavior via Implementation resolved in runtime (using inject macro with same sintaxe of alias):

```elixir
defmodule Bar do
  use Injectx

  inject TestBehaviour

  def greetings(name), do: TestBehaviour.greetings(name)
end
```

### Or you can inject all implementations at once (using inject_all function):

```elixir
defmodule Caller do
  use Injectx

  # resolve all injection bindings for certain behavior
  @all inject_all(TestBehaviour)

....
  def call(), 
    do: Enum.each(@all, fn impl -> impl.greetings("Teddy") end)
end
```

## Dispatching

Injectx also provides the ability to dynamically dispatch your implementations.
For this it is only necessary to use the dispatcher function. Sync and Async are possible options:

```elixir
defmodule SomeBehaviour do
    @callback test(integer()) :: {:ok, integer()}
end

defmodule SomeImpl1 do
  @behaviour SomeBehaviour

  def test(1), do: {:ok, 1}
end

defmodule SomeImpl2 do
  @behaviour SomeBehaviour

  def test(1), do: {:ok, 2}
end

... bootstrap
  @impl true
  def start(_type, _args) do
    context = %Context{
      bindings: [
        %Context.Binding{
          behavior: SomeBehaviour,
          definitions: [
            %Context.BindingDefinition{module: SomeImpl1, default: true},
            %Context.BindingDefinition{module: SomeImpl2}
          ]
        }
      ]
    }

    Context.from(context)
    ....
  end

...write some client module...

defmodule SomeClientModule do
  use Injectx

  def call(arg), do: dispatching(TestBehaviour, :test, [arg], async: true)
   
end

...then call it `iex -S mix`

iex(1)> SomeClientModule.call(1)
[{:ok, InjectxTest.TestImpl2, {:ok, 2}}, {:ok, InjectxTest.TestImpl1, {:ok, 1}}]
```