mongo_entity_store 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 381bcb65dda4bd6210e20e336d8c0e2936016921
+  data.tar.gz: 9f31363aa40b798f859541c04c99a50f360cbb04
+SHA512:
+  metadata.gz: 9a59c6440e303d4ed2b77e6e1112cc7749cabe45e5f6bca87f9c1196f8ff205b507893f6f55f8e5e7d80ba3683810e48031cc61cc2bf6ab900977a24d8b31c9a
+  data.tar.gz: bbadc70bf04b5d300ebed283cec85b79077da636ba25865d3e7900a3273a7aaeddbc0094152eff67ff58924a54df0b92c546ae9d0a79952dfea75fc589d6eaed

data/lib/mongo_entity_store/external_store.rb

@@ -0,0 +1,62 @@
+require 'mongo'
+require 'uri'
+
+module EntityStore
+  class ExternalStore
+    include Mongo
+
+    class << self
+      attr_accessor :connection_profile
+      attr_writer :connect_timeout
+
+      def connection
+        @_connection ||= Mongo::MongoClient.from_uri(ExternalStore.connection_profile, :connect_timeout => EntityStore::Config.connect_timeout)
+      end
+
+      def database
+        @_database ||= ExternalStore.connection_profile.split('/').last
+      end
+    end
+
+    def open
+      ExternalStore.connection.db(ExternalStore.database)
+    end
+    
+    def collection
+      @_collection ||= open['events']
+    end
+    
+    def ensure_indexes
+      collection.ensure_index([['_type', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])      
+    end
+    
+    def add_event(entity_type, event)
+      collection.insert({
+        '_entity_type' => entity_type, '_type' => event.class.name 
+        }.merge(event.attributes)
+      )
+    end
+    
+    # Public - get events since a Time or ID
+    # 
+    # since         - Time or String id to filter events from 
+    # type          - String optionally filter the event type to return (default=nil)
+    # max_items     - Fixnum max items to return (default=100)
+    # 
+    # Returns Enumerable EventDataObject
+    def get_events(since, type=nil, max_items=100)
+      since_id = since.is_a?(Time) ? BSON::ObjectId.from_time(since) : BSON::ObjectId.from_string(since)
+
+      query = { '_id' => { '$gt' => since_id } }
+      query['_type'] = type if type
+      
+      options = {
+        :sort => [['_id', Mongo::ASCENDING]],
+        :limit => max_items
+      }
+      
+      collection.find(query, options).collect { |e| EventDataObject.new(e)}
+    end
+    
+  end
+end

data/lib/mongo_entity_store/mongo_entity_store.rb

@@ -0,0 +1,204 @@
+require 'mongo'
+require 'entity_store'
+require 'uri'
+
+module EntityStore
+  class MongoEntityStore
+    include Mongo
+    include Logging
+
+    class << self
+      attr_accessor :connection_profile
+      attr_writer :connect_timeout
+
+      def connection
+        @_connection ||= Mongo::MongoClient.from_uri(MongoEntityStore.connection_profile, :connect_timeout => EntityStore::Config.connect_timeout, :refresh_mode => :sync)
+      end
+
+      def database
+        @_database ||= MongoEntityStore.connection_profile.split('/').last.split('?').first
+      end
+    end
+
+    def open
+      MongoEntityStore.connection.db(MongoEntityStore.database)
+    end
+
+    def entities
+      @entities_collection ||= open['entities']
+    end
+
+    def events
+      @events_collection ||= open['entity_events']
+    end
+
+    def clear
+      entities.drop
+      @entities_collection = nil
+      events.drop
+      @events_collection = nil
+    end
+
+    def ensure_indexes
+      events.ensure_index([['_entity_id', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])
+      events.ensure_index([['_entity_id', Mongo::ASCENDING], ['entity_version', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])
+    end
+
+    def add_entity(entity, id = BSON::ObjectId.new)
+      entities.insert('_id' => id, '_type' => entity.class.name, 'version' => entity.version).to_s
+    end
+
+    def save_entity(entity)
+      entities.update({'_id' => BSON::ObjectId.from_string(entity.id)}, { '$set' => { 'version' => entity.version } })
+    end
+
+    # Public: create a snapshot of the entity and store in the entities collection
+    #
+    def snapshot_entity(entity)
+      query = {'_id' => BSON::ObjectId.from_string(entity.id)}
+      updates = { '$set' => { 'snapshot' => entity.attributes } }
+
+      if entity.class.respond_to? :entity_store_snapshot_key
+        # If there is a snapshot key, store it too
+        updates['$set']['snapshot_key'] = entity.class.entity_store_snapshot_key
+      else
+        # Otherwise, make sure there isn't one set
+        updates['$unset'] = { 'snapshot_key' => '' }
+      end
+
+      entities.update(query, updates, { :upsert => true} )
+    end
+
+    # Public - remove the snapshot for an entity
+    #
+    def remove_entity_snapshot(id)
+      entities.update({'_id' => BSON::ObjectId.from_string(id)}, { '$unset' => { 'snapshot' => 1}})
+    end
+
+    # Public: remove all snapshots
+    #
+    # type        - String optional class name for the entity
+    #
+    def remove_snapshots type=nil
+      query = {}
+      query['_type'] = type if type
+      entities.update(query, { '$unset' => { 'snapshot' => 1 } }, { multi: true })
+    end
+
+    def clear_entity_events(id, excluded_types)
+      events.remove({
+        '_entity_id' => BSON::ObjectId.from_string(id),
+        '_type' => { '$nin' => excluded_types },
+      })
+    end
+
+    def add_events(items)
+      events_with_id = items.map { |e| [ BSON::ObjectId.new, e ] }
+      add_events_with_ids(events_with_id)
+    end
+
+    def add_events_with_ids(event_id_map)
+      docs = event_id_map.map do |id, event|
+        {
+          '_id' => id,
+          '_type' => event.class.name,
+          '_entity_id' => BSON::ObjectId.from_string(event.entity_id)
+        }.merge(event.attributes)
+      end
+
+      events.insert(docs)
+    end
+
+    # Public: loads the entity from the store, including any available snapshots
+    # then loads the events to complete the state
+    #
+    # ids           - Array of Strings representation of BSON::ObjectId
+    # options       - Hash of options (default: {})
+    #                 :raise_exception - Boolean (default: true)
+    #
+    # Returns an array of entities
+    def get_entities(ids, options={})
+
+      object_ids = ids.map do |id|
+        begin
+          BSON::ObjectId.from_string(id)
+        rescue BSON::InvalidObjectId
+          raise NotFound.new(id) if options.fetch(:raise_exception, true)
+          nil
+        end
+      end
+
+      entities.find('_id' => { '$in' => object_ids }).map do |attrs|
+        begin
+          entity_type = EntityStore::Config.load_type(attrs['_type'])
+
+          # Check if there is a snapshot key in use
+          if entity_type.respond_to? :entity_store_snapshot_key
+            active_key = entity_type.entity_store_snapshot_key
+            # Discard the snapshot if the keys don't match
+            attrs.delete('snapshot') unless active_key == attrs['snapshot_key']
+          end
+
+          entity = entity_type.new(attrs['snapshot'] || {'id' => attrs['_id'].to_s })
+        rescue => e
+          log_error "Error loading type #{attrs['_type']}", e
+          raise
+        end
+
+        entity
+      end
+
+    end
+
+    # Public:  get events for an array of criteria objects
+    #           because each entity could have a different reference
+    #           version this allows optional criteria to be specifed
+    #
+    #
+    # criteria  - Hash :id mandatory, :since_version optional
+    #
+    # Examples
+    #
+    # get_events_for_criteria([ { id: "23232323"}, { id: "2398429834", since_version: 4 } ] )
+    #
+    # Returns Hash with id as key and Array of Event instances as value
+    def get_events(criteria)
+      return {} if criteria.empty?
+
+      query_items = criteria.map do |item|
+        raise ArgumentError.new(":id missing from criteria") unless item[:id]
+        item_query = { '_entity_id' => BSON::ObjectId.from_string(item[:id]) }
+        item_query['entity_version'] = { '$gt' => item[:since_version] } if item[:since_version]
+        item_query
+      end
+
+      query = { '$or' => query_items }
+
+      result = Hash[ criteria.map { |item| [ item[:id], [] ] } ]
+
+      events.find(query).each do |attrs|
+        result[attrs['_entity_id'].to_s] << attrs
+      end
+
+      result.each do |id, events|
+        # Have to do the sort client side as otherwise the query will not use
+        # indexes (http://docs.mongodb.org/manual/reference/operator/query/or/#or-and-sort-operations)
+        events.sort_by! { |attrs| [attrs['entity_version'], attrs['_id'].to_s] }
+
+        # Convert the attributes into event objects
+        events.map! do |attrs|
+          begin
+            EntityStore::Config.load_type(attrs['_type']).new(attrs)
+          rescue => e
+            log_error "Error loading type #{attrs['_type']}", e
+            nil
+          end
+        end
+
+        events.compact!
+      end
+
+      result
+    end
+  end
+end

data/lib/mongo_entity_store/version.rb

@@ -0,0 +1,3 @@
+module EntityStoreMongo
+  VERSION = "0.1.0".freeze
+end

data/lib/mongo_entity_store.rb

@@ -0,0 +1,4 @@
+module EntityStore
+  require_relative 'mongo_entity_store/mongo_entity_store'
+  require_relative 'mongo_entity_store/external_store'
+end

data/spec/mongo_entity_store/external_store_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+class DummyEvent
+  include Event
+  attr_accessor :name
+end
+
+class DummyEventTwo
+  include Event
+  attr_accessor :name
+end
+
+describe ExternalStore do
+  before(:each) do
+    ExternalStore.connection_profile = "mongodb://localhost/external_store_default"
+    ExternalStore.new.collection.drop
+    @store = ExternalStore.new
+  end
+  describe "#add_event" do
+    before(:each) do
+      @entity_type = random_string
+      @event = DummyEvent.new(:name => random_string, :entity_id => random_object_id)
+    end
+
+    subject { @store.add_event(@entity_type, @event) }
+
+    it "creates a record in the collection" do
+      subject
+      item = @store.collection.find_one
+      item['_entity_type'].should eq(@entity_type)
+      item['_type'].should eq(@event.class.name)
+      item['name'].should eq(@event.name)
+      item['entity_id'].should eq(@event.entity_id)
+    end
+  end
+
+  describe "#get_events" do
+    before(:each) do
+      @reference_time = Time.now
+      @ids = (-2..2).collect { |i| BSON::ObjectId.from_time(@reference_time + i) }
+
+      @store.collection.insert({'_id' => @ids[0], '_type' => 'DummyEvent'})
+      @store.collection.insert({'_id' => @ids[1], '_type' => 'DummyEventTwo'})
+      @store.collection.insert({'_id' => @ids[2], '_type' => 'DummyEvent'})
+      @store.collection.insert({'_id' => @ids[3], '_type' => 'DummyEventTwo'})
+      @store.collection.insert({'_id' => @ids[4], '_type' => 'DummyEvent'})
+    end
+
+    subject { @store.get_events @since, @type }
+
+    context "when time passed as since" do
+      before(:each) do
+        @since = @reference_time
+      end
+      context "when no type filter" do
+        before(:each) do
+          @type = nil
+          @results = subject
+        end
+        it "returns two records" do
+          @results.count.should eq(2)
+        end
+        it "it returns the 4th item first" do
+          @results.first.id.should eq(@ids[3].to_s)
+        end
+        it "it returns the 5th item second" do
+          @results[1].id.should eq(@ids[4].to_s)
+        end
+      end
+      context "when type filter 'DummyEventTwo' passed" do
+        before(:each) do
+          @type = "DummyEventTwo"
+          @results = subject
+        end
+        it "returns 1 record" do
+          @results.count.should eq(1)
+        end
+        it "returns the 4th item" do
+          @results.first.id.should eq(@ids[3].to_s)
+        end
+      end
+    end
+
+    context "when id passed as since" do
+      before(:each) do
+        @since = @ids[1].to_s
+      end
+      context "when no type filter passed" do
+        before(:each) do
+          @type = nil
+          @results = subject
+        end
+        it "returns 3 records" do
+          @results.count.should eq(3)
+        end
+        it "it returns the 3rd item first" do
+          @results.first.id.should eq(@ids[2].to_s)
+        end
+        it "it returns the 4th item second" do
+          @results[1].id.should eq(@ids[3].to_s)
+        end
+        it "it returns the 5th item second" do
+          @results[2].id.should eq(@ids[4].to_s)
+        end
+      end
+      context "when type filter 'DummyEvent' passed" do
+        before(:each) do
+          @type = "DummyEvent"
+          @results = subject
+        end
+        it "returns 2 records" do
+          @results.count.should eq(2)
+        end
+        it "returns the 3rd item" do
+          @results.first.id.should eq(@ids[2].to_s)
+        end
+        it "returns the 5th item" do
+          @results[1].id.should eq(@ids[4].to_s)
+        end
+      end
+    end
+  end
+
+end

data/spec/mongo_entity_store/mongo_entity_store_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe MongoEntityStore do
+  class DummyEntity
+    include EntityStore::Entity
+
+    attr_accessor :name, :description
+
+    def set_name(new_name)
+      record_event DummyEntityNameSet.new(name: new_name)
+    end
+  end
+
+  class DummyEntityWithSnapshotKey < DummyEntity
+    def self.entity_store_snapshot_key
+      @entity_store_snapshot_key ||= 1
+    end
+
+    def self.increment_entity_store_snapshot_key!
+      @entity_store_snapshot_key = entity_store_snapshot_key + 1
+    end
+  end
+
+  class DummyEntityNameSet
+    include EntityStore::Event
+
+    attr_accessor :name
+
+    def apply(entity)
+      entity.name = self.name
+    end
+
+    def ==(other)
+      # Crude check relying on inspect, ok for tests
+      self.inspect == other.inspect
+    end
+  end
+
+  let(:store) do
+    MongoEntityStore.connection_profile = "mongodb://localhost/entity_store_default"
+    MongoEntityStore.new
+  end
+
+  describe "event storage" do
+    let(:entity_id) { random_object_id }
+
+    let(:first_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 1, :name => random_string) }
+    let(:second_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 2, :name => random_string) }
+    let(:third_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 2, :name => random_string) }
+    let(:unrelated_event) { DummyEntityNameSet.new(:entity_id => random_object_id, :entity_version => 4, :name => random_string) }
+    let(:fourth_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 3, :name => random_string) }
+
+    before do
+      store.add_events([ second_event, unrelated_event, first_event, third_event, fourth_event ])
+    end
+
+    subject { store.get_events( [{ id: event_entity_id, since_version: since_version }])[event_entity_id] }
+
+    context "all events" do
+      let(:event_entity_id) { entity_id }
+      let(:since_version) { 0 }
+
+      it "should return the four events in order" do
+        subject.should == [first_event, second_event, third_event, fourth_event]
+      end
+    end
+
+    context "subset of events" do
+      let(:event_entity_id) { entity_id }
+      let(:since_version) { second_event.entity_version }
+
+      it "should only include events greater than the given version" do
+        subject.should == [ fourth_event ]
+      end
+    end
+
+    context "no events" do
+      let(:event_entity_id) { random_object_id }
+      let(:since_version) { 0 }
+
+      it "should return an empty array" do
+        subject.should be_empty
+      end
+    end
+  end
+
+  describe "#clear_entity_events" do
+    let(:entity_id) { random_object_id }
+    let(:second_entity_id) { random_object_id }
+
+    let(:first_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 1, :name => random_string) }
+    let(:second_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 2, :name => random_string) }
+    let(:third_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 2, :name => random_string) }
+    let(:unrelated_event) { DummyEntityNameSet.new(:entity_id => second_entity_id, :entity_version => 4, :name => random_string) }
+    let(:fourth_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 3, :name => random_string) }
+
+    before do
+      store.add_events([ second_event, unrelated_event, first_event, third_event, fourth_event ])
+    end
+
+    subject { store.clear_entity_events(entity_id, []) }
+
+    it "clears the events from the entity" do
+      subject
+      events = store.get_events( [ id: entity_id ])[entity_id]
+      expect(events).to be_empty
+    end
+
+    it "does not delete unrelated the events" do
+      subject
+      events = store.get_events( [ id: second_entity_id ])[second_entity_id]
+      expect(events.count).to eq(1)
+    end
+  end
+
+  describe "#get_entities" do
+    let(:entity_class) { DummyEntity }
+
+    let(:saved_entity) do
+      entity = entity_class.new(:name => random_string, :description => random_string)
+      entity.id = store.add_entity(entity)
+      entity
+    end
+
+    let(:id) { saved_entity.id }
+    let(:options) { { } }
+
+    subject { store.get_entities( [ id ], options) }
+
+    it "should retrieve an entity from the store with the same ID" do
+      subject.first.id.should == saved_entity.id
+    end
+
+    it "should retrieve an entity from the store with the same class" do
+      subject.first.class.should == saved_entity.class
+    end
+
+    it "should have the same version" do
+      subject.first.version.should == saved_entity.version
+    end
+
+    context "when a snapshot does not exist" do
+      it "should not have set the name" do
+        subject.first.name.should be_nil
+      end
+    end
+
+    context "when a snapshot exists" do
+      before do
+        saved_entity.version = 10
+        store.snapshot_entity(saved_entity)
+      end
+
+      context "when a snapshot key not in use" do
+        it "should have set the name" do
+          subject.first.name.should == saved_entity.name
+        end
+      end
+
+      context "when a snapshot key is in use" do
+        let(:entity_class) { DummyEntityWithSnapshotKey }
+
+        context "when the key matches the class's key" do
+          it "should have set the name" do
+            subject.first.name.should == saved_entity.name
+          end
+        end
+
+        context "when the key does not match the class's key" do
+          before do
+            entity_class.increment_entity_store_snapshot_key!
+          end
+
+          it "should ignore the invalidated snapshot" do
+            subject.first.name.should be_nil
+          end
+        end
+      end
+    end
+
+    describe "context when enable exceptions" do
+      let(:options) do
+        { raise_exception: true }
+      end
+
+      context "when invalid id format passed" do
+        let(:id) { random_string }
+
+        it "should raise not found" do
+          expect { subject }.to raise_error(NotFound)
+        end
+      end
+    end
+
+  end
+
+  describe "#snapshot_entity" do
+    let(:entity_class) { DummyEntity }
+
+    let(:entity) do
+      entity_class.new(:id => random_object_id, :version => random_integer, :name => random_string)
+    end
+
+    let(:saved_entity) do
+      store.entities.find_one({'_id' => BSON::ObjectId.from_string(entity.id)})
+    end
+
+    subject { store.snapshot_entity(entity) }
+
+    it "should add a snaphot to the entity record" do
+      subject
+      snapshot = saved_entity['snapshot']
+
+      snapshot['id'].should eq(entity.id)
+      snapshot['version'].should eq(entity.version)
+      snapshot['name'].should eq(entity.name)
+      snapshot['description'].should eq(entity.description)
+    end
+
+    context "entity with snapshot key" do
+      let(:entity_class) { DummyEntityWithSnapshotKey }
+
+      it "should store the snapshot key" do
+        subject
+        saved_entity['snapshot_key'].should == entity.class.entity_store_snapshot_key
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'rake'
+require 'rspec'
+require 'mongo'
+require 'hatchet'
+
+require "#{Rake.application.original_dir}/lib/mongo_entity_store"
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+include EntityStore
+
+Hatchet.configure do |config|
+  config.level :fatal
+  config.formatter = Hatchet::SimpleFormatter.new
+  config.appenders << Hatchet::LoggerAppender.new do |appender|
+    appender.logger = Logger.new(STDOUT)
+  end
+end
+include Hatchet
+
+EntityStore::Config.logger = log
+
+def random_string
+  (0...24).map{ ('a'..'z').to_a[rand(26)] }.join
+end
+
+def random_integer
+  rand(9999)
+end
+
+def random_time
+  Time.now - random_integer
+end
+
+def random_object_id
+  BSON::ObjectId.from_time(random_time, :unique => true).to_s
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: mongo_entity_store
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Bird
+- Stepheb Binns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: entity_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: bson
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: hatchet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Event sourced entity store with a mongo body
+email: adam.bird@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongo_entity_store.rb
+- lib/mongo_entity_store/external_store.rb
+- lib/mongo_entity_store/mongo_entity_store.rb
+- lib/mongo_entity_store/version.rb
+- spec/mongo_entity_store/external_store_spec.rb
+- spec/mongo_entity_store/mongo_entity_store_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/cronogy/mongo_entity_store
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Event sourced entity store with a mongo body
+test_files:
+- spec/spec_helper.rb
+- spec/mongo_entity_store/external_store_spec.rb
+- spec/mongo_entity_store/mongo_entity_store_spec.rb