sandthorn_driver_sequel 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee9068238f286a01fb246ec4f23d62c335033aab
-  data.tar.gz: b467b5e449080ab8476492fce07ebb96df1a9a2e
+  metadata.gz: 6df7059570ed2a75376a49b5568cde3dcda5abef
+  data.tar.gz: d0df6fa0c71d2388f31897fcb4c1918ecbe6bdd2
 SHA512:
-  metadata.gz: 7eaf9662b2ad127ab2a55195e5cc2b846158cce9039bfa5f52c7cddedde310867edeb9bc907e3fa0cdd4f05b37258c19190e4b75c6d82788c12591ad7054b5bc
-  data.tar.gz: a9837bfcee62c4324c54a849aecaf605ad9e20272b3a018369529b6959ecc14f9d23459798ff94e7197db517112b12964797ac494a01a0a9aa742865583fbca9
+  metadata.gz: cff7f24db48fe2ec230c54526f3231fff0c2f7cd94ed12b585807cfa06084cba5a7c4d7d63b670816844ba8b5f6a3114a6d755bb0b16b6cb2e3336ea9c68236c
+  data.tar.gz: 2592b3457a5c030517d968302aa4c716af3cd58fa3080c1378960a066a40fbf28000e963ab22d75c0fbf600acd3b4f75799ceea63d3a01f1c7d90d59927b5ea4

data/.gitignore

@@ -15,4 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-*.sqlite3
+*.sqlite3
+.idea

data/Guardfile

@@ -0,0 +1,7 @@
+interactor :simple
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/sandthorn_driver_sequel/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/lib/sandthorn_driver_sequel/access/aggregate_access.rb

@@ -0,0 +1,50 @@
+module SandthornDriverSequel
+  class AggregateAccess < Access::Base
+
+    def find_or_register(aggregate_id, aggregate_type)
+      if aggregate = find_by_aggregate_id(aggregate_id)
+        aggregate
+      else
+        register_aggregate(aggregate_id, aggregate_type)
+      end
+    end
+
+    # Create a database row for an aggregate.
+    # Return the row.
+    def register_aggregate(aggregate_id, aggregate_type)
+      id = storage.aggregates.insert(aggregate_id: aggregate_id, aggregate_type: aggregate_type.to_s)
+      find(id)
+    end
+
+    # Find by database table id.
+    def find(id)
+      storage.aggregates[id]
+    end
+
+    def find_by_aggregate_id(aggregate_id)
+      storage.aggregates.first(aggregate_id: aggregate_id)
+    end
+
+    # Throws an error if the aggregate isn't registered.
+    def find_by_aggregate_id!(aggregate_id)
+      aggregate = find_by_aggregate_id(aggregate_id)
+      raise Errors::NoAggregateError, aggregate_id unless aggregate
+      aggregate
+    end
+
+    def aggregate_types
+      storage.aggregates.select(:aggregate_type).distinct.select_map(:aggregate_type)
+    end
+
+    # Returns aggregate ids.
+    # @param aggregate_type, optional,
+    def aggregate_ids(aggregate_type: nil)
+      aggs = storage.aggregates
+      if aggregate_type
+        aggs = aggs.where(aggregate_type: aggregate_type.to_s)
+      end
+      aggs.order(:id).select_map(:aggregate_id)
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel/access/event_access.rb

