sequent 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b29c09f7745423baaf4a1fdf5954fbc1c3b2da0dbcd6fcacc39f736bf182d4a
-  data.tar.gz: cdf428e608251b1e258b9c8cf55cece3994fb8c06861960be788c0ab285701f9
+  metadata.gz: 8c1a651a4d982304df2f61362bcefc1736a1eecb6a0693f0da66e95319199311
+  data.tar.gz: '0168575dabe5b65335e56b3feb815c3e8c8abb7b413ae94c271f3480e58fc327'
 SHA512:
-  metadata.gz: dcfcea2c8f881ab307d2416573da1f3e751d893471cf2d8997b13f29a1bef15e57f6dffb5167f9b822baaff92670a9db95a32dc62d0b66ecf046390a47f5e3d8
-  data.tar.gz: 14b30c86e2f66d037278fb3819e8604c9c264556f30c7c817eadbb698d3bdb1d343b5f26cf6989ddeef90b06f4d830392afb19ccbeab1ccc19e3ab2334e06731
+  metadata.gz: 39d2faaf084d719c881b9901977bc96b38d8054fd24061d6104ee9036a5e9971565c60cde02f9b874efe722c79d847d544639a08eea6a693d7d027ba8ac49348
+  data.tar.gz: 3a4d7fdd19a09aad5e603d04c571d1c84ff53a63cfaf5571259dc250a4a5b08e7872a98e2ea367a27d719131d49d102da4dfab621e33c8209c88c24b173409e0

data/lib/sequent/configuration.rb

@@ -24,6 +24,8 @@ module Sequent
     DEFAULT_OFFLINE_REPLAY_PERSISTOR_CLASS = Sequent::Core::Persistors::ActiveRecordPersistor
     DEFAULT_ONLINE_REPLAY_PERSISTOR_CLASS = Sequent::Core::Persistors::ActiveRecordPersistor
 
+    DEFAULT_EVENT_RECORD_HOOKS_CLASS = Sequent::Core::EventRecordHooks
+
     attr_accessor :aggregate_repository
 
     attr_accessor :event_store,
@@ -34,6 +36,8 @@ module Sequent
                   :transaction_provider,
                   :event_publisher
 
+    attr_accessor :event_record_hooks_class
+
     attr_accessor :command_handlers,
                   :command_filters
 
@@ -80,7 +84,7 @@ module Sequent
       self.event_record_class = Sequent::Core::EventRecord
       self.stream_record_class = Sequent::Core::StreamRecord
       self.snapshot_event_class = Sequent::Core::SnapshotEvent
-      self.transaction_provider = Sequent::Core::Transactions::NoTransactions.new
+      self.transaction_provider = Sequent::Core::Transactions::ActiveRecordTransactionProvider.new
       self.uuid_generator = Sequent::Core::RandomUuidGenerator
       self.event_publisher = Sequent::Core::EventPublisher.new
       self.disable_event_handlers = false
@@ -92,6 +96,8 @@ module Sequent
       self.migrations_class_name = MIGRATIONS_CLASS_NAME
       self.number_of_replay_processes = DEFAULT_NUMBER_OF_REPLAY_PROCESSES
 
+      self.event_record_hooks_class = DEFAULT_EVENT_RECORD_HOOKS_CLASS
+
       self.offline_replay_persistor_class = DEFAULT_OFFLINE_REPLAY_PERSISTOR_CLASS
       self.online_replay_persistor_class = DEFAULT_ONLINE_REPLAY_PERSISTOR_CLASS
       self.database_config_directory = DEFAULT_DATABASE_CONFIG_DIRECTORY

data/lib/sequent/core/aggregate_repository.rb

@@ -28,6 +28,8 @@ module Sequent
         end
       end
 
+      class HasUncommittedEvents < StandardError; end
+
       # Adds the given aggregate to the repository (or unit of work).
       #
       # Only when +commit+ is called all aggregates in the unit of work are 'processed'
@@ -123,6 +125,14 @@ module Sequent
         Thread.current[AGGREGATES_KEY] = nil
       end
 
