aggregates 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00b1d88fe05dec5dcc22db0e1349c2dd91645b4e33755f8fbf9e3d3ea9085fab
-  data.tar.gz: ad8bd4c5cd4c1e781776ea4890f59e59d952a6cc30e4509c41e92da649b691ba
+  metadata.gz: a8ea9821a6f5fa681750a5d64885972c899285705e255c519336ceba98dc4afd
+  data.tar.gz: 875d8fa0127fd8b708e656c9761a5852baa54cccee2885f27a95f6cc40c3a5bb
 SHA512:
-  metadata.gz: dbd3330da62e2783c4911116e266511ff5decc8f629eefbc7e671a8128fb7082f62aff6a1edac6018243ed6d1856a823dd84e3cef879edb741376f9a273ddaf8
-  data.tar.gz: c5ff7486bda8e1412cc6624db657c7deeb8f94f5d823cbdc799e9bf42c862bbc0735fa3ba589fc10c64a30275f8aa514f33ab33ff4f345807a2da244dc5438d5
+  metadata.gz: b42b9939913cf8854cd33c35b9fa56b85a84b287a5dea4fd402ec7263f20aec612bbe1b35ca49e1fe8b0ae39c4a7cd8e28d55afd01b0239acf5da3ccfebf8945
+  data.tar.gz: 74e3e52d34228e9aba39d161dc237a756d8f343281944653cd08020d1ce9f4b154302d2d0afb95374ea8d964fa9b751a2bf0f67ef0fa94a3e35a85197ec4071b

data/README.md

@@ -23,16 +23,14 @@ _Warning:_ This Gem is in active development and probably doesn't work correctly
     - [Creating Commands](#creating-commands)
     - [Creating Events](#creating-events)
     - [Processing Commands](#processing-commands)
+    - [Value Objects](#value-objects)
     - [Filtering Commands](#filtering-commands)
     - [Processing Events](#processing-events)
-    - [Executing Commands](#executing-commands)
-    - [Auditing Aggregates](#auditing-aggregates)
-    - [Configuring](#configuring)
+    - [Building The Domain](#building-the-domain)
+    - [Executing Your Domain](#executing-your-domain)
       - [Storage Backends](#storage-backends)
-        - [Dynamoid](#dynamoid)
-      - [Adding Command Processors](#adding-command-processors)
-      - [Adding Event Processors](#adding-event-processors)
-      - [Adding Command Filters](#adding-command-filters)
+      - [Executing Commands](#executing-commands)
+      - [Auditing Aggregates](#auditing-aggregates)
   - [Development](#development)
   - [Tests](#tests)
   - [Versioning](#versioning)
@@ -48,7 +46,7 @@ _Warning:_ This Gem is in active development and probably doesn't work correctly
 
 - Pluggable Event / Command Storage Backends
 - Tools for Command Validation, Filtering, and Execution.
-- Opinioned structure for CQRS, Domain-Driven Design, and Event Sourcing.
+- Opinionated structure for CQRS, Domain-Driven Design, and Event Sourcing.
 
 ## Requirements
 
@@ -71,7 +69,7 @@ Or Add the following to your Gemfile:
 An AggregateRoot is a grouping of domain object(s) that work to encapsulate
 a single part of your Domain or Business Logic. The general design of aggregate roots should be as follows:
 
-- Create functions that encapsulate different operations on your Aggregate Roots. These functions should enforce buisiness logic constraints and then capture state changes by creating events.
+- Create functions that encapsulate different operations on your Aggregate Roots. These functions should enforce business logic constraints and then capture state changes by creating events.
 - Create event handlers that actually perform the state changes captured by those events.
 
 A simple example is below:
@@ -80,11 +78,11 @@ A simple example is below:
 class Post < Aggregates::AggregateRoot
   # Write functions that encapsulate business logic.
   def publish(command)
-    apply EventPublished, body: command.body, category: command.category
+    apply PostPublished, body: command.body, category: command.category
   end
 
   # Modify the state of the aggregate from the emitted events.
-  on EventPublished do |event|
+  on PostPublished do |event|
     @body = event.body
     @category = event.category
   end
@@ -96,23 +94,23 @@ as well. Every `on` block that applies to the event will be called in order from
 
 ### Creating Commands
 
-Commands are a type of domain message that define the shape and contract of data needed to perform an action. Essentially, they provide the api for interacting with your domain. Commands should have descriptive names capturing the change they are intended to make. For instance, `ChangeUserEmail` or `AddComment`.
+Commands are a type of domain message that define the shape and contract of data needed to perform an action. 
+Essentially, they provide the api for interacting with your domain. 
+Commands should have descriptive names capturing the change they are intended to make. 
+For instance, `ChangeUserEmail` or `AddComment`.
 
 ```ruby
 class PublishPost < Aggregates::Command
-  attribute :body, Types::String
-  attribute :category, Types::String
-
-  # Input Validation Handled via dry-validation.
-  # Reference: https://dry-rb.org/gems/dry-validation/1.6/
-  class Contract < Contract
-    rule(:body) do
-      key.failure('Post not long enough') unless value.length > 10
-    end
-  end
+  interacts_with Post
+
+  attribute :body
+  attribute :category
+  validates_length_of :body, minimum: 10
 end
 ```
 
+You can specify them via attr accessors and use `ActiveModel::Validations` to enforce data constraints. 
+
 ### Creating Events
 
 An Event describes something that happened. They are named in passed tense.
@@ -120,9 +118,9 @@ For instance, if the user's email has changed, then you might create an event ty
 `UserEmailChanged`.
 
 ```ruby
-class PublishPost < Aggregates::Command
-  attribute :body, Types::String
-  attribute :category, Types::String
+class PostPublished < Aggregates::Event
+  attribute :body
+  attribute :category
 end
 ```
 
@@ -131,48 +129,60 @@ end
 The goal of a `CommandProcessor` is to route commands that have passed validation and
 filtering. They should invoke business logic on their respective aggregates. Doing so is accomplished by using the same message-handling DSL as in our `AggregateRoots`, this time for commands.
 
-A helper function, `with_aggregate`, is provided to help retrieve the appropriate aggregate
-for a given command.
-
 ```ruby
 class PostCommandProcessor < Aggregates::CommandProcessor
-  on PublishPost do |command|
-    with_aggregate(Post, command) do |post|
-      post.publsh(command)
-    end
+  # Instead of `process`, you may use `on`
+  process PublishPost do |command, post|
+    post.publish(command)
   end
 end
 ```
+_Note:_ the message-handling DSL (`process`) supports passing a super class of any given event
+as well. Every `process` block that applies to the event will be called in order from most specific to least specific.
+
+### Value Objects
+
+Often times you will find that you will have data clumps that are similar pieces of data that have the same rules, and schema. Typically these values represent a valid type in your domain and should be combined as a single value. That is where `ValueObject` comes in. The api is the same as commands and events.
+
+```ruby
+class Name < Aggregates::ValueObject
+  attribute :first_name
+  attribute :last_name
+  validates_presence_of :first_name, :last_name
+end
+```
+
+When you have a command, validation logic will automatically include validating nested value objects to an arbitrary depth.
 
-_Note:_ the message-handling DSL (`on`) supports passing a super class of any given event
-as well. Every `on` block that applies to the event will be called in order from most specific to least specific.
 
 ### Filtering Commands
 
-There are times where commands should not be executed by the domain logic. You can opt to include a condition in your command processor or aggregate. However, that is not always extensible if you have repeated logic between many commands. Additionally, it violates the single responsiblity principal.
+There are times where commands should not be executed by the domain logic. You can opt to include a condition in your command processor or aggregate. However, that is not always extensible if you have repeated logic between many commands. Additionally, it violates the single responsibility principal.
 
-Instead, it is best to support this kind of filtering logic using `CommandFilters`. A `CommandFilter` uses the same Message Handling message-handling DSL as the rest of the `Aggregates` gem. This time, it needs to return a true/false back to the gem to determine whether or not (true/false) the command should be allowed. Many command filters can provide many blocks of the `on` DSL. If any one of the filters rejects the command then the command will not be procesed.
+Instead, it is best to support this kind of filtering logic using `CommandFilters`. A `CommandFilter` uses the same Message Handling message-handling DSL as the rest of the `Aggregates` gem. 
+This time, it needs to return a true/false back to the gem to determine whether or not (true/false) the command should be allowed. Many command filters can provide many blocks of the `filter` or `on` DSL. 
+If any one of the filters rejects the command then the command will not be processed.
 
 ```ruby
 class UpdatePostCommand < Aggregates::Command
-  attribute :commanding_user_id, Types::String
+  interacts_with Post
+  attribute :commanding_user_id
 end
 
 class UpdatePostBody < UpdatePostCommand
-  attribute :body, Types::String
+  attribute :body
 end
 
 class PostCommandFilter < Aggregates::CommandFilter
-  on UpdatePostCommand do |command|
-    with_aggregate(Post, command) do |post|
-      post.owner_id == command.commanding_user_id
-    end
+  # Instead of `filter`, you may use `on`
+  filter UpdatePostCommand do |command, post|
+    post.owner_id == command.commanding_user_id
   end
 end
 ```
 
 In this example, we are using a super class of `UpdatePostBody`.
-As with all MessageProcessors, calling `on` with a super class
+As with all MessageProcessors, calling `filter` with a super class
 will be called when any child class is being processed. In other words,
 `on UpdatePostCommand` will be called when you call `Aggregates.execute_command`
 with an instance of `UpdatePostBody`.
@@ -191,33 +201,55 @@ class RssUpdateProcessor < Aggregates::EventProcessor
     # ...
   end
 
-  on EventPublished do |event|
+  on PostPublished do |event|
     update_feed_for_new_post(event)
   end
 end
 ```
 
-_Note:_ the message-handling DSL (`on`) supports passing a super class of any given event
-as well. Every `on` block that applies to the event will be called in order from most specific to least specific.
+### Building The Domain
+
+```ruby
+domain = Aggregates.create_domain do
+  # Adding Command Processors
+  process_commands_with PostCommandProcessor.new
+  # Adding Event Processors
+  process_events_with RssUpdateProcessor.new
+  # Adding Command Filters
+  filter_commands_with MyCommandFilter.new
+end
+```
 
-### Executing Commands
+### Executing Your Domain
+
+#### Storage Backends
+
+Storage Backends are the method by which events and commands are stored in
+the system. You need to specify one in order to execute your domain.
+
+```ruby
+executor = domain.execute_with MyAwesomeStorageBackend.new
+```
+
+#### Executing Commands
 
 ```ruby
 aggregate_id = Aggregates.new_aggregate_id
 command = CreateThing.new(foo: 1, bar: false, aggregate_id: aggregate_id)
-Aggregates.execute_command command
+executor.execute_command(command)
 
 increment = IncrementFooThing.new(aggregate_id: aggregate_id)
 toggle = ToggleBarThing.new(aggregate_id: aggregate_id)
-Aggregates.execute_commands increment, toggle
+executor.execute_command(command)
+executor.execute_command(command)
 ```
 
-### Auditing Aggregates
+#### Auditing Aggregates
 
 ```ruby
 aggregate_id = Aggregates.new_aggregate_id
 # ... Commands and stuff happened.
-auditor = Aggregates.audit MyAggregateType aggregate_id
+auditor = executor.audit MyAggregateType aggregate_id
 
 # Each of these returns a list to investigate using.
 events = auditor.events # Or events_processed_by(time) or events_processed_after(time)
@@ -228,49 +260,6 @@ commands = auditor.commands # Or commands_processed_by(time) or commands_process
 aggregate_at_time = auditor.inspect_state_at(Time.now - 1.hour)
 ```
 
-### Configuring
-
-#### Storage Backends
-
-Storage Backends at the method by which events and commands are stored in
-the system.
-
-```ruby
-Aggregates.configure do |config|
-  config.store_with MyAwesomeStorageBackend.new
-end
-```
-
-##### Dynamoid
-
-If `Aggregates` can `require 'dynamoid'` then it will provide the `Aggregates::Dynamoid::DynamoidStorageBackend` that
-stores using the [Dynmoid Gem](https://github.com/Dynamoid/dynamoid) for AWS DynamoDB.
-
-#### Adding Command Processors
-
-```ruby
-Aggregates.configure do |config|
-  # May call this method many times with different processors.
-  config.process_commands_with PostCommandProcessor.new
-end
-```
-
-#### Adding Event Processors
-
-```ruby
-Aggregates.configure do |config|
-  # May call this method many times with different processors.
-  config.process_events_with RssUpdateProcessor.new
-end
-```
-
-#### Adding Command Filters
-
-```ruby
-Aggregates.configure do |config|
-  config.filter_commands_with MyCommandFilter.new
-end
-```
 
 ## Development
 

data/lib/aggregates.rb

@@ -1,33 +1,44 @@
 # frozen_string_literal: true
 
-require 'zeitwerk'
-
-loader = Zeitwerk::Loader.for_gem
-loader.setup
+require 'securerandom'
+
+require_relative './aggregates/domain_object'
+require_relative './aggregates/domain_message'
+require_relative './aggregates/message_processor'
+
+require_relative './aggregates/aggregate_root'
+require_relative './aggregates/auditor'
+require_relative './aggregates/command'
+require_relative './aggregates/command_processor'
+require_relative './aggregates/command_filter'
+require_relative './aggregates/command_validation_error'
+require_relative './aggregates/domain'
+require_relative './aggregates/domain_executor'
+require_relative './aggregates/event'
+require_relative './aggregates/event_processor'
+require_relative './aggregates/event_stream'
+require_relative './aggregates/value_object'
+
+require_relative './aggregates/storage_backend'
+require_relative './aggregates/in_memory_storage_backend'
 
 # A helpful library for building CQRS and Event Sourced Applications.
 module Aggregates
-  def self.configure
-    yield Configuration.instance
-  end
-
   def self.new_aggregate_id
-    SecureRandom.uuid.to_s
+    new_uuid
   end
 
   def self.new_message_id
-    SecureRandom.uuid.to_s
-  end
-
-  def self.execute_command(command)
-    CommandDispatcher.instance.execute_command command
+    new_uuid
   end
 
-  def self.execute_commands(*commands)
-    CommandDispatcher.instance.execute_commands(*commands)
+  def self.create_domain(&block)
+    domain = Domain.new
+    domain.instance_exec(&block)
+    domain
   end
 
-  def self.audit(type, aggregate_id)
-    Auditor.new type, aggregate_id
+  def self.new_uuid
+    SecureRandom.uuid.to_s
   end
 end

data/lib/aggregates/aggregate_repository.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative './event_stream'
+
+module Aggregates
+  # Uses the storage backend to store load aggregates.
+  class AggregateRepository
+    def initialize(storage_backend)
+      @storage_backend = storage_backend
+    end
+
+    def load_aggregate(type, id, at: nil)
+      event_stream = create_aggregate_event_stream(type, id)
+      aggregate = type.new(id, event_stream)
+      replay_events_on_aggregate(aggregate, event_stream, at)
+      aggregate
+    end
+
+    private
+
+    def create_aggregate_event_stream(type, id)
+      EventStream.new(@storage_backend, type, id)
+    end
+
+    def replay_events_on_aggregate(aggregate, event_stream, at)
+      events = event_stream.load_events ending_at: at
+      events.each do |event|
+        aggregate.process_event(event)
+      end
+    end
+  end
+end

data/lib/aggregates/aggregate_root.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './message_processor'
+
 module Aggregates
   # An AggregateRoot is a central grouping of domain object(s) that work to encapsulate
   # parts of our Domain or Business Logic.
@@ -10,31 +12,23 @@ module Aggregates
   #
   #   - Create event handlers that actually performed the state changes captured by the events
   #     made by processing commands using the above functions.
-  class AggregateRoot < EventProcessor
-    attr_reader :id
+  class AggregateRoot
+    include MessageProcessor
 
-    # Returns a new instance of an aggregate by loading and reprocessing all events for that aggregate.
-    def self.get_by_id(id)
-      instance = new id
-      instance.replay_history
-      instance
-    end
+    attr_reader :id
 
     # Creates a new instance of an aggregate root. This should not be called directly. Instead, it should
     # be called by calling AggregateRoot.get_by_id.
     # :reek:BooleanParameter
-    def initialize(id, mutable: true)
-      super()
-
+    def initialize(id, event_stream)
       @id = id
-      @mutable = mutable
       @sequence_number = 1
-      @event_stream = EventStream.new id
+      @event_stream = event_stream
     end
 
     def process_event(event)
-      super
       @sequence_number += 1
+      handle_message event
     end
 
     # Takes an event type and some parameters with which to create it. Then performs the following actions
@@ -43,21 +37,10 @@ module Aggregates
     #   3.) Produces the event on the event stream so that is saved by the storage backend and processed
     #       by the configured processors of the given type.
     def apply(event, params = {})
-      raise FrozenError unless @mutable
-
       event = build_event(event, params)
-      process_event event
-      @event_stream.publish event
-    end
-
-    # Loads all events from the event stream of this instance and reprocesses them to
-    # get the current state of the aggregate.
-    def replay_history(up_to: nil)
-      events = @event_stream.load_events
-      events = events.select { |event| event.created_at <= up_to } if up_to.present?
-      events.each do |event|
-        process_event event
-      end
+      results = process_event(event)
+      @event_stream.publish(event)
+      results
     end
 
     private

data/lib/aggregates/auditor.rb

@@ -6,7 +6,8 @@ module Aggregates
   class Auditor
     attr_reader :type, :aggregate_id
 
-    def initialize(type, aggregate_id)
+    def initialize(storage_backend, type, aggregate_id)
+      @storage_backend = storage_backend
       @type = type
       @aggregate_id = aggregate_id
     end
@@ -15,19 +16,18 @@ module Aggregates
     # on the aggregate alone. Only events that happened prior to the time specified are
     # processed.
     def inspect_state_at(time)
-      aggregate = @type.new @aggregate_id, mutable: false
-      aggregate.replay_history up_to: time
-      aggregate
+      aggregate_repository = AggregateRepository.new(@storage_backend)
+      aggregate_repository.load_aggregate(@type, @aggregate_id, at: time)
     end
 
     # Returns all stored events for a given aggregate.
     def events
-      @events ||= Configuration.storage_backend.load_events_by_aggregate_id(@aggregate_id)
+      @events ||= @storage_backend.load_events_by_aggregate_id(@aggregate_id)
     end
 
     # Returns all commands for a given aggregate.
     def commands
-      @commands ||= Configuration.storage_backend.load_commands_by_aggregate_id(@aggregate_id)
+      @commands ||= @storage_backend.load_commands_by_aggregate_id(@aggregate_id)
     end
 
     def events_processed_by(time)

data/lib/aggregates/command.rb

@@ -1,25 +1,30 @@
 # frozen_string_literal: true
 
-require 'dry/monads'
-require 'dry-validation'
+require 'active_model/errors'
 
 module Aggregates
   # Commands are a type of message that define the shape and contract data that is accepted for an attempt
   # at performing a state change on a given aggregate. Essentially, they provide the api for interacting with
   # your domain. Commands should have descriptive names capturing the change they are intended to make to the domain.
   # For instance, `ChangeUserEmail` or `AddComment`.
+  # :reek:MissingSafeMethod { exclude: [ validate! ] }
   class Command < DomainMessage
-    # Provides a default contract for data validation on the command itself.
-    class Contract < Dry::Validation::Contract
-    end
+    class << self
+      attr_reader :aggregate_type
 
-    def validate
-      Contract.new.call(attributes).errors.to_h
+      def interacts_with(aggregate_type)
+        @aggregate_type = aggregate_type
+      end
     end
 
     def validate!
-      errors = validate
-      raise CommandValidationError, errors unless errors.length.zero?
+      super
+    rescue ActiveModel::ValidationError
+      raise Aggregates::CommandValidationError, errors.as_json
+    end
+
+    def load_related_aggregate(aggregate_repo)
+      aggregate_repo.load_aggregate(self.class.aggregate_type, aggregate_id)
     end
   end
 end

data/lib/aggregates/command_dispatcher.rb

@@ -1,53 +1,38 @@
 # frozen_string_literal: true
 
-require 'singleton'
-
 module Aggregates
   # The CommandDispatcher is effectively a router of incoming commands to CommandProcessors that are responsible
   # for handling them appropriately. By convention, you likely will not need to interact with it directly, instead
   # simply call Aggregates.process_command or Aggregates.process_commands.
   class CommandDispatcher
-    include Singleton
-
-    def initialize
-      @config = Configuration.instance
-    end
-
-    # Takes a sequence of commands and executes them one at a time.
-    def process_commands(*commands)
-      commands.each do |command|
-        process_command command
-      end
+    def initialize(command_processors, command_filters)
+      @command_processors = command_processors
+      @command_filters = command_filters
     end
 
     # Takes a single command and processes it. The command will be validated through it's contract, sent to command
     # processors and finally stored with the configured StorageBackend used for messages.
-    def process_command(command)
-      command.validate!
-      return unless should_process? command
+    def execute_command(execution)
+      return false unless should_process? execution
 
-      send_to_processors command
-      store command
+      send_to_processors(execution)
+      true
     end
 
     private
 
-    def should_process?(command)
+    def should_process?(execution)
       # Each command processor is going to give a true/false value for itself.
       # So if they all allow it, then we can return true. Else false.
-      @config.command_filters.all? do |command_filter|
-        command_filter.allow? command
+      @command_filters.all? do |command_filter|
+        command_filter.allow?(execution)
       end
     end
 
-    def send_to_processors(command)
-      @config.command_processors.each do |command_processor|
-        command_processor.process_command command
+    def send_to_processors(execution)
+      @command_processors.each do |command_processor|
+        command_processor.process(execution)
       end
     end
-
-    def store(command)
-      @config.storage_backend.store_command command
-    end
   end
 end

data/lib/aggregates/command_execution.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Aggregates
+  # Captures the execution of a command with the aggregate at its current state.
+  class CommandExecution
+    attr_reader :command
+
+    def initialize(aggregate_repo, command)
+      @aggregate_repo = aggregate_repo
+      @command = command
+    end
+
+    def execute_with(handler)
+      handler.invoke_handlers(command, aggregate)
+    end
+
+    def aggregate
+      command.load_related_aggregate(@aggregate_repo)
+    end
+  end
+end

data/lib/aggregates/command_filter.rb

@@ -2,12 +2,13 @@
 
 module Aggregates
   # Applies filters to commands to decouple filtering logic from the CommandProcessor.
-  class CommandFilter
-    include MessageProcessor
-    include WithAggregateHelpers
+  class CommandFilter < CommandProcessor
+    class << self
+      alias filter on
+    end
 
-    def allow?(command)
-      handle_message(command).all?
+    def allow?(execution)
+      process(execution).all?
     end
   end
 end

data/lib/aggregates/command_processor.rb

@@ -4,10 +4,13 @@ module Aggregates
   # A command processor is a type that correlates commands to operations on an aggregate root.
   class CommandProcessor
     include MessageProcessor
-    include WithAggregateHelpers
 
-    def process_command(command)
-      handle_message command
+    class << self
+      alias process on
+    end
+
+    def process(execution)
+      execution.execute_with(self)
     end
   end
 end

data/lib/aggregates/domain.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative './command_dispatcher'
+require_relative './domain_executor'
+
+module Aggregates
+  # Defines the collection of command processors, event processors, and command filters
+  # that are executed together.
+  class Domain
+    attr_reader :command_processors, :event_processors, :command_filters
+
+    def initialize
+      @command_processors = []
+      @event_processors = []
+      @command_filters = []
+    end
+
+    def process_events_with(*event_processors)
+      event_processors.each do |event_processor|
+        @event_processors << event_processor
+      end
+    end
+
+    def process_commands_with(*command_processors)
+      command_processors.each do |command_processor|
+        @command_processors << command_processor
+      end
+    end
+
+    def filter_commands_with(*command_filters)
+      command_filters.each do |command_filter|
+        @command_filters << command_filter
+      end
+    end
+
+    def execute_with(storage_backend)
+      DomainExecutor.new(storage_backend, self)
+    end
+  end
+end

data/lib/aggregates/domain_executor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative './aggregate_repository'
+require_relative './command_execution'
+
+module Aggregates
+  # Combines a storage backend and a domain in order to execute that domain.
+  class DomainExecutor
+    attr_reader :storage_backend, :domain
+
+    def initialize(storage_backend, domain)
+      @aggregate_repository = AggregateRepository.new(storage_backend)
+      @dispatcher = CommandDispatcher.new(domain.command_processors, domain.command_filters)
+      @storage_backend = storage_backend
+    end
+
+    def execute_command(command)
+      command.validate!
+      command_execution = CommandExecution.new(@aggregate_repository, command)
+      dispatch(command_execution)
+    end
+
+    def audit(type, aggregate_id)
+      Auditor.new(@storage_backend, type, aggregate_id)
+    end
+
+    private
+
+    def store_command(command)
+      @storage_backend.store_command(command)
+    end
+
+    def dispatch(command_execution)
+      result = @dispatcher.execute_command(command_execution)
+      store_command(command_execution.command) if result
+      result
+    end
+  end
+end

data/lib/aggregates/domain_message.rb

@@ -1,23 +1,17 @@
 # frozen_string_literal: true
 
-require 'dry-struct'
-
 module Aggregates
   # The DomainMessage is not a class that should generally be interacted with unless
   # extending Aggregates itself. It provides some core functionality that message types
   # (Event and Command) both require.
-  class DomainMessage < Dry::Struct
-    attribute :aggregate_id, Types::String
-    attribute :message_id, Types::String.default(proc { Aggregates.new_message_id })
-    attribute :created_at, Types::Strict::DateTime.default(proc { Time.now })
-
-    def to_json(*args)
-      json_data = attributes.merge({ JSON.create_id => self.class.name })
-      json_data.to_json(args)
+  class DomainMessage < DomainObject
+    def initialize(attributes = {})
+      super(attributes.merge({ message_id: Aggregates.new_message_id, created_at: Time.now }))
     end
 
-    def self.json_create(arguments)
-      new arguments
-    end
+    attribute :aggregate_id
+    attribute :message_id
+    attribute :created_at
+    validates_presence_of :aggregate_id, :message_id, :created_at
   end
 end

data/lib/aggregates/domain_object.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module Aggregates
+  # Defines an object that is an element of the domain.
+  class DomainObject
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ActiveModel::Attributes
+
+    validate :validate_nested_fields
+
+    def to_json(*args)
+      json_data = attributes.merge({ JSON.create_id => self.class.name })
+      json_data.to_json(*args)
+    end
+
+    def self.json_create(arguments)
+      new(**arguments)
+    end
+
+    protected
+
+    def add_nested_errors_for(attribute, other_validator)
+      nested_errors = other_validator.errors
+      errors.messages[attribute] = nested_errors.messages
+      errors.details[attribute]  = nested_errors.details
+    end
+
+    def validate_nested_fields
+      attributes.each do |key, value|
+        add_nested_errors_for(key.to_sym, value) if value.is_a?(DomainObject) && !value.valid?
+      end
+    end
+  end
+end

data/lib/aggregates/event.rb

@@ -6,6 +6,7 @@ module Aggregates
   # For instance, if the user's email has changed, then you might create an event type called
   # UserEmailChanged.
   class Event < DomainMessage
-    attribute :sequence_number, Types::Integer
+    attribute :sequence_number
+    validates_presence_of :sequence_number
   end
 end

data/lib/aggregates/event_processor.rb

@@ -7,9 +7,6 @@ module Aggregates
   # for your application.
   class EventProcessor
     include MessageProcessor
-
-    def process_event(event)
-      handle_message event
-    end
+    alias process_event handle_message
   end
 end

data/lib/aggregates/event_stream.rb

@@ -6,20 +6,33 @@ module Aggregates
   #
   # There is likely no need to interact with this class directly.
   class EventStream
-    def initialize(aggregate_id)
+    def initialize(storage_backend, event_processors, aggregate_id)
+      @storage_backend = storage_backend
+      @event_processors = event_processors
       @aggregate_id = aggregate_id
-      @config = Configuration.instance
     end
 
-    def load_events
-      @config.storage_backend.load_events_by_aggregate_id(@aggregate_id)
+    def load_events(ending_at: nil)
+      events = @storage_backend.load_events_by_aggregate_id(@aggregate_id)
+      events = events.select { |event| event.created_at <= ending_at } if ending_at.present?
+      events
     end
 
     def publish(event)
-      @config.event_processors.each do |event_processor|
-        event_processor.process_event event
+      send_to_event_processors(event)
+      store_event(event)
+    end
+
+    private
+
+    def send_to_event_processors(event)
+      @event_processors.each do |event_processor|
+        event_processor.process_event(event)
       end
-      @config.storage_backend.store_event event
+    end
+
+    def store_event(event)
+      @storage_backend.store_event(event)
     end
   end
 end

data/lib/aggregates/identity.rb

@@ -5,7 +5,7 @@ module Aggregates
   module Identity
     NAME = 'aggregates'
     LABEL = 'Aggregates'
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
     VERSION_LABEL = "#{LABEL} #{VERSION}"
   end
 end

data/lib/aggregates/in_memory_storage_backend.rb

@@ -13,13 +13,11 @@ module Aggregates
     end
 
     def store_command(command)
-      commands_for_aggregate_id = load_commands_by_aggregate_id(command.aggregate_id)
-      commands_for_aggregate_id << command
+      load_commands_by_aggregate_id(command.aggregate_id) << command
     end
 
     def store_event(event)
-      event_for_aggregate_id = load_events_by_aggregate_id(event.aggregate_id)
-      event_for_aggregate_id << event
+      load_events_by_aggregate_id(event.aggregate_id) << event
     end
 
     def load_events_by_aggregate_id(aggregate_id)

data/lib/aggregates/message_processor.rb

@@ -27,7 +27,7 @@ module Aggregates
       host_class.extend(ClassMethods)
     end
 
-    def find_message_handlers(message, &block)
+    def with_message_handlers(message, &block)
       search_class = message.class
       while search_class != DomainMessage
         handlers = self.class.message_mapping[search_class]
@@ -36,10 +36,16 @@ module Aggregates
       end
     end
 
-    def handle_message(message)
-      find_message_handlers.map do |handler|
-        instance_exec(message, &handler)
+    def invoke_handlers(message, *additional_args)
+      results = []
+      with_message_handlers(message) do |handler|
+        results << instance_exec(message, *additional_args, &handler)
       end
+      results
+    end
+
+    def handle_message(message)
+      invoke_handlers(message)
     end
   end
 end

data/lib/aggregates/{types.rb → value_object.rb}

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry-struct'
-
 module Aggregates
-  module Types
-    include Dry.Types
+  class ValueObject < DomainObject
   end
 end

metadata

@@ -1,57 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: aggregates
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Zach Probst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-09 00:00:00.000000000 Z
+date: 2021-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dry-struct
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: dry-validation
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: zeitwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '6.1'
 description:
 email:
 - zprobst@resilientvitality.com
@@ -64,16 +36,19 @@ files:
 - LICENSE.md
 - README.md
 - lib/aggregates.rb
+- lib/aggregates/aggregate_repository.rb
 - lib/aggregates/aggregate_root.rb
 - lib/aggregates/auditor.rb
 - lib/aggregates/command.rb
 - lib/aggregates/command_dispatcher.rb
+- lib/aggregates/command_execution.rb
 - lib/aggregates/command_filter.rb
 - lib/aggregates/command_processor.rb
 - lib/aggregates/command_validation_error.rb
-- lib/aggregates/configuration.rb
+- lib/aggregates/domain.rb
+- lib/aggregates/domain_executor.rb
 - lib/aggregates/domain_message.rb
-- lib/aggregates/dynamoid/dynamoid_storage_backend.rb
+- lib/aggregates/domain_object.rb
 - lib/aggregates/event.rb
 - lib/aggregates/event_processor.rb
 - lib/aggregates/event_stream.rb
@@ -81,8 +56,7 @@ files:
 - lib/aggregates/in_memory_storage_backend.rb
 - lib/aggregates/message_processor.rb
 - lib/aggregates/storage_backend.rb
-- lib/aggregates/types.rb
-- lib/aggregates/with_aggregate_helpers.rb
+- lib/aggregates/value_object.rb
 homepage: https://github.com/resilient-vitality/aggregates
 licenses:
 - MIT

data/lib/aggregates/configuration.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-module Aggregates
-  # Stores all of the items needed to dictate the exact behavior needed by
-  # the application consuming the Aggregates gem.
-  class Configuration
-    include Singleton
-
-    attr_reader :command_processors, :event_processors,
-                :storage_backend, :command_filters
-
-    def initialize
-      @command_processors = []
-      @event_processors = []
-      @command_filters = []
-      @storage_backend = InMemoryStorageBackend.new
-    end
-
-    def filter_commands_with(command_filter)
-      @command_filters << command_filter
-    end
-
-    def store_with(storage_backend)
-      @storage_backend = storage_backend
-    end
-
-    def process_events_with(event_processor)
-      @event_processors << event_processor
-    end
-
-    def process_commands_with(command_processor)
-      @command_processors << command_processor
-    end
-  end
-end

data/lib/aggregates/dynamoid/dynamoid_storage_backend.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Style/Documentation
-
-module Aggregates
-  # rubocop:enable Style/Documentation
-  begin
-    require 'dynamoid'
-
-    # Extensions to the Aggregates gem that provide message storage on DynamoDB.
-    module Dynamoid
-      # Stores events in DynamoDB using `Dynamoid`
-      class DynamoEventStore
-        include ::Dynamoid::Document
-
-        field :aggregate_id
-        field :sequence_number, :integer
-        field :data
-
-        table name: :events, hash_key: :aggregate_id, range_key: :sequence_number, timestamps: true
-
-        def self.store!(event, data)
-          args = { aggregate_id: event.aggregate_id, sequence_number: event.sequence_number, data: data }
-          event = new args
-          event.save!
-        end
-      end
-
-      # Stores commands in DynamoDB using `Dynamoid`
-      class DynamoCommandStore
-        include ::Dynamoid::Document
-
-        field :aggregate_id
-        field :data
-
-        table name: :commands, hash_key: :aggregate_id, range_key: :created_at, timestamps: true
-
-        def self.store!(command, data)
-          args = { aggregate_id: command.aggregate_id, data: data }
-          command = new args
-          command.save!
-        end
-      end
-
-      # Stores messages on DynamoDB using the dynamoid gem.
-      class DynamoidStorageBackend < StorageBackend
-        def store_event(event)
-          data = message_to_json_string(event)
-          DynamoEventStore.store! event, data
-        end
-
-        def store_command(command)
-          data = message_to_json_string(command)
-          DynamoCommandStore.store! command, data
-        end
-
-        def load_events_by_aggregate_id(aggregate_id)
-          DynamoEventStore.where(aggregate_id: aggregate_id).all.map do |stored_event|
-            json_string_to_message stored_event.data
-          end
-        end
-
-        def load_commands_by_aggregate_id(aggregate_id)
-          DynamoCommandStore.where(aggregate_id: aggregate_id).all.map do |stored_command|
-            json_string_to_message stored_command.data
-          end
-        end
-      end
-    end
-  rescue LoadError
-    # This is intentional to no do anything if it is not loadable.
-  end
-end

data/lib/aggregates/with_aggregate_helpers.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Aggregates
-  # Helper functions for running blocks with a specified aggregate.
-  module WithAggregateHelpers
-    # Class Methods to extend onto the host class.
-    module ClassMethods
-      def with_aggregate(type, command, &block)
-        aggregate_id = command.aggregate_id
-        with_aggregate_by_id(type, aggregate_id, &block)
-      end
-
-      def with_aggregate_by_id(type, aggregate_id)
-        yield type.get_by_id aggregate_id
-      end
-    end
-
-    def self.included(host_class)
-      host_class.extend(ClassMethods)
-    end
-  end
-end