@@ -0,0 +1,81 @@
+module SandthornDriverSequel
+  class EventAccess < Access::Base
+    # = EventAccess
+    # Reads and writes events.
+
+    def store_events(aggregate, events)
+      events = Utilities.array_wrap(events)
+      timestamp = Time.now.utc
+      events.each do |event|
+        store_event(aggregate, timestamp, event)
+      end
+      aggregate.save
+    end
+
+    def find_events_by_aggregate_id(aggregate_id)
+      aggregate_version = Sequel.qualify(storage.events_table_name, :aggregate_version)
+      wrap(storage.events
+        .join(storage.aggregates, id: :aggregate_table_id)
+        .where(aggregate_id: aggregate_id)
+        .select(
+          :sequence_number,
+          :aggregate_id,
+          :aggregate_table_id,
+          aggregate_version,
+          :event_name,
+          :event_data,
+          :timestamp)
+        .all)
+    end
+
+    # Returns events that occurred after the given snapshot
+    def after_snapshot(snapshot)
+      _aggregate_version = snapshot.aggregate_version
+      aggregate_table_id = snapshot.aggregate_table_id
+      wrap(storage.events
+        .where(aggregate_table_id: aggregate_table_id)
+        .where { aggregate_version > _aggregate_version }.all)
+    end
+
+    def get_events(*args)
+      query_builder = EventQuery.new(storage)
+      query_builder.build(*args)
+      wrap(query_builder.events)
+    end
+
+    private
+
+    def wrap(arg)
+      events = Utilities.array_wrap(arg)
+      events.map { |e| EventWrapper.new(e.values) }
+    end
+
+    def build_event_data(aggregate, timestamp, event)
+      {
+          aggregate_table_id: aggregate.id,
+          aggregate_version: event.aggregate_version,
+          event_name: event.event_name,
+          event_data: event.event_data,
+          timestamp: timestamp
+      }
+    end
+
+    def check_versions!(aggregate, event)
+      version = aggregate.aggregate_version
+      if version != event[:aggregate_version]
+        raise Errors::ConcurrencyError.new(event, aggregate)
+      end
+    rescue TypeError
+      raise Errors::EventFormatError, "Event has wrong format: #{event.inspect}"
+    end
+
+    def store_event(aggregate, timestamp, event)
+      event = EventWrapper.new(event)
+      aggregate.aggregate_version += 1
+      check_versions!(aggregate, event)
+      data = build_event_data(aggregate, timestamp, event)
+      storage.events.insert(data)
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel/access/snapshot_access.rb

@@ -0,0 +1,87 @@
+module SandthornDriverSequel
+  class SnapshotAccess < Access::Base
+
+    def find_by_aggregate_id(aggregate_id)
+      aggregate = aggregates.find_by_aggregate_id(aggregate_id)
+      storage.snapshots.first(aggregate_table_id: aggregate.id)
+    end
+
+    def find(snapshot_id)
+      storage.snapshots[snapshot_id]
+    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
+    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, 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)
+      else
+        insert_snapshot(aggregate, snapshot_data)
+      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)
+      {
+          snapshot_data:      snapshot_data.data,
+          aggregate_version:  snapshot_data.aggregate_version
+      }
+    end
+
+    def valid_snapshot?(snapshot)
+      snapshot && snapshot[:snapshot_data]
+    end
+
+    def update_snapshot(snapshot, snapshot_data)
+      data = build_snapshot(snapshot_data)
+      storage.snapshots.where(id: snapshot.id).update(data)
+    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
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel/access.rb

@@ -0,0 +1,20 @@
+module SandthornDriverSequel
+  module Access
+    class Base
+      # = Access::Base
+      # Inheriting classes use +storage+ to provide access to a
+      # particular database model/table.
+      def initialize(storage)
+        @storage = storage
+      end
+
+      private
+
+      attr_reader :storage
+    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/errors.rb

@@ -1,7 +1,49 @@
 module SandthornDriverSequel::Errors
