sandthorn_driver_sequel 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d205c3b770d2f9e6df066e3c28bcb8cb690978e5
-  data.tar.gz: 9fdaf52d4a30f3d1e5e40967ffdfa6554179962c
+  metadata.gz: bce877362844db909c0b8d1d6548ad29c41750e5
+  data.tar.gz: d6ad4a8929b306e4a962eb1195db49d0bbfd9de9
 SHA512:
-  metadata.gz: 44c1d90a3247da4deaf51f811f2005b7b86ec55dd14cf1a9cd8a0124f36a8344f523dfb917a63b65a8d64b38e2afc4b99ecb3542b37cc33dc409c5f5688c60ec
-  data.tar.gz: 0b4614730ab5f124e3f3133fefae5985d06c298312e1f4066f3af9ee78ba70709643783b97c6b4b5a4947ce7cd8b65a54d10bd854f2d92d3b56f0002dc4d7459
+  metadata.gz: 7b1294dc014cac377927b4e74c72270258b4b85ef4cd0a420971408d12f6536da71df03239c69328ae0c57a914556d1304c29845ca581485c8005f9f068223da
+  data.tar.gz: 67a03daf9055212d0d0d9610df5cc49ec6a7d51e779ce7036206861aa1e0e226b5710f0923e727e2916d50e7602b8c13e528d99343743df5ca23f1e175c31a30

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1
+ruby-2.0

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
+  - 2.2.3
   - 2.1.0
-  - 2.0.0
+  - 2.0.0

data/README.md

@@ -20,7 +20,36 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### `SandthornDriverSequel.configure`
+
+Change the global configuration, the default data serialization for events and snapshots are YAML.
+
+Change the serialization of events and snapshots to Oj.
+
+```ruby
+SandthornDriverSequel.configure { |conf|
+  conf.event_serializer = Proc.new { |data| Oj::dump(data) }
+  conf.event_deserializer = Proc.new { |data| Oj::load(data) }
+  conf.snapshot_serializer = Proc.new { |data| Oj::dump(data) }
+  conf.snapshot_deserializer = Proc.new { |data| Oj::dump(data) }
+}
+```
+
+### `SandthornDriverSequel.driver_from_connection`
+
+Creates a driver from a Sequel connection. Its possible to send in a block like the one for `configure` to chage configuration for the driver.
+
+```ruby
+driver = SandthornDriverSequel.driver_from_connection(connection: Sequel.sqlite)
+```
+
+### `SandthornDriverSequel.driver_from_url`
+
+Creates a driver from a Sequel url. Its possible to send in a block like the one for `configure` to change configuration for the driver.
+
+```ruby
+driver = SandthornDriverSequel.driver_from_connection(url: "<sequel url string>")
+```
 
 ## Contributing
 

data/lib/sandthorn_driver_sequel/access/aggregate_access.rb

@@ -1,3 +1,5 @@
+require "sandthorn_driver_sequel/access"
+
 module SandthornDriverSequel
   class AggregateAccess < Access::Base
 

data/lib/sandthorn_driver_sequel/access/event_access.rb

@@ -1,8 +1,16 @@
+require "sandthorn_driver_sequel/access"
+
 module SandthornDriverSequel
   class EventAccess < Access::Base
     # = EventAccess
     # Reads and writes events.
 
+    def initialize storage, serializer, deserializer
+      @serializer = serializer
+      @deserializer = deserializer
+      super storage
+    end
+
     def store_events(aggregate, events)
       events = Utilities.array_wrap(events)
       timestamp = Time.now.utc
@@ -48,16 +56,25 @@ module SandthornDriverSequel
 
     def wrap(arg)
       events = Utilities.array_wrap(arg)
+      events.each { |e| e[:event_args] = deserialize(e[:event_data]) }
       events.map { |e| EventWrapper.new(e.values) }
     end
 
+    def deserialize event_data
+      @deserializer.call(event_data)
+    end
+
+    def serialize event_args
+      @serializer.call(event_args)
+    end
+
     def build_event_data(aggregate, timestamp, event)
       {
-          aggregate_table_id: aggregate.id,
-          aggregate_version: aggregate.aggregate_version,
-          event_name: event.event_name,
-          event_data: event.event_data,
-          timestamp: timestamp
+        aggregate_table_id: aggregate.id,
+        aggregate_version: aggregate.aggregate_version,
+        event_name: event.event_name,
+        event_data: serialize(event.event_args),
+        timestamp: timestamp
       }
     end
 

