sandthorn 0.13.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29159ff3ce6f7b8393363e2bf740c3a37d57a2b2
-  data.tar.gz: 9b1053c87fb402b1887acb6bc8a0fd6faee71ebf
+  metadata.gz: d4f14306b2c1c46da7b99ce8409f6e69dcddf050
+  data.tar.gz: 87dc839602892021e7aa13b2830bedbb1cc90891
 SHA512:
-  metadata.gz: e5cf43faad3a61d3fe307c1598701e99644c7f2d7ea57aa336cd6f22fe9b4c6d707406657ee824619baf0b32ff5418500b46649ace7e1cefa25092529a739b7c
-  data.tar.gz: 2802ac2bf37494ff1ddd4cfd050057e070ddad9422ccee0f9078be37c12c2772bf3402ca7cee6ce92839c042df04df996b658cf3b50bbd1376e60231e590440f
+  metadata.gz: 627da016b372e4f64e452c7bd3a6a8b69412f11e43b2f885e46b1aff6593d4cc73db78521761d5ef2f670ff238836b17a9e25d36208db37830670b38b30fea41
+  data.tar.gz: a6db0ce8921f77bfeccf4fca94ba3ba2228f5f00d73318c445d5b3a60f9b8d7df98e3bfca6475bc27df9ff60a5704d3e51a0f46afeb8094bb0087bcd5a2b697a

data/.travis.yml

@@ -1,6 +1,8 @@
 language: ruby
 rvm:
-  - 2.1.0
-  - 2.1.1
+  - 2.4.1
+  - 2.3.4
+  - 2.2.6
+  - 2.1.10
   - 2.0.0
 sudo: false

data/README.md

@@ -13,8 +13,7 @@ A ruby library for saving an object's state as a series of events.
 
 ## When do I need event sourcing?
 
-If the history of how an object came to be is important a well known technique is to generate a separate history log. The log is generated in parallel with the object and all actions to the object needs to be stored to the log by a separate method call. With event sourcing the history log is now integrated with the object and generated based on the actions that are made on the object, the log is now the fact that the object is built upon.
-
+When state changes made to an object is important a common technique is to store the changes in a separate history log where the log is generated in parallel with the object internal state. With event sourcing the history log is now integrated within the object and generated based on the actions made to the object. The entries in log is the facts the object is built upon.
 
 ## Why Sandthorn?
 