-    class Error < StandardError; end
-    class ConcurrencyError < Error; end
-    class InternalError < Error; end
-    class NoAggregateError < Error; end
-    class WrongAggregateVersionError < Error; end
+  Error = Class.new(StandardError)
+  InternalError = Class.new(Error)
+  NoAggregateError = Class.new(Error)
+  EventFormatError = Class.new(Error)
+
+  class ConcurrencyError < Error
+    attr_reader :event, :aggregate
+    def initialize(event, aggregate)
+      @event = event
+      @aggregate = aggregate
+      super(create_message)
+    end
+
+    def create_message
+      "#{aggregate.aggregate_type} with id #{aggregate.aggregate_id}: " +
+      "expected event with version #{aggregate.aggregate_version}, but got #{event.aggregate_version}"
+    end
+  end
+
+  class WrongAggregateVersionError < Error;
+    def initialize(aggregate, version)
+      @aggregate = aggregate
+      @version = version
+      super(create_message)
+    end
+
+    def create_message
+      "#{@aggregate[:aggregate_type]} with id #{@aggregate[:aggregate_id]}" +
+      " should be at version #{@version}" +
+      " but was #{@aggregate[:aggregate_version]} in the event store."
+    end
+  end
+
+  class WrongSnapshotVersionError < Error
+    attr_reader :aggregate, :version
+    def initialize(aggregate, version)
+      @aggregate = aggregate
+      @version = version
+      super(create_message)
+    end
+
+    def create_message
+      "#{aggregate[:aggregate_type]} with id #{aggregate[:aggregate_id]}: tried to save snapshot with version "+
+      "#{version}, but current version is at #{aggregate[:aggregate_version]}"
+    end
+  end
+
 end    

data/lib/sandthorn_driver_sequel/event_query.rb

@@ -0,0 +1,90 @@
+module SandthornDriverSequel
+  class EventQuery
+    def initialize(storage)
+      @storage = storage
+    end
+
+    def build(
+      aggregate_types: [],
+      take: 0,
+      after_sequence_number: 0,
+      include_events: [],
+      exclude_events: [])
+
+      aggregate_types.map!(&:to_s)
+      include_events.map!(&:to_s)
+      exclude_events.map!(&:to_s)
+
+      query = storage.events
+      query = add_aggregate_types(query, aggregate_types)
+      query = add_sequence_number(query, after_sequence_number)
+      query = add_included_events(query, include_events)
+      query = add_excluded_events(query, exclude_events)
+      query = add_select(query)
+      query = add_limit(query, take)
+      @query = query.order(:sequence_number)
+    end
+
+    def events
+      @query.all
+    end
+
+    private
+
+    attr_reader :storage
+
+    def add_limit(query, take)
+      if take > 0
+        query.limit(take)
+      else
+        query
+      end
+    end
+
+    def add_select(query)
+      query.select(*select_columns)
+    end
+
+    def select_columns
+      rel = Sequel.qualify(storage.events_table_name, :aggregate_version)
+      [
+        :aggregate_type,
+        rel,
+        :aggregate_id,
+        :sequence_number,
+        :event_name,
+        :event_data,
+        :timestamp
+      ]
+    end
+
+    def add_excluded_events(query, exclude_events)
+      if exclude_events.any?
+        query.exclude(event_name: exclude_events)
+      else
+        query
+      end
+    end
+
+    def add_included_events(query, include_events)
+      if include_events.any?
+        query.where(event_name: include_events)
+      else
+        query
+      end
+    end
+
+    def add_sequence_number(query, after_sequence_number)
+      query.where { sequence_number > after_sequence_number }
+    end
+
+    def add_aggregate_types(query, aggregate_types)
+      if aggregate_types.any?
+        query.join(storage.aggregates, id: :aggregate_table_id, aggregate_type: aggregate_types)
+      else
+        query.join(storage.aggregates, id: :aggregate_table_id)
+      end
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel/event_store.rb

@@ -1,201 +1,138 @@
-require 'sandthorn_driver_sequel/sequel_driver'
-
 module SandthornDriverSequel
   class EventStore
     include EventStoreContext
+
     attr_reader :driver, :context, :url
+
     def initialize url: nil, context: nil
       @driver = SequelDriver.new url: url
       @context = context
       @url = url
     end
 
-    def save_events aggregate_events, originating_aggregate_version, aggregate_id, *class_name
-      current_aggregate_version = originating_aggregate_version
-      aggregate_type = class_name.first.to_s
+    def save_events events, aggregate_id, class_name
       driver.execute_in_transaction do |db|
-        if current_aggregate_version == 0
-          to_insert = {aggregate_id: aggregate_id, aggregate_type: aggregate_type, aggregate_version: 0}
-          pk_id = db[aggregates_table_name].insert(to_insert)
-        else
-          current_aggregate = get_current_aggregate_from_aggregates_table aggregate_id, aggregate_type, db
-          pk_id = current_aggregate[:id]
-          if current_aggregate[:aggregate_version] != current_aggregate_version
-            error_message = "#{aggregate_type} with id #{aggregate_id} should be att version #{current_aggregate_version} but was #{current_aggregate[:aggregate_version]} in the event store."
-            raise SandthornDriverSequel::Errors::WrongAggregateVersionError.new(error_message)
-          end
-        end
-        timestamp = Time.now.utc
-        aggregate_events.each do |event|
-          current_aggregate_version += 1
-          if current_aggregate_version != event[:aggregate_version]
-            error_message = "#{aggregate_type} with id #{aggregate_id}: expected event with version #{current_aggregate_version}, but got #{event[:aggregate_version]}"
-            raise SandthornDriverSequel::Errors::ConcurrencyError.new(error_message)
-          end
-          to_insert = ({aggregate_table_id: pk_id, aggregate_version: event[:aggregate_version], event_name: event[:event_name], event_data: event[:event_data], timestamp: timestamp})
-          db[events_table_name].insert(to_insert)
-        end
-        db[aggregates_table_name].where(id: pk_id).update(aggregate_version: current_aggregate_version)
+        aggregates = get_aggregate_access(db)
+        event_access = get_event_access(db)
+        aggregate = aggregates.find_or_register(aggregate_id, class_name)
+        event_access.store_events(aggregate, events)
+      end
+    end
+
+    def get_aggregate_events(aggregate_id)
+      driver.execute do |db|
+        events = get_event_access(db)
+        events.find_events_by_aggregate_id(aggregate_id)
       end
     end
 
-    def save_snapshot aggregate_snapshot, aggregate_id, class_name
-      #ar_snapshot.event_name = snapshot[:event_name]
-      #ar_snapshot.event_data = snapshot[:event_data]
-      #ar_snapshot.aggregate_version = snapshot[:aggregate_version]
-      #ar_snapshot.aggregate_id = aggregate_id
+    def save_snapshot aggregate_snapshot, aggregate_id
       driver.execute_in_transaction do |db|
-        current_aggregate = get_current_aggregate_from_aggregates_table aggregate_id, class_name, db
-        pk_id = current_aggregate[:id]
-        current_snapshot = get_current_snapshot pk_id, db
-        aggregate_version = aggregate_snapshot[:aggregate_version]
-        return if !current_snapshot.nil? && current_snapshot[:aggregate_version] == aggregate_version
-        if current_aggregate[:aggregate_version] < aggregate_version
-          error_message = "#{class_name} with id #{aggregate_id}: tried to save snapshot with version #{aggregate_version}, but current version is at #{current_aggregate[:aggregate_version]}"
-          raise SandthornDriverSequel::Errors::WrongAggregateVersionError.new error_message
-        end
-        if current_snapshot.nil?
-          to_insert = {aggregate_version: aggregate_version, snapshot_data: aggregate_snapshot[:event_data], aggregate_table_id: pk_id }
-          db[snapshots_table_name].insert(to_insert)
+        snapshot_access = get_snapshot_access(db)
+        snapshot_access.record_snapshot(aggregate_id, aggregate_snapshot)
+      end
+    end
+
+    # If the aggregate has a snapshot, return events starting from the snapshots.
+    # Otherwise, return all events.
+    # TODO: needs a better name
+    def get_aggregate_events_from_snapshot(aggregate_id)
+      driver.execute do |db|
+        snapshots = get_snapshot_access(db)
+        event_access = get_event_access(db)
+        snapshot = snapshots.find_by_aggregate_id(aggregate_id)
+        if snapshot
+          events = event_access.after_snapshot(snapshot)
+          snapshot_event = build_snapshot_event(snapshot)
+          events.unshift(snapshot_event)
         else
-          to_update = {aggregate_version: aggregate_version, snapshot_data: aggregate_snapshot[:event_data] }
-          db[snapshots_table_name].where(aggregate_table_id: pk_id).update(to_update)
+          event_access.find_events_by_aggregate_id(aggregate_id)
         end
       end
     end
 
-    def get_aggregate_events aggregate_id, *class_name
-      #aggregate_type = class_name.to_s unless class_name.nil?
-      return aggregate_events aggregate_id: aggregate_id
+    def build_snapshot_event(snapshot)
+      {
+          aggregate_version: snapshot[:aggregate_version],
+          event_data: snapshot[:snapshot_data],
+          event_name: "aggregate_set_from_snapshot"
+      }
     end
 
     def get_aggregate aggregate_id, *class_name
-      snapshot = get_snapshot aggregate_id, class_name
-      after_aggregate_version = 0
-      after_aggregate_version = snapshot[:aggregate_version] unless snapshot.nil?
-      events = aggregate_events after_aggregate_version: after_aggregate_version, aggregate_id: aggregate_id
-      unless snapshot.nil?
-        snap_event = snapshot
-        snap_event[:event_name] = "aggregate_set_from_snapshot"
-        events = events.unshift(snap_event)
-      end
-      events
+      warn(":get_aggregate is deprecated. Use :get_aggregate_events_from_snapshot")
+      get_aggregate_events_from_snapshot(aggregate_id)
     end
-    def get_aggregate_list_by_typename class_name
-      aggregate_type = class_name.to_s
+
+    def get_aggregate_ids(aggregate_type: nil)
       driver.execute do |db|
-        db[aggregates_table_name].where(aggregate_type: aggregate_type).select(:aggregate_id).map { |e| e[:aggregate_id] }
+        access = get_aggregate_access(db)
+        access.aggregate_ids(aggregate_type: aggregate_type)
       end
     end
 
-    def get_all_typenames
-      driver.execute do |db|
-        db[aggregates_table_name].select(:aggregate_type).distinct.order(:aggregate_type).map{|e| e[:aggregate_type]}
-      end
+    def get_aggregate_list_by_typename(type)
+      warn(":get_aggregate_list_by_typenames is deprecated. Use :get_aggregate_ids")
+      get_aggregate_ids(type: type)
     end
 
-    def get_snapshot aggregate_id, *class_name
-      aggregate_type = class_name.first.to_s
+    def get_all_types
       driver.execute do |db|
-        current_aggregate = get_current_aggregate_from_aggregates_table aggregate_id, aggregate_type, db
-        snap = get_current_snapshot current_aggregate[:id], db
-        return nil if snap.nil?
-        return {aggregate_version: snap[:aggregate_version], event_data: snap[:snapshot_data]}
+        access = get_aggregate_access(db)
+        access.aggregate_types
       end
     end
 
-    def get_new_events_after_event_id_matching_classname event_id, class_name, args = {}
-      take = args.fetch(:take, 0)
-      aggregate_type = class_name.to_s
+    def get_snapshot aggregate_id
       driver.execute do |db|
-        query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_type: aggregate_type)
-        query = query.where{sequence_number > event_id}
-        rel = "#{events_table_name}__aggregate_version".to_sym
-        query = query.select(:aggregate_type, rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp)
-        query = query.limit(take) if take > 0
-        return query.order(:sequence_number).all
+        snapshots = get_snapshot_access(db)
+        snapshot = snapshots.find_by_aggregate_id(aggregate_id)
+        transform_snapshot(snapshot)
       end
     end
-    def get_events aggregate_types: [], take: 0, after_sequence_number: 0, include_events: [], exclude_events: []
-      include_events = include_events.map { |e| e.to_s  }
-      exclude_events = exclude_events.map { |e| e.to_s  }
-      aggregate_types = aggregate_types.map { |e| e.to_s  }
+
+    def get_events(*args)
       driver.execute do |db|
-        if aggregate_types.empty?
-          query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id)
-        else
-          query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_type: aggregate_types)
-        end
-        query = query.where{sequence_number > after_sequence_number}
-        unless include_events.empty?
-          query = query.where(event_name: include_events)
-        end
-        unless exclude_events.empty?
-          query = query.exclude(event_name: exclude_events)
-        end
-        rel = "#{events_table_name}__aggregate_version".to_sym
-        query = query.select(:aggregate_type, rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp)
-        query = query.limit(take) if take > 0
-        return query.order(:sequence_number).all
+        event_access = get_event_access(db)
+        event_access.get_events(*args)
       end
     end
-    def obsolete_snapshots class_names: [], max_event_distance: 100
+
+    def get_new_events_after_event_id_matching_classname event_id, class_name, take: 0
+      get_events(after_sequence_number: event_id, aggregate_types: Utilities.array_wrap(class_name), take: take)
+    end
+
+    def obsolete_snapshots(*args)
       driver.execute do |db|
-        rel = "#{snapshots_table_name}__aggregate_version".to_sym
-        aggr_rel = "#{aggregates_table_name}__aggregate_version".to_sym
-        query_select = eval("lambda{(#{aggr_rel} - coalesce(#{rel},0)).as(distance)}")
-        query = db[aggregates_table_name].left_outer_join(snapshots_table_name, aggregate_table_id: :id)
-        query = query.select &query_select
-        query = query.select_append(:aggregate_id, :aggregate_type)
-        query_where = eval("lambda{(#{aggr_rel} - coalesce(#{rel},0)) > max_event_distance}")
-        query = query.where &query_where 
-        unless class_names.empty?
-          class_names.map! {|c|c.to_s}
-          query = query.where(aggregate_type: class_names)
-        end
-        query.all
+        snapshots = get_snapshot_access(db)
+        snapshots.obsolete(*args)
       end
     end
+
     private
 
-    def aggregate_events after_aggregate_version: 0, aggregate_id: nil
-      
-      rel = "#{events_table_name}__aggregate_version".to_sym
-      where_proc = eval("lambda{ #{rel} > after_aggregate_version }")
-      driver.execute do |db|
-        query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_id: aggregate_id)
-        query = query.where &where_proc
-        result = query.select(rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp).order(:sequence_number).all
-      end
-          
-      # result = nil
-      # Benchmark.bm do |x|
-      #   x.report("find") { 
-      #     rel = "#{events_table_name}__aggregate_version".to_sym
-      #     where_proc = eval("lambda{ #{rel} > after_aggregate_version }")
-      #     driver.execute do |db|
-      #       query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_id: aggregate_id)
-      #       query = query.where &where_proc
-      #       result = query.select(rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp).order(:sequence_number).all
-      #     end
-      #   }
-
-      # end
-      # result
-    end
-    def get_current_aggregate_from_aggregates_table aggregate_id, aggregate_type, db
-      aggregate_type = aggregate_type.to_s
-      current_aggregate = db[aggregates_table_name].where(aggregate_id: aggregate_id)
-      if current_aggregate.empty?
-        error_message = "#{aggregate_type} with id #{aggregate_id} was not found in the eventstore."
-        raise SandthornDriverSequel::Errors::NoAggregateError.new(error_message)
-      end
-      current_aggregate.first
+    def transform_snapshot(snapshot)
+      {
+          aggregate_version: snapshot.aggregate_version,
+          event_data: snapshot.snapshot_data
+      }
+    end
+
+    def get_aggregate_access(db)
+      AggregateAccess.new(storage(db))
+    end
+
+    def get_event_access(db)
+      EventAccess.new(storage(db))
     end
-    def get_current_snapshot aggregate_table_id, db
-      snap = db[snapshots_table_name].where(aggregate_table_id: aggregate_table_id)
-      return nil if snap.empty?
-      snap.first
+
+    def get_snapshot_access(db)
+      SnapshotAccess.new(storage(db))
     end
+
+    def storage(db)
+      Storage.new(db, context)
+    end
+
   end
-end
+end