akasha 0.2.0 → 0.3.0

data/docker/docker-compose.yml

@@ -0,0 +1,17 @@
+version: '3'
+
+services:
+  eventstore:
+    image: eventstore/eventstore
+    environment:
+      - EVENTSTORE_MEM_DB="true"
+      - EVENTSTORE_START_STANDARD_PROJECTIONS="true"
+    expose:
+      - "2113"
+      - "1113"
+  tests:
+    build: ..
+    links:
+      - eventstore
+    environment:
+      -  EVENTSTORE_URL=http://admin:changeit@eventstore:2113

data/examples/sinatra/Gemfile

@@ -1,4 +1,4 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-gem 'sinatra'
-gem 'akasha'
+gem 'akasha', path: '../../'
+gem 'sinatra', '~>2', '>2.0.1'

data/examples/sinatra/Gemfile.lock

@@ -1,24 +1,46 @@
+PATH
+  remote: ../..
+  specs:
+    akasha (0.2.0)
+      corefines (~> 1.11)
+      faraday (~> 0.15)
+      faraday_middleware
+      rack (~> 2.0)
+      retries (~> 0.0)
+      typhoeus (~> 1.3)
+
 GEM
   remote: https://rubygems.org/
   specs:
-    akasha (0.1.0)
+    corefines (1.11.0)
+    ethon (0.11.0)
+      ffi (>= 1.3.0)
+    faraday (0.15.2)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.12.2)
+      faraday (>= 0.7.4, < 1.0)
+    ffi (1.9.25)
+    multipart-post (2.0.0)
     mustermann (1.0.2)
     rack (2.0.5)
-    rack-protection (2.0.1)
+    rack-protection (2.0.2)
       rack
-    sinatra (2.0.1)
+    retries (0.0.5)
+    sinatra (2.0.2)
       mustermann (~> 1.0)
       rack (~> 2.0)
-      rack-protection (= 2.0.1)
+      rack-protection (= 2.0.2)
       tilt (~> 2.0)
     tilt (2.0.8)
