sequent 0.1.1 → 0.1.2

data/lib/sequent/core/record_sessions/active_record_session.rb

@@ -0,0 +1,92 @@
+require 'active_record'
+
+module Sequent
+  module Core
+    module RecordSessions
+      #
+      # Session objects are used to update view state
+      #
+      # The ActiveRecordSession object can be used when you use ActiveRecord as view state store.
+      #
+      class ActiveRecordSession
+
+        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
+          defaults = {update_sequence_number: true}
+          args = defaults.merge(options)
+          record = record_class.unscoped.where(where_clause).first
+          raise("Record of class #{record_class} with where clause #{where_clause} not found while handling event #{event}") unless record
+          yield record if block_given?
+          record.sequence_number = event.sequence_number if args[:update_sequence_number]
+          record.updated_at = event.created_at if record.respond_to?(:updated_at)
+          record.save!
+        end
+
+        def create_record(record_class, values)
+          record = new_record(record_class, values)
+          yield record if block_given?
+          record.save!
+          record
+        end
+
+        def create_or_update_record(record_class, values, created_at = Time.now)
+          record = get_record(record_class, values)
+          unless record
+            record = new_record(record_class, values.merge(created_at: created_at))
+          end
+          yield record
+          record.save!
+          record
+        end
+
+        def get_record!(record_class, where_clause)
+          record_class.unscoped.where(where_clause).first!
+        end
+
+        def get_record(record_class, where_clause)
+          record_class.unscoped.where(where_clause).first
+        end
+
+        def delete_all_records(record_class, where_clause)
+          record_class.unscoped.where(where_clause).delete_all
+        end
+
+        def delete_record(_, record)
+          record.destroy
+        end
+
+        def update_all_records(record_class, where_clause, updates)
+          record_class.unscoped.where(where_clause).update_all(updates)
+        end
+
+        def do_with_records(record_class, where_clause)
+          record_class.unscoped.where(where_clause).each do |record|
+            yield record
+            record.save!
+          end
+        end
+
+        def do_with_record(record_class, where_clause)
+          record = record_class.unscoped.where(where_clause).first!
+          yield record
+          record.save!
+        end
+
+        def find_records(record_class, where_clause)
+          record_class.unscoped.where(where_clause)
+        end
+
+        def last_record(record_class, where_clause)
+          record_class.unscoped.where(where_clause).last
+        end
+
+        private
+
+        def new_record(record_class, values)
+          record_class.unscoped.new(values)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sequent/core/record_sessions/record_sessions.rb

@@ -0,0 +1,2 @@
+require_relative 'active_record_session'
+require_relative 'replay_events_session'

data/lib/sequent/core/record_sessions/replay_events_session.rb

@@ -0,0 +1,306 @@
+require 'set'
+require 'active_record'
+
+module Sequent
+  module Core
+    module RecordSessions
+      #
+      # Session objects are used to update view state
+      #
+      # The ReplayEventsSession is optimized for bulk loading records in a Postgres database using CSV import.
+      #
+      # After lot of experimenting this turned out to be the fastest way to to bulk inserts in the database.
+      # You can tweak the amount of records in the CSV via +insert_with_csv_size+ before
+      # it flushes to the database to gain (or loose) speed.
+      #
+      # It is highly recommended to create +indices+ on the in memory +record_store+ to speed up the processing.
+      # By default all records are indexed by +aggregate_id+ if they have such a property.
+      #
+      # Example:
+      #
+      #   class InvoiceEventHandler < Sequent::Core::BaseEventHandler
+      #     on RecipientMovedEvent do |event|
+      #       update_all_records InvoiceRecord, recipient_id: event.recipient.aggregate_id do |record|
+      #         record.recipient_street = record.recipient.street
+      #       end
+      #     end
+      #   end
+      #
+      # In this case it is wise to create an index on InvoiceRecord on the recipient_id like you would in the database.
+      #
+      # Example:
+      #
+      #   ReplayEventsSession.new(
+      #     50,
+      #     {InvoiceRecord => [[:recipient_id]]}
+      #   )
+      class ReplayEventsSession
+
+        attr_reader :record_store
+        attr_accessor :insert_with_csv_size
+
+        def self.struct_cache
+          @struct_cache ||= {}
+        end
+
+        module InitStruct
+          def set_values(values)
+            values.each do |k, v|
+              self[k] = v
+            end
+            self
+          end
+        end
+
+        # +insert_with_csv_size+ number of records to insert in a single batch
+        #
+        # +indices+ Hash of indices to create in memory. Greatly speeds up the replaying.
+        #   Key corresponds to the name of the 'Record'
+        #   Values contains list of lists on which columns to index. E.g. [[:first_index_column], [:another_index, :with_to_columns]]
+        def initialize(insert_with_csv_size = 50, indices = {})
+          @insert_with_csv_size = insert_with_csv_size
+          @record_store = Hash.new { |h, k| h[k] = Set.new }
+          @record_index = {}
+          @indices = indices
+        end
+
+        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
+          defaults = {update_sequence_number: true}
+          args = defaults.merge(options)
+          record = get_record!(record_class, where_clause)
+          record.updated_at = event.created_at if record.respond_to?(:updated_at)
+          yield record if block_given?
+          record.sequence_number = event.sequence_number if args[:update_sequence_number]
+        end
+
+        def create_record(record_class, values)
+          column_names = record_class.column_names
+          values.merge!(updated_at: values[:created_at]) if column_names.include?("updated_at")
+          struct_class_name = "#{record_class.to_s}Struct"
+          if self.class.struct_cache.has_key?(struct_class_name)
+            struct_class = self.class.struct_cache[struct_class_name]
+          else
+
+            # We create a struct on the fly.
+            # Since the replay happens in memory we implement the ==, eql? and hash methods
+            # to point to the same object. A record is the same if and only if they point to
+            # the same object. These methods are necessary since we use Set instead of [].
+            class_def=<<-EOD
+      #{struct_class_name} = Struct.new(*#{column_names.map(&:to_sym)})
+              class #{struct_class_name}
+                include InitStruct
+                def ==(other)
+                  return true if self.equal?(other)
+                  super
+                end
+                def eql?(other)
+                  self == other
+                end
+                def hash
+                  self.object_id.hash
+                end
+              end
+            EOD
+            eval("#{class_def}")
+            struct_class = ReplayEventsSession.const_get(struct_class_name)
+            self.class.struct_cache[struct_class_name] = struct_class
+          end
+          record = struct_class.new.set_values(values)
+
+          yield record if block_given?
+          @record_store[record_class] << record
+          if record.respond_to? :aggregate_id
+            @record_index[[record_class, record.aggregate_id]] = record
+          end
+
+          if indexed?(record_class)
+            do_with_cache_keys(record_class, record) do |key|
+              @record_index[key] = [] unless @record_index.has_key?(key)
+              @record_index[key] << record
+            end
+          end
+          record
+        end
+
+        def create_or_update_record(record_class, values, created_at = Time.now)
+          record = get_record(record_class, values)
+          unless record
+            record = create_record(record_class, values.merge(created_at: created_at))
+          end
+          yield record if block_given?
+          record
+        end
+
+        def get_record!(record_class, where_clause)
+          record = get_record(record_class, where_clause)
+          raise("record #{record_class} not found for #{where_clause}, store: #{@record_store[record_class]}") unless record
+          record
+        end
+
+        def get_record(record_class, where_clause)
+          results = find_records(record_class, where_clause)
+          results.empty? ? nil : results.first
+        end
+
+        def delete_all_records(record_class, where_clause)
+          find_records(record_class, where_clause).each do |record|
+            delete_record(record_class, record)
+          end
+        end
+
+        def delete_record(record_class, record)
+          @record_store[record_class].delete(record)
+          if indexed?(record_class)
+            do_with_cache_keys(record_class, record) do |key|
+              @record_index[key].delete(record) if @record_index.has_key?(key)
+            end
+          end
+        end
+
+        def update_all_records(record_class, where_clause, updates)
+          find_records(record_class, where_clause).each do |record|
+            updates.each_pair do |k, v|
+              record[k.to_sym] = v
+            end
+          end
+        end
+
+        def do_with_records(record_class, where_clause)
+          records = find_records(record_class, where_clause)
+          records.each do |record|
+            yield record
+          end
+        end
+
+        def do_with_record(record_class, where_clause)
+          record = get_record!(record_class, where_clause)
+          yield record
+        end
+
+        def find_records(record_class, where_clause)
+          if where_clause.has_key? :aggregate_id and where_clause.size == 1
+            [@record_index[[record_class, where_clause[:aggregate_id]]]].compact
+          elsif use_index?(record_class, where_clause)
+            values = get_index(record_class, where_clause).map { |field| where_clause[field] }
+            @record_index[[record_class, *values]] || []
+          else
+            @record_store[record_class].select do |record|
+              where_clause.all? do |k, v|
+                expected_value = v.kind_of?(Symbol) ? v.to_s : v
+                actual_value = record[k.to_sym]
+                actual_value = actual_value.to_s if actual_value.kind_of? Symbol
+                if expected_value.kind_of?(Array)
+                  expected_value.include?(actual_value)
+                else
+                  actual_value == expected_value
+                end
+              end
+
+            end
+          end.dup
+        end
+
+        def last_record(record_class, where_clause)
+          results = find_records(record_class, where_clause)
+          results.empty? ? nil : results.last
+        end
+
+        def commit
+          begin
+            @record_store.each do |clazz, records|
+              if records.size > @insert_with_csv_size
+                csv = CSV.new("")
+                column_names = clazz.column_names.reject { |name| name == "id" }
+                records.each do |obj|
+                  begin
+                    csv << column_names.map do |column_name|
+                      obj[column_name]
+                    end
+                  end
+                end
+
+                buf = ''
+                conn = ActiveRecord::Base.connection.raw_connection
+                copy_data = StringIO.new csv.string
+                conn.transaction do
+                  conn.exec("COPY #{clazz.table_name} (#{column_names.join(",")}) FROM STDIN WITH csv")
+                  begin
+                    while copy_data.read(1024, buf)
+                      ### Uncomment this to test error-handling for exceptions from the reader side:
+                      # raise Errno::ECONNRESET, "socket closed while reading"
+                      until conn.put_copy_data(buf)
+                        sleep 0.1
+                      end
+                    end
+                  rescue Errno => err
+                    errmsg = "%s while reading copy data: %s" % [err.class.name, err.message]
+                    conn.put_copy_end(errmsg)
+                  ensure
+                    conn.put_copy_end
+                    copy_data.close
+                    while res = conn.get_result
+                      status = res.res_status(res.result_status)
+                      if status != "PGRES_COMMAND_OK"
+                        raise "Postgres copy command failed: #{status}, #{res.error_message}"
+                      end
+                    end
+                  end
+                end
+
+              else
+
+                clazz.unscoped do
+                  inserts = []
+                  column_names = clazz.column_names.reject { |name| name == "id" }
+                  prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
+                  records.each do |r|
+                    values = column_names.map { |name| r[name.to_sym] }
+                    inserts << values
+                  end
+                  sql = %Q{insert into #{clazz.table_name} (#{column_names.join(",")}) values (#{prepared_values})}
+                  inserts.each do |insert|
+                    clazz.connection.raw_connection.async_exec(sql, insert)
+                  end
+                end
+              end
+            end
+
+
+          ensure
+            clear
+          end
+        end
+
+        def clear
+          @record_store.clear
+          @record_index.clear
+        end
+
+        private
+        def indexed?(record_class)
+          @indices.has_key?(record_class)
+        end
+
+        def do_with_cache_keys(record_class, record)
+          @indices[record_class].each do |index|
+            cache_key = [record_class]
+            index.each do |key|
+              cache_key << record[key]
+            end
+            yield cache_key
+          end
+        end
+
+        def use_index?(record_class, where_clause)
+          @indices.has_key?(record_class) and @indices[record_class].any? { |indexed_where| where_clause.keys.size == indexed_where.size and (where_clause.keys - indexed_where).empty? }
+        end
+
+        def get_index(record_class, where_clause)
+          @indices[record_class].find { |indexed_where| where_clause.keys.size == indexed_where.size and (where_clause.keys - indexed_where).empty? }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sequent/core/tenant_event_store.rb

@@ -0,0 +1,18 @@
+##
+# Multi-tenant event store that replays events grouped by a specific tenant.
+#
+module Sequent
+  module Core
+    class TenantEventStore < EventStore
+
+      def replay_events_for(organization_id)
+        replay_events do
+          aggregate_ids = @record_class.connection.select_all("select distinct aggregate_id from #{@record_class.table_name} where organization_id = '#{organization_id}'").map { |hash| hash["aggregate_id"] }
+          @record_class.connection.select_all("select id, event_type, event_json from #{@record_class.table_name} where aggregate_id in (#{aggregate_ids.map { |id| %Q{'#{id}'} }.join(",")}) order by id")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/sequent/core/transactions/active_record_transaction_provider.rb

@@ -0,0 +1,16 @@
+module Sequent
+  module Core
+    module Transactions
+
+      class ActiveRecordTransactionProvider
+        def transactional
+          ActiveRecord::Base.transaction do
+            yield
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sequent/core/transactions/no_transactions.rb

@@ -0,0 +1,13 @@
+module Sequent
+  module Core
+    module Transactions
+
+      class NoTransactions
+        def transactional
+          yield
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/core/transactions/transactions.rb

@@ -0,0 +1,2 @@
+require_relative 'active_record_transaction_provider'
+require_relative 'no_transactions'

data/lib/sequent/core/value_object.rb

@@ -0,0 +1,48 @@
+require 'active_model'
+require_relative 'helpers/string_support'
+require_relative 'helpers/equal_support'
+require_relative 'helpers/copyable'
+require_relative 'helpers/attribute_support'
+require_relative 'helpers/param_support'
+
+module Sequent
+
+  module Core
+    #
+    # ValueObject is a container for data that belongs together but requires no identity
+    #
+    # If something requires identity is up to you to decide. An example in for instance
+    # the invoicing domain could be a person's Address.
+    #
+    #   class Address < Sequent::Core::ValueObject
+    #     attrs street: String, city: String, country: Country
+    #   end
+    #
+    # A ValueObject is equal to another ValueObject if and only if all +attrs+ are equal.
+    #
+    # You can copy a valueobject as follows:
+    #
+    #   new_address = address.copy(street: "New Street")
+    #
+    # This a deep clone of the address with the street attribute containing "New Street"
+    class ValueObject
+      include Sequent::Core::Helpers::StringSupport,
+              Sequent::Core::Helpers::EqualSupport,
+              Sequent::Core::Helpers::Copyable,
+              Sequent::Core::Helpers::AttributeSupport,
+              Sequent::Core::Helpers::ParamSupport,
+              ActiveModel::Serializers::JSON,
+              ActiveModel::Validations
+
+      self.include_root_in_json=false
+
+      def initialize(args = {})
+        @errors = ActiveModel::Errors.new(self)
+        update_all_attributes args
+      end
+
+    end
+
+  end
+end
+

data/lib/sequent/migrations/migrate_events.rb

@@ -0,0 +1,53 @@
+##
+# When you need to upgrade the event store based on information of the previous schema version
+# this is the place you need to implement a migration.
+# Examples are: corrupt events (due to insufficient testing for instance...)
+# or adding extra events to the event stream if a new concept is introduced.
+#
+# To implement a migration you should create a class according to the following contract:
+# module Database
+#   class MigrateToVersionXXX
+#     def initialize(env)
+#       @env = env
+#     end
+#
+#     def migrate
+#       # your migration code here...
+#     end
+#   end
+# end
+#
+module Sequent
+  module Migrations
+    class MigrateEvents
+
+      ##
+      # @param env The string representing the current environment. E.g. "development", "production"
+      def initialize(env)
+        @env = env
+      end
+
+      ##
+      #
+      # @param current_version The current version of the application. E.g. 10
+      # @param new_version The version to migrate to. E.g. 11
+      # @param &after_migration_block an optional block to run after the migrations run. E.g. close resources
+      #
+      def execute_migrations(current_version, new_version, &after_migration_block)
+        if current_version != new_version and current_version > 0
+          ((current_version + 1)..new_version).each do |upgrade_to_version|
+            migration_class = "MigrateToVersion#{upgrade_to_version}".to_sym
+            if Kernel.const_defined?(migration_class)
+              begin
+                Kernel.const_get(migration_class).new(@env).migrate
+              ensure
+                after_migration_block.call if after_migration_block
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/migrations/migrations.rb

@@ -0,0 +1,7 @@
+module Sequent
+  module Migrations
+
+  end
+end
+
+require_relative 'migrate_events'

data/lib/sequent/sequent.rb

@@ -0,0 +1,3 @@
+require_relative 'core/core'
+require_relative 'migrations/migrations'
+require_relative 'test/test'

data/lib/sequent/test/command_handler_helpers.rb

@@ -0,0 +1,101 @@
+module Sequent
+  module Test
+    ##
+    # Use in tests
+    #
+    # This provides a nice DSL for event based testing of your CommandHandler like
+    #
+    # given_events InvoiceCreatedEvent.new(args)
+    # when_command PayInvoiceCommand(args)
+    # then_events InvoicePaidEvent(args)
+    #
+    # Example for Rspec config
+    #
+    # RSpec.configure do |config|
+    #   config.include Sequent::Test::CommandHandlerHelpers
+    # end
+    #
+    # Then in a spec
+    #
+    # describe InvoiceCommandHandler do
+    #
+    #   before :each do
+    #     @event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
+    #     @repository = Sequent::Core::AggregateRepository.new(@event_store)
+    #     @command_handler = InvoiceCommandHandler.new(@repository)
+    #   end
+    #
+    #   it "marks an invoice as paid" do
+    #     given_events InvoiceCreatedEvent.new(args)
+    #     when_command PayInvoiceCommand(args)
+    #     then_events InvoicePaidEvent(args)
+    #   end
+    #
+    # end
+    module CommandHandlerHelpers
+
+      class FakeEventStore
+        def initialize
+          @all_events = []
+          @stored_events = []
+        end
+
+        def load_events(aggregate_id)
+          deserialize_events(@all_events).select { |event| aggregate_id == event.aggregate_id }
+        end
+
+        def stored_events
+          deserialize_events(@stored_events)
+        end
+
+        def commit_events(_, events)
+          serialized = serialize_events(events)
+          @all_events += serialized
+          @stored_events += serialized
+        end
+
+        def given_events(events)
+          @all_events += serialize_events(events)
+          @stored_events = []
+        end
+
+        private
+        def serialize_events(events)
+          events.map { |event| [event.class.name.to_sym, event.to_json] }
+        end
+
+        def deserialize_events(events)
+          events.map do |type, json|
+            Class.const_get(type).deserialize_from_json(JSON.parse(json))
+          end
+        end
+
+      end
+
+      def given_events *events
+        raise ArgumentError.new("events can not be nil") if events.compact.empty?
+        @event_store.given_events(events)
+      end
+
+      def when_command command
+        raise "@command_handler is mandatory when using the #{self.class}" unless @command_handler
+        raise "Command handler #{@command_handler} cannot handle command #{command}, please configure the command type (forgot an include in the command class?)" unless @command_handler.handles_message?(command)
+        @command_handler.handle_message(command)
+        @repository.commit(command)
+      end
+
+      def then_events *events
+        @event_store.stored_events.map(&:class).should == events.map(&:class)
+        @event_store.stored_events.zip(events).each do |actual, expected|
+          JSON.parse(actual.payload.to_json).should == JSON.parse(expected.payload.to_json) if expected
+        end
+      end
+
+      def then_no_events
+        then_events
+      end
+
+    end
+
+  end
+end

data/lib/sequent/test/test.rb

@@ -0,0 +1 @@
+require_relative 'command_handler_helpers'

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Sequent
+  VERSION = '0.1.2'
+end