data/lib/sandthorn_driver_sequel/access/snapshot_access.rb

@@ -1,21 +1,50 @@
+require "sandthorn_driver_sequel/access"
+
 module SandthornDriverSequel
   class SnapshotAccess < Access::Base
 
+    def initialize storage, serializer, deserializer
+      @serializer = serializer
+      @deserializer = deserializer
+      super storage
+    end
+
     def find_by_aggregate_id(aggregate_id)
-      aggregate = aggregates.find_by_aggregate_id(aggregate_id)
-      storage.snapshots.first(aggregate_table_id: aggregate.id)
+      
+      aggregate_from_table = aggregates.find_by_aggregate_id(aggregate_id)
+      return nil if aggregate_from_table.nil?
+      snapshot = storage.snapshots.first(aggregate_table_id: aggregate_from_table.id)
+      if snapshot
+        aggregate = deserialize(snapshot[:snapshot_data])
+        
+        snapshot_data = {
+          aggregate: aggregate,
+          snapshot_id: snapshot.id,
+          aggregate_table_id: snapshot[:aggregate_table_id]
+        }
+        return SnapshotWrapper.new(snapshot_data)
+      end
+      
+      return nil
     end
 
     def find(snapshot_id)
-      storage.snapshots[snapshot_id]
+      
+      snapshot = storage.snapshots[snapshot_id]
+      aggregate = deserialize(snapshot[:snapshot_data])
+
+      snapshot_data = {
+        aggregate: aggregate,
+        snapshot_id: snapshot_id,
+        aggregate_table_id: snapshot[:aggregate_table_id]
+      }
+      
+      SnapshotWrapper.new(snapshot_data)
     end
 
-    def record_snapshot(aggregate_id, snapshot_data)
-      aggregate = aggregates.find_by_aggregate_id!(aggregate_id)
-      previous_snapshot = find_by_aggregate_id(aggregate_id)
-      if perform_snapshot?(aggregate, previous_snapshot)
-        perform_snapshot(aggregate, previous_snapshot, snapshot_data)
-      end
+    def record_snapshot(aggregate)
+      aggregate_from_table = aggregates.find_by_aggregate_id!(aggregate.aggregate_id)
+      perform_snapshot(aggregate, aggregate_from_table.id)
     end
 
     def obsolete(aggregate_types: [], max_event_distance: 100)
@@ -38,49 +67,38 @@ module SandthornDriverSequel
       @aggregates ||= AggregateAccess.new(storage)
     end
 
-    def perform_snapshot?(aggregate, snapshot)
-      return true if snapshot.nil?
-      snapshot = SnapshotWrapper.new(snapshot)
-      aggregate.aggregate_version > snapshot.aggregate_version
-    end
-
-    def perform_snapshot(aggregate, snapshot, snapshot_data)
-      check_snapshot_version!(aggregate, snapshot_data)
-      if valid_snapshot?(snapshot)
-        update_snapshot(snapshot, snapshot_data)
+    def perform_snapshot(aggregate, aggregate_table_id) 
+      current_snapshot = storage.snapshots.first(aggregate_table_id: aggregate_table_id)
+      snapshot = build_snapshot(aggregate)
+      if current_snapshot
+        update_snapshot(snapshot, current_snapshot.id)
       else
-        insert_snapshot(aggregate, snapshot_data)
+        insert_snapshot(snapshot, aggregate_table_id)
       end
     end
 
-    def insert_snapshot(aggregate, snapshot_data)
-      data = build_snapshot(snapshot_data)
-      data[:aggregate_table_id] = aggregate.id
-      storage.snapshots.insert(data)
-    end
-
-    def build_snapshot(snapshot_data)
-      snapshot_data = SnapshotWrapper.new(snapshot_data)
+    def build_snapshot(aggregate)
       {
-          snapshot_data:      snapshot_data.data,
-          aggregate_version:  snapshot_data.aggregate_version
+        snapshot_data:      serialize(aggregate),
+        aggregate_version:  aggregate.aggregate_version
       }
     end
 
-    def valid_snapshot?(snapshot)
-      snapshot && snapshot[:snapshot_data]
+    def insert_snapshot(snapshot, id)
+      snapshot[:aggregate_table_id] = id
+      storage.snapshots.insert(snapshot)
     end
 