@@ -25,88 +24,6 @@ Check out examples of Sandthorn:
 * [Examples](https://github.com/Sandthorn/sandthorn_examples) including a product shop and TicTacToe game.
 * Live [demo](http://infinite-mesa-8629.herokuapp.com/) comparing Active Record and Sandthorn.
 
-## How do I use Sandthorn?
-
-
-
-Think of it as an object database where you store not only what the new value of an attribute is, but also when and why it changed.
-_Example:_
-
-```ruby
-
-# Setup the Aggregate
-
-# The one available right now
-require 'sandthorn'
-require 'sandthorn_driver_sequel'
-
-class Ship
-  include Sandthorn::AggregateRoot
-  attr_reader :name
-
-  def initialize name: nil, shipping_company: nil
-    @name = name
-  end
-
-  # State-changing command
-  def rename! new_name: ""
-    unless new_name.empty? or new_name == name
-      @name = new_name
-      ship_was_renamed
-    end
-  end
-
-  private
-
-  # Commit the event and state-change is automatically recorded.
-  def ship_was_renamed
-    commit
-  end
-end
-
-# Configure one driver
-url = "sqlite://spec/db/sequel_driver.sqlite3"
-sql_event_store = SandthornDriverSequel.driver_from_url(url: url)
-Sandthorn.configure do |c|
-  c.event_store = sql_event_store
-end
-
-# Or configure many drivers
-url = "sqlite://spec/db/sequel_driver.sqlite3"
-sql_event_store = SandthornDriverSequel.driver_from_url(url: url)
-url_two = "sqlite://spec/db/sequel_driver_two.sqlite3"
-other_store = SandthornDriverSequel.driver_from_url(url: url_two)
-
-Sandthorn.configure do |c|
-  c.event_stores = {
-    default: sql_event_store,
-    other_event_store: other_store
-  }
-end
-
-# Assign your aggregates to a named event store
-
-class Boat
-  include Sandthorn::AggregateRoot
-  event_store :other_event_store
-end
-
-# Aggregates with no explicit event store will use the default event store
-
-# Migrate db schema for the sequel driver
-migrator = SandthornDriverSequel::Migration.new url: url
-SandthornDriverSequel.migrate_db url: url
-
-# Usage
-ship = Ship.new name: "Titanic"
-ship.rename! new_name: "Vasa"
-
-ship.save
-
-new_ship = Ship.find ship.id
-puts new_ship.name
-```
-
 # Installation
 
 Add this line to your application's Gemfile:
@@ -124,79 +41,42 @@ Or install it yourself as:
 # Configuring Sandthorn
 
 ## Driver
+Sandthorn can be setup with one or more drivers. A driver is bound to a specific data store where events are saved and loaded from. The current implemented drivers are [sandthorn_driver_sequel](https://github.com/Sandthorn/sandthorn_driver_sequel) for SQL via [Sequel](https://github.com/jeremyevans/sequel) and [sandthorn_driver_event_store](https://github.com/Sandthorn/sandthorn_driver_event_store) that uses [Get Event Store](https://geteventstore.com).
 
-Sandthorn relies on a driver that is specific to the data storage that you are using. This means Sandthorn can be used with any data storage given that a driver exists.
+This means Sandthorn can be used with any data store given that a driver exists.
 
-To setup a driver you need to add it to your project's Gemfile and configure it in your application code.
-
-    gem 'sandthorn_driver_sequel'
-
-
-The driver is configured when your application launches. Here's an example of how to do it using the Sequel driver and a sqlite3 database.
+Here's an example of setting up Sandthorn with the Sequel driver and a sqlite3 database.
 
 ```ruby
-url = "sqlite://spec/db/sequel_driver.sqlite3"
+url = "sqlite://sql.sqlite3"
 driver = SandthornDriverSequel.driver_from_url(url: url)
 Sandthorn.configure do |conf|
   conf.event_stores = { default: driver }
 end
 ```
 
-First we specify the path to the sqlite3 database in the `url` variable. Secondly, the specific driver is instantiated with the `url`. Hence, the driver could be instantiated using a different configuration, for example, an address to a Postgres database. Finally, `Sandthorn.configure` accepts a keyword list with options. It´s here the driver is bound to Sandthorn via a context.
-
-The first time you use the Sequel driver it is necessary to install the database schema.
-
-```ruby
-url = "sqlite://spec/db/sequel_driver.sqlite3"
-SandthornDriverSequel::Migration.new url: url
-SandthornDriverSequel.migrate_db url: url
-```
-
-Optionally, when using Sandthorn in your tests you can configure it in a `spec_helper.rb` which is then required by your test suites [example](https://github.com/Sandthorn/sandthorn_examples/blob/master/sandthorn_tictactoe/spec/spec_helper.rb#L20-L30). Note that the Sequel driver accepts a special parameter to empty the database between each test.
-
-The Sequel driver is the only production-ready driver to date.
-
-
 ## Map aggregate types to event stores
 
-Its possible to map aggregate_types to events stores from the configuration setup. This makes it possible to work with data from different stores that are using the same context, and will override any event_store setting within an aggregate.
+Its possible to save events from different classes into different stores. Below the events from class FooAggregate are stored into the sql_foo.sqlite3 database and events from class BarAggregate are stored in sql_bar.sqlite3.
 
 ```ruby
-url_foo = "sqlite://spec/db/sequel_driver_foo.sqlite3"
-driver_foo = SandthornDriverSequel.driver_from_url(url: url_foo)
+driver_foo = SandthornDriverSequel.driver_from_url(url: "sqlite://sql_foo.sqlite3")
+driver_bar = SandthornDriverSequel.driver_from_url(url: "sqlite://sql_bar.sqlite3")
 
-url_bar = "sqlite://spec/db/sequel_driver_bar.sqlite3"
-driver_bar = SandthornDriverSequel.driver_from_url(url: url_bar)
-
-class AnAggregate
+class FooAggregate
   Include Sandthorn::AggregateRoot
 end
 
-class AnOtherAggregate
+class BarAggregate
   Include Sandthorn::AggregateRoot
 end
 
 Sandthorn.configure do |conf|
   conf.event_stores = { foo: driver_foo, bar: driver_bar }
-  conf.map_types = { foo: [AnAggregate], bar: [AnOtherAggregate] }
+  conf.map_types = { foo: [FooAggregate], bar: [BarAggregate] }
 end
 ```
 
-## Data serialization
-
-Its possible to configure how events and snapshots are serialized. Since version `0.11.0` of Sandthorn the serialization of events and snapshots is the responsibility of the driver. This means drivers can have different serialization mechanism, independent of each other.
-
-The default serializer of the Sequel driver is YAML.
-
-Here's how to use the Oj gem to serialize data in the Sequel driver:
-
-```ruby
-oj_driver = SandthornDriverSequel.driver_from_connection(connection: Sequel.sqlite) { |conf|
-  conf.event_serializer = Proc.new { |data| Oj::dump(data) }
-  conf.event_deserializer = Proc.new { |data| Oj::load(data) }
-}
-```
-
 # Usage
 
 ## Aggregate Root
@@ -217,7 +97,7 @@ All objects that include `Sandthorn::AggregateRoot` is provided with an `aggrega
 
 An abstraction over `commit` that creates events methods that can be used from within a command method.
 
-In this exampel the `events` method will generate a method called `marked`, this method take *args as input that will result in the method argument on the event. It also take a block that will be executed before the event is commited and is used to groups the state changes to the event (but is only optional right now).
+In this exampel the `events` method will generate a method called `marked`, this method take an block that will be executed before the event is commited and is used to groups the state changes to the event. The block is optional and the state changes could have been made outside the `marked` method.
 
 ```ruby
 class Board
@@ -227,7 +107,7 @@ class Board
 
   def mark player, pos_x, pos_y
     # change some state
-    marked(player) do
+    marked() do
       @pos_x = pos_x
       @pos_y = pos_y
     end
@@ -237,7 +117,7 @@ end
 
 ### `Sandthorn::AggregateRoot::constructor_events`
 
-Before version 0.13.0 the only initial event on an aggregate were `new`. With the `constructor_events` its possible to be more specific on how an aggregate came to be.
+With `constructor_events` its possible to be more specific on how an aggregate came to be. The first event will now have the name `board_created` instead of the default `new`.
 
 ```ruby
 class Board
@@ -257,9 +137,9 @@ end
 
 ### `Sandthorn::AggregateRoot::stateless_events`
 
-Calling `stateless_events` creates public class methods. The first argument is an `aggregate_id`. The resulting event is attached to the referenced aggregate. The rest of the arguments are optional and are stored in the method_args of the event.
+Calling `stateless_events` creates public class methods. The first argument is an `aggregate_id` and the second argument is optional but has to be a hash and is stored in the attribute_deltas of the event.
 
-When creating a stateless event, the corresponding aggregate is never loaded. The event is appendend to the aggregate's event stream.
+When creating a stateless event, the corresponding aggregate is never loaded and the event is saved without calling the save method.
 
 ```ruby
 class Board
@@ -269,7 +149,7 @@ class Board
 
 end
 
-Board.player_went_to_toilet "board_aggregate_id", player_id, time
+Board.player_went_to_toilet "board_aggregate_id", {player_id: "1", time: "10:12"}
 ```
 
 ### `Sandthorn::AggregateRoot::default_attributes`
@@ -286,7 +166,7 @@ end
 
 ### `Sandthorn::AggregateRoot.commit`
 
-It is required that an event is commited to the aggregate to be stored as an event. `commit` extracts the object's delta and locally caches the state changes that has been applied to the aggregate. Commonly, commit is called when an event is applied. In [CQRS](http://martinfowler.com/bliki/CQRS.html), events are named using past tense.
+To generate an event the commit method has to be called within the aggregate. `commit` extracts the object's delta and locally caches the state changes that has been applied to the aggregate.
 
 ```ruby
 def mark player, pos_x, pos_y
@@ -301,11 +181,11 @@ end
 
 `commit` determines the state changes by monitoring the object's readable fields.
 
-Since version 0.10.0 of Sandthorn the concept `events` have been introduced to abstract away the usage of `commit`. Commit still works as before but we think that the `events` abstraction makes the aggregate more readable.
+The concept `events` have been introduced to abstract away the usage of `commit`. Commit still works as before but we think that the `events` abstraction makes the aggregate more readable.
 
 ### `Sandthorn::AggregateRoot.save`
 
-Once one or more commits have been applied to an aggregate it should be saved. This means all commited events will be persisted by the specific Sandthorn driver. `save` is called by the owning object.
+The save method store generated events, this means all commited events will be persisted via a Sandthorn driver.
 
 ```ruby
 board = Board.new
@@ -315,7 +195,7 @@ board.save
 
 ### `Sandthorn::AggregateRoot.all`
 
-It is possible to retrieve an array with all instances of a specific aggregate.
+Retrieve an array with all instances of a specific aggregate type.
 
 ```ruby
 Board.all
@@ -329,20 +209,18 @@ Board.all.select { |board| board.active == true }
 
 ### `Sandthorn::AggregateRoot.find`
 
-Using `find` it is possible to retrieve a specific aggregate using it's id.
+Loads a specific aggregate using it's uuid.
 
 ```ruby
 uuid = '550e8400-e29b-41d4-a716-446655440000'
 board = Board.find(uuid)
-board.aggregate_id == uuid
 ```
 
-If no aggregate with the specifid id is found, a `Sandthorn::Errors::AggregateNotFound` exception is raised.
-
+If no aggregate with the specifid uuid is found, a `Sandthorn::Errors::AggregateNotFound` exception is raised.
 
 ### `Sandthorn::AggregateRoot.aggregate_trace`
 
-Using `aggregate_trace` one can store meta data with events. The data is not aggregate specific, for example, one can store who executed a specific command on the aggregate.
+Using `aggregate_trace` one can store meta data on events. The data is not aggregate specific and it can for example store who executed a specific command on the aggregate.
 
 ```ruby
 board.aggregate_trace {player: "Fred"} do |aggregate|
@@ -353,7 +231,7 @@ end
 
 `aggregate_trace` can also be specified on a class.
 
-````ruby
+```ruby
 Board.aggregate_trace {ip: :127.0.0.1} do
   board = Board.new
   board.mark :o , 0, 1

data/lib/sandthorn.rb

@@ -32,50 +32,20 @@ module Sandthorn
       SecureRandom.uuid
     end
 
-    def get_aggregate_events aggregate_type, aggregate_id
-      event_store_for(aggregate_type).get_aggregate_events aggregate_id
-    end
-
     def save_events aggregate_events, aggregate_id, aggregate_type
       event_store_for(aggregate_type).save_events aggregate_events, aggregate_id, *aggregate_type
     end
 
-    def get_aggregate aggregate_id, aggregate_type
-      event_store_for(aggregate_type).get_aggregate_events_from_snapshot aggregate_id
-    end
-
-    def save_snapshot(aggregate)
-      event_store_for(aggregate.class).save_snapshot(aggregate)
-    end
-
-    def get_aggregate_list_by_type aggregate_type
-      event_store_for(aggregate_type).get_aggregate_ids(aggregate_type: aggregate_type)
-    end
-
     def all aggregate_type
       event_store_for(aggregate_type).all(aggregate_type)
     end
 
     def find aggregate_id, aggregate_type
-      event_store_for(aggregate_type).find(aggregate_id)
+      event_store_for(aggregate_type).find(aggregate_id, aggregate_type)
     end
 
-    def get_events event_store: :default, aggregate_types: [], take: 0, after_sequence_number: 0
-      event_store = find_event_store(event_store)
-      events = event_store.get_events aggregate_types: aggregate_types, take: take, after_sequence_number: after_sequence_number
-      events.map do |event|
-        Event.new(event)
-      end
-    end
-
-    def obsolete_snapshots type_names: [], min_event_distance: 0
-      obsolete = event_stores.flat_map { |event_store| event_store.obsolete_snapshots(aggregate_types: type_names, max_event_distance: min_event_distance) }
-      obsolete.map do |single_obsolete|
-        type = Kernel.const_get single_obsolete[:aggregate_type]
-        aggregate = type.aggregate_find(single_obsolete[:aggregate_id]).tap do |agg|
-          yield agg if block_given?
-        end
-      end
+    def save_snapshot(aggregate)
+      raise "Not Implemented"
     end
 
     def find_event_store(name)

data/lib/sandthorn/aggregate_root_base.rb

@@ -42,9 +42,9 @@ module Sandthorn
         @aggregate_trace_information = nil
       end
 
-      def commit *args
+      def commit
         event_name = caller_locations(1,1)[0].label.gsub(/block ?(.*) in /, "")
-        commit_with_event_name(event_name, args)
+        commit_with_event_name(event_name)
       end
 
       def default_attributes
@@ -82,12 +82,17 @@ module Sandthorn
         end
 
         def aggregate_find aggregate_id
-          events = Sandthorn.find(aggregate_id, self)
-          unless events && !events.empty?
-            raise Sandthorn::Errors::AggregateNotFound
-          end
+          begin
+            events = Sandthorn.find(aggregate_id, self)
+            unless events && !events.empty?
+              raise Errors::AggregateNotFound
+            end
 
-          aggregate_build events
+            return aggregate_build events
+          rescue Exception
+            raise Errors::AggregateNotFound
+          end
+            
         end
 
         def new *args, &block
@@ -100,26 +105,20 @@ module Sandthorn
           aggregate.send :set_aggregate_id, Sandthorn.generate_aggregate_id
 
           aggregate.aggregate_trace @@aggregate_trace_information do |aggr|
-            aggr.send :commit, *args
+            aggr.send :commit
             return aggr
           end
 
         end
 
         def aggregate_build events
-          if first_event_snapshot?(events)
-            aggregate = events.first[:aggregate]
-            events.shift
-          else
-            aggregate = create_new_empty_aggregate
-          end
+          aggregate = create_new_empty_aggregate
 
           if events.any?
             current_aggregate_version = events.last[:aggregate_version]
             aggregate.send :set_orginating_aggregate_version!, current_aggregate_version
             aggregate.send :set_current_aggregate_version!, current_aggregate_version
           end
-
           attributes = build_instance_vars_from_events events
           aggregate.send :clear_aggregate_events
 
@@ -130,15 +129,12 @@ module Sandthorn
           aggregate
         end
 
-
-
         def stateless_events(*event_names)
           event_names.each do |name|
             define_singleton_method name do |aggregate_id, *args|
-              event = build_event(name.to_s, args, [], nil)
+              event = build_stateless_event(name.to_s, args)
               Sandthorn.save_events([event], aggregate_id, self)
               return aggregate_id
-
             end
           end
         end
@@ -152,7 +148,7 @@ module Sandthorn
                 aggregate.aggregate_initialize
                 aggregate.send :set_aggregate_id, Sandthorn.generate_aggregate_id
                 aggregate.instance_eval(&block) if block
-                aggregate.send :commit_with_event_name, name.to_s, args
+                aggregate.send :commit_with_event_name, name.to_s
                 return aggregate
               end
 
@@ -165,7 +161,7 @@ module Sandthorn
           event_names.each do |name|
             define_method(name) do |*args, &block|
               block.call() if block
-              commit_with_event_name(name.to_s, args)
+              commit_with_event_name(name.to_s)
             end
             private name.to_s
           end
@@ -173,30 +169,33 @@ module Sandthorn
 
         private
 
-        def build_event name, args, attribute_deltas, aggregate_version, trace_information = nil
+        def build_stateless_event name, args = []
+
+          formated_attribute_deltas = args.first.map do |key, value|
+            {
+              attribute_name: key.to_s,
+              old_value: nil,
+              new_value: value
+            }
+          end unless args.empty?
 
           data = {
-            method_name: name,
-            method_args: args,
-            attribute_deltas: attribute_deltas
+            attribute_deltas: formated_attribute_deltas
           }
 
-          unless trace_information.nil? || trace_information.empty?
-            data.merge!({ trace: trace_information })
-          end
-
           return {
-            aggregate_version: aggregate_version,
+            aggregate_version: nil,
             event_name: name,
-            event_args: data
+            event_data: data,
+            event_metadata: nil
           }
 
         end
 
         def build_instance_vars_from_events events
           events.each_with_object({}) do |event, instance_vars|
-            event_args = event[:event_args]
-            attribute_deltas = event_args[:attribute_deltas]
+            event_data = event[:event_data]
+            attribute_deltas = event_data[:attribute_deltas]
             unless attribute_deltas.nil?
               deltas = attribute_deltas.each_with_object({}) do |delta, acc|
                 acc[delta[:attribute_name]] = delta[:new_value]
@@ -206,10 +205,6 @@ module Sandthorn
           end
         end
 
-        def first_event_snapshot? events
-          events.first[:aggregate]
-        end
-
         def create_new_empty_aggregate
           allocate
         end
@@ -256,24 +251,19 @@ module Sandthorn
         @aggregate_id = aggregate_id
       end
 
-      def commit_with_event_name(event_name, args)
+      def commit_with_event_name(event_name)
         aggregate_attribute_deltas = get_delta
 
         increase_current_aggregate_version!
         data = {
-          method_name: event_name,
-          method_args: args,
           attribute_deltas: aggregate_attribute_deltas
         }
-        trace_information = @aggregate_trace_information
-        unless trace_information.nil? || trace_information.empty?
-          data.merge!({ trace: trace_information })
-        end
 
         @aggregate_events << ({
           aggregate_version: @aggregate_current_event_version,
           event_name: event_name,
-          event_args: data
+          event_data: data,
+          event_metadata: @aggregate_trace_information
         })
 
         self