sandthorn_driver_sequel 3.2.1 → 4.0.0

data/spec/event_access_spec.rb

@@ -17,10 +17,7 @@ module SandthornDriverSequel
     let(:storage) { Storage.new(db, :test) }
     let(:event_serializer) { -> (data) { YAML.dump(data) } }
     let(:event_deserializer) { -> (data) { YAML.load(data) } }
-    let(:snapshot_serializer) { -> (data) { YAML.dump(data) } }
-    let(:snapshot_deserializer) { -> (data) { YAML.load(data) } }
     let(:aggregate_access) { AggregateAccess.new(storage) }
-    let(:snapshot_access) { SnapshotAccess.new(storage, snapshot_serializer, snapshot_deserializer)}
     let(:access) { EventAccess.new(storage, event_serializer, event_deserializer) }
 
 
@@ -29,11 +26,13 @@ module SandthornDriverSequel
         {
           aggregate_version: 1,
           event_name: "new",
-          event_args: "new_data"
+          event_data: "new_data",
+          event_metadata: nil
         },{
           aggregate_version: 2,
           event_name: "foo",
-          event_args: "foo_data"
+          event_data: "foo_data",
+          event_metadata: nil
         }
       ]
     end
@@ -88,22 +87,5 @@ module SandthornDriverSequel
       end
     end
 
-    describe "#after_snapshot" do
-      it "returns events after the given snapshot" do
-        access.store_events(aggregate, events.first)
-
-        aggregate_struct = Struct::AggregateMock.new aggregate_id, events.first[:aggregate_version]
-
-        snapshot_id = snapshot_access.record_snapshot(aggregate_struct)
-        snapshot = snapshot_access.find(snapshot_id)
-
-        access.store_events(aggregate, events.last)
-        
-        events = access.after_snapshot(snapshot)
-        expect(events.count).to eq(1)
-        expect(events.first[:event_args]).to eq("foo_data")
-      end
-    end
-
   end
 end

data/spec/event_store_spec.rb

@@ -1,76 +1,46 @@
-require 'spec_helper'
-module SandthornDriverSequel
-  describe EventStore do
+# require 'spec_helper'
+# module SandthornDriverSequel
+#   describe EventStore do
     
-    before(:each) { prepare_for_test context: nil; }
-    let(:event_store) { SandthornDriverSequel.driver_from_url url: event_store_url }  
+#     before(:each) { prepare_for_test context: nil; }
+#     let(:event_store) { SandthornDriverSequel.driver_from_url url: event_store_url }  
     
-    describe("when getting the same data from find and get_aggregate_events_from_snapshot") do
-      let(:test_events) do
-        e = [] 
-        e << {aggregate_version: 1, event_name: "new",  event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>aggregate_id}]}}
-        e << {aggregate_version: 2, event_name: "foo",  event_args: "noop"}
-        e << {aggregate_version: 3, event_name: "flubber",  event_args: "noop"}
-      end
-      let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
+#     describe("when getting the same data from find and aggregate_events") do
+#       let(:test_events) do
+#         e = [] 
+#         e << {aggregate_version: 1, event_name: "new",  event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>aggregate_id}]}, event_meta_data: nil}
+#         e << {aggregate_version: 2, event_name: "foo",  event_data: "noop", event_meta_data: nil}
+#         e << {aggregate_version: 3, event_name: "flubber",  event_data: "noop", event_meta_data: nil}
+#       end
+#       let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
       
-      
-
-      before do
-        event_store.save_events test_events, aggregate_id, String
-      end
-
-      context "find" do
-
-        let(:find_events) do
-          event_store.find aggregate_id
-        end
-
-        let(:get_aggregate_events_from_snapshot_events) do
-          event_store.get_aggregate_events_from_snapshot aggregate_id
-        end
-
-        it "should get same events" do
-          find_events.each_with_index do |event, index|
-            expect(find_events[index]).to eql get_aggregate_events_from_snapshot_events[index]
-          end
-        end
-      end
-
-      context "all" do
-
-        let(:test_events_2) do
-          e = [] 
-          e << {aggregate_version: 1, event_name: "new",  event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>aggregate_id_2}]}}
-          e << {aggregate_version: 2, event_name: "foo",  event_args: "noop"}
-          e << {aggregate_version: 3, event_name: "flubber",  event_args: "noop"}
-        end
-        let(:aggregate_id_2) {"d0456e26-e29a-4f67-92fa-130b3a31a39b"}
-
-        before do
-          event_store.save_events test_events_2, aggregate_id_2, String
-        end
-
-        let(:all_events) do
-          event_store.all String
-        end
-
-        let(:obsolete_all) do
-          return event_store.get_aggregate_ids(aggregate_type: String).map do |id|
-            event_store.get_aggregate_events_from_snapshot(id)
-          end
-        end
-
-        it "should get two arrays of events" do
-          expect(all_events.length).to eql 2
-        end
-
-        it "should get same events" do
-          all_events.each_with_index do |events, index|
-            expect(events).to eql obsolete_all[index]
-          end
-        end
-      end
-    end
-  end
-end
+#       before do
+#         event_store.save_events test_events, aggregate_id, String
+#       end
+
+#       context "all" do
+
+#         let(:test_events_2) do
+#           e = [] 
+#           e << {aggregate_version: 1, event_name: "new",  event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>aggregate_id_2}]}, event_meta_data: nil}
+#           e << {aggregate_version: 2, event_name: "foo",  event_data: "noop", event_meta_data: nil}
+#           e << {aggregate_version: 3, event_name: "flubber",  event_data: "noop", event_meta_data: nil}
+#         end
+#         let(:aggregate_id_2) {"d0456e26-e29a-4f67-92fa-130b3a31a39b"}
+
+#         before do
+#           event_store.save_events test_events_2, aggregate_id_2, String
+#         end
+
+#         let(:all_events) do
+#           event_store.all String
+#         end
+
+#         it "should get two arrays of events" do
+#           expect(all_events.length).to eql 2
+#         end
+
+#       end
+#     end
+#   end
+# end

data/spec/event_store_with_context_spec.rb

@@ -8,16 +8,16 @@ module SandthornDriverSequel
     context("when saving in one context and retrieving in another") do
       let(:test_events) do
         e = [] 
-        e << {aggregate_version: 1, event_name: "new",  event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
-        e << {aggregate_version: 2, event_name: "foo",  event_args: "noop"}
-        e << {aggregate_version: 3, event_name: "flubber",  event_args: "noop"}
+        e << {aggregate_version: 1, event_name: "new",  event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: nil}
+        e << {aggregate_version: 2, event_name: "foo",  event_data: "noop", event_metadata: nil}
+        e << {aggregate_version: 3, event_name: "flubber",  event_data: "noop", event_metadata: nil}
       end
       let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
       it "should not find them" do
         event_store_without_context.save_events test_events, aggregate_id, String
-        events = event_store_without_context.get_aggregate_events aggregate_id
+        events = event_store_without_context.find aggregate_id, String
         expect(events.length).to eql test_events.length
-        events_2 = event_store_with_context.get_aggregate_events aggregate_id
+        events_2 = event_store_with_context.find aggregate_id, String
         expect(events_2.length).to eql 0
       end
     end

data/spec/get_events_spec.rb

@@ -5,25 +5,25 @@ module SandthornDriverSequel
     before(:each) { prepare_for_test }
     let(:test_events_a) do
       e = []
-      e << {aggregate_version: 1, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
-      e << {aggregate_version: 2, event_name: "foo", event_args: "A2"}
-      e << {aggregate_version: 3, event_name: "bard", event_args: "A3"}
+      e << {aggregate_version: 1, event_name: "new", event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: {a: 1}}
+      e << {aggregate_version: 2, event_name: "foo", event_data: "A2", event_metadata: {a: 1}}
+      e << {aggregate_version: 3, event_name: "bard", event_data: "A3", event_metadata: {a: 1}}
     end
     let(:aggregate_id_a) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
     let(:test_events_b) do
       e = []
-      e << {aggregate_version: 1, event_name: "new", event_args: "B1" }
-      e << {aggregate_version: 2, event_name: "foo", event_args: "B2"}
-      e << {aggregate_version: 3, event_name: "bar", event_args: "B3"}
+      e << {aggregate_version: 1, event_name: "new", event_data: "B1", event_metadata: 1}
+      e << {aggregate_version: 2, event_name: "foo", event_data: "B2", event_metadata: 2}
+      e << {aggregate_version: 3, event_name: "bar", event_data: "B3", event_metadata: 3}
     end
     let(:aggregate_id_b) {"c0456e26-1234-4f67-92fa-130b3a31a39a"}
     let(:test_events_c) do
       e = []
-      e << {aggregate_version: 1, event_name: "new", event_args: "C1" }
+      e << {aggregate_version: 1, event_name: "new", event_data: "C1", event_metadata: 4}
     end
     let(:test_events_c_2) do
       e = []
-      e << {aggregate_version: 2, event_name: "flubber", event_args: "C2" }
+      e << {aggregate_version: 2, event_name: "flubber", event_data: "C2", event_metadata: 6}
     end
     let(:aggregate_id_c) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
     before(:each) do
@@ -82,47 +82,12 @@ module SandthornDriverSequel
         it "should contain only events for aggregate_id_a" do
           events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
         end
-      end
-    end
-    context "when using :get_new_events_after_event_id_matching_classname to get events" do
-      context "and getting events for SandthornDriverSequel::EventStore after 0" do
-        let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore}
-        it "should find 3 events" do
-          expect(events.length).to eql 3
-        end
-        it "should be in sequence_number order" do
-          check = 0
-          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-        end
-        it "should contain only events for aggregate_id_a" do
-          events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
-        end
-        it "should be able to get events after a sequence number" do
-          new_from = events[1][:sequence_number]
-          ev = event_store.get_new_events_after_event_id_matching_classname new_from, SandthornDriverSequel::EventStore
-          expect(ev.last[:aggregate_version]).to eql 3
-          expect(ev.length).to eql 1
-        end
-        it "should be able to limit the number of results" do
-          ev = event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore, take: 2
-          expect(ev.length).to eql 2
-          expect(ev.last[:aggregate_version]).to eql 2
-        end
-      end
-      context "and getting events for String after 0" do
-        let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, "String"}
-        it "should find 3 events" do
-          expect(events.length).to eql 2
-        end
-        it "should be in sequence_number order" do
-          check = 0
-          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-        end
-        it "should contain only events for aggregate_id_c" do
-          events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_c  }
+
+        it "shoul have correct event_metadata" do
+          events.each { |e| expect(e[:event_metadata]).to eql ({a: 1})  }
         end
       end
     end
