sandthorn_driver_sequel 1.1.0 → 2.0.0

data/lib/sandthorn_driver_sequel/event_store_context.rb

@@ -1,5 +1,6 @@
 module SandthornDriverSequel
   module EventStoreContext
+    attr_reader :context
     def events_table_name
       with_context_if_exists :events
     end

data/lib/sandthorn_driver_sequel/migration.rb

@@ -37,6 +37,15 @@ module SandthornDriverSequel
           was_migrated aggr_migration_0, db
         end
       end
+      aggr_migration_1 = "#{aggregates_table_name}-20141024"
+      unless has_been_migrated?(aggr_migration_1)
+        driver.execute do |db|
+          db.alter_table(aggregates_table_name) do
+            set_column_default :aggregate_version, 0
+          end
+        end
+      end
+
     end
     def events
       events_migration_0 = "#{events_table_name}-20130308"
@@ -95,7 +104,6 @@ module SandthornDriverSequel
           String :migration_name, null: false
           index [:migration_name], unique: true
           DateTime :timestamp, :null=>false
-          index [:migration_name], unique: true
         end
       end
     end

data/lib/sandthorn_driver_sequel/old_event_store.rb

@@ -0,0 +1,228 @@
+require 'sandthorn_driver_sequel/sequel_driver'
+
+module SandthornDriverSequel
+  class OldEventStore
+    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.to_s
+      driver.execute_in_transaction do |db|
+        if current_aggregate_version == 0
+          pk_id = register_new_aggregate(aggregate_id, aggregate_type, db)
+        else
+          current_aggregate = get_current_aggregate_from_aggregates_table(aggregate_id, aggregate_type, db)
+          check_initial_aggregate_version!(current_aggregate, current_aggregate_version)
+          pk_id = current_aggregate[:id]
+        end
+        timestamp = Time.now.utc
+        aggregate_events.each do |event|
+          current_aggregate_version += 1
+          check_event_aggregate_version!(event, class_name, current_aggregate_version)
+          insert_event(db, event, pk_id, timestamp)
+        end
+        db[aggregates_table_name].where(id: pk_id).update(aggregate_version: current_aggregate_version)
+      end
+    end
+
+    def insert_event(db, event, pk_id, timestamp)
+      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
+
+    def check_event_aggregate_version!(event, aggregate_type, current_aggregate_version)
+      if event[:aggregate_version] != current_aggregate_version
+        raise SandthornDriverSequel::Errors::ConcurrencyError, event, aggregate_type, current_aggregate_version
+      end
+    end
+
+    def check_initial_aggregate_version!(aggregate, current_aggregate_version)
+      if aggregate[:aggregate_version] != current_aggregate_version
+        raise SandthornDriverSequel::Errors::WrongAggregateVersionError, aggregate, current_aggregate_version
+      end
+    end
+
+    def register_new_aggregate(aggregate_id, aggregate_type, db)
+      to_insert = {
+          aggregate_id: aggregate_id,
+          aggregate_type: aggregate_type,
+          aggregate_version: 0
+      }
+      pk_id = db[aggregates_table_name].insert(to_insert)
+    end
+
+    def save_snapshot aggregate_snapshot, aggregate_id, class_name
+      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 snapshot_fresh?(current_snapshot, aggregate_version)
+        check_snapshot_version!(current_aggregate, aggregate_version)
+        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)
+        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)
+        end
+      end
+    end
+
+    def snapshot_fresh?(current_snapshot, aggregate_version)
+      !current_snapshot.nil? && current_snapshot[:aggregate_version] == aggregate_version
+    end
+
+    def check_snapshot_version!(aggregate, aggregate_version)
+      if aggregate[:aggregate_version] < aggregate_version
+        raise SandthornDriverSequel::Errors::WrongSnapshotVersionError, aggregate, version
+      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
+    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
+    end
+    def get_aggregate_list_by_typename class_name
+      aggregate_type = class_name.to_s
+      driver.execute do |db|
+        db[aggregates_table_name].where(aggregate_type: aggregate_type).select(:aggregate_id).map { |e| e[:aggregate_id] }
+      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
+    end
+
+    def get_snapshot aggregate_id, *class_name
+      aggregate_type = class_name.first.to_s
+      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]}
+      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
+      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
+      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  }
+      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
+      end
+    end
+    def obsolete_snapshots aggregate_types: [], max_event_distance: 100
+      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
+      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
+    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
+    end
+  end
+end

data/lib/sandthorn_driver_sequel/sequel_driver.rb

@@ -2,39 +2,22 @@ require 'sequel'
 
 module SandthornDriverSequel
   class SequelDriver
+
     def initialize args = {}
       @url = args.fetch(:url)
       Sequel.default_timezone = :utc
       @db = Sequel.connect(@url)
     end
-    def execute &block
-      return block.call @db
+
+    def execute
+      yield @db
     end
+
     def execute_in_transaction &block
-      @db.transaction {|tr|
-        return block.call @db
-      }
+      @db.transaction do
+        block.call(@db)
+      end
     end
 
   end
 end
-
-
-# module SandthornDriverSequel
-#   class SequelDriver
-#     def initialize args = {}
-#       @url = args.fetch(:url)
-#       Sequel.default_timezone = :utc
-#     end
-#     def execute &block
-#       Sequel.connect(@url) { |db| return block.call db}
-#     end
-#     def execute_in_transaction &block
-#       Sequel.connect(@url) do |db|
-#         db.transaction do
-#           return block.call db
-#         end
-#       end
-#     end 
-#   end
-# end

data/lib/sandthorn_driver_sequel/storage.rb

@@ -0,0 +1,46 @@
+module SandthornDriverSequel
+  class Storage
+    # = Storage
+    # Abstracts access to contextualized database tables.
+    #
+    # == Rationale
+    # Provide object-oriented access to the different tables to other objects.
+    # Make it unnecessary for them to know about the current context.
+    include EventStoreContext
+
+    attr_reader :db
+
+    def initialize(db, context)
+      @db = db
+      @context = context
+    end
+
+    # Returns a Sequel::Model for accessing aggregates
+    def aggregates
+      Class.new(Sequel::Model(aggregates_table))
+    end
+
+    # Returns a Sequel::Model for accessing events
+    def events
+      Class.new(Sequel::Model(events_table))
+    end
+
+    # Returns a Sequel::Model for accessing snapshots
+    def snapshots
+      Class.new(Sequel::Model(snapshots_table))
+    end
+
+    def aggregates_table
+      db[aggregates_table_name]
+    end
+
+    def events_table
+      db[events_table_name]
+    end
+
+    def snapshots_table
+      db[snapshots_table_name]
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel/utilities/array.rb

@@ -0,0 +1,13 @@
+module SandthornDriverSequel
+  module Utilities
+    def self.array_wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/sandthorn_driver_sequel/utilities.rb

@@ -0,0 +1 @@
+require "sandthorn_driver_sequel/utilities/array"

data/lib/sandthorn_driver_sequel/version.rb

@@ -1,3 +1,3 @@
 module SandthornDriverSequel
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/lib/sandthorn_driver_sequel/wrappers/event_wrapper.rb

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

data/lib/sandthorn_driver_sequel/wrappers/snapshot_wrapper.rb

@@ -0,0 +1,11 @@
+module SandthornDriverSequel
+  class SnapshotWrapper < SimpleDelegator
+    def aggregate_version
+      self[:aggregate_version]
+    end
+
+    def data
+      self[:event_data]
+    end
+  end
+end

data/lib/sandthorn_driver_sequel/wrappers.rb

@@ -0,0 +1,2 @@
+require "sandthorn_driver_sequel/wrappers/event_wrapper"
+require "sandthorn_driver_sequel/wrappers/snapshot_wrapper"

data/lib/sandthorn_driver_sequel.rb

@@ -1,5 +1,10 @@
 require "sandthorn_driver_sequel/version"
+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'

data/sandthorn_driver_sequel.gemspec

@@ -22,7 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
 
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "coveralls"
   spec.add_development_dependency "gem-release"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "pry"
@@ -33,7 +32,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "ruby-beautify"
   spec.add_development_dependency "msgpack"
   spec.add_development_dependency "snappy"
+  spec.add_development_dependency "guard-rspec"
 
-  spec.add_runtime_dependency     "sequel"
+  spec.add_runtime_dependency     "sequel", "~> 4.17"
   spec.add_runtime_dependency     "pg"
 end

data/spec/aggregate_access_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module SandthornDriverSequel
+  describe AggregateAccess do
+    include EventStoreContext
+    let(:context) { :test }
+    let(:db) { Sequel.connect(event_store_url)}
+    let(:aggregate_id) { generate_uuid }
+    let(:storage) { Storage.new(db, :test) }
+    let(:access) { AggregateAccess.new(storage) }
+
+    before { prepare_for_test }
+
+    describe "#find" do
+      it "finds by table id" do
+        aggregate = access.register_aggregate(aggregate_id, "boo")
+        aggregate = access.find(aggregate.id)
+        expect(aggregate.aggregate_id).to eq(aggregate_id)
+        expect(aggregate.aggregate_type).to eq("boo")
+      end
+
+      it "doesn't find by table id" do
+        access.register_aggregate(aggregate_id, "foo")
+        max_id = db[aggregates_table_name].max(:id)
+        expect(access.find(max_id + 1)).to be_nil
+      end
+    end
+
+    describe "#find_by_aggregate_id" do
+      context "when the aggregate is registered" do
+        it "returns the aggregate" do
+          access.register_aggregate(aggregate_id, "bar")
+          aggregate = access.find_by_aggregate_id(aggregate_id)
+          expect(aggregate.aggregate_id).to eq(aggregate_id)
+        end
+      end
+
+      context "when the aggregate isn't registered" do
+        it "returns nil" do
+          expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
+        end
+      end
+    end
+
+    describe "#find_or_register" do
+      context "when the aggregate is registered" do
+        it "returns the aggregate" do
+          access.register_aggregate(aggregate_id, "baz")
+          aggregate = access.find_or_register(aggregate_id, "qux")
+          expect(aggregate.aggregate_id).to eq(aggregate_id)
+          expect(aggregate.aggregate_type).to eq("baz")
+        end
+      end
+    end
+
+    describe "#register_aggregate" do
+      it "returns the aggregate" do
+        aggregate = access.register_aggregate(aggregate_id, "bar")
+        expect(aggregate.aggregate_id).to eq(aggregate_id)
+        expect(aggregate.aggregate_type).to eq("bar")
+        expect(aggregate.id).to_not be_nil
+      end
+    end
+
+    describe "#aggregate_types" do
+      it "returns all aggregate types in the event store" do
+        types = ["foo", "bar", "qux"]
+        types.each do |type|
+          access.register_aggregate(generate_uuid, type)
+        end
+        expect(access.aggregate_types).to eq(types.sort)
+      end
+    end
+
+    describe "#aggregate_ids" do
+      context "when given no argument" do
+        it "returns all aggregate ids" do
+          aggregate_ids = 3.times.map { generate_uuid }
+          aggregate_ids.each { |id| access.register_aggregate(id, "foo") }
+          expect(access.aggregate_ids).to eq(aggregate_ids)
+        end
+      end
+      context "when given an aggregate type" do
+        it "returns only aggregates of that type" do
+          foo_agg_id, bar_agg_id = generate_uuid, generate_uuid
+          access.register_aggregate(foo_agg_id, "foo")
+          access.register_aggregate(bar_agg_id, "bar")
+          expect(access.aggregate_ids(aggregate_type: "foo")).to eq([foo_agg_id])
+        end        
+      end
+    end
+
+    def generate_uuid
+      SecureRandom.uuid
+    end
+  end
+end