+      # Clears the Unit of Work.
+      #
+      # A +HasUncommittedEvents+ is raised when there are uncommitted_events in the Unit of Work.
+      def clear!
+        fail HasUncommittedEvents if aggregates.values.any? { |x| !x.uncommitted_events.empty? }
+        clear
+      end
+
       private
 
       def aggregates

data/lib/sequent/core/aggregate_root.rb

@@ -1,9 +1,11 @@
 require 'base64'
 require_relative 'helpers/message_handler'
+require_relative 'helpers/autoset_attributes'
 require_relative 'stream_record'
 
 module Sequent
   module Core
+
     module SnapshotConfiguration
       module ClassMethods
         ##
@@ -33,6 +35,7 @@ module Sequent
     #
     class AggregateRoot
       include Helpers::MessageHandler
+      include Helpers::AutosetAttributes
       include SnapshotConfiguration
 
       attr_reader :id, :uncommitted_events, :sequence_number, :event_stream
@@ -102,6 +105,30 @@ module Sequent
         apply_event(event)
         @uncommitted_events << event
       end
+
+      # Only apply the event if one of the attributes of the event changed
+      #
+      # on NameSet do |event|
+      #   @first_name = event.first_name
+      #   @last_name = event.last_name
+      # end
+      #
+      # # The event is applied
+      # apply_if_changed NameSet, first_name: 'Ben', last_name: 'Vonk'
+      #
+      # # This event is not applied
+      # apply_if_changed NameSet, first_name: 'Ben', last_name: 'Vonk'
+      #
+      def apply_if_changed(event_class, args = {})
+        if args.empty?
+          apply event_class
+        elsif self.class
+             .event_attribute_keys(event_class)
+             .any? { |k| instance_variable_get(:"@#{k.to_s}") != args[k.to_sym] }
+          apply event_class, args
+        end
+      end
+
     end
   end
 end

data/lib/sequent/core/command.rb

@@ -16,6 +16,7 @@ module Sequent
               Sequent::Core::Helpers::EqualSupport,
               Sequent::Core::Helpers::ParamSupport,
               Sequent::Core::Helpers::Mergable
+      include ActiveModel::Validations::Callbacks
       include Sequent::Core::Helpers::TypeConversionSupport
 
       attrs created_at: DateTime

data/lib/sequent/core/event_record.rb

@@ -4,6 +4,46 @@ require_relative 'sequent_oj'
 module Sequent
   module Core
 
+    # == Event Record Hooks
+    #
+    # These hooks are called during the life cycle of
+    # Sequent::Core::EventRecord. It is recommended to create a subclass of
+    # +Sequent::Core::EventRecordHooks+ when implementing this in your
+    # application.
+    #
+    #   Sequent.configure do |config|
+    #     config.event_record_hooks_class = MyApp::EventRecordHooks
+    #   end
+    #
+    #   module MyApp
+    #     class EventRecordHooks < Sequent::EventRecordHooks
+    #
+    #       # Adds additional metadata to the +event_records+ table.
+    #       def self.after_serialization(event_record, event)
+    #         event_record.metadata = event.metadata if event.respond_to?(:metadata)
+    #       end
+    #
+    #     end
+    #   end
+    class EventRecordHooks
+
+      # Called after assigning Sequent's event attributes to the +event_record+.
+      #
+      # *Params*
+      # - +event_record+ An instance of Sequent.configuration.event_record_class
+      # - +event+ An instance of the Sequent::Core::Event being persisted
+      #
+      #     class EventRecordHooks < Sequent::EventRecordHooks
+      #       def self.after_serialization(event_record, event)
+      #         event_record.seen_by_hook = true
+      #       end
+      #     end
+      def self.after_serialization(event_record, event)
+        # noop
+      end
+
+    end
+
     module SerializesEvent
       def event
         payload = Sequent::Core::Oj.strict_load(self.event_json)
@@ -17,6 +57,8 @@ module Sequent
         self.event_type = event.class.name
         self.created_at = event.created_at
         self.event_json = self.class.serialize_to_json(event)
+
+        Sequent.configuration.event_record_hooks_class.after_serialization(self, event)
       end
 
       module ClassMethods

