@bottlenecked Thank you very much again.
I agree with all of your points. I will try to redirect my thinking toward the CQRS kind of thinking.
@benwilson512 Thank you very much! I will review the post ASAP.
@slashdotdash Thank you very much! I’ll check out them the aggregate_state/3 method.
Although I think I am leaning toward CQRS currently.
I have a lot to learn tho.
Thank you very much to you all that invested your time to respond to my questions. you are awesome.
Busting some CQRS myths
Myth #1 – CQRS = Event Sourcing and vice versa
Event sourcing often fits well with CQRS, as it makes building and updating read stores over time a bit more straightforward in eventually consistent models. Additionally, the aggregates living in the command side for behavior-heavier systems and task-based UIs more obvious.
However, event sourcing is a completely orthogonal concept to CQRS . While they fit well together, doing CQRS does not require event sourcing, and doing event sourcing does not automatically mean we’re doing CQRS.
Hi, @Blokh,
There is a way to “plug” Event Sourcing easily in combination with Ecto. Here is simplest example
defmodule Sourced.Repo do
use Ecto.Repo, otp_app: :sourced, adapter: Ecto.Adapters.Postgres
end
defmodule Sourced.DomainEvent do
use Ecto.Schema
import Ecto.Changeset
schema "domain_events" do
field(:name, :string)
field(:source, :string)
field(:data, :string)
end
def append(params) do
fields = [:name, :source, :data]
__MODULE__
|> struct([])
|> cast(params, fields)
|> validate_required(fields)
end
end
defmodule Sourced.User do
use Ecto.Schema
import Ecto.Changeset
alias Sourced.DomainEvent
schema "users" do
field(:first_name, :string)
field(:last_name, :string)
field(:age, :integer)
field(:email, :string)
end
def create(params) do
required = [:first_name, :last_name, :email]
fields = [:age | required]
# this should be regular path, where you cast params to your model
__MODULE__
|> struct([])
|> cast(params, fields)
|> validate_required(required)
# at this point we will know if change to model is valid
|> case do
%{valid?: false, errors: errors} ->
# if change didn't pass validation, return error
{:error, errors}
%{changes: changes} = model_changeset ->
# now we want to generate and "pack" events
# note that we can split `:change` to several events
# but below I put them all in single event
event_changeset =
DomainEvent.append(%{
name: "user_created",
source: Atom.to_string(__MODULE__),
data: Jason.encode!(changes)
})
# use ecto multi and explicit repo transaction so we make sure that
# all data is stored!!! otherwise you will endup with incosistency
# between state and event journal
Ecto.Multi.new()
|> Ecto.Multi.insert("create_user", model_changeset)
|> Ecto.Multi.insert("user_created", event_changeset)
|> Sourced.Repo.transaction()
end
end
end
And here is test case (again, very simple)
defmodule SourcedTest do
use ExUnit.Case
setup do
# Explicitly get a connection before each test
:ok = Ecto.Adapters.SQL.Sandbox.checkout(Sourced.Repo)
end
test "should persist new user and domain event" do
assert {:ok, %{"create_user" => _, "user_created" => _}} =
Sourced.User.create(%{
first_name: "foo",
last_name: "bar",
email: "foo.bar@example.com"
})
end
end
One disclaimer for about example. What ever CQRS is trying to solve, it is NOT solved in this example. So either you have to solve it by your self or use 3rd party lib.
Event sourcing is more than just writing to a table called events. The “sourcing” bit of event sourcing means that you are driving state exclusively off of the event log. Your example here simply writes an event alongside the normal table insert, it doesn’t drive the table insert off of the event. To do this properly you also need order guarantees: that each event is processed in order to other events.
That is true, and that is why I put disclaimer at the bottom and this is just one possible path and not solution
Thank you @mjaric and @benwilson512.
I’ve took the CQRS approach.
I will take a while to study how to properly code in elixir especially with the CQRS approach. but that’s fine I’ll do my best 