nexia_event_store 0.5.11 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ba34c0d5ef8c010cf4378aa8aa773f77d760e27
-  data.tar.gz: 4601504e87c8130f3ebb3b0a15cde6e394a60e3f
+  metadata.gz: dc9b1f564f3ddc8e4d22914517f12d8cc6f53d02
+  data.tar.gz: e1c77390b4b25728ed97aff1704aa1ecbfabf7c8
 SHA512:
-  metadata.gz: 56e6c84f86f90cbaae47b55c05a87afbfa4a5a64249fbe46bef3160d152636b6d8b8f4b9916af967f85360644106ce212e663ee7a3bcd49ace4825f322f8ec83
-  data.tar.gz: 318a0f4c25dd1bbb71cd5cc0c576bf30fb671a11e92062659dca5d83c0709fd8fa076cddfe080091302fed8e43eac2bf5926a55a62adf5b5836a5a22ecef26dd
+  metadata.gz: 605f0b48862fd33d06ae738ed0be5c67c5a0bca60c0f02f4358f02017a81d98de7cc4400eec8e0acf03319d047012ae68e121b329b4c87b67450779631066d2f
+  data.tar.gz: d52f66b078358357c0f8b86a30d81e2659e24a9da5114d1155f2f4034609b9eba1173f54376db965fac5aba347adc2cd5c2b0fae052d861da78680e76128b46b

data/lib/event_store/aggregate.rb

@@ -10,9 +10,9 @@ module EventStore
       :last_event,
       :rebuild_snapshot!,
       :delete_snapshot!,
-      :version,
-      :version_for,
-      :snapshot_version_table
+      :event_id,
+      :event_id_for,
+      :snapshot_event_id_table
 
     def_delegators :event_stream,
       :events,

data/lib/event_store/client.rb

@@ -4,12 +4,12 @@ module EventStore
 
     def_delegators :aggregate,
                    :delete_snapshot!,
-                   :snapshot_version_table,
-                   :version_for,
+                   :snapshot_event_id_table,
+                   :event_id,
+                   :event_id_for,
                    :event_table,
                    :type,
-                   :id,
-                   :version
+                   :id
 
     def_delegators :event_stream,
                    :count
@@ -46,8 +46,8 @@ module EventStore
       translate_events(raw_event_stream)
     end
 
-    def event_stream_from(version_number, max=nil)
-      translate_events(aggregate.events_from(version_number, max))
+    def event_stream_from(event_id, max=nil)
+      translate_events(aggregate.events_from(event_id, max))
     end
 
     def last_event_before(start_time, fully_qualified_names = [])
@@ -70,8 +70,8 @@ module EventStore
       aggregate.event_stream
     end
 
-    def raw_event_stream_from version_number, max=nil
-      aggregate.events_from(version_number, max)
+    def raw_event_stream_from(event_id, max=nil)
+      aggregate.events_from(event_id, max)
     end
 
     def destroy!
@@ -99,7 +99,7 @@ module EventStore
     def translate_event(event_hash)
       return if event_hash.empty?
       occurred_at = TimeHacker.translate_occurred_at_from_local_to_gmt(event_hash[:occurred_at])
-      SerializedEvent.new event_hash[:fully_qualified_name], event_hash[:serialized_event], event_hash[:version], occurred_at
+      SerializedEvent.new event_hash[:fully_qualified_name], event_hash[:serialized_event], event_hash[:id], occurred_at
     end
   end
 end

data/lib/event_store/event_stream.rb

@@ -11,28 +11,26 @@ module EventStore
     end
 
     def append(raw_events)
-      EventStore.db.transaction do
-        next_version = last_version + 1
-
-        prepared_events = raw_events.map do |raw_event|
-          event = prepare_event(raw_event, next_version)
-          next_version += 1
-          ensure_all_attributes_have_values!(event)
-          event
-        end
-
-        events.multi_insert(prepared_events)
+      prepared_events = raw_events.map do |raw_event|
+        event = prepare_event(raw_event)
+        ensure_all_attributes_have_values!(event)
+        event
+      end
 