data/lib/sequent/core/event_store.rb

@@ -187,18 +187,11 @@ SELECT aggregate_id
             event_stream.stream_record_id = stream_record.id
           end
           uncommitted_events.map do |event|
-            values = {
-              command_record_id: command_record.id,
-              stream_record_id: event_stream.stream_record_id,
-              aggregate_id: event.aggregate_id,
-              sequence_number: event.sequence_number,
-              event_type: event.class.name,
-              event_json: Sequent.configuration.event_record_class.serialize_to_json(event),
-              created_at: event.created_at
-            }
-            values = values.merge(organization_id: event.organization_id) if event.respond_to?(:organization_id)
-
-            Sequent.configuration.event_record_class.new(values)
+            Sequent.configuration.event_record_class.new.tap do |record|
+              record.command_record_id = command_record.id
+              record.stream_record_id = event_stream.stream_record_id
+              record.event = event
+            end
           end
         end
         connection = Sequent.configuration.event_record_class.connection

data/lib/sequent/core/ext/ext.rb

@@ -6,7 +6,7 @@ end
 
 class String
   def self.deserialize_from_json(value)
-    value
+    value&.to_s
   end
 end
 
@@ -25,7 +25,7 @@ end
 class BigDecimal
   def self.deserialize_from_json(value)
     return nil if value.nil?
-    BigDecimal.new(value)
+    BigDecimal(value)
   end
 end
 

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

@@ -0,0 +1,56 @@
+module Sequent
+  module Core
+    module Helpers
+      ##
+      # In some cases you just want to store the events as instance variables
+      # on the AggregateRoot. In that case you can use the following code:
+      #
+      # class LineItemsSet < Sequent::Event
+      #   attrs line_items: array(LineItem)
+      # end
+      #
+      # class Invoice < Sequent::AggregateRoot
+      #   self.autoset_attributes_for_events LineItemsSet
+      # end
+      #
+      # This will automatically create the following block
+      #
+      # on LineItemSet do |event|
+      #   @line_items = event.line_items
+      # end
+      #
+      # The +autoset_attributes_for_events+ will set all the defined +attrs+
+      # as instance variable, except for the ones defined in +autoset_ignore_attributes+.
+      #
+      module AutosetAttributes
+        module ClassMethods
+
+          @@autoset_ignore_attributes = %w{aggregate_id sequence_number created_at}
+
+          def set_autoset_ignore_attributes(attribute_names)
+            @@autoset_ignore_attributes = attribute_names
+          end
+
+          def event_attribute_keys(event_class)
+            event_class.types.keys.reject { |k| @@autoset_ignore_attributes.include?(k.to_s) }
+          end
+
+          def autoset_attributes_for_events(*event_classes)
+            event_classes.each do |event_class|
+              on event_class do |event|
+                self.class.event_attribute_keys(event_class).each do |attribute_name|
+                  instance_variable_set(:"@#{attribute_name.to_s}", event.send(attribute_name.to_sym))
+                end
+              end
+            end
+          end
+        end
+
+        def self.included(host_class)
+          host_class.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+require 'active_model'
+require_relative 'value_validators'
+
+module Sequent
+  module Core
+    module Helpers
+      # Validates Boolean's
+      # Automatically included when using a
+      #
+      #   attrs value: Boolean
+      #
+      # The values:
+      #
+      # `true`, `false`, `'true'`, `'false'`, `nil`, and `blank?`
+      #
+      # are considered valid Booleans.
+      #
+      # They will be converted to `true`, `false` or `nil`
+      class BooleanValidator < ActiveModel::EachValidator
+        def validate_each(subject, attribute, value)
+          subject.errors.add attribute, :invalid_boolean unless Sequent::Core::Helpers::ValueValidators.for(Boolean).valid_value?(value)
+        end
+      end
+    end
+  end
+end

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

@@ -1,11 +1,39 @@
+require_relative 'string_validator'
+require_relative 'boolean_validator'
+require_relative 'date_time_validator'
+require_relative 'date_validator'
+require_relative 'secret'
+
 module Sequent
   module Core
     module Helpers
       class DefaultValidators
         VALIDATORS = {
-          Integer => ->(klass, field) { klass.validates_numericality_of field, only_integer: true, allow_nil: true, allow_blank: true },
-          Date => ->(klass, field) { klass.validates field, "sequent::Core::Helpers::Date" => true },
-          DateTime => ->(klass, field) { klass.validates field, "sequent::Core::Helpers::DateTime" => true }
+          Integer => ->(klass, field) do
+            klass.validates_numericality_of field, only_integer: true, allow_nil: true, allow_blank: true
+          end,
+          Date => ->(klass, field) do
+            klass.validates field, "sequent::Core::Helpers::Date" => true
+          end,
+          DateTime => ->(klass, field) do
+            klass.validates field, "sequent::Core::Helpers::DateTime" => true
+          end,
+          Boolean => -> (klass, field) do
+            klass.validates field, "sequent::Core::Helpers::Boolean" => true
+          end,
+          String => -> (klass, field) do
+            klass.validates field, "sequent::Core::Helpers::String" => true
+          end,
+          Sequent::Core::Helpers::Secret => -> (klass, field) do
+            klass.after_validation do |object|
+              if object.errors&.any?
+                object.send("#{field}=", nil)
+              else
+                raw_value = object.send(field)
+                object.send("#{field}=", Sequent::Secret.new(raw_value)) if raw_value
+              end
+            end
+          end
         }
 
         def self.for(type)

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

@@ -1,13 +1 @@
-require_relative 'uuid_helper'
-require_relative 'copyable'
-require_relative 'value_validators'
-require_relative 'string_to_value_parsers'
-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 'type_conversion_support'
-require_relative 'date_validator'
-require_relative 'date_time_validator'
+Dir["#{File.dirname(__FILE__)}/*rb"].each { |f| require_relative f }

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

@@ -3,22 +3,42 @@ module Sequent
     module Helpers
       ##
       # Creates ability to use DSL like:
-      # class MyProjector < Sequent::Projector
       #
-      #   on MyEvent do |event|
-      #     do_some_logic
+      #   class MyProjector < Sequent::Projector
+      #
+      #     on MyEvent do |event|
+      #       @foo = event.foo
+      #     end
+      #
+      #   end
+      #
+      # If you extend from +Sequent::AggregateRoot+, +Sequent::Projector+, +Sequent::Workflow+
+      # or +Sequent::CommandHandler+ you will get this functionality
+      # for free.
+      #
+      # It is possible to register multiple handler blocks in the same +MessageHandler+
+      #
+      #   class MyProjector < Sequent::Projector
+      #
+      #     on MyEvent do |event|
+      #       @foo = event.foo
+      #     end
+      #
+      #     on MyEvent, OtherEvent do |event|
+      #       @bar = event.bar
+      #     end
+      #
       #   end
-      # end
       #
-      # You typically do not need to include this module in your classes. If you extend from
-      # Sequent::AggregateRoot, Sequent::Projector, Sequent::Workflow or Sequent::CommandHandler
-      # you will get this functionality for free.
+      # The order of which handler block is executed first is not guaranteed.
       #
       module MessageHandler
-
         module ClassMethods
           def on(*message_classes, &block)
-            message_classes.each { |message_class| message_mapping[message_class] = block }
+            message_classes.each do |message_class|
+              message_mapping[message_class] ||= []
+              message_mapping[message_class] << block
+            end
           end
 
           def message_mapping
@@ -35,8 +55,8 @@ module Sequent
         end
 
         def handle_message(message)
-          handler = self.class.message_mapping[message.class]
-          self.instance_exec(message, &handler) if handler
+          handlers = self.class.message_mapping[message.class]
+          handlers.each { |handler| self.instance_exec(message, &handler) } if handlers
         end
       end
     end

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

@@ -0,0 +1,124 @@
+require 'bcrypt'
+
+module Sequent
+  module Core
+    module Helpers
+
+      #
+      # You can use this in Commands to handle for instance passwords
+      # safely. It uses BCrypt to encrypt the Secret.
+      #
+      # Attributes that are of type Secret are encrypted **after** successful validation in the CommandService
+      # automatically. So there is no need to do this yourself, Sequent will take care of this for you.
+      # As a result the CommandHandlers will receive the encrypted values.
+      #
+      # Since this is meant to be used in +Command+s based on input you can
+      # put in +String+s and +Secret+s.
+      #
+      # Example usage:
+      #
+      #   class CreateUser < Sequent::Command
+      #     attrs email: String, password: Sequent::Secret
+      #   end
+      #
+      #   command = CreateUser.new(
+      #     aggregate_id: Sequent.new_uuid,
+      #     email: 'ben@sequent.io',
+      #     password: 'secret',
+      #   )
+      #
+      #   puts command.password
+      #   => secret
+      #
+      #   command.valid?
+      #   => true
+      #
+      #   command = command.parse_attrs_to_correct_types
+      #   puts command.password
+      #   => SAasdf239as$%^@#%dasfgasasdf (or something similar :-))
+      #
+      # When command validation fails attributes of type Sequent::Secret are cleared.
+      #
+      #   command.valid?
+      #   => false
+      #
+      #   puts command.password
+      #   => ''
+      #
+      # There is no real need to use this type in Events since there we are
+      # only interested in the encrypted String at that point.
+      #
+      # Besides the Sequent::Secret type there are also some helper methods available to
+      # assist in verifying secrets.
+      #
+      # See +encrypt_secret+
+      # See +re_encrypt_secret+
+      # See +verify_secret+
+      class Secret
+
+        class << self
+          def deserialize_from_json(value)
+            new(value)
+          end
+
+          ##
+          # Creates a hash for the given clear text password.
+          #
+          def encrypt_secret(clear_text_secret)
+            fail ArgumentError.new('clear_text_secret can not be blank') if clear_text_secret.blank?
+            BCrypt::Password.create(clear_text_secret)
+          end
+
+          ##
+          # Creates a hash for the given clear text secret using the given hashed secret as a salt
+          # (essentially re-creating the secret hash).
+          #
+          def re_encrypt_secret(clear_text_secret, hashed_secret)
+            fail ArgumentError.new('clear_text_secret can not be blank') if clear_text_secret.blank?
+            fail ArgumentError.new('hashed_secret can not be blank') if hashed_secret.blank?
+
+            BCrypt::Engine.hash_secret(clear_text_secret, hashed_secret)
+          end
+
+          ##
+          # Verifies that the hashed and clear text secret are equal.
+          #
+          def verify_secret(hashed_secret, clear_text_secret)
+            return false if (hashed_secret.blank? || clear_text_secret.blank?)
+
+            BCrypt::Password.new(hashed_secret) == clear_text_secret
+          end
+        end
+
+        attr_reader :value
+
+        def initialize(value)
+          fail ArgumentError.new('value can not be blank') if value.blank?
+          if value.is_a?(Secret)
+            @value = value.value
+          else
+            @value = value
+          end
+        end
+
+        def encrypt
+          @value = self.class.encrypt_secret(@value)
+          self
+        end
+
+        def verify_secret(clear_text_secret)
+          self.class.verify_secret(@value, clear_text_secret)
+        end
+
+        def ==(other)
+          return false unless other&.class == Secret
+
+          other.value == @value
+        end
+      end
+    end
+  end
+
+  # Shortcut
+  Secret = Core::Helpers::Secret
+end

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

@@ -7,14 +7,15 @@ module Sequent
       class StringToValueParsers
         PARSERS = {
           ::Symbol => ->(value) { Symbol.deserialize_from_json(value) },
-          ::String => ->(value) { value },
+          ::String => ->(value) { value&.to_s },
           ::Integer => ->(value) { parse_to_integer(value) },
           ::BigDecimal => ->(value) { parse_to_bigdecimal(value) },
           ::Float => ->(value) { parse_to_float(value) },
           ::Boolean => ->(value) { parse_to_bool(value) },
           ::Date => ->(value) { parse_to_date(value) },
           ::DateTime => ->(value) { parse_to_date_time(value) },
-          ::Sequent::Core::Helpers::ArrayWithType => ->(values, type_in_array) { parse_array(values, type_in_array) }
+          ::Sequent::Core::Helpers::ArrayWithType => ->(values, type_in_array) { parse_array(values, type_in_array) },
+          ::Sequent::Core::Helpers::Secret => ->(value) { Sequent::Core::Helpers::Secret.new(value).encrypt },
         }
 
         def self.parse_to_integer(value)
@@ -23,7 +24,7 @@ module Sequent
         end
 
         def self.parse_to_bigdecimal(value)
-          BigDecimal.new(value) unless value.blank?
+          BigDecimal(value) unless value.blank?
         end
 
         def self.parse_to_float(value)

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

@@ -0,0 +1,24 @@
+require 'active_model'
+require_relative 'value_validators'
+
+module Sequent
+  module Core
+    module Helpers
+      # Validates String's
+      # Automatically included when using a
+      #
+      #   attrs value: String
+      #
+      # Basically all ruby String are valid Strings.
+      #
+      # For now we do fail when value is not a String
+      # or contains a any chars defined in ValueValidators::INVALID_CHARS
+      #
+      class StringValidator < ActiveModel::EachValidator
+        def validate_each(subject, attribute, value)
+          subject.errors.add attribute, :invalid_string unless Sequent::Core::Helpers::ValueValidators.for(String).valid_value?(value)
+        end
+      end
+    end
+  end
+end

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

@@ -4,9 +4,13 @@ module Sequent
   module Core
     module Helpers
       class ValueValidators
+        INVALID_STRING_CHARS = [
+          "\u0000",
+        ]
+
         VALIDATORS = {
           ::Symbol => ->(_) { true },
-          ::String => ->(value) { value.nil? || value.is_a?(String) },
+          ::String => ->(value) { valid_string?(value) },
           ::Integer => ->(value) { valid_integer?(value) },
           ::Boolean => ->(value) { valid_bool?(value) },
           ::Date => ->(value) { valid_date?(value) },
@@ -36,6 +40,14 @@ module Sequent
           value.is_a?(DateTime) || !!DateTime.iso8601(value.dup) rescue false
         end
 
+        def self.valid_string?(value)
+          return true if value.nil?
+          value.to_s && !INVALID_STRING_CHARS.any? { |invalid_char| value.to_s.include?(invalid_char) }
+        rescue => e
+          p foo: e
+          false
+        end
+
         def self.for(klass)
           new(klass)
         end

data/lib/sequent/core/persistors/replay_optimized_postgres_persistor.rb

@@ -172,7 +172,7 @@ module Sequent
 
         def create_record(record_class, values)
           column_names = record_class.column_names
-          values = record_class.column_defaults.merge(values)
+          values = record_class.column_defaults.with_indifferent_access.merge(values)
           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)
@@ -300,9 +300,9 @@ module Sequent
             if records.size > @insert_with_csv_size
               csv = CSV.new("")
               column_names = clazz.column_names.reject { |name| name == "id" }
-              records.each do |obj|
+              records.each do |record|
                 csv << column_names.map do |column_name|
-                  ActiveRecord::Base.connection.type_cast(obj[column_name], @column_cache[clazz.name][column_name])
+                  cast_value_to_column_type(clazz, column_name, record)
                 end
               end
 
@@ -321,9 +321,9 @@ module Sequent
                 inserts = []
                 column_names = clazz.column_names.reject { |name| name == "id" }
                 prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
-                records.each do |r|
+                records.each do |record|
                   values = column_names.map do |column_name|
-                    ActiveRecord::Base.connection.type_cast(r[column_name.to_sym], @column_cache[clazz.name][column_name])
+                    cast_value_to_column_type(clazz, column_name, record)
                   end
                   inserts << values
                 end
@@ -342,6 +342,12 @@ module Sequent
           @record_store.clear
           @record_index.clear
         end
+
+        private
+
+        def cast_value_to_column_type(clazz, column_name, record)
+          ActiveRecord::Base.connection.type_cast(record[column_name.to_sym], @column_cache[clazz.name][column_name])
+        end
       end
     end
   end

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

@@ -7,8 +7,24 @@ module Sequent
           ActiveRecord::Base.transaction(requires_new: true) do
             yield
           end
+          after_commit_queue.each &:call
+        ensure
+          clear_after_commit_queue
         end
 
+        def after_commit(&block)
+          after_commit_queue << block
+        end
+
+        private
+
+        def after_commit_queue
+          Thread.current[:after_commit_queue] ||= []
+        end
+
+        def clear_after_commit_queue
+          Thread.current[:after_commit_queue] = []
+        end
       end
 
     end

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

@@ -1,7 +1,11 @@
 module Sequent
   module Core
     module Transactions
-
+      #
+      # NoTransactions is used when replaying the +ViewSchema+ for
+      # view schema upgrades. Transactions are not needed there since the
+      # view state will always be recreated anyway.
+      #
       class NoTransactions
         def transactional
           yield

data/lib/sequent/core/workflow.rb

@@ -8,6 +8,23 @@ module Sequent
       def execute_commands(*commands)
         Sequent.configuration.command_service.execute_commands(*commands)
       end
+
+      # Workflow#after_commit will accept a block to execute
+      # after the transaction commits. This is very useful to
+      # isolate side-effects. They will run only on the
+      # transaction's success and will not be able to roll it
+      # back when there is an exception. Useful if your background
+      # jobs processor is not using the same database connection
+      # to enqueue jobs.
+      def after_commit(ignore_errors: false, &block)
+        Sequent.configuration.transaction_provider.after_commit &block
+      rescue StandardError => error
+        if ignore_errors
+          Sequent.logger.warn("An exception was raised in an after_commit hook: #{error}, #{error.inspect}")
+        else
+          raise error
+        end
+      end
     end
   end
 end

data/lib/sequent/test/event_handler_helpers.rb

@@ -27,6 +27,21 @@ module Sequent
     # end
     module WorkflowHelpers
 
+      class FakeTransactionProvider
+        def initialize
+          @after_commit_blocks = []
+        end
+
+        def transactional
+          yield
+          @after_commit_blocks.each(&:call)
+        end
+
+        def after_commit(&block)
+          @after_commit_blocks << block
+        end
+      end
+
       class FakeCommandService
         attr_reader :recorded_commands
 
@@ -66,8 +81,12 @@ module Sequent
 
       def self.included(spec)
         spec.let(:fake_command_service) { FakeCommandService.new }
+        spec.let(:fake_transaction_provider) { FakeTransactionProvider.new }
         spec.before do
-          Sequent.configure { |c| c.command_service = fake_command_service }
+          Sequent.configure do |c|
+            c.command_service = fake_command_service
+            c.transaction_provider = fake_transaction_provider
+          end
         end
       end
     end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '3.1.1'
+  VERSION = '3.1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Lars Vonk
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-28 00:00:00.000000000 Z
+date: 2019-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,9 +21,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,9 +31,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.3'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -41,9 +41,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -51,9 +51,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '5.3'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -124,20 +124,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.12.1
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.1.0
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.1.0
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -268,6 +282,8 @@ files:
 - lib/sequent/core/helpers/array_with_type.rb
 - lib/sequent/core/helpers/association_validator.rb
 - lib/sequent/core/helpers/attribute_support.rb
+- lib/sequent/core/helpers/autoset_attributes.rb
+- lib/sequent/core/helpers/boolean_validator.rb
 - lib/sequent/core/helpers/copyable.rb
 - lib/sequent/core/helpers/date_time_validator.rb
 - lib/sequent/core/helpers/date_validator.rb
@@ -277,8 +293,10 @@ files:
 - lib/sequent/core/helpers/mergable.rb
 - lib/sequent/core/helpers/message_handler.rb
 - lib/sequent/core/helpers/param_support.rb
+- lib/sequent/core/helpers/secret.rb
 - lib/sequent/core/helpers/string_support.rb
 - lib/sequent/core/helpers/string_to_value_parsers.rb
+- lib/sequent/core/helpers/string_validator.rb
 - lib/sequent/core/helpers/type_conversion_support.rb
 - lib/sequent/core/helpers/uuid_helper.rb
 - lib/sequent/core/helpers/value_validators.rb