Organizer passes the result of a callable to another callable (as long as the result is successfull). It is mostly useful when you need to execute a series of operations resembling a pipeline. You might alredy be familiar with some solutions that deal with this (Promises, Railway Programming, Pipe operators). Kit::Organizer is a flavor of functional interactor.

Introduction

Describing a list of operations often leads to code that is difficult to follow or nested requires a lot of nesting. For instance:

fire_user_created_event(persist_user(validate_password(validate_email({ email: email, password: password }))))

# or

valid_email?    = validate_email(email)
valid_password? = validate_password(password)
if valid_email? && valid_password?
  user = persist_user(email: email, password: password)
  if user
    fire_user_created_event(user: user)
  end
end

With Organizer, this is expressed as:

Kit::Organize::Services::Organize.call(
  list: [
    [:alias, :validate_email],
    [:alias, :validate_password],
    [:alias, :persist_user],
    [:alias, :fire_user_created_event],
  ],
  ctx: {
    email: '',
    password: '',
  },
)

Context

An organizer uses a context. The context contains everything the set of operations need to work. When an operation is called, it can affect the context.

Callable

A callable is expected to return a result tupple of the following format:

[:ok] || [:ok, context_update] || [:error] || [:error, context_update]