-    def update_snapshot(snapshot, snapshot_data)
-      data = build_snapshot(snapshot_data)
-      storage.snapshots.where(id: snapshot.id).update(data)
+    def update_snapshot(snapshot, id)
+      storage.snapshots.where(id: id).update(snapshot)
     end
 
-    def check_snapshot_version!(aggregate, snapshot_data)
-      snapshot = SnapshotWrapper.new(snapshot_data)
-      if aggregate.aggregate_version < snapshot.aggregate_version
-        raise Errors::WrongSnapshotVersionError.new(aggregate, snapshot.aggregate_version)
-      end
+    def serialize aggregate
+      @serializer.call(aggregate)
+    end
+
+    def deserialize snapshot_data
+      @deserializer.call(snapshot_data)
     end
 
   end

data/lib/sandthorn_driver_sequel/access.rb

@@ -14,7 +14,3 @@ module SandthornDriverSequel
     end
   end
 end
-
-require "sandthorn_driver_sequel/access/aggregate_access"
-require "sandthorn_driver_sequel/access/event_access"
-require "sandthorn_driver_sequel/access/snapshot_access"

data/lib/sandthorn_driver_sequel/event_store.rb

@@ -1,13 +1,25 @@
+require "sandthorn_driver_sequel/access/aggregate_access"
+require "sandthorn_driver_sequel/access/event_access"
+require "sandthorn_driver_sequel/access/snapshot_access"
+require "sandthorn_driver_sequel/storage"
+
 module SandthornDriverSequel
   class EventStore
     include EventStoreContext
 
-    attr_reader :driver, :context, :url
+    attr_reader :driver, :context
 
-    def initialize url: nil, context: nil
-      @driver = SequelDriver.new url: url
+    def initialize connection, configuration, context = nil
+      @driver = connection
       @context = context
-      @url = url
+      @event_serializer = configuration.event_serializer
+      @event_deserializer = configuration.event_deserializer
+      @snapshot_serializer = configuration.snapshot_serializer
+      @snapshot_deserializer = configuration.snapshot_deserializer
+    end
+
+    def self.from_url url, configuration, context = nil
+      new(SequelDriver.new(url: url), configuration, context)
     end
 
     def save_events events, aggregate_id, class_name
@@ -26,10 +38,10 @@ module SandthornDriverSequel
       end
     end
 
-    def save_snapshot aggregate_snapshot, aggregate_id
+    def save_snapshot aggregate
       driver.execute_in_transaction do |db|
         snapshot_access = get_snapshot_access(db)
-        snapshot_access.record_snapshot(aggregate_id, aggregate_snapshot)
+        snapshot_access.record_snapshot(aggregate)
       end
     end
 
@@ -53,9 +65,7 @@ module SandthornDriverSequel
 
     def build_snapshot_event(snapshot)
       {
-          aggregate_version: snapshot[:aggregate_version],
-          event_data: snapshot[:snapshot_data],
-          event_name: "aggregate_set_from_snapshot"
+        aggregate: snapshot.data,
       }
     end
 
@@ -87,7 +97,7 @@ module SandthornDriverSequel
       driver.execute do |db|
         snapshots = get_snapshot_access(db)
         snapshot = snapshots.find_by_aggregate_id(aggregate_id)
-        transform_snapshot(snapshot)
+        snapshot.data
       end
     end
 
@@ -119,19 +129,19 @@ module SandthornDriverSequel
     end
 
     def get_aggregate_access(db)
-      AggregateAccess.new(storage(db))
+      @aggregate_access ||= AggregateAccess.new(storage(db))
     end
 
     def get_event_access(db)
-      EventAccess.new(storage(db))
+      @event_access ||= EventAccess.new(storage(db), @event_serializer, @event_deserializer)
     end
 
     def get_snapshot_access(db)
-      SnapshotAccess.new(storage(db))
+      @snapshot_access ||= SnapshotAccess.new(storage(db), @snapshot_serializer, @snapshot_deserializer)
     end
 
     def storage(db)
-      Storage.new(db, context)
+      @storage ||= Storage.new(db, @context)
     end
 
   end

data/lib/sandthorn_driver_sequel/migration.rb

@@ -3,8 +3,9 @@ module SandthornDriverSequel
   class Migration
     include EventStoreContext
     attr_reader :driver, :context
-    def initialize url: nil, context: nil
-      @driver = SequelDriver.new url: url
+    def initialize url: nil, connection: nil, context: nil
+      @driver = SequelDriver.new connection: connection if connection
+      @driver = SequelDriver.new url: url if url
       @context = context
     end
     def migrate!