-
+  
   end
 end

data/spec/migration_specifying_domain_spec.rb

@@ -5,29 +5,29 @@ module SandthornDriverSequel
     def check_tables context = nil
       events = :events
       aggregates = :aggregates
-      snapshots = :snapshots
+      
       if context
         events = "#{context}_#{events}".to_sym
         aggregates = "#{context}_#{aggregates}".to_sym
-        snapshots = "#{context}_#{snapshots}".to_sym
+      
       end
       migration.driver.execute do |db|
         expect(db.table_exists? events).to be_truthy, "expected table :#{events} to exist, but it didn't"
         expect(db.table_exists? aggregates).to be_truthy, "expected table :#{aggregates} to exist, but it didn't"
-        expect(db.table_exists? snapshots).to be_truthy, "expected table :#{snapshots} to exist, but it didn't"
+      
       end
     end
     let(:migration) { Migration.new url: event_store_url, context: context  }
     before(:each) { migration.migrate! }
     context "when default (nil) eventstore contex" do
       let(:context) { nil }
-      it "should create the tables events, aggregates and snapshots" do
+      it "should create the tables events and aggregates" do
         check_tables
       end
     end
     context "when specifying context" do
       let(:context) { :another_domain }
-      it "should create the tables events, aggregates and snapshots" do
+      it "should create the tables events and aggregates" do
         check_tables context
       end
     end
@@ -35,7 +35,7 @@ module SandthornDriverSequel
     context "when migrating a connection" do
       let(:migration) { Migration.new connection: Sequel.sqlite, context: context }
       let(:context) { :some_domain }
-      it "should create the tables events, aggregates and snapshots" do
+      it "should create the tables events and aggregates" do
         check_tables context
       end
     end

data/spec/saving_events_spec.rb

@@ -6,24 +6,25 @@ module SandthornDriverSequel
     context "when saving a prefectly sane event stream" do
       let(:test_events) do
         e = []
