sequent 0.1.1 → 0.1.2

data/lib/sequent/core/event_store.rb

@@ -0,0 +1,110 @@
+require 'oj'
+require_relative 'event_record'
+
+module Sequent
+  module Core
+    class EventStoreConfiguration
+      attr_accessor :record_class, :event_handlers
+
+      def initialize(record_class = Sequent::Core::EventRecord, event_handlers = [])
+        @record_class = record_class
+        @event_handlers = event_handlers
+      end
+    end
+
+    class EventStore
+
+      class << self
+        attr_accessor :configuration,
+                      :instance
+      end
+
+      # Creates a new EventStore and overwrites all existing config.
+      # The new EventStore can be retrieved via the +EventStore.instance+ method.
+      #
+      # If you don't want a singleton you can always instantiate it yourself using the +EventStore.new+.
+      def self.configure
+        self.configuration = EventStoreConfiguration.new
+        yield(configuration) if block_given?
+        EventStore.instance = EventStore.new(configuration)
+      end
+
+      def initialize(configuration = EventStoreConfiguration.new)
+        @record_class = configuration.record_class
+        @event_handlers = configuration.event_handlers
+      end
+
+      ##
+      # Stores the events in the EventStore and publishes the events
+      # to the registered event_handlers.
+      #
+      def commit_events(command, events)
+        store_events(command, events)
+        publish_events(events, @event_handlers)
+      end
+
+      ##
+      # Returns all events for the aggregate ordered by sequence_number
+      #
+      def load_events(aggregate_id)
+        event_types = {}
+        @record_class.connection.select_all("select event_type, event_json from #{@record_class.table_name} where aggregate_id = '#{aggregate_id}' order by sequence_number asc").map! do |event_hash|
+          event_type = event_hash["event_type"]
+          event_json = Oj.strict_load(event_hash["event_json"])
+          unless event_types.has_key?(event_type)
+            event_types[event_type] = Class.const_get(event_type.to_sym)
+          end
+          event_types[event_type].deserialize_from_json(event_json)
+        end
+      end
+
+      ##
+      # Replays all events in the event store to the registered event_handlers.
+      #
+      # @param block that returns the event stream.
+      def replay_events
+        event_stream = yield
+        event_types = {}
+        event_stream.each do |event_hash|
+          event_type = event_hash["event_type"]
+          payload = Oj.strict_load(event_hash["event_json"])
+          unless event_types.has_key?(event_type)
+            event_types[event_type] = Class.const_get(event_type.to_sym)
+          end
+          event = event_types[event_type].deserialize_from_json(payload)
+          @event_handlers.each do |handler|
+            handler.handle_message event
+          end
+        end
+      end
+
+      protected
+      def record_class
+        @record_class
+      end
+
+      private
+
+      def publish_events(events, event_handlers)
+        events.each do |event|
+          event_handlers.each do |handler|
+            handler.handle_message event
+          end
+        end
+      end
+
+      def to_events(event_records)
+        event_records.map(&:event)
+      end
+
+      def store_events(command, events = [])
+        command_record = Sequent::Core::CommandRecord.create!(:command => command)
+        events.each do |event|
+          @record_class.create!(:command_record => command_record, :event => event)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/sequent/core/helpers/association_validator.rb

@@ -0,0 +1,39 @@
+require 'active_model'
+module Sequent
+  module Core
+    module Helpers
+      #
+      # Validator for associations. Typically used in Sequent::Core::Command,
+      # Sequent::Core::Event and Sequent::Core::ValueObjects.
+      #
+      # Example:
+      #
+      #   class RegisterForTrainingCommand < UpdateCommand
+      #     attrs trainee: Person
+      #
+      #     validates_presence_of :trainee
+      #     validates_with Sequent::Core::Helpers::AssociationValidator, associations: [:trainee]
+      #
+      #   end
+      class AssociationValidator < ActiveModel::Validator
+
+        def validate(record)
+          associations = options[:associations]
+          associations = [associations] unless associations.instance_of?(Array)
+          associations.each do |association|
+            next unless association # since ruby 2.0...?
+            value = record.instance_variable_get("@#{association.to_s}")
+            if value && !value.kind_of?(Array) && record.respond_to?(:attributes) && !value.kind_of?(record.attributes[association])
+              record.errors[association] = "is not of type #{record.attributes[association]}"
+            elsif value && value.kind_of?(Array)
+              record.errors[association] = "is invalid" if value.any? { |v| not v.valid? }
+            else
+              record.errors[association] = "is invalid" if value && value.invalid?
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/attribute_support.rb

