entity_store_sequel 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca75da75c0371ee57e8f87d2177691af50e1c231
+  data.tar.gz: a64bb369cb3b59e6fc065fdc209d4011499a8137
+SHA512:
+  metadata.gz: 8e31b881de426b9590058dfe63cbc877e1921da6560e93b00c43e8a4082ffe2b75567861bfb47b4f5628c987caa9a8379afa4f524e7eb106ce0c266c48b0aecb
+  data.tar.gz: 0a7a1d86c96dc4cabd20b4b85d2cff026c74ffd197a96705058081f15c37a161504aa15190b6fa386da3941de709dcb5f93f94e54141d7044d9d857147c5f550

data/lib/entity_store_sequel/postgres_entity_store.rb

@@ -0,0 +1,226 @@
+require 'sequel'
+require 'uri'
+require 'json'
+require 'pigeon_hole'
+require 'entity_store'
+
+module EntityStoreSequel
+  class PostgresEntityStore
+    include EntityStore::Logging
+
+    Sequel.extension :pg_array_ops
+    Sequel.extension :pg_json_ops
+
+    class << self
+      attr_accessor :connection_string
+      attr_writer :connect_timeout
+
+      def database
+        return @_database if @_database
+
+        @_database ||= Sequel.connect(connection_string)
+        @_database.extension :pg_array
+        @_database.extension :pg_json
+
+        @_database
+      end
+
+      def init
+        unless database.table_exists?(:entities)
+          database.create_table :entities do
+            column :id, :char, primary_key: true, size: 24
+            String :_type
+            integer :snapshot_key
+            integer :version
+            column :snapshot, :jsonb
+          end
+        end
+
+        unless database.table_exists?(:entity_events)
+          database.create_table :entity_events do
+            column :id, :char, primary_key: true, size: 24
+            String :_type
+            column :_entity_id, :char, size: 24
+            integer :entity_version
+            column :data, :jsonb
+          end
+        end
+      end
+    end
+
+    def open
+      PostgresEntityStore.database
+    end
+
+    def entities
+      @entities_collection ||= open[:entities]
+    end
+
+    def events
+      @events_collection ||= open[:entity_events]
+    end
+
+    def clear
+      open.drop_table(:entities, :entity_events)
+      @entities_collection = nil
+      @events_collection = nil
+    end
+
+    def ensure_indexes
+    end
+
+    def add_entity(entity, id = BSON::ObjectId.new)
+      entities.insert(:id => id.to_s, :_type => entity.class.name, :version => entity.version)
+      id.to_s
+    end
+
+    def save_entity(entity)
+      entities.where(:id => entity.id).update(:version => entity.version)
+    end
+
+    # Public: create a snapshot of the entity and store in the entities collection
+    #
+    def snapshot_entity(entity)
+      if entity.class.respond_to? :entity_store_snapshot_key
+        # If there is a snapshot key, store it too
+        snapshot_key = entity.class.entity_store_snapshot_key
+      else
+        # Otherwise, make sure there isn't one set
+        snapshot_key = nil
+      end
+
+      unless entities[:id => entity.id]
+        entities.insert(:id => entity.id, :_type => entity.class.name, :version => entity.version)
+      end
+
+      entities
+        .where(:id => entity.id)
+        .update(:snapshot => PigeonHole.generate(entity.attributes), :snapshot_key => snapshot_key )
+    end
+
+    # Public - remove the snapshot for an entity
+    #
+    def remove_entity_snapshot(id)
+      entities.where(:id => id).update(:snapshot => nil)
+    end
+
+    # Public: remove all snapshots
+    #
+    # type        - String optional class name for the entity
+    #
+    def remove_snapshots(type=nil)
+      if type
+        entities.where(:_type => type).update(:snapshot => nil)
+      else
+        entities.update(:snapshot => nil)
+      end
+    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)
+      event_id_map.each do |id, event|
+        doc = {
+          :id => id.to_s,
+          :_type => event.class.name,
+          :_entity_id => BSON::ObjectId.from_string(event.entity_id).to_s,
+          :entity_version => event.entity_version,
+          :data => PigeonHole.generate(event.attributes),
+        }
+        events.insert(doc)
+      end
+    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={})
+      ids.each 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.where(:id => 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
+            unless active_key == attrs[:snapshot_key]
+              attrs.delete(:snapshot)
+            end
+          end
+
+          if attrs[:snapshot]
+            hash = attrs[:snapshot].to_h
+            entity = entity_type.new(hash)
+          else
+            entity = entity_type.new({'id' => attrs[:id].to_s })
+          end
+        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?
+
+      result = {}
+
+      criteria.each do |item|
+        raise ArgumentError.new(":id missing from criteria") unless item[:id]
+
+        query = events.where(:_entity_id => item[:id])
+
+        if item[:since_version]
+          query = query.where('entity_version > ?', item[:since_version])
+        end
+
+        result[item[:id]] = query.order(:entity_version, :id).map do |attrs|
+          begin
+            hash = attrs[:data].to_h
+            hash[:entity_version] = attrs[:entity_version]
+            EntityStore::Config.load_type(attrs[:_type]).new(hash)
+          rescue => e
+            log_error "Error loading type #{attrs[:_type]}", e
+            next
+          end
+        end.compact
+      end
+
+      result
+    end
+  end
+end

data/lib/entity_store_sequel/version.rb

@@ -0,0 +1,3 @@
+module EntityStoreSequel
+  VERSION = "0.0.1".freeze
+end

data/lib/entity_store_sequel.rb

@@ -0,0 +1,3 @@
+module EntityStoreSequel
+  require_relative 'entity_store_sequel/postgres_entity_store'
+end

data/lib/sequel/core_ext.rb

@@ -0,0 +1,5 @@
+module Sequel
+  def self.parse_json(json)
+    PigeonHole.parse(json)
+  end
+end

data/lib/tasks/entity_store.rake

@@ -0,0 +1,11 @@
+require "#{Rake.application.original_dir}/lib/entity_store"
+
+namespace :entity_store_sequel do
+  task :drop_db do
+    EntityStore::PostgresEntityStore.new.clear
+  end
+
+  task :create_db do
+    EntityStore::PostgresEntityStore.init
+  end
+end

data/spec/entity_store_sequel/postgres_entity_store_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe PostgresEntityStore 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 DummyEntityWithDate
+    include EntityStore::Entity
+
+    attr_accessor :name, :description, :date, :symbol, :symbol_hash
+    attr_accessor :nested_hash
+
+    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
+    described_class.connection_string = ENV['SQL_CONNECTION'] || 'postgres://localhost/cronofy_test'
+    described_class.init
+    described_class.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 "#get_entities" do
+    let(:entity_class) { DummyEntityWithDate }
+    let(:entity_date) { random_time }
+
+    let(:saved_entity) do
+      entity = entity_class.new(
+        :name => random_string,
+        :description => random_string,
+        :date => entity_date,
+        :symbol => :foo,
+        :symbol_hash => { foo: :bar },
+        :nested_hash => { foo: { bar: :baz } },
+      )
+      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
+
+      it "should not have a date set" do
+        subject.first.date.should be_nil
+      end
+
+      it "should not have a symbol set" do
+        subject.first.symbol.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
+
+        it "should have a date set" do
+          subject.first.date.should == saved_entity.date
+        end
+
+        it "should have a symbol set" do
+          subject.first.symbol.should == :foo
+        end
+
+        it "should have a symbol hash set" do
+          subject.first.symbol_hash.should ==  { "foo" => :bar }
+          subject.first.nested_hash.should ==  { "foo" => { "bar" => :baz } }
+        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) { DummyEntityWithDate }
+
+    let(:entity) do
+      entity_class.new(:id => random_object_id, :version => random_integer, :name => random_string)
+    end
+
+    let(:saved_entity) do
+      store.entities.where(:id => entity.id).first
+    end
+
+    let(:snapshot) { saved_entity[:snapshot] }
+
+    subject { store.snapshot_entity(entity) }
+
+    it "should add a snaphot to the entity record" do
+      subject
+
+      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/entity_store_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class DummyEntity
+  include Entity
+
+  attr_accessor :name
+
+  def set_name(name)
+    record_event DummyEntityNameSet.new(name: name)
+  end
+end
+
+class DummyEntityNameSet
+  include Event
+
+  attr_accessor :name
+
+  def apply(entity)
+    entity.name = name
+  end
+end
+
+class DummyEntitySubscriber
+  class << self
+    attr_accessor :event_name
+  end
+
+  def dummy_entity_name_set(event)
+    DummyEntitySubscriber.event_name = event.name
+  end
+end
+
+describe "end to end" do
+  before(:each) do
+    PostgresEntityStore.connection_string = ENV['SQL_CONNECTION'] || 'postgres://localhost/cronofy_test'
+    PostgresEntityStore.init
+
+    EntityStore::Config.setup do |config|
+      config.store = PostgresEntityStore.new
+      config.event_subscribers << DummyEntitySubscriber
+    end
+  end
+
+  context "when save entity" do
+    let(:name) { random_string }
+    before(:each) do
+      @entity = DummyEntity.new
+      @entity.set_name name
+      @id = Store.new.save @entity
+    end
+
+    it "publishes event to the subscriber" do
+      DummyEntitySubscriber.event_name.should eq(name)
+    end
+    it "is retrievable with the events applied" do
+      EntityStore::Store.new.get(@entity.id).name.should eq(name)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rspec'
+require 'hatchet'
+require 'sequel'
+
+require "#{Rake.application.original_dir}/lib/entity_store_sequel"
+
+require_relative '../lib/sequel/core_ext'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+include EntityStore
+include EntityStoreSequel
+
+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.at(Time.now.to_i - random_integer)
+end
+
+def random_object_id
+  BSON::ObjectId.from_time(random_time, :unique => true).to_s
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: entity_store_sequel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stephen Binns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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: pg
+  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: sequel_pg
+  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: 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: pigeon_hole
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !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: Sequel body for Entity Store
+email: stephen@cronofy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/entity_store_sequel.rb
+- lib/entity_store_sequel/postgres_entity_store.rb
+- lib/entity_store_sequel/version.rb
+- lib/sequel/core_ext.rb
+- lib/tasks/entity_store.rake
+- spec/entity_store_sequel/postgres_entity_store_spec.rb
+- spec/entity_store_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/cronofy/entity_store_sequel
+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.6.6
+signing_key: 
+specification_version: 4
+summary: Sequel body for Entity Store
+test_files:
+- spec/entity_store_sequel/postgres_entity_store_spec.rb
+- spec/entity_store_spec.rb
+- spec/spec_helper.rb
+has_rdoc: