rails_event_store 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 55f134f7a328395f2aaaee363409e3174c781ced
+  data.tar.gz: c0a7f0ac41fbe5688cc0407cd3ed07a62437d9f1
+SHA512:
+  metadata.gz: fae4e8a9c0f3d414720795c557e7a6c2647b6d5b28f2197eba9715d54579b4028b063d6ed8a357055a158c1d694c71a1e0238f03fa8687d6251061101671019a
+  data.tar.gz: d4336f83e8c4a6e366ccb9e9e2f0a2c2deb545e766f21446354460fb92b288ec7e4129d8e03063cad436b64c78a18586c75c42536e8618fd2fe54d180cd1e2c8

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.1.5
+
+before_install: gem install bundler
+
+gemfile:
+  Gemfile
+
+script: bundle exec rspec

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,111 @@
+# EventStore
+
+A Ruby implementation of an EventStore based on Active Record.
+
+## Installation
+
+* Add following line to your application's Gemfile:
+
+```ruby
+gem 'rails_event_store'
+```
+
+* Use provided task to generate a table to store events in you DB.
+
+```ruby
+rails generate rails_event_store:migrate
+rake db:migrate
+```
+
+## Usage
+
+To communicate with ES you have to create instance of `RailsEventStore::Client` class.
+
+```ruby
+client = RailsEventStore::Client.new
+```
+
+#### Creating new event
+
+Firstly you have to define own event model extending `RailsEventStore::Event` class.
+
+```ruby
+class OrderCreated < RailsEventStore::Event
+end
+```
+
+```ruby
+stream_name = "order_1"
+event_data = {
+               data: { data: "sample" },
+               event_id: "b2d506fd-409d-4ec7-b02f-c6d2295c7edd"
+             }
+event = OrderCreated.new(event_data)
+
+#publishing event for specific stream
+client.publish_event(event, stream_name)
+
+#publishing global event. In this case stream_name is 'all'.
+client.publish_event(event)
+```
+
+#### Creating new event with optimistic locking:
+
+```ruby
+class OrderCreated < RailsEventStore::Event
+end
+```
+
+```ruby
+stream_name = "order_1"
+event_data = {
+               data: { data: "sample" },
+               event_id: "b2d506fd-409d-4ec7-b02f-c6d2295c7edd"
+             }
+event = OrderCreated.new(event_data)
+expected_version = "850c347f-423a-4158-a5ce-b885396c5b73" #last event_id
+client.publish_event(event, stream_name, expected_version)
+```
+
+#### Reading stream's events forward in batch
+
+```ruby
+stream_name = "order_1"
+start = 1
+count = 40
+client.read_all_events(stream_name, start, count)
+```
+
+#### Reading all events from stream forward
+
+This method allows us to load all stream's events ascending.
+
+```ruby
+stream_name = "order_1"
+client.read_all_events(stream_name)
+```
+
+#### Reading all events forward
+
+This method allows us to load all stored events ascending.
+
+```ruby
+client.read_all_streams
+```
+
+#### Subscribing to events
+
+To listen on specific events synchronously you have to create subscriber reprezentation. The only requirement is that subscriber class has to implement the 'handle_event(event)' method.
+
+```ruby
+class InvoiceReadModel
+	def handle_event(event)
+		#we deal here with event's data
+	end
+end
+```
+
+```ruby
+invoice = InvoiceReadModel.new
+client.subscribe(invoice, ['PriceChanged', 'ProductAdded'])
+```

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler/gem_tasks'
+
+

data/lib/rails_event_store.rb

@@ -0,0 +1,14 @@
+require 'rails_event_store/event_entity'
+require 'rails_event_store/generators/migrate_generator'
+require 'rails_event_store/generators/templates/migration_template'
+require 'rails_event_store/version'
+require 'rails_event_store/event'
+require 'rails_event_store/repositories/event_repository'
+require 'rails_event_store/actions/append_event_to_stream'
+require 'rails_event_store/actions/read_all_events'
+require 'rails_event_store/actions/read_events_batch'
+require 'rails_event_store/actions/delete_stream_events'
+require 'rails_event_store/actions/read_all_streams'
+require 'rails_event_store/pub_sub/broker'
+require 'rails_event_store/errors'
+require 'rails_event_store/client'

data/lib/rails_event_store/actions/append_event_to_stream.rb

@@ -0,0 +1,34 @@
+module RailsEventStore
+  module Actions
+    class AppendEventToStream
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call(stream_name, event, expected_version)
+        raise WrongExpectedEventVersion if version_incorrect?(stream_name, expected_version)
+        event.validate!
+        save_event(event, stream_name)
+        return event
+      end
+
+      private
+      attr_reader :repository
+
+      def version_incorrect?(stream_name, expected_version)
+        unless expected_version.nil?
+          find_last_event_version(stream_name) != expected_version
+        end
+      end
+
+      def find_last_event_version(stream_name)
+        repository.last_stream_event(stream_name).event_id
+      end
+
+      def save_event(event, stream_name)
+        repository.create(event.to_h.merge!(stream: stream_name))
+      end
+    end
+  end
+end

data/lib/rails_event_store/actions/delete_stream_events.rb

@@ -0,0 +1,23 @@
+module RailsEventStore
+  module Actions
+    class DeleteStreamEvents
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call(stream_name)
+        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+        delete_stream(stream_name)
+      end
+
+      private
+      attr_reader :repository
+
+      def delete_stream(stream_name)
+        repository.delete({stream: stream_name})
+      end
+    end
+  end
+end
+

data/lib/rails_event_store/actions/read_all_events.rb

@@ -0,0 +1,22 @@
+module RailsEventStore
+  module Actions
+    class ReadAllEvents
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call(stream_name)
+        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+        get_all_events(stream_name)
+      end
+
+      private
+      attr_reader :repository
+
+      def get_all_events(stream_name)
+        repository.load_all_events_forward(stream_name)
+      end
+    end
+  end
+end

data/lib/rails_event_store/actions/read_all_streams.rb

@@ -0,0 +1,21 @@
+module RailsEventStore
+  module Actions
+    class ReadAllStreams
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call
+        get_all_events.group_by { |event| event.stream }
+      end
+
+      private
+      attr_reader :repository
+
+      def get_all_events
+        repository.get_all_events
+      end
+    end
+  end
+end

data/lib/rails_event_store/actions/read_events_batch.rb

@@ -0,0 +1,29 @@
+module RailsEventStore
+  module Actions
+    class ReadEventsBatch
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call(stream_name, start, count)
+        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+        event = find_event(start)
+        get_events_batch(stream_name, event.id, count)
+      end
+
+      private
+      attr_reader :repository
+
+      def get_events_batch(stream_name, start, count)
+        repository.load_events_batch(stream_name, start, count)
+      end
+
+      def find_event(start)
+        event = repository.find({event_id: start})
+        raise EventNotFound if event.nil?
+        event
+      end
+    end
+  end
+end

data/lib/rails_event_store/client.rb

@@ -0,0 +1,39 @@
+module RailsEventStore
+  class Client
+
+    def initialize(repository = Repositories::EventRepository.new)
+      @repository = repository
+    end
+
+    def publish_event(event_data, stream_name = 'all', expected_version = nil)
+      event = Actions::AppendEventToStream.new(@repository).call(stream_name, event_data, expected_version)
+      event_broker.notify_subscribers(event)
+    end
+
+    def delete_stream(stream_name)
+      Actions::DeleteStreamEvents.new(@repository).call(stream_name)
+    end
+
+    def read_events(stream_name, start, count)
+      Actions::ReadEventsBatch.new(@repository).call(stream_name, start, count)
+    end
+
+    def read_all_events(stream_name)
+      Actions::ReadAllEvents.new(@repository).call(stream_name)
+    end
+
+    def read_all_streams
+      Actions::ReadAllStreams.new(@repository).call
+    end
+
+    def subscribe(subscriber, event_types = [])
+      event_broker.add_subscriber(subscriber, event_types)
+    end
+
+    private
+
+    def event_broker
+      @event_broker ||= PubSub::Broker.new
+    end
+  end
+end

data/lib/rails_event_store/errors.rb

@@ -0,0 +1,8 @@
+module RailsEventStore
+  WrongExpectedEventVersion  = Class.new(StandardError)
+  IncorrectStreamData        = Class.new(StandardError)
+  EventCannotBeSaved         = Class.new(StandardError)
+  EventNotFound              = Class.new(StandardError)
+  SubscriberNotExist         = Class.new(StandardError)
+  MethodNotDefined           = Class.new(StandardError)
+end

data/lib/rails_event_store/event.rb

@@ -0,0 +1,44 @@
+require 'securerandom'
+
+module RailsEventStore
+  class Event
+
+    def initialize(event_data)
+      @event_type = event_data.fetch(:event_type, event_name)
+      @event_id = event_data.fetch(:event_id, generate_id).to_s
+      @metadata = event_data.fetch(:metadata, nil)
+      @data = event_data.fetch(:data, nil)
+    end
+
+    attr_reader :event_type, :event_id, :metadata, :data
+
+    def validate!
+      [event_type, event_id, data].each do |attribute|
+        raise IncorrectStreamData if is_invalid?(attribute)
+      end
+    end
+
+    def to_h
+      {
+          event_type: event_type,
+          event_id: event_id,
+          metadata: metadata,
+          data: data
+      }
+    end
+
+    private
+
+    def is_invalid?(attribute)
+      attribute.nil? || attribute.empty?
+    end
+
+    def generate_id
+      SecureRandom.uuid
+    end
+
+    def event_name
+      self.class.name
+    end
+  end
+end

data/lib/rails_event_store/event_entity.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+module RailsEventStore
+  class EventEntity < ActiveRecord::Base
+    self.primary_key = :id
+    self.table_name = 'event_store_events'
+    serialize :metadata
+    serialize :data
+    validates_uniqueness_of :event_id
+  end
+end

data/lib/rails_event_store/generators/migrate_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+
+module RailsEventStore
+  class MigrateGenerator < Rails::Generators::Base
+    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
+
+    def create_migration
+      template "migration_template.rb", "db/migrate/#{timestamp}_create_events_table.rb"
+    end
+
+    private
+
+    def timestamp
+      Time.now.strftime("%Y%m%d%H%M%S")
+    end
+
+  end
+end

data/lib/rails_event_store/generators/templates/migration_template.rb

@@ -0,0 +1,19 @@
+class CreateEventsTable < ActiveRecord::Migration
+
+  def self.up
+    create_table(:event_store_events) do |t|
+      t.string      :stream,      null: false
+      t.string      :event_type,  null: false
+      t.string      :event_id,    null: false
+      t.text        :metadata
+      t.text        :data,        null: false
+      t.timestamps
+    end
+    add_index :event_store_events, :stream
+    add_index :event_store_events, :event_id
+  end
+
+  def self.down
+    drop_table :event_store_events
+  end
+end

data/lib/rails_event_store/pub_sub/broker.rb

@@ -0,0 +1,33 @@
+module RailsEventStore
+  module PubSub
+    class Broker
+
+      def initialize
+        @subscribers = {}
+      end
+
+      def add_subscriber(subscriber, event_types)
+        raise SubscriberNotExist  if subscriber.nil?
+        raise MethodNotDefined    unless subscriber.methods.include? :handle_event
+        subscribe(subscriber, [*event_types])
+      end
+
+      def notify_subscribers(event)
+        if subscribers.key? event.event_type
+          subscribers[event.event_type].each do |subscriber|
+            subscriber.handle_event(event)
+          end
+        end
+      end
+
+      private
+      attr_reader :subscribers
+
+      def subscribe(subscriber, event_types)
+        event_types.each do |type|
+          (subscribers[type] ||= []) << subscriber
+        end
+      end
+    end
+  end
+end

data/lib/rails_event_store/repositories/event_repository.rb

@@ -0,0 +1,54 @@
+module RailsEventStore
+  module Repositories
+    class EventRepository
+
+      def initialize(adapter = EventEntity)
+        @adapter = adapter
+      end
+      attr_reader :adapter
+
+      def find(condition)
+        adapter.where(condition).first
+      end
+
+      def create(data)
+        model = adapter.new(data)
+        raise EventCannotBeSaved unless model.valid?
+        model.save
+      end
+
+      def delete(condition)
+        adapter.destroy_all condition
+      end
+
+      def get_all_events
+        adapter.find(:all, order: 'stream').map &method(:map_record)
+      end
+
+      def last_stream_event(stream_name)
+        adapter.where(stream: stream_name).last.map &method(:map_record)
+      end
+
+      def load_all_events_forward(stream_name)
+        adapter.where(stream: stream_name).order('id ASC').map &method(:map_record)
+      end
+
+      def load_events_batch(stream_name, start_point, count)
+        adapter.where('id >= ? AND stream = ?', start_point, stream_name).limit(count).map &method(:map_record)
+      end
+
+      private
+
+      def map_record(record)
+        event_data = {
+            stream:     record.stream,
+            event_type: record.event_type,
+            event_id:   record.event_id,
+            metadata:   record.metadata,
+            data:       record.data
+        }
+        OpenStruct.new(event_data)
+      end
+    end
+  end
+end

data/lib/rails_event_store/version.rb

@@ -0,0 +1,3 @@
+module RailsEventStore
+  VERSION = '0.1.1'
+end

data/rails_event_store.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_event_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails_event_store'
+  spec.version       = RailsEventStore::VERSION
+  spec.authors       = ['rybex']
+  spec.email         = ['tomek.rybka@gmail.com']
+
+  spec.summary       = %q{Implementation of Event Store in Ruby}
+  spec.description   = %q{Implementation of Event Store in Ruby}
+  spec.homepage      = ''
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rails', '~> 4.2.1'
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: rails_event_store
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- rybex
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+description: Implementation of Event Store in Ruby
+email:
+- tomek.rybka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/rails_event_store.rb
+- lib/rails_event_store/actions/append_event_to_stream.rb
+- lib/rails_event_store/actions/delete_stream_events.rb
+- lib/rails_event_store/actions/read_all_events.rb
+- lib/rails_event_store/actions/read_all_streams.rb
+- lib/rails_event_store/actions/read_events_batch.rb
+- lib/rails_event_store/client.rb
+- lib/rails_event_store/errors.rb
+- lib/rails_event_store/event.rb
+- lib/rails_event_store/event_entity.rb
+- lib/rails_event_store/generators/migrate_generator.rb
+- lib/rails_event_store/generators/templates/migration_template.rb
+- lib/rails_event_store/pub_sub/broker.rb
+- lib/rails_event_store/repositories/event_repository.rb
+- lib/rails_event_store/version.rb
+- rails_event_store.gemspec
+homepage: ''
+licenses: []
+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.3
+signing_key: 
+specification_version: 4
+summary: Implementation of Event Store in Ruby
+test_files: []