+    typhoeus (1.3.0)
+      ethon (>= 0.9.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  akasha
-  sinatra
+  akasha!
+  sinatra (~> 2, > 2.0.1)
 
 BUNDLED WITH
    1.16.2

data/examples/sinatra/app.rb

@@ -1,6 +1,8 @@
 require 'akasha'
 require 'sinatra'
+require 'singleton'
 
+# An example aggregate.
 class User < Akasha::Aggregate
   attr_reader :email
 
@@ -15,6 +17,14 @@ class User < Akasha::Aggregate
   end
 end
 
+# An example materializer.
+class UserListMaterializer < Akasha::EventListener
+  def on_user_signed_up(user_id, **)
+    # Update database.
+  end
+end
+
+# An example event listener; will be used asynchronously.
 class Notifier < Akasha::EventListener
   def on_user_signed_up(user_id, **)
     notify_about_signup(user_id)
@@ -26,42 +36,63 @@ class Notifier < Akasha::EventListener
     # Here we could just grab email from the event but let's demonstrate
     # how to load an aggregate from events.
     user = User.find_or_create(user_id)
-    email = <<~EOS
+    email = <<~EMAIL
       User #{user.email} just signed up!
-    EOS
+    EMAIL
     # Let's not send any emails... :)
     puts email
   end
 end
 
-before do
-  @command_router = Akasha::CommandRouter.new
+# Example Akasha application.
+class MyAkashaApp
+  include Singleton
 
-  # Aggregates will load from and save to in-memory storage.
-  repository = Akasha::Repository.new(Akasha::Storage::MemoryEventStore.new)
-  Akasha::Aggregate.connect!(repository)
+  attr_accessor :command_router
 
-  # Set up event listeners.
-  @event_router = Akasha::EventRouter.new
-  @event_router.register_event_listener(:user_signed_up, Notifier)
-  repository.subscribe(@event_router)
+  def initialize # rubocop:disable Metrics/MethodLength
+    # Aggregates will load from and save to in-memory storage.
+    repository = Akasha::Repository.new(
+      Akasha::Storage::HttpEventStore.new(
+        username: 'admin',
+        password: 'changeit'
+      ),
+      namespace: :my_app
+    )
+    Akasha::Aggregate.connect!(repository)
 
-  # This is how you link commands to aggregates.
-  @command_router.register_default_route(:sign_up, User)
+    # Set up event listeners.
+    event_router = Akasha::EventRouter.new(
+      user_signed_up: UserListMaterializer
+    )
+    event_router.connect!(repository)
+
+    async_event_router = Akasha::AsyncEventRouter.new(
+      user_signed_up: Notifier
+    )
+    async_event_router.connect!(repository) # Returns Thread instance.
+
+    @command_router = Akasha::CommandRouter.new(
+      sign_up: User,
+      sign_up_admin: lambda { |aggregate_id, **data|
+        user = User.find_or_create(aggregate_id)
+        user.sign_up(email: data[:email], password: data[:password], admin: true)
+        user.save!
+      }
+    )
+  end
+end
 
-  # Nearly identital to the default handling above but we're setting the admin
-  # flag to demo custom command handling.
-  @command_router.register_route(:sign_up_admin) do |aggregate_id, **data|
-    user = User.find_or_create(aggregate_id)
-    user.sign_up(email: data[:email], password: data[:password], admin: true)
-    user.save!
+helpers do
+  def route_command(*args)
+    MyAkashaApp.instance.command_router.route!(*args)
   end
 end
 
 post '/users/:user_id' do # With CQRS client pass unique aggregate ids.
-  @command_router.route!(:sign_up,
-                 params[:user_id],
-                 email: params[:email],
-                 password: params[:password])
+  route_command(:sign_up,
+                params[:user_id],
+                email: params[:email],
+                password: params[:password])
   'OK'
 end

data/lib/akasha.rb

@@ -3,6 +3,8 @@ require 'akasha/aggregate'
 require 'akasha/command_router'
 require 'akasha/event_listener'
 require 'akasha/event_router'
+require 'akasha/async_event_router'
 require 'akasha/repository'
 require 'akasha/storage/http_event_store'
 require 'akasha/storage/memory_event_store'
+require 'akasha/checkpoint/http_event_store_checkpoint'

data/lib/akasha/aggregate/syntax_helpers.rb

@@ -20,7 +20,7 @@ module Akasha
     module ClassMethods
       # Connects to a repository.
       def connect!(repository)
-        @@repository = repository
+        @@repository = repository # rubocop:disable Style/ClassVars
       end
 
       # Returns repository or nil if `connect!` not called.

data/lib/akasha/async_event_router.rb

@@ -0,0 +1,44 @@
+require_relative 'event_router_base'
+require_relative 'checkpoint/http_event_store_checkpoint'
+
+module Akasha
+  # Event router working that can run in the background, providing eventual
+  # consistency. Can use the same EventListeners as the synchronous EventRouter.
+  class AsyncEventRouter < EventRouterBase
+    DEFAULT_POLL_SECONDS = 2
+    DEFAULT_PAGE_SIZE = 20
+    DEFAULT_PROJECTION_STREAM = 'AsyncEventRouter'.freeze
+    DEFAULT_CHECKPOINT_STRATEGY = Akasha::Checkpoint::HttpEventStoreCheckpoint
+
+    def connect!(repository, projection_name: DEFAULT_PROJECTION_STREAM,
+                 checkpoint_strategy: DEFAULT_CHECKPOINT_STRATEGY,
+                 page_size: DEFAULT_PAGE_SIZE, poll: DEFAULT_POLL_SECONDS)
+      projection_stream = repository.store.streams[projection_name]
+      checkpoint = checkpoint_strategy.is_a?(Class) ? checkpoint_strategy.new(projection_stream) : checkpoint_strategy
+      repository.merge_all_by_event(into: projection_name, only: registered_event_names)
+      Thread.new do
+        run_forever(projection_stream, checkpoint, page_size, poll)
+      end
+    end
+
+    private
+
+    # TODO: Make it stoppable.
+    def run_forever(projection_stream, checkpoint, page_size, poll)
+      position = checkpoint.latest
+      loop do
+        projection_stream.read_events(position, page_size, poll) do |events|
+          begin
+            events.each do |event|
+              route(event.name, event.metadata[:aggregate_id], **event.data)
+              position = checkpoint.ack(position)
+            end
+          rescue RuntimeError => e
+            puts e # TODO: Decide on a strategy.
+            position = checkpoint.ack(position)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akasha/changeset.rb

@@ -11,7 +11,9 @@ module Akasha
 
     # Adds an event to the changeset.
     def append(event_name, **data)
-      @events << Akasha::Event.new(event_name, **data)
+      id = SecureRandom.uuid
+      event = Akasha::Event.new(event_name, id, { aggregate_id: @aggregate_id }, **data)
+      @events << event
     end
 
     # Returns true if no changes recorded.

data/lib/akasha/checkpoint/http_event_store_checkpoint.rb

@@ -0,0 +1,45 @@
+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)
+        @stream = stream
+        @interval = interval
+        return if @stream.respond_to?(:metadata) && @stream.respond_to?(:metadata=)
+        raise UnsupportedStorageError, "Storage does not support checkpoints: #{stream.class}"
+      end
+
+      # Returns the most recently stored next position.
+      def latest
+        @next_position ||= (read_position || 0)
+      end
+
+      # Returns the next position, conditionally storing it (based on the configurable interval).
+      def ack(position)
+        @next_position = position + 1
+        if (@next_position % @interval).zero?
+          # TODO: Race condition; use optimistic cocurrency.
+          @stream.metadata = @stream.metadata.merge(next_position: @next_position)
+        end
+        @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}"
+      end
+
+      protected
+
+      def read_position
+        @stream.metadata[:next_position]
+      rescue Akasha::Storage::HttpEventStore::HttpClientError => e
+        return 0 if e.status_code == 404
+        raise
+      end
+    end
+  end
+end

data/lib/akasha/command_router.rb

@@ -1,13 +1,22 @@
 require_relative 'command_router/default_handler'
+require 'corefines/hash'
 
 module Akasha
   # Routes commands to their handlers.
   class CommandRouter
+    using Corefines::Hash
+
     # Raised when no corresponding target can be found for a command.
     NotFoundError = Class.new(RuntimeError)
 
-    def initialize
-      @routes = {}
+    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.

data/lib/akasha/event.rb

@@ -1,28 +1,24 @@
+require 'securerandom'
 require 'time'
 
 module Akasha
-  # Event contains all information pertaining to a single
-  # event recorded by the system.
+  # Describes a single event recorded by the system.
   class Event
-    attr_reader :name, :data, :created_at
+    attr_reader :id, :name, :data, :metadata
 
-    def initialize(name, created_at = Time.now.utc, **data)
+    def initialize(name, id = nil, metadata = {}, **data)
+      @id = id || SecureRandom.uuid.to_s # TODO: Use something better.
       @name = name
-      @created_at = created_at
+      @metadata = metadata || { created_at: Time.now.utc }
       @data = data
     end
 
-    def metadata
-      {
-        created_at: @created_at
-      }
-    end
-
     def ==(other)
       self.class == other.class &&
+        id == other.id &&
         name == other.name &&
         data == other.data &&
-        created_at == other.created_at
+        metadata == other.metadata
     end
   end
 end

data/lib/akasha/event_router.rb

@@ -1,38 +1,15 @@
-module Akasha
-  # Routes events to event listeners.
-  class EventRouter
-    def initialize
-      @routes = Hash.new { |hash, key| hash[key] = [] }
-    end
+require_relative 'event_router_base'
 
-    # Registers a new event listener, derived from
-    # `Akasha::EventListener`.
-    def register_event_listener(event_name, listener_class)
-      @routes[event_name] << listener_class
-    end
-
-    # Routes an event.
-    def route(event_name, aggregate_id, **data)
-      @routes[event_name].each do |listener_class|
-        listener = listener_class.new
-        begin
-          listener.public_send(:"on_#{event_name}", aggregate_id, **data)
-        rescue RuntimeError => e
-          log "Error handling event #{event_name.inspect}: #{e}"
-        end
+module Akasha
+  # Routes events synchronously, providing consistency.
+  # Useful for routing to materializers, providing read-your-writes
+  # guarantee.
+  class EventRouter < EventRouterBase
+    # Connects to the repository.
+    def connect!(repository)
+      repository.subscribe do |aggregate_id, event|
+        route(event.name, aggregate_id, **event.data)
       end
     end
-
-    # Routes an event (an Akasha::Event instance).
-    # This is interface allowing  subscription via `Akasha::Repository#subscribe`.
-    def call(aggregate_id, event)
-      route(event.name, aggregate_id, **event.data)
-    end
-
-    private
-
-    def log(msg)
-      puts msg
-    end
   end
 end

data/lib/akasha/event_router_base.rb

@@ -0,0 +1,39 @@
+module Akasha
+  # Base class for routing events to event listeners.
+  class EventRouterBase
+    def initialize(routes = {})
+      @routes = Hash.new { |hash, key| hash[key] = [] }
+      @routes.merge!(routes)
+    end
+
+    # Registers a new event listener, derived from
+    # `Akasha::EventListener`.
+    def register_event_listener(event_name, listener)
+      @routes[event_name] << listener
+    end
+
+    # Routes an event.
+    def route(event_name, aggregate_id, **data)
+      @routes[event_name].each do |listener|
+        listener = listener.new if listener.is_a?(Class)
+        begin
+          listener.public_send(:"on_#{event_name}", aggregate_id, **data)
+        rescue RuntimeError => e
+          log "Error handling event #{event_name.inspect}: #{e}"
+        end
+      end
+    end
+
+    protected
+
+    def registered_event_names
+      @routes.keys
+    end
+
+    private
+
+    def log(msg)
+      puts msg
+    end
+  end
+end