-        e << {aggregate_version: 1, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
-        e << {aggregate_version: 2, event_name: "foo", event_args: "noop"}
-        e << {aggregate_version: 3, event_name: "flubber", event_args: "noop"}
+        e << {aggregate_version: 1, event_name: "new", event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: [1,2,3]}
+        e << {aggregate_version: 2, event_name: "foo", event_data: "noop", event_metadata: nil}
+        e << {aggregate_version: 3, event_name: "flubber", event_data: "noop", event_metadata: nil}
       end
 
       let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
 
       it "should be able to save and retrieve events on the aggregate" do
         event_store.save_events test_events, aggregate_id, String
-        events = event_store.get_aggregate_events aggregate_id
+        events = event_store.find aggregate_id, String
         expect(events.length).to eql test_events.length
       end
 
       it "should have correct keys when asking for events" do
         event_store.save_events test_events, aggregate_id, String
-        events = event_store.get_aggregate aggregate_id, String
+        events = event_store.find aggregate_id, String
         event = events.first
-        expect(event[:event_args]).to eql(test_events.first[:event_args])
+        expect(event[:event_data]).to eql(test_events.first[:event_data])
+        expect(event[:event_metadata]).to eql(test_events.first[:event_metadata])
         expect(event[:event_name]).to eql("new")
         expect(event[:aggregate_id]).to eql aggregate_id
         expect(event[:aggregate_version]).to eql 1
@@ -35,13 +36,13 @@ module SandthornDriverSequel
     context "when saving two aggregate types" do
       let(:test_events_1) do
         e = []
-        e << {aggregate_version: 1, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
-        e << {aggregate_version: 2, event_name: "foo", event_args: "noop"}
-        e << {aggregate_version: 3, event_name: "flubber", event_args: "noop"}
+        e << {aggregate_version: 1, event_name: "new", event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: nil}
+        e << {aggregate_version: 2, event_name: "foo", event_data: "noop", event_metadata: nil}
+        e << {aggregate_version: 3, event_name: "flubber", event_data: "noop", event_metadata: nil}
       end
       let(:test_events_2) do
         e = []
-        e << {aggregate_version: 1, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: 1, event_name: "new", event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: nil}
       end
       let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
       let(:aggregate_id_2) {"c0456e26-e92b-4f67-92fa-130b3a31b93b"}
@@ -53,43 +54,36 @@ module SandthornDriverSequel
         event_store.save_events test_events_2, aggregate_id_3, String
       end
 
-      it "both types should exist in get_all_typenames in alphabetical order" do
-        names = event_store.get_all_types
-        expect(names.length).to eql 2
-        expect(names.first).to eql "Hash"
-        expect(names.last).to eql "String"
-      end
-
-      it "should list the aggregate ids when asking for get_aggregate_list_by_typename" do
-        ids = event_store.get_aggregate_ids(aggregate_type: String)
-        expect(ids.length).to eql 2
-        expect(ids.any? { |e| e == aggregate_id_1 }).to be_truthy
-        expect(ids.any? { |e| e == aggregate_id_3 }).to be_truthy
+      it "should get the correct aggregate_id in events when asking for all" do
+        aggregate_events = event_store.all(String)
+        expect(aggregate_events.length).to eql 2
+        expect(aggregate_events.first.any? { |e| e[:aggregate_id] == aggregate_id_1 }).to be_truthy
+        expect(aggregate_events.last.any? { |e| e[:aggregate_id] == aggregate_id_3 }).to be_truthy
       end
     end
 
     context "when saving events that have no aggregate_version" do
       let(:test_events) do
         e = []
-        e << {aggregate_version: nil, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
-        e << {aggregate_version: nil, event_name: "foo", event_args: "noop"}
-        e << {aggregate_version: nil, event_name: "flubber", event_args: "noop"}
+        e << {aggregate_version: nil, event_name: "new", event_data: {:attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}, event_metadata: nil}
+        e << {aggregate_version: nil, event_name: "foo", event_data: "noop", event_metadata: nil}
+        e << {aggregate_version: nil, event_name: "flubber", event_data: "noop", event_metadata: nil}
       end
 
       let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
 
       it "should be able to save and retrieve events on the aggregate" do
         event_store.save_events test_events, aggregate_id, String
-        events = event_store.get_aggregate_events aggregate_id
+        events = event_store.find aggregate_id, String
         expect(events.length).to eql test_events.length
       end
 
       it "should have correct keys when asking for events" do
         event_store.save_events test_events, aggregate_id, String
-        events = event_store.get_aggregate aggregate_id, String
+        events = event_store.find aggregate_id, String
         event = events.first
 
-        expect(event[:event_args]).to eql(test_events.first[:event_args])
+        expect(event[:event_data]).to eql(test_events.first[:event_data])
         expect(event[:event_name]).to eql("new")
         expect(event[:aggregate_id]).to eql aggregate_id
         expect(event[:aggregate_version]).to eql 1

data/spec/storage_spec.rb

@@ -56,6 +56,7 @@ module SandthornDriverSequel
           aggregate_version: 1,
           event_name: "foo",
           event_data: "bar",
+          event_metadata: nil,
           timestamp: Time.now.utc
       }
       event_id = storage.events.insert(data)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sandthorn_driver_sequel
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Lars Krantz
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-04 00:00:00.000000000 Z
+date: 2017-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -167,33 +167,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: sequel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.17'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.17'
 description: Sequel driver for Sandthorn
 email:
 - lars.krantz@alaz.se
@@ -218,7 +204,6 @@ files:
 - lib/sandthorn_driver_sequel/access.rb
 - lib/sandthorn_driver_sequel/access/aggregate_access.rb
 - lib/sandthorn_driver_sequel/access/event_access.rb
-- lib/sandthorn_driver_sequel/access/snapshot_access.rb
 - lib/sandthorn_driver_sequel/errors.rb
 - lib/sandthorn_driver_sequel/event_query.rb
 - lib/sandthorn_driver_sequel/event_store.rb
@@ -231,10 +216,8 @@ files:
 - lib/sandthorn_driver_sequel/version.rb
 - lib/sandthorn_driver_sequel/wrappers.rb
 - lib/sandthorn_driver_sequel/wrappers/event_wrapper.rb
-- lib/sandthorn_driver_sequel/wrappers/snapshot_wrapper.rb
 - sandthorn_driver_sequel.gemspec
 - spec/aggregate_access_spec.rb
-- spec/asking_for_aggregates_to_snapshot_spec.rb
 - spec/benchmark_spec.rb
 - spec/configuration_spec.rb
 - spec/db/.keep
@@ -245,8 +228,6 @@ files:
 - spec/get_events_spec.rb
 - spec/migration_specifying_domain_spec.rb
 - spec/saving_events_spec.rb
-- spec/saving_snapshot_spec.rb
-- spec/snapshot_access_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb
 homepage: ''
@@ -275,7 +256,6 @@ specification_version: 4
 summary: Sequel driver for Sandthorn
 test_files:
 - spec/aggregate_access_spec.rb
-- spec/asking_for_aggregates_to_snapshot_spec.rb
 - spec/benchmark_spec.rb
 - spec/configuration_spec.rb
 - spec/db/.keep
@@ -286,8 +266,5 @@ test_files:
 - spec/get_events_spec.rb
 - spec/migration_specifying_domain_spec.rb
 - spec/saving_events_spec.rb
-- spec/saving_snapshot_spec.rb
-- spec/snapshot_access_spec.rb
 - spec/spec_helper.rb
 - spec/storage_spec.rb
-has_rdoc: 

data/lib/sandthorn_driver_sequel/access/snapshot_access.rb

@@ -1,105 +0,0 @@
-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_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)
-      
-      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)
-      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)
-      aggregate_types.map!(&:to_s)
-      snapshot_version = Sequel.qualify(storage.snapshots_table_name, :aggregate_version)
-      aggregate_version = Sequel.qualify(storage.aggregates_table_name, :aggregate_version)
-      query = storage.aggregates.left_outer_join(storage.snapshots, aggregate_table_id: :id)
-      query = query.select { (aggregate_version - snapshot_version).as(distance) }
-      query = query.select_append(:aggregate_id, :aggregate_type)
-      query = query.where { (aggregate_version - coalesce(snapshot_version, 0)) > max_event_distance }
-      if aggregate_types.any?
-        query = query.where(aggregate_type: aggregate_types)
-      end
-      query.all
-    end
-
-    private
-
-    def aggregates
-      @aggregates ||= AggregateAccess.new(storage)
-    end
-
-    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(snapshot, aggregate_table_id)
-      end
-    end
-
-    def build_snapshot(aggregate)
-      {
-        snapshot_data:      serialize(aggregate),
-        aggregate_version:  aggregate.aggregate_version
-      }
-    end
-
-    def insert_snapshot(snapshot, id)
-      snapshot[:aggregate_table_id] = id
-      storage.snapshots.insert(snapshot)
-    end
-
-    def update_snapshot(snapshot, id)
-      storage.snapshots.where(id: id).update(snapshot)
-    end
-
-    def serialize aggregate
-      @serializer.call(aggregate)
-    end
-
-    def deserialize snapshot_data
-      @deserializer.call(snapshot_data)
-    end
-
-  end
-end