data/lib/sandthorn_driver_sequel/sequel_driver.rb

@@ -3,10 +3,11 @@ require 'sequel'
 module SandthornDriverSequel
   class SequelDriver
 
-    def initialize args = {}
-      @url = args.fetch(:url)
+    def initialize(args = {})
       Sequel.default_timezone = :utc
-      @db = Sequel.connect(@url)
+      @db = args.fetch(:connection) {
+        Sequel.connect(args.fetch(:url))
+      }
     end
 
     def execute

data/lib/sandthorn_driver_sequel/version.rb

@@ -1,3 +1,3 @@
 module SandthornDriverSequel
-  VERSION = "2.1.1"
+  VERSION = "3.0.0"
 end

data/lib/sandthorn_driver_sequel/wrappers/event_wrapper.rb

@@ -2,7 +2,7 @@ require 'delegate'
 module SandthornDriverSequel
   class EventWrapper < SimpleDelegator
 
-    [:aggregate_version, :event_name, :event_data, :timestamp, :aggregate_table_id].each do |attribute|
+    [:aggregate_version, :event_name, :event_data, :event_args, :timestamp, :aggregate_table_id].each do |attribute|
       define_method(attribute) do
         fetch(attribute)
       end

data/lib/sandthorn_driver_sequel/wrappers/snapshot_wrapper.rb

@@ -1,11 +1,19 @@
 module SandthornDriverSequel
   class SnapshotWrapper < SimpleDelegator
     def aggregate_version
-      self[:aggregate_version]
+      self[:aggregate].aggregate_version
     end
 
     def data
-      self[:event_data]
+      self[:aggregate]
+    end
+
+    def snapshot_id
+      self[:snapshot_id]
+    end
+
+    def aggregate_table_id
+      self[:aggregate_table_id]
     end
   end
 end

data/lib/sandthorn_driver_sequel.rb

@@ -3,20 +3,104 @@ require "sandthorn_driver_sequel/utilities"
 require "sandthorn_driver_sequel/wrappers"
 require "sandthorn_driver_sequel/event_query"
 require "sandthorn_driver_sequel/event_store_context"
-require "sandthorn_driver_sequel/access"
-require "sandthorn_driver_sequel/storage"
 require 'sandthorn_driver_sequel/event_store'
 require 'sandthorn_driver_sequel/errors'
 require 'sandthorn_driver_sequel/migration'
+require 'yaml'
 
 module SandthornDriverSequel
   class << self
-    def driver_from_url url: nil, context: nil
-      EventStore.new url: url, context: context
-    end
+    
     def migrate_db url: nil, context: nil
       migrator = Migration.new url: url, context: context
       migrator.migrate!
     end
+
+    def driver_from_url url: nil, context: nil
+
+      if block_given?
+        configuration = Configuration.new
+        yield(configuration)
+      else
+        configuration = self.configuration
+      end
+
+      EventStore.from_url(url, configuration, context)
+    end
+
+    def driver_from_connection connection: nil, context: nil
+      if block_given?
+        configuration = Configuration.new
+        yield(configuration)
+      else
+        configuration = self.configuration
+      end
+      EventStore.new(SequelDriver.new(connection: connection), configuration, context)
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    private
+
+    class Configuration
+
+      #event
+      def event_serializer=(block)
+        @event_serializer = block
+      end
+
+      def event_deserializer=(block)
+        @event_deserializer = block
+      end
+
+      def event_serializer
+        @event_serializer || default_event_serializer
+      end
+
+      def event_deserializer
+        @event_deserializer || default_event_deserializer
+      end
+
+      def default_event_serializer
+        -> (data) { YAML.dump(data) }
+      end
+
+      def default_event_deserializer
+        -> (data) { YAML.load(data) }
+      end
+
+      #snapshot
+      def snapshot_serializer=(block)
+        @snapshot_serializer = block
+      end
+
+      def snapshot_deserializer=(block)
+        @snapshot_deserializer = block
+      end
+
+      def snapshot_serializer
+        @snapshot_serializer || default_snapshot_serializer
+      end
+
+      def snapshot_deserializer
+        @snapshot_deserializer || default_snapshot_deserializer
+      end
+
+      def default_snapshot_serializer
+        -> (data) { YAML.dump(data) }
+      end
+
+      def default_snapshot_deserializer
+        -> (data) { YAML.load(data) }
+      end
+
+      
+    end
   end
 end