@@ -0,0 +1,207 @@
+require 'active_support'
+# TODO: Move this into a separate core_ext folder like for instance Rails does.
+# WARNING: Monkey patches below...
+class Symbol
+  def self.deserialize_from_json(value)
+    value.try(:to_sym)
+  end
+end
+
+class String
+  def self.deserialize_from_json(value)
+    value
+  end
+end
+
+class Integer
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : value.to_i
+  end
+end
+
+class Boolean
+  def self.deserialize_from_json(value)
+    value.nil? ? nil : (value.present? ? value : false)
+  end
+end
+
+class Date
+  def self.deserialize_from_json(value)
+    value.nil? ? nil : Date.iso8601(value.dup)
+  end
+end
+
+class DateTime
+  def self.deserialize_from_json(value)
+    value.nil? ? nil : DateTime.iso8601(value.dup)
+  end
+end
+
+class Array
+  def self.deserialize_from_json(value)
+    value
+  end
+end
+
+module Sequent
+  module Core
+    module Helpers
+      # Provides functionality for defining attributes with their types
+      #
+      # Since our Commands and ValueObjects are not backed by a database like e.g. rails
+      # we can not infer their types. We need the types to be able to parse from and to json.
+      # We could have stored te type information in the json, but we didn't.
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::ValueObject, Sequent::Core::Event or Sequent::Core::BaseCommand you will
+      # get this functionality for free.
+      #
+      module AttributeSupport
+        # module containing class methods to be added
+        module ClassMethods
+
+          def types
+            @types ||= {}
+            if @merged_types
+              @merged_types
+            else
+              @merged_types = is_a?(Class) && superclass.respond_to?(:types) ? @types.merge(superclass.types) : @types
+              included_modules.select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }.each do |mod|
+                @merged_types.merge!(mod.types)
+              end
+              @merged_types
+            end
+          end
+
+          def attrs(args)
+            @types ||= {}
+            @types.merge!(args)
+            args.each do |attribute, _|
+              attr_accessor attribute
+            end
+
+            # Generate method that sets all defined attributes based on the attrs hash.
+            class_eval <<EOS
+              def update_all_attributes(attrs)
+                super if defined?(super)
+                #{@types.map { |attribute, _|
+              "@#{attribute} = attrs[:#{attribute}]"
+            }.join("\n            ")}
+                self
+              end
+EOS
+
+            class_eval <<EOS
+               def update_all_attributes_from_json(attrs)
+                 super if defined?(super)
+                 #{@types.map { |attribute, type|
+              "@#{attribute} = #{type}.deserialize_from_json(attrs['#{attribute}'])"
+            }.join("\n           ")}
+               end
+EOS
+          end
+
+          #
+          # Allows you to define something is an array of a type
+          # Example:
+          #
+          #   attrs trainees: array(Person)
+          #
+          def array(type)
+            ArrayWithType.new(type)
+          end
+
+          def deserialize_from_json(args)
+            unless args.nil?
+              obj = allocate()
+              obj.update_all_attributes_from_json(args)
+              obj
+            end
+          end
+
+
+          def numeric?(object)
+            true if Float(object) rescue false
+          end
+
+        end
+
+        # extend host class with class methods when we're included
+        def self.included(host_class)
+          host_class.extend(ClassMethods)
+        end
+
+
+        # needed for active module JSON serialization
+        def attributes
+          self.class.types
+        end
+
+        def validation_errors(prefix = nil)
+          result = errors.to_hash
+          self.class.types.each do |field|
+            value = self.instance_variable_get("@#{field[0]}")
+            if value.respond_to? :validation_errors
+              value.validation_errors.each { |k, v| result["#{field[0].to_s}_#{k.to_s}".to_sym] = v }
+            end
+          end
+          prefix ? HashWithIndifferentAccess[result.map { |k, v| ["#{prefix}_#{k}", v] }] : result
+        end
+
+        # If you have a Date object validate it with this method when the unparsed input is a String
+        # This scenario is typically when a date is posted from the web.
+        #
+        # Example
+        #
+        #   class Person < Sequent::Core::ValueObject
+        #     attrs date_of_birth: Date
+        #
+        #     validate :valid_date
+        #   end
+        #
+        # If the date_of_birth is a valid date it will be parsed into a proper Date object.
+        # This implementation currently only support dd-mm-yyyy format.
+        def valid_date
+          self.class.types.each do |name, clazz|
+            if clazz == Date
+              return if self.instance_variable_get("@#{name}").kind_of? Date
+              unless self.instance_variable_get("@#{name}").blank?
+                if (/\d{2}-\d{2}-\d{4}/ =~ self.instance_variable_get("@#{name}")).nil?
+                  @errors.add(name.to_s, :invalid_date) if (/\d{2}-\d{2}-\d{4}/ =~ self.instance_variable_get("@#{name}")).nil?
+                else
+                  begin
+                    self.instance_variable_set "@#{name}", Date.strptime(self.instance_variable_get("@#{name}"), "%d-%m-%Y")
+                  rescue
+                    @errors.add(name.to_s, :invalid_date)
+                  end
+                end
+              end
+
+            end
+          end
+        end
+
+      end
+
+      class ArrayWithType
+        attr_accessor :item_type
+
+        def initialize(item_type)
+          raise "needs a item_type" unless item_type
+          @item_type = item_type
+        end
+
+        def deserialize_from_json(value)
+          value.nil? ? nil : value.map { |item| item_type.deserialize_from_json(item) }
+        end
+
+        def to_s
+          "Sequent::Core::Helpers::ArrayWithType.new(#{item_type})"
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/sequent/core/helpers/boolean_support.rb

@@ -0,0 +1,36 @@
+module Sequent
+  module Core
+    module Helpers
+      #
+      # Parses the strings "true", "false" and nil to true, false, false
+      #
+      # You need to include this module explicitly when working with booleans.
+      #
+      # Example:
+      #
+      #   class Registration < Sequent::Core::ValueObject
+      #     include Sequent::Core::Helpers::BooleanSupport
+      #     attrs accepted_terms: Boolean
+      #   end
+      module BooleanSupport
+
+        def self.included(base)
+          base.before_validation :parse_booleans
+        end
+
+        def parse_booleans
+          attributes.each do |name, type|
+            if type == Boolean
+              raw_value = self.instance_variable_get("@#{name}")
+              return if raw_value.kind_of? Boolean
+              return unless [nil, "true", "false"].include?(raw_value)
+              bool_value = raw_value == "true" ? true : false
+              self.instance_variable_set "@#{name}", bool_value
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/core/helpers/copyable.rb

@@ -0,0 +1,25 @@
+module Sequent
+  module Core
+    module Helpers
+      # Make a deep clone of an object that include AttributeSupport
+      #
+      #   person = Person.new(name: 'Ben').copy(name: 'Kim')
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::ValueObject, Sequent::Core::Event or Sequent::Core::BaseCommand you will
+      # get this functionality for free.
+      #
+      module Copyable
+        def copy(attrs = {})
+          the_copy = Marshal.load(Marshal.dump(self))
+          attrs.each do |name, value|
+            the_copy.send("#{name}=", value)
+          end
+          the_copy
+        end
+
+      end
+    end
+  end
+end
+

data/lib/sequent/core/helpers/equal_support.rb

@@ -0,0 +1,41 @@
+module Sequent
+  module Core
+    module Helpers
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::ValueObject, Sequent::Core::Event or Sequent::Core::BaseCommand you will
+      # get this functionality for free.
+      #
+      module EqualSupport
+        def ==(other)
+          return false if other == nil
+          return false if self.class != other.class
+          self.class.types.each do |name, _|
+            self_value = self.send(name)
+            other_value = other.send(name)
+            if self_value.class == DateTime && other_value.class == DateTime
+              # we don't care about milliseconds. If you know a better way of checking for equality please improve.
+              return false unless (self_value.iso8601 == other_value.iso8601)
+            else
+              return false unless (self_value == other_value)
+            end
+          end
+          true
+        end
+
+        def hash
+          hash = 17
+          self.class.types.each do |name, _|
+            hash = hash * 31 + self.send(name).hash
+          end
+          hash
+        end
+
+        def eql?(other)
+          self == other
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/core/helpers/helpers.rb

@@ -0,0 +1,9 @@
+require_relative 'uuid_helper'
+require_relative 'copyable'
+require_relative 'attribute_support'
+require_relative 'equal_support'
+require_relative 'param_support'
+require_relative 'mergable'
+require_relative 'association_validator'
+require_relative 'string_support'
+require_relative 'boolean_support'

data/lib/sequent/core/helpers/mergable.rb

@@ -0,0 +1,21 @@
+module Sequent
+  module Core
+    module Helpers
+      # Looks like Copyable but changes this instance
+      #
+      #   ben = Person.new(name: 'Ben').merge!(name: 'Ben Vonk')
+      #
+      module Mergable
+
+        def merge!(attrs = {})
+          attrs.each do |name, value|
+            self.send("#{name}=", value)
+          end
+          self
+        end
+
+      end
+    end
+  end
+end
+

data/lib/sequent/core/helpers/param_support.rb

@@ -0,0 +1,80 @@
+require 'active_support'
+
+module Sequent
+  module Core
+    module Helpers
+      # Class to support binding from a params hash like the one from Sinatra
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::ValueObject, Sequent::Core::Event or Sequent::Core::BaseCommand you will
+      # get this functionality for free.
+      #
+      module ParamSupport
+        module ClassMethods
+          def from_params(params = {})
+            result = allocate
+            params = HashWithIndifferentAccess.new(params)
+            result.attributes.each do |attribute, type|
+              value = params[attribute]
+
+              next if value.blank?
+              if type.respond_to? :from_params
+                value = type.from_params(value)
+              elsif type.is_a? Sequent::Core::Helpers::ArrayWithType
+                value = value.map { |v| type.item_type.from_params(v) }
+              elsif type <= Date
+                value = Date.strptime(value, "%d-%m-%Y") if value
+              end
+              result.instance_variable_set(:"@#{attribute}", value)
+            end
+            result
+          end
+
+        end
+        # extend host class with class methods when we're included
+        def self.included(host_class)
+          host_class.extend(ClassMethods)
+        end
+
+        def to_params(root)
+          make_params root, as_params
+        end
+
+        def as_params
+          hash = HashWithIndifferentAccess.new
+          self.class.types.each do |field|
+            value = self.instance_variable_get("@#{field[0]}")
+            next if field[0] == "errors"
+            if value.respond_to?(:as_params) && value.kind_of?(ValueObject)
+              value = value.as_params
+            elsif value.kind_of?(Array)
+              value = value.map { |val| val.kind_of?(ValueObject) ? val.as_params : val }
+            elsif value.kind_of? Date
+              value = value.strftime("%d-%m-%Y") if value
+            end
+            hash[field[0]] = value
+          end
+          hash
+        end
+
+        private
+        def make_params(root, hash)
+          result={}
+          hash.each do |k, v|
+            key = "#{root}[#{k}]"
+            if v.is_a? Hash
+              make_params(key, v).each do |k, v|
+                result[k] = v.nil? ? "" : v.to_s
+              end
+            elsif v.is_a? Array
+              result[key] = v
+            else
+              result[key] = v.nil? ? "" : v.to_s
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/self_applier.rb

@@ -0,0 +1,45 @@
+module Sequent
+  module Core
+    module Helpers
+      ##
+      # Creates ability to use DSL like:
+      # class MyEventHandler < Sequent::Core::BaseEventHandler
+      #
+      #   on MyEvent do |event|
+      #     do_some_logic
+      #   end
+      # end
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::AggregateRoot, Sequent::Core::BaseEventHandler or Sequent::Core::BaseCommandHandler
+      # you will get this functionality for free.
+      #
+      module SelfApplier
+
+        module ClassMethods
+
+          def on(*message_classes, &block)
+            @message_mapping ||= {}
+            message_classes.each { |message_class| @message_mapping[message_class] = block }
+          end
+
+          def message_mapping
+            @message_mapping || {}
+          end
+        end
+
+        def self.included(host_class)
+          host_class.extend(ClassMethods)
+        end
+
+        def handle_message(message)
+          handler = self.class.message_mapping[message.class]
+          self.instance_exec(message, &handler) if handler
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/sequent/core/helpers/string_support.rb

@@ -0,0 +1,22 @@
+module Sequent
+  module Core
+    module Helpers
+      #
+      # You typically do not need to include this module in your classes. If you extend from
+      # Sequent::Core::ValueObject, Sequent::Core::Event or Sequent::Core::BaseCommand you will
+      # get this functionality for free.
+      #
+      module StringSupport
+        def to_s
+          s = "#{self.class.name}: "
+          self.instance_variables.each do |name|
+            value = self.instance_variable_get("#{name}")
+            s += "#{name}=[#{value}], "
+          end
+          "{" + s.chomp(", ") + "}"
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/core/helpers/uuid_helper.rb

@@ -0,0 +1,17 @@
+require 'securerandom'
+
+module Sequent
+  module Core
+    module Helpers
+      module UuidHelper
+
+        def new_uuid
+          SecureRandom.uuid
+        end
+
+        module_function :new_uuid
+
+      end
+    end
+  end
+end