-        yield(prepared_events) if block_given?
+      inserted_ids = events.multi_insert(prepared_events, return: :primary_key)
+      prepared_events.each_with_index do |event, idx|
+        event[:id] = inserted_ids[idx]
       end
+
+      yield(prepared_events) if block_given?
     end
 
     def events
-      @events_query ||= EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).order(:version)
+      @events_query ||= EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).order(:id)
     end
 
-    def events_from(version_number, max = nil)
-      events.limit(max).where{ version >= version_number.to_i }.all.map do |event|
+    def events_from(event_id, max = nil)
+      events.limit(max).where{ id >= event_id.to_i }.all.map do |event|
         event[:serialized_event] = EventStore.unescape_bytea(event[:serialized_event])
         event
       end
@@ -85,10 +83,9 @@ module EventStore
 
   private
 
-    def prepare_event(raw_event, version_number)
+    def prepare_event(raw_event)
       raise ArgumentError.new("Cannot Append a Nil Event") unless raw_event
-      { :version              => version_number,
-        :aggregate_id         => raw_event.aggregate_id,
+      { :aggregate_id         => raw_event.aggregate_id,
         :occurred_at          => Time.parse(raw_event.occurred_at.to_s).utc, #to_s truncates microseconds, which brake Time equality
         :serialized_event     => EventStore.escape_bytea(raw_event.serialized_event),
         :fully_qualified_name => raw_event.fully_qualified_name,
@@ -97,17 +94,11 @@ module EventStore
     end
 
     def ensure_all_attributes_have_values!(event_hash)
-      [:aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :version].each do |attribute_name|
+      [:aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event].each do |attribute_name|
         if event_hash[attribute_name].to_s.strip.empty?
           raise AttributeMissingError, "value required for #{attribute_name}"
         end
       end
     end
-
-    def last_version
-      last = events.select(:version).last
-      last && last[:version] || -1
-    end
-
   end
 end

data/lib/event_store/snapshot.rb

@@ -4,13 +4,13 @@ module EventStore
   class Snapshot
     include Enumerable
 
-    attr_reader :snapshot_version_table, :snapshot_table
+    attr_reader :snapshot_event_id_table, :snapshot_table
 
     def initialize aggregate
       @aggregate = aggregate
       @redis = EventStore.redis
       @snapshot_table = "#{@aggregate.type}_snapshots_for_#{@aggregate.id}"
-      @snapshot_version_table = "#{@aggregate.type}_snapshot_versions_for_#{@aggregate.id}"
+      @snapshot_event_id_table = "#{@aggregate.type}_snapshot_event_ids_for_#{@aggregate.id}"
     end
 
     def exists?
@@ -21,12 +21,12 @@ module EventStore
       to_a.last
     end
 
-    def version(snapshot_key =:current_version)
-      (@redis.hget(snapshot_version_table, snapshot_key) || -1).to_i
+    def event_id(snapshot_key =:current_event_id)
+      (@redis.hget(snapshot_event_id_table, snapshot_key) || -1).to_i
     end
 
-    def version_for(fully_qualified_name, sub_key = nil)
-      version(snapshot_key(fully_qualified_name: fully_qualified_name, sub_key: sub_key))
+    def event_id_for(fully_qualified_name, sub_key = nil)
+      event_id(snapshot_key(fully_qualified_name: fully_qualified_name, sub_key: sub_key))
     end
 
     def count(logger=default_logger)
@@ -43,13 +43,13 @@ module EventStore
       result_hash = events_hash.inject([]) do |snapshot, (key, value)|
         fully_qualified_name, _ = key.split(EventStore::SNAPSHOT_KEY_DELIMITER)
         raw_event               = value.split(EventStore::SNAPSHOT_DELIMITER)
-        version                 = raw_event.first.to_i
+        event_id                = raw_event.first.to_i
         serialized_event        = EventStore.unescape_bytea(raw_event[1])
         occurred_at             = Time.parse(raw_event.last)
-        snapshot + [SerializedEvent.new(fully_qualified_name, serialized_event, version, occurred_at)]
+        snapshot + [SerializedEvent.new(fully_qualified_name, serialized_event, event_id, occurred_at)]
       end
       logger.debug { "#{self.class.name} serializing events took #{Time.now - t} seconds" }
-      result_hash.sort_by(&:version).each { |e| yield e }
+      result_hash.sort_by(&:event_id).each { |e| yield e }
     end
 
     def rebuild_snapshot!(logger=default_logger)
@@ -69,25 +69,25 @@ module EventStore
     end
 
     def delete_snapshot!
-      EventStore.redis.del [snapshot_table, snapshot_version_table]
+      EventStore.redis.del [snapshot_table, snapshot_event_id_table]
     end
 
     def store_snapshot(prepared_events)
       valid_snapshot_events = []
-      valid_snapshot_versions = []
+      valid_snapshot_event_ids = []
 
       prepared_events.each do |event_hash|
-        if event_hash[:version].to_i > current_version_numbers[snapshot_key(event_hash)].to_i
-          valid_snapshot_events   += snapshot_event(event_hash)
-          valid_snapshot_versions += snapshot_version(event_hash)
+        if event_hash[:id].to_i > current_event_id_numbers[snapshot_key(event_hash)].to_i
+          valid_snapshot_events    += snapshot_event(event_hash)
+          valid_snapshot_event_ids += snapshot_event_id(event_hash)
         end
       end
 
-      unless valid_snapshot_versions.empty?
-        valid_snapshot_versions += [:current_version, valid_snapshot_versions.last.to_i]
+      unless valid_snapshot_event_ids.empty?
+        valid_snapshot_event_ids += [:current_event_id, valid_snapshot_event_ids.last.to_i]
 
         @redis.multi do
-          @redis.hmset(snapshot_version_table, valid_snapshot_versions)
+          @redis.hmset(snapshot_event_id_table, valid_snapshot_event_ids)
           @redis.hmset(snapshot_table, valid_snapshot_events)
         end
       end
@@ -106,24 +106,24 @@ module EventStore
     def snapshot_event(event)
       [
         snapshot_key(event),
-        [ event[:version].to_s,
+        [ event[:id].to_s,
           event[:serialized_event],
           event[:occurred_at].to_s
         ].join(EventStore::SNAPSHOT_DELIMITER)
       ]
     end
 
-    def snapshot_version(event)
+    def snapshot_event_id(event)
       [
         snapshot_key(event),
-        event[:version]
+        event[:id]
       ]
     end
 
-    def current_version_numbers
-      current_versions = @redis.hgetall(snapshot_version_table)
-      current_versions.default = -1
-      current_versions
+    def current_event_id_numbers
+      @redis.hgetall(snapshot_event_id_table).tap { |event_ids|
+        event_ids.default = -1
+      }
     end
 
     def read_raw_snapshot(logger=default_logger)

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.5.11'
+  VERSION = '0.6.0'
 end

data/lib/event_store.rb

@@ -17,7 +17,7 @@ Sequel.extension :migration
 
 module EventStore
   Event = Struct.new(:aggregate_id, :occurred_at, :fully_qualified_name, :sub_key, :serialized_event)
-  SerializedEvent = Struct.new(:fully_qualified_name, :serialized_event, :version, :occurred_at)
+  SerializedEvent = Struct.new(:fully_qualified_name, :serialized_event, :event_id, :occurred_at)
   SNAPSHOT_DELIMITER     = "__NexEvStDelim__"
   SNAPSHOT_KEY_DELIMITER = ":"
   NO_SUB_KEY              = "NO_SUB_KEY"

data/spec/event_store/client_spec.rb

@@ -15,7 +15,7 @@ describe EventStore::Client do
 
       events_by_aggregate_id  = {AGGREGATE_ID_ONE => [], AGGREGATE_ID_TWO => []}
       @event_time = Time.parse("2001-01-01 00:00:00 UTC")
-      ([AGGREGATE_ID_ONE]*5 + [AGGREGATE_ID_TWO]*5).shuffle.each_with_index do |aggregate_id, version|
+      ([AGGREGATE_ID_ONE]*5 + [AGGREGATE_ID_TWO]*5).shuffle.each_with_index do |aggregate_id, event_id|
         events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "zone_1_event", "1", serialized_binary_event_data)
         events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "zone_2_event", "2", serialized_binary_event_data)
         events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "system_event", EventStore::NO_SUB_KEY, serialized_binary_event_data)
@@ -116,48 +116,49 @@ describe EventStore::Client do
     end
 
 
-    describe '#raw_event_streams_from_version' do
+    describe '#raw_event_streams_from_event_id' do
       subject { es_client.new(AGGREGATE_ID_ONE, :device) }
+      let(:raw_stream) { subject.raw_event_stream }
+      let(:minimum_event_id) { raw_stream.events.all[1][:id] }
+      let(:events_from) { subject.raw_event_stream_from(minimum_event_id) }
 
-      it 'should return all the raw events in the stream starting from a certain version' do
-        minimum_event_version = 2
-        raw_stream = subject.raw_event_stream_from(minimum_event_version)
-        event_versions = raw_stream.inject([]){|m, event| m << event[:version]; m}
-        expect(event_versions.min).to be >= minimum_event_version
+      it 'should return all the raw events in the stream starting from a certain event_id' do
+        event_ids = events_from.inject([]){|m, event| m << event[:id]; m}
+        expect(event_ids.min).to be >= minimum_event_id
       end
 
       it 'should return no more than the maximum number of events specified above the ' do
-        max_number_of_events  = 5
-        minimum_event_version = 2
-        raw_stream = subject.raw_event_stream_from(minimum_event_version, max_number_of_events)
+        max_number_of_events = 5
+        minimum_event_id = 2
+        raw_stream = subject.raw_event_stream_from(minimum_event_id, max_number_of_events)
         expect(raw_stream.count).to eq(max_number_of_events)
       end
 
       it 'should be empty for version above the current highest version number' do
-        raw_stream = subject.raw_event_stream_from(subject.version + 1)
+        raw_stream = subject.raw_event_stream_from(subject.event_id + 1)
         expect(raw_stream).to be_empty
       end
     end
 
-    describe 'event_stream_from_version' do
+    describe 'event_stream_from_event_id' do
       subject { es_client.new(AGGREGATE_ID_ONE, :device) }
 
-      it 'should return all the raw events in the stream starting from a certain version' do
-        minimum_event_version = 2
-        raw_stream = subject.raw_event_stream_from(minimum_event_version)
-        event_versions = raw_stream.inject([]){|m, event| m << event[:version]; m}
-        expect(event_versions.min).to be >= minimum_event_version
+      it 'should return all the raw events in the stream starting from a certain event_id' do
+        minimum_event_id = 2
+        raw_stream = subject.raw_event_stream_from(minimum_event_id)
+        event_ids = raw_stream.inject([]){|m, event| m << event[:id]; m}
+        expect(event_ids.min).to be >= minimum_event_id
       end
 
       it 'should return no more than the maximum number of events specified above the ' do
         max_number_of_events  = 5
-        minimum_event_version = 2
-        raw_stream = subject.raw_event_stream_from(minimum_event_version, max_number_of_events)
+        minimum_event_id = 2
+        raw_stream = subject.raw_event_stream_from(minimum_event_id, max_number_of_events)
         expect(raw_stream.count).to eq(max_number_of_events)
       end
 
-      it 'should be empty for version above the current highest version number' do
-        raw_stream = subject.raw_event_stream_from(subject.version + 1)
+      it 'should be empty for event_id above the current highest event id' do
+        raw_stream = subject.raw_event_stream_from(subject.event_id + 1)
         expect(raw_stream).to eq([])
       end
     end
@@ -242,10 +243,10 @@ describe EventStore::Client do
       let(:client) { es_client.new(AGGREGATE_ID_ONE, :device) }
 
       it 'should return the last event in the event stream' do
-        last_event = EventStore.db.from(client.event_table).where(aggregate_id: AGGREGATE_ID_ONE).order(:version).last
+        last_event = EventStore.db.from(client.event_table).where(aggregate_id: AGGREGATE_ID_ONE).order(:id).last
         peek = client.peek
         expect(peek.fully_qualified_name).to eq(last_event[:fully_qualified_name])
-        expect(peek.version).to eq(last_event[:version])
+        expect(peek.event_id).to eq(last_event[:id])
       end
     end
   end
@@ -260,7 +261,7 @@ describe EventStore::Client do
       let(:really_new_event) { EventStore::Event.new(AGGREGATE_ID_ONE, (event_time + 100).utc,  "really_new", "zone", "#{1002.to_s(2)}_foo") }
       let(:duplicate_event)  { EventStore::Event.new(AGGREGATE_ID_ONE, (event_time).utc,        "duplicate", "zone", "#{12.to_s(2)}_foo") }
 
-      describe "when expected version number is greater than the last version" do
+      describe "when expected event id is greater than the last event id" do
         describe 'and there are no prior events of type' do
           before(:each) do
             client.append([old_event])
@@ -280,16 +281,16 @@ describe EventStore::Client do
             expect(client.count).to eq(initial_count + events.length)
           end
 
-          it "should increment the version number by the number of events added" do
+          it "should change the event id number" do
             events = [new_event, really_new_event]
-            expect{client.append(events)}.to change(client, :version).by(events.length)
+            expect{ client.append(events) }.to change(client, :event_id)
           end
 
-          it "sets the snapshot version number to match that of the last event in the aggregate's event stream" do
-            expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
+          it "sets the snapshot event id number to match that of the last event in the aggregate's event stream" do
+            expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
 
             client.append([new_event, really_new_event])
-            expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
+            expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
           end
 
           it "should write-through-cache the event in a snapshot without duplicating events" do
@@ -311,12 +312,6 @@ describe EventStore::Client do
             client.append([old_event])
           end
 
-          xit 'should raise a ConcurrencyError if the the event version is less than current version' do
-            client.append([duplicate_event])
-            reset_current_version_for(client)
-            expect { client.append([duplicate_event]) }.to raise_error(EventStore::ConcurrencyError)
-          end
-
           it 'should not raise an error when two events of the same type are appended' do
             client.append([duplicate_event])
             client.append([duplicate_event]) #will fail automatically if it throws an error, no need for assertions (which now print warning for some reason)
@@ -331,11 +326,11 @@ describe EventStore::Client do
             expect(client.snapshot.to_a).to eq(expected)
           end
 
-          it "sets the snapshot version number to match that of the last event in the aggregate's event stream" do
-            expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
+          it "sets the snapshot event id to match that of the last event in the aggregate's event stream" do
+            expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
 
             client.append([old_event, old_event])
-            expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
+            expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
           end
         end
       end
@@ -370,11 +365,6 @@ describe EventStore::Client do
           end
         end
       end
-
-      def reset_current_version_for(client)
-        aggregate = client.instance_variable_get("@aggregate")
-        EventStore.redis.hset(aggregate.snapshot_version_table, :current_version, 1000)
-      end
     end
 
     describe '#last_event_before' do

data/spec/event_store/snapshot_spec.rb

@@ -11,8 +11,8 @@ module EventStore
 
       it "should build an empty snapshot for a new client" do
         expect(client.snapshot.any?).to eq(false)
-        expect(client.version).to eq(-1)
-        expect(EventStore.redis.hget(client.snapshot_version_table, :current_version)).to eq(nil)
+        expect(client.event_id).to eq(-1)
+        expect(EventStore.redis.hget(client.snapshot_event_id_table, :current_event_id)).to eq(nil)
       end
 
       it "a client should rebuild a snapshot" do
@@ -61,7 +61,7 @@ module EventStore
       end
 
       it "increments the version number of the snapshot when an event is appended" do
-        expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
+        expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
       end
     end
 

data/spec/unit/snapshot_unit_spec.rb

@@ -11,13 +11,13 @@ module EventStore
 
     subject(:snapshot)   { EventStore::Snapshot.new(aggregate) }
 
-    it "has a version table for the snapshot" do
-      expect(snapshot.snapshot_version_table).to eq "#{aggregate_type}_snapshot_versions_for_#{aggregate_id}"
+    it "has a event_id table for the snapshot" do
+      expect(snapshot.snapshot_event_id_table).to eq "#{aggregate_type}_snapshot_event_ids_for_#{aggregate_id}"
     end
 
     context "with events in the snapshot table" do
       let(:first_event) {
-        { version: 1,
+        { id: 1,
           fully_qualified_name: "fqn",
           sub_key: "sub",
           serialized_event: EventStore.escape_bytea("cheerios"),
@@ -25,7 +25,7 @@ module EventStore
         }
       }
       let(:last_event) {
-        { version: 2,
+        { id: 2,
           fully_qualified_name: "fqn2",
           sub_key: "sub2",
           serialized_event: EventStore.escape_bytea("cheerios2"),
@@ -39,29 +39,29 @@ module EventStore
       describe "#last_event" do
         let(:events) { [ last_event, first_event ] }
 
-        it "returns the event with the highest version" do
+        it "returns the event with the highest event_id" do
           expect(snapshot.last_event.fully_qualified_name).to eq(last_event[:fully_qualified_name])
         end
       end
 
-      describe "#version" do
-        it "is the highest version of the last inserted event in the snapshot" do
-          expect(snapshot.version).to eq(last_event[:version])
+      describe "#event_id" do
+        it "is the highest event_id of the last inserted event in the snapshot" do
+          expect(snapshot.event_id).to eq(last_event[:id])
         end
       end
 
-      describe "#version_for" do
+      describe "#event_id_for" do
         let(:subkey) { first_event[:sub_key] }
         let(:fqn)    { first_event[:fully_qualified_name] }
 
-        it "returns the version number for the last event of specific fqn" do
-          expect(snapshot.version_for(fqn, subkey)).to eq(first_event[:version])
+        it "returns the event_id number for the last event of specific fqn" do
+          expect(snapshot.event_id_for(fqn, subkey)).to eq(first_event[:id])
         end
       end
 
       describe "#rebuild_snapshot!" do
         it "deletes the existing snapshot" do
-          expect(redis).to receive(:del).with([snapshot.snapshot_table , snapshot.snapshot_version_table])
+          expect(redis).to receive(:del).with([snapshot.snapshot_table , snapshot.snapshot_event_id_table])
           snapshot.rebuild_snapshot!
         end
 
@@ -78,7 +78,6 @@ module EventStore
       describe "events" do
         let(:serialized_attrs) { [ :fully_qualified_name,
                                    :serialized_event,
-                                   :version,
                                    :occurred_at ] }
 
         it "contains SerializedEvents" do
@@ -92,6 +91,11 @@ module EventStore
           }
         end
 
+        it "maps the event_id to the serialized event's id" do
+          expect(snapshot.to_a.first.event_id).to eq(first_event[:id])
+          expect(snapshot.to_a.last.event_id).to eq(last_event[:id])
+        end
+
         it "unescapes the serialized events" do
           expected_event = EventStore.unescape_bytea(first_event[:serialized_event])
           expect(snapshot.first.serialized_event).to eq(expected_event)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.6.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin