akasha 0.4.0.pre.189 → 0.4.0.pre.200

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dee7c7f2fc76bfc5230f08b7bfb26c3f1affe7ddd61ae97f5ab867053a28a52
-  data.tar.gz: 547d35288fc58ee79bdc904b62c0ece3b61288b120dff57acc12dd7c803bc0ed
+  metadata.gz: 5188ceabcaec253c22b9e59ee21907a3288cb1105898d75a35afb2b365327f0a
+  data.tar.gz: eb5b504cb7305e06c081f1c0370bbf94d1bf299b26f2e8ca403e4c68b1827e5d
 SHA512:
-  metadata.gz: 4157d7302f8b2fdfdfc51f67680c6d3b7e62ac93ffb8cfdc45424d03a35badc3fdc3ceaa9dc8be407a671c204b3e12058e3d29b0945ea20c1040ce89519bb960
-  data.tar.gz: e524477a7662f28f1405a363a3bf8557b5de64672f65f8b77171540396ada3b5ee300eefbfc9b514c52dd1eee6c756aef6ac16f81d3c079fb5c7261e88578191
+  metadata.gz: 0198526485615fab2f0397391d8a1ca84b621fbf7e32633952c761fe48095db7557d359d4bf8f20e27632dddac6be2a11e08e109e185ef063259d11ca6ae540f
+  data.tar.gz: f29bae127e182faa83963e84bd653d70b4fb30a8a15053fc822895e19018f235cc7e2af1d3a2493d7ec78c826a6d647b58392ab4f686784319cdb6debd2e19f4

data/.rubocop.yml

@@ -17,3 +17,5 @@ Rails/Output:
   Enabled: false
 Style/FormatStringToken:
   Enabled: false
+Metrics/ParameterLists:
+  Max: 6

data/.travis.yml

@@ -10,7 +10,7 @@ cache: bundler
 before_install:
 - gem update --system
 - gem update bundler
-- bundle update
+- bundle update # This is a library, build with the latest dependencies.
 
 matrix:
   include:

data/CHANGELOG.md

@@ -1,42 +1,47 @@
 # Changelog
 
-## Version 0.4.0.edge3
+## Version 0.4.0.pre
 
-* Fixed issue for passsing Handlers to EventRouter via constructor, when they aren't wrapped in array.
-
-## Version 0.4.0.edge2
+* Support for optimistic concurrency for commands. Enabled by default, will raise `ConflictError` if the aggregate
+  handling a command is modified by another process. Will internally retry the command up to 2 times before giving up.
+  See `OptimisticTransactor` for a list of available options you can pass to `CommandRouter#route!`. [#17](https://github.com/bilus/akasha/pull/17)
 
 * Control the maximum number of retries in case of network related failures. [#14](https://github.com/bilus/akasha/pull/14)
-  Example:
 
+  Example:
    ```ruby
    store = Akasha::Storage::HttpEventStore.new(..., max_retries: 10)
    ```
 
-
-## Version 0.4.0.edge1
-
 * Optional namespacing for aggregate/projection streams and events allowing for isolation
   between applications. [#12](https://github.com/bilus/akasha/pull/12)
+
 * Fix Unhandled events in stream break aggregate loading. [Issue #5](https://github.com/bilus/akasha/issues/5)
 
+* Fixed issue for passsing Handlers to EventRouter via constructor, when they are not wrapped in array. [#15](https://github.com/bilus/akasha/pull/15)
+
 
 ## Version 0.3.0
 
 * Asynchronous event listeners (`AsyncEventRouter`). [#9](https://github.com/bilus/akasha/pull/9)
+
 * Simplified initialization of event- and command routers. [#10](https://github.com/bilus/akasha/pull/10)
+
 * Remove dependency on the `http_event_store` gem.
+
 * `Event#metadata` is no longer OpenStruct. [#10](https://github.com/bilus/akasha/pull/10)
 
 ## Version 0.2.0
 
 * Synchronous event listeners (see `examples/sinatra/app.rb`). [#4](https://github.com/bilus/akasha/pull/4)
+
 * HTTP-based Eventstore storage. [#7](https://github.com/bilus/akasha/pull/7)
 
 
 ## Version 0.1.0
 
 * Cleaner syntax for adding events to changesets: `changeset.append(:it_happened, foo: 'bar')`. [#1](https://github.com/bilus/akasha/pull/1)
+
 * Support for command routing (`Akasha::CommandRouter`). [#2](https://github.com/bilus/akasha/pull/2)
 
 

data/README.md

@@ -47,8 +47,15 @@ This library itself makes no assumptions about any web framework, you can use it
   - [x] Faster shutdown
 - [x] Namespacing for events and aggregates and the projection
 - [x] Way to control the number of retries in face of network failures
-- [ ] Version-based concurrency
-- [ ] Telemetry (Dogstatsd)
+- [x] Version-based concurrency
+  - [x] Retries.
+- [ ] Documentation
+  - [ ] Yard docs on github pages
+  - [ ] Quick start
+  - [ ] Movie theater booking
+- [ ] User-defined ConflictResolver.
+- [ ] Snapshots
+- [ ] Telemetry (configurable backend, default: Dogstatsd)
 - [ ] Socket-based Eventstore storage backend
 
 

data/lib/akasha.rb

@@ -1,4 +1,6 @@
+require 'akasha/exceptions'
 require 'akasha/event'
+require 'akasha/recorded_event'
 require 'akasha/aggregate'
 require 'akasha/command_router'
 require 'akasha/event_listener'

data/lib/akasha/aggregate.rb

@@ -19,9 +19,10 @@ module Akasha
   class Aggregate
     include SyntaxHelpers
 
-    attr_reader :changeset
+    attr_reader :changeset, :revision
 
     def initialize(id)
+      @revision = -1 # No stream exists.
       @changeset = Changeset.new(id)
     end
 
@@ -30,8 +31,9 @@ module Akasha
     def apply_events(events)
       events.each do |event|
         method_name = event_handler(event)
-        send(method_name, event.data) if respond_to?(method_name)
+        public_send(method_name, event.data) if respond_to?(method_name)
       end
+      @revision = events.last&.revision.to_i
     end
 
     private

data/lib/akasha/aggregate/syntax_helpers.rb

@@ -37,9 +37,9 @@ module Akasha
     # Aggregate instance methods.
     module InstanceMethods
       # Saves the aggregate.
-      def save!
+      def save!(concurrency: :none)
         return if changeset.empty?
-        self.class.repository.save_aggregate(self)
+        self.class.repository.save_aggregate(self, concurrency: concurrency)
         changeset.clear!
       end
     end

data/lib/akasha/checkpoint/http_event_store_checkpoint.rb

@@ -2,9 +2,6 @@ module Akasha
   module Checkpoint
     # Stores stream position via HTTP Eventstore API.
     class HttpEventStoreCheckpoint
-      Error = Class.new(RuntimeError)
-      StreamNotFoundError = Class.new(Error)
-
       # Creates a new checkpoint, storing position in `stream` every `interval` events.
       # Use `interval` greater than zero for idempotent event listeners.
       def initialize(stream, interval: 1)
@@ -31,7 +28,7 @@ module Akasha
         @next_position
       rescue Akasha::Storage::HttpEventStore::HttpClientError => e
         raise if e.status_code != 404
-        raise StreamNotFoundError, "Stream cannot be checkpointed; it does not exist: #{@stream.name}"
+        raise CheckpointStreamNotFoundError, "Stream cannot be checkpointed; it does not exist: #{@stream.name}"
       end
 
       protected

data/lib/akasha/command_router.rb

@@ -1,4 +1,4 @@
-require_relative 'command_router/default_handler'
+require_relative 'command_router/optimistic_transactor'
 require 'corefines/hash'
 
 module Akasha
@@ -6,40 +6,51 @@ module Akasha
   class CommandRouter
     using Corefines::Hash
 
-    # Raised when no corresponding target can be found for a command.
-    NotFoundError = Class.new(RuntimeError)
-
-    def initialize(routes = {})
-      @routes = routes.flat_map do |command, target|
-        if target.is_a?(Class)
-          { command => DefaultHandler.new(target) }
-        else
-          { command => target }
-        end
-      end
-    end
-
-    # Registers a custom route, specifying either a lambda or a block.
-    # If both lambda and block are specified, lambda takes precedence.
-    def register_route(command, lambda = nil, &block)
-      callable = lambda || block
-      @routes[command] = callable
+    def initialize(**routes)
+      @routes = routes
     end
 
-    # Registers a default route, mapping a command to an aggregate class.
-    # As a result, when `#route!` is called for that command, the aggregate
-    # will be loaded from repository, the command will be sent to the object
-    # to invoke the object's method, and finally the aggregate will be saved.
-    def register_default_route(command, aggregate_class)
-      register_route(command, DefaultHandler.new(aggregate_class))
+    # Registers a handler.
+    #
+    # As a result, when `#route!` is called for that command, the aggregate will be
+    # loaded from repository, the command will be sent to the object to invoke the
+    # object's method, and finally the aggregate will be saved.
+    def register(command, aggregate_class = nil, &block)
+      raise ArgumentError, 'Pass either aggregate class or block' if aggregate_class && block
+      handler = aggregate_class || block
+      @routes[command] = handler
     end
 
     # Routes a command to the registered target.
-    # Raises NotFoundError if no corresponding target can be found.
-    def route!(command, aggregate_id, **data)
+    # Raises `NotFoundError` if no corresponding target can be found.
+    #
+    # Arguments:
+    #   - command - name of the command
+    #   - aggregate_id - aggregate id
+    #   - options - flags:
+    #     - transactor - transactor instance to replace the default one (`OptimisticTransactor`);
+    #   See docs for `OptimisticTransactor` for a list of additional supported options.
+    def route!(command, aggregate_id, options = {}, **data)
       handler = @routes[command]
-      return handler.call(command, aggregate_id, **data) if handler
-      raise NotFoundError, "Target for command #{command.inspect} not found"
+      case handler
+      when Class
+        transactor = options.fetch(:transactor, default_transactor)
+        transactor.call(handler, command, aggregate_id, options, **data)
+      when handler.respond_to?(:call)
+        handler.call(command, aggregate_id, options, **data)
+      when Proc
+        handler.call(command, aggregate_id, options, **data)
+      when nil
+        raise HandlerNotFoundError, "Handler for command #{command.inspect} not found"
+      else
+        raise UnsupportedHandlerError, "Unsupported command handler #{handler.inspect}"
+      end
+    end
+
+    private
+
+    def default_transactor
+      OptimisticTransactor.new
     end
   end
 end

data/lib/akasha/command_router/optimistic_transactor.rb

@@ -0,0 +1,67 @@
+require 'retries'
+
+module Akasha
+  class CommandRouter
+    # Default command transactor providing optional optimistic concurrency.
+    # Works by loading aggregate from the repo by id, having it handle the command,
+    # and saving changes to the aggregate to the repository.
+    class OptimisticTransactor
+      # The default maximum number of retries when conflict is detected.
+      MAX_CONFLICT_RETRIES = 2
+      # A lower limit for a retry interval.
+      MIN_CONFLICT_RETRY_INTERVAL = 0
+      # An upper limit for a retry interval.
+      MAX_CONFLICT_RETRY_INTERVAL = 1
+
+      # Have an aggregate handle a command.
+      # - `aggregate_class` - aggregate class you want to handle the command,
+      # - `command` - command the aggregate will process, corresponding to a method of the aggregate class.
+      # - `aggregate_id` - id of the aggregate instance the command is for,
+      # - `options`:
+      #     - concurrency - `:optimistic` or `:none` (default: `:optimistic`);
+      #     - revision - set to aggregate revision to detect conflicts while saving
+      #       aggregates (requires `concurrency == :optimistic`); `nil` to just save
+      #       without concurrency control;
+      #     - max_conflict_retries - how many times to retry processing a command if a conflict
+      #       is detected (`ConflictError`); default: MAX_CONFLICT_RETRIES;
+      #     - min_conflict_retry_interval - minimum time to sleep between retries; default MIN_CO_RETRY_INTERVAL;
+      #     - max_conflict_retry_interval - maximum time to sleep between retries; default MIN_CO_RETRY_INTERVAL.
+      # - `data`- command payload.
+      def call(aggregate_class, command, aggregate_id, options, **data)
+        max_conflict_retries = options.fetch(:max_conflict_retries, MAX_CONFLICT_RETRIES)
+        min_conflict_retry_interval = options.fetch(:min_conflict_retry_interval, MIN_CONFLICT_RETRY_INTERVAL)
+        max_conflict_retry_interval = options.fetch(:max_conflict_retry_interval, MAX_CONFLICT_RETRY_INTERVAL)
+        with_retries(base_sleep_seconds: min_conflict_retry_interval, max_sleep_seconds: max_conflict_retry_interval,
+                     max_tries: 1 + max_conflict_retries, rescue: [Akasha::ConflictError]) do
+          handle_command(aggregate_class, command, aggregate_id, options, **data)
+        end
+      end
+
+      protected
+
+      def handle_command(aggregate_class, command, aggregate_id, options, **data)
+        concurrency, revision = parse_options!(options)
+        aggregate = aggregate_class.find_or_create(aggregate_id)
+        check_conflict!(aggregate, revision) if concurrency == :optimistic
+        aggregate.public_send(command, **data)
+        aggregate.save!(concurrency: concurrency)
+      end
+
+      private
+
+      def parse_options!(options)
+        concurrency = options[:concurrency] || :optimistic
+        revision = options[:revision]
+        if concurrency == :none && !revision.nil?
+          raise ArgumentError, "Unexpected revision #{revision.inspect} when concurrency set to #{concurrency.inspect}"
+        end
+        [concurrency, revision]
+      end
+
+      def check_conflict!(aggregate, revision)
+        return if revision.nil? || revision == aggregate.revision
+        raise StaleRevisionError, "Conflict detected; expected: #{revision} got: #{aggregate.revision}"
+      end
+    end
+  end
+end

data/lib/akasha/exceptions.rb

@@ -0,0 +1,56 @@
+module Akasha
+  # Base exception class for all Akasha errors.
+  Error = Class.new(RuntimeError)
+
+  ## Command routing errors
+
+  # Base exception class for errors related to routing commands.
+  CommandRoutingError = Class.new(Error)
+
+  # No corresponding target for a command.
+  HandlerNotFoundError = Class.new(CommandRoutingError)
+
+  # Type of the handler found for a command is not supported.
+  UnsupportedHandlerError = Class.new(CommandRoutingError)
+
+  ## Concurrency errors
+
+  # Base exception class for concurrency-related errors.
+  ConcurrencyError = Class.new(Error)
+
+  # Stale aggregate revision number passed with command.
+  # It typically means that another actor already updated the
+  # aggregate.
+  StaleRevisionError = Class.new(ConcurrencyError)
+
+  # Stream modified while processing a command.
+  ConflictError = Class.new(ConcurrencyError)
+
+  # Missing stream when saving checkpoint.
+  CheckpointStreamNotFoundError = Class.new(Error)
+
+  ## Storega errors
+
+  # Base class for all storage backend errors.
+  StorageError = Class.new(Error)
+
+  # Stream name contains invalid characters.
+  InvalidStreamNameError = Class.new(StorageError)
+
+  # Base class for HTTP errors.
+  class HttpError < StorageError
+    attr_reader :status_code, :response_headers
+
+    def initialize(env)
+      @status_code = env.status.to_i
+      @response_headers = env.response_headers
+      super("Unexpected HTTP response: #{@status_code}")
+    end
+  end
+
+  # 4xx HTTP status code.
+  HttpClientError = Class.new(HttpError)
+
+  # 5xx HTTP status code.
+  HttpServerError = Class.new(HttpError)
+end

data/lib/akasha/recorded_event.rb

@@ -0,0 +1,20 @@
+require_relative './event'
+
+module Akasha
+  # Event read from a stream.
+  class RecordedEvent < Event
+    attr_reader :revision, :updated_at
+
+    def initialize(name, id, revision, updated_at, metadata, **data)
+      super(name, id, metadata, **data)
+      @revision = revision
+      @updated_at = updated_at
+    end
+
+    def ==(other)
+      super(other) &&
+        @revision == other.revision &&
+        @updated_at.utc.iso8601 == other.updated_at.utc.iso8601
+    end
+  end
+end

data/lib/akasha/repository.rb

@@ -8,6 +8,8 @@ module Akasha
     STREAM_NAME_SEP = '-'.freeze
 
     # Creates a new repository using the underlying `store` (e.g. `MemoryEventStore`).
+    # - namespace - optional namespace allowing for multiple applications to share the same Eventstore
+    #               database without name conflicts
     def initialize(store, namespace: nil)
       @store = store
       @subscribers = []
@@ -30,10 +32,11 @@ module Akasha
     end
 
     # Saves an aggregate to the repository, appending events to the corresponding stream.
-    def save_aggregate(aggregate)
+    def save_aggregate(aggregate, concurrency: :none)
       changeset = aggregate.changeset
       events = changeset.events.map { |event| event.with_metadata(namespace: @namespace) }
-      stream(aggregate.class, changeset.aggregate_id).write_events(events)
+      revision = aggregate.revision if concurrency == :optimistic
+      stream(aggregate.class, changeset.aggregate_id).write_events(events, revision: revision)
       notify_subscribers(changeset.aggregate_id, events)
     end
 

data/lib/akasha/storage/http_event_store.rb

@@ -1,6 +1,5 @@
 require_relative 'http_event_store/client'
 require_relative 'http_event_store/stream'
-require_relative 'http_event_store/exceptions'
 
 module Akasha
   module Storage

data/lib/akasha/storage/http_event_store/client.rb

@@ -34,9 +34,9 @@ module Akasha
         end
 
         # Append events to stream, idempotently retrying_on_network_failures up to `max_retries`
-        def retry_append_to_stream(stream_name, events, expected_version = nil, max_retries: 0)
+        def retry_append_to_stream(stream_name, events, expected_revision = nil, max_retries: 0)
           retrying_on_network_failures(max_retries) do
-            append_to_stream(stream_name, events, expected_version)
+            append_to_stream(stream_name, events, expected_revision)
           end
         end
 
@@ -98,58 +98,58 @@ module Akasha
         end
 
         def auth_headers
-          if @username && @password
-            auth = Base64.urlsafe_encode64([@username, @password].join(':'))
-            {
-              'Authorization' => "Basic #{auth}"
-            }
-          else
-            {}
-          end
+          return {} unless @username && @password
+          auth = Base64.urlsafe_encode64([@username, @password].join(':'))
+          { 'Authorization' => "Basic #{auth}" }
         end
 
         def retrying_on_network_failures(max_retries)
-          with_retries(base_sleep_seconds: MIN_RETRY_INTERVAL,
-                       max_sleep_seconds: MAX_RETRY_INTERVAL,
+          with_retries(base_sleep_seconds: MIN_RETRY_INTERVAL, max_sleep_seconds: MAX_RETRY_INTERVAL,
                        max_tries: 1 + max_retries,
                        rescue: [Faraday::TimeoutError, Faraday::ConnectionFailed]) do
             yield
           end
         end
 
-        def append_to_stream(stream_name, events, _expected_version = nil)
+        def append_to_stream(stream_name, events, expected_revision)
           @conn.post("/streams/#{stream_name}") do |req|
             req.headers = {
               'Content-Type' => 'application/vnd.eventstore.events+json',
-              # 'ES-ExpectedVersion' => expected_version
+              'ES-ExpectedVersion' => expected_revision
             }
             req.body = to_event_data(events).to_json
           end
+        rescue HttpClientError => e
+          raise unless e.status_code == 400
+          actual_version = e.response_headers['ES-CurrentVersion']
+          raise Akasha::ConflictError,
+                "Race condition; expected last event version: #{expected_revision} actual: #{actual_version}"
         end
 
         def safe_read_events(stream_name, start, count, poll)
-          resp = @conn.get("/streams/#{stream_name}/#{start}/forward/#{count}") do |req|
-            req.headers = {
-              'Accept' => 'application/json'
-            }
-            req.headers['ES-LongPoll'] = poll if poll&.positive?
-            req.params['embed'] = 'body'
-          end
-          event_data = resp.body['entries']
-          to_events(event_data)
-        rescue HttpClientError => e
-          return [] if e.status_code == 404
-          raise
-        rescue URI::InvalidURIError
-          raise InvalidStreamNameError, "Invalid stream name: #{stream_name}"
+          handling_read_exceptions(stream_name) do
+            resp = @conn.get("/streams/#{stream_name}/#{start}/forward/#{count}") do |req|
+              req.headers = {
+                'Accept' => 'application/json'
+              }
+              req.headers['ES-LongPoll'] = poll if poll&.positive?
+              req.params['embed'] = 'body'
+            end
+            to_events(resp.body['entries'])
+          end || []
         end
 
         def safe_read_metadata(stream_name)
-          metadata = request(:get, "/streams/#{stream_name}/metadata", nil, 'Accept' => 'application/json')
-          metadata.symbolize_keys
+          handling_read_exceptions(stream_name) do
+            metadata = request(:get, "/streams/#{stream_name}/metadata", nil, 'Accept' => 'application/json')
+            metadata.symbolize_keys
+          end || {}
+        end
+
+        def handling_read_exceptions(stream_name)
+          yield
         rescue HttpClientError => e
-          return {} if e.status_code == 404
-          raise
+          raise unless e.status_code == 404
         rescue URI::InvalidURIError
           raise InvalidStreamNameError, "Invalid stream name: #{stream_name}"
         end

data/lib/akasha/storage/http_event_store/event_serializer.rb

@@ -24,7 +24,10 @@ module Akasha
           es_events.map do |ev|
             metadata = ev['metaData']&.symbolize_keys || {}
             data = ev['data']&.symbolize_keys || {}
-            event = Akasha::Event.new(ev['eventType'].to_sym, ev['eventId'], metadata, **data)
+            revision = ev['eventNumber']
+            updated_at = Time.iso8601(ev['updated']) if ev.key?('updated')
+            event = Akasha::RecordedEvent.new(ev['eventType'].to_sym, ev['eventId'], revision, updated_at,
+                                              metadata, **data)
             event
           end
         end

data/lib/akasha/storage/http_event_store/response_handler.rb

@@ -4,11 +4,11 @@ module Akasha
       # Handles responses from Eventstore HTTP API.
       class ResponseHandler < Faraday::Response::Middleware
         def on_complete(env)
-          case env[:status]
+          case env.status
           when (400..499)
-            raise HttpClientError, env.status
+            raise HttpClientError, env
           when (500..599)
-            raise HttpServerError, env.status
+            raise HttpServerError, env
           end
         end
       end

data/lib/akasha/storage/http_event_store/stream.rb

@@ -8,6 +8,7 @@ module Akasha
         # Create a stream object for accessing a ES stream.
         # Does not create the underlying stream itself.
         # Use the `max_retries` option to choose how many times to retry in case
+        # of network failures.
         def initialize(client, stream_name, max_retries: 0)
           @client = client
           @name = stream_name
@@ -15,10 +16,14 @@ module Akasha
         end
 
         # Appends `events` to the stream.
-        # of network failures.
-        def write_events(events)
+        # You can specify `revision` to use optimistic concurrency control:
+        #    - nil  - just append, no concurrency control,
+        #    - -1   - the stream doesn't exist,
+        #    - >= 0 - expected revision of the last event in stream.
+        def write_events(events, revision: nil)
           return if events.empty?
-          @client.retry_append_to_stream(@name, events, max_retries: @max_retries)
+          expected_version = revision.nil? ? -2 : revision
+          @client.retry_append_to_stream(@name, events, expected_version, max_retries: @max_retries)
         end
 
         # Reads events from the stream starting from `start` inclusive.

data/lib/akasha/storage/memory_event_store/stream.rb

@@ -12,8 +12,9 @@ module Akasha
         end
 
         # Appends events to the stream.
-        def write_events(events)
-          @events += @before_write.call(events)
+        def write_events(events, revision: nil)
+          check_revision!(revision)
+          @events += to_recorded_events(@events.size, @before_write.call(events))
         end
 
         # Reads events from the stream starting from `start` inclusive.
@@ -32,6 +33,22 @@ module Akasha
         def identity
           ->(x) { x }
         end
+
+        def check_revision!(expected_revision)
+          return if expected_revision.nil?
+          actual_revision = @events.size - 1
+          return if expected_revision == actual_revision
+          raise ConflictError,
+                "Race condition; expected last event version: #{expected_revision} actual: #{actual_revision}"
+        end
+
+        def to_recorded_events(current_revision, events)
+          events.each_with_index.map do |event, i|
+            updated_at = Time.now.utc # Cheating.
+            RecordedEvent.new(event.name, event.id, current_revision + i,
+                              updated_at, event.metadata, **event.data)
+          end
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: akasha
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.189
+  version: 0.4.0.pre.200
 platform: ruby
 authors:
 - Marcin Bilski
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-02 00:00:00.000000000 Z
+date: 2018-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corefines
@@ -227,16 +227,17 @@ files:
 - lib/akasha/changeset.rb
 - lib/akasha/checkpoint/http_event_store_checkpoint.rb
 - lib/akasha/command_router.rb
-- lib/akasha/command_router/default_handler.rb
+- lib/akasha/command_router/optimistic_transactor.rb
 - lib/akasha/event.rb
 - lib/akasha/event_listener.rb
 - lib/akasha/event_router.rb
 - lib/akasha/event_router_base.rb
+- lib/akasha/exceptions.rb
+- lib/akasha/recorded_event.rb
 - lib/akasha/repository.rb
 - lib/akasha/storage/http_event_store.rb
 - lib/akasha/storage/http_event_store/client.rb
 - lib/akasha/storage/http_event_store/event_serializer.rb
-- lib/akasha/storage/http_event_store/exceptions.rb
 - lib/akasha/storage/http_event_store/projection_manager.rb
 - lib/akasha/storage/http_event_store/response_handler.rb
 - lib/akasha/storage/http_event_store/stream.rb

data/lib/akasha/command_router/default_handler.rb

@@ -1,19 +0,0 @@
-module Akasha
-  class CommandRouter
-    # Default command handler.
-    # Works by loading aggregate from the repo by id,
-    # invoking its method `command`, passing all data,
-    # and saving changes to the aggregate in the end.
-    class DefaultHandler
-      def initialize(klass)
-        @klass = klass
-      end
-
-      def call(command, aggregate_id, **data)
-        aggregate = @klass.find_or_create(aggregate_id)
-        aggregate.public_send(command, **data)
-        aggregate.save!
-      end
-    end
-  end
-end

data/lib/akasha/storage/http_event_store/exceptions.rb

@@ -1,27 +0,0 @@
-module Akasha
-  module Storage
-    class HttpEventStore
-      # Base class for all HTTP Event store errors.
-      Error = Class.new(RuntimeError)
-
-      # Stream name contains invalid characters.
-      InvalidStreamNameError = Class.new(Error)
-
-      # Base class for HTTP errors.
-      class HttpError < Error
-        attr_reader :status_code
-
-        def initialize(status_code)
-          @status_code = status_code
-          super("Unexpected HTTP response: #{@status_code}")
-        end
-      end
-
-      # 4xx HTTP status code.
-      HttpClientError = Class.new(HttpError)
-
-      # 5xx HTTP status code.
-      HttpServerError = Class.new(HttpError)
-    end
-  end
-end