statesman 3.5.0 → 7.4.0

data/CHANGELOG.md

@@ -1,3 +1,109 @@
+## v7.4.0 26th August 2020
+
+### Added
+
+- [Gem Metadata](https://guides.rubygems.org/specification-reference/#metadata)
+  to make finding changes between releases even easier.
+
+## v7.3.0, 24th August 2020
+
+### Changed
+
+- Use correct Arel for null [#409](https://github.com/gocardless/statesman/pull/#409)
+
+## v7.2.0, 19th May 2020
+
+### Changed
+
+- Set non-empty password for postgres tests [#398](https://github.com/gocardless/statesman/pull/#398)
+- Handle transitions differently for MySQL [#399](https://github.com/gocardless/statesman/pull/#399)
+- pg requirement from >= 0.18, <= 1.1 to >= 0.18, <= 1.3 [#400](https://github.com/gocardless/statesman/pull/#400)
+- Lazily enable mysql gaplock protection [#402](https://github.com/gocardless/statesman/pull/#402)
+
+## v7.1.0, 10th Feb 2020
+
+- Fix `to_s` on `TransitionFailedError` & `GuardFailedError`. `.message` and
+    `.to_s` diverged when `from` and `to` accessors where added in v4.1.3
+
+## v7.0.1, 8th Jan 2020
+
+- Fix deprecation warning with Ruby 2.7 [#386](https://github.com/gocardless/statesman/pull/386)
+
+## v7.0.0, 8th Jan 2020
+
+**Breaking changes**
+
+- Drop official support for Rails 4.2, 5.0 and 5.1, following our [compatibility
+  policy](https://github.com/gocardless/statesman/blob/master/docs/COMPATIBILITY.md).
+
+## v6.0.0, 20th December 2019
+
+**Breaking changes**
+
+- Drop official support for Ruby 2.2 and 2.3 following our [compatibility
+  policy](https://github.com/gocardless/statesman/blob/master/docs/COMPATIBILITY.md).
+
+## v5.2.0, 17th December 2019
+
+- Issue `most_recent_transition_join` query as a single-line string [#381](https://github.com/gocardless/statesman/pull/381)
+
+## v5.1.0, 22th November 2019
+
+- Correct `Statesman::Adapters::ActiveRecordQueries` error text [@Bramjetten](https://github.com/gocardless/statesman/pull/376)
+- Removes duplicate `map` call [Isaac Seymour](https://github.com/gocardless/statesman/pull/362)
+- Update changelog with instructions of how to use `ActiveRecordQueries` added
+  in v5.0.0
+- Pass exception into `after_transition_failure` and `after_guard_failure` callbacks [@credric-cordenier](https://github.com/gocardless/statesman/pull/378)
+
+## v5.0.0, 11th November 2019
+
+- Adds new syntax and restrictions to ActiveRecordQueries [PR#358](https://github.com/gocardless/statesman/pull/358). With the introduction of this, defining `self.transition_class` or `self.initial_state` is deprecated and will be removed in the next major release.
+  Change
+  ```ruby
+    include Statesman::Adapters::ActiveRecordQueries
+    def self.initial_state
+      :initial
+    end
+    def self.transition_class
+      MyTransition
+    end
+  ```
+  to
+  ```ruby
+    include Statesman::Adapters::ActiveRecordQueries[
+      initial_state: :inital,
+      transition_class: MyTransition
+    ]
+  ```
+
+## v4.1.4, 11th November 2019
+
+- Reverts the breaking changes from [PR#358](https://github.com/gocardless/statesman/pull/358) & `v4.1.3` that where included in the last minor release. If you have changed your code to work with these changes `v5.0.0` will be a copy of `v4.1.3` with a bugfix applied.
+
+## v4.1.3, 6th November 2019
+
+- Add accessible from / to state attributes on the `TransitionFailedError` to avoid parsing strings [@ahjmorton](https://github.com/gocardless/statesman/pull/367)
+- Add `after_transition_failure` mechanism [@credric-cordenier](https://github.com/gocardless/statesman/pull/366)
+
+## v4.1.2, 17th August 2019
+
+- Add support for Rails 6 [@greysteil](https://github.com/gocardless/statesman/pull/360)
+
+## v4.1.1, 6th July 2019
+
+- Fix statesman index detection for indexes that start t-z [@hmarr](https://github.com/gocardless/statesman/pull/354)
+- Correct access of metadata via `state_machine` [@glenpike](https://github.com/gocardless/statesman/pull/349)
+
+## v4.1.0, 10 April 2019
+
+- Add better support for mysql (and others) in `transition_conflict_error?` [@greysteil](https://github.com/greysteil) (https://github.com/gocardless/statesman/pull/342)
+
+## v4.0.0, 22 February 2019
+
+- Forces Statesman to use a new transactions with `requires_new: true` (https://github.com/gocardless/statesman/pull/249)
+- Fixes an issue with `after_commit` transition blocks that where being
+    executed even if the transaction rolled back. ([patch](https://github.com/gocardless/statesman/pull/338) by [@matid](https://github.com/matid))
+
 ## v3.5.0, 2 November 2018
 
 - Expose `most_recent_transition_join` - ActiveRecords `or` requires that both

data/Gemfile

@@ -1,12 +1,18 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
-gem "rails", "~> #{ENV['RAILS_VERSION']}" if ENV["RAILS_VERSION"]
+# rubocop:disable Bundler/DuplicatedGem
+if ENV['RAILS_VERSION'] == 'master'
+  gem "rails", git: "https://github.com/rails/rails"
+elsif ENV['RAILS_VERSION']
+  gem "rails", "~> #{ENV['RAILS_VERSION']}"
+end
+# rubocop:enable Bundler/DuplicatedGem
 
 group :development do
-  gem "mongoid", ">= 3.1" unless ENV["EXCLUDE_MONGOID"]
-
   # test/unit is no longer bundled with Ruby 2.2, but required by Rails
-  gem "test-unit", "~> 3.0" if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
+  gem "test-unit", "~> 3.3" if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
 end

data/Guardfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 

data/README.md

@@ -1,4 +1,4 @@
-![Statesman](http://f.cl.ly/items/410n2A0S3l1W0i3i0o2K/statesman.png)
+<p align="center"><img src="http://f.cl.ly/items/410n2A0S3l1W0i3i0o2K/statesman.png" alt="Statesman"></p>
 
 A statesmanlike state machine library.
 
@@ -30,7 +30,7 @@ protection.
 To get started, just add Statesman to your `Gemfile`, and then run `bundle`:
 
 ```ruby
-gem 'statesman', '~> 3.4.1'
+gem 'statesman', '~> 7.1.0'
 ```
 
 ## Usage
@@ -76,22 +76,16 @@ Then, link it to your model:
 
 ```ruby
 class Order < ActiveRecord::Base
-  include Statesman::Adapters::ActiveRecordQueries
-
   has_many :order_transitions, autosave: false
 
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: OrderTransition,
+    initial_state: :pending
+  ]
+
   def state_machine
     @state_machine ||= OrderStateMachine.new(self, transition_class: OrderTransition)
   end
-
-  def self.transition_class
-    OrderTransition
-  end
-
-  def self.initial_state
-    :pending
-  end
-  private_class_method :initial_state
 end
 ```
 
@@ -164,8 +158,9 @@ class Order < ActiveRecord::Base
   end
 
   # Optionally delegate some methods
-  delegate :can_transition_to?, :transition_to!, :transition_to, :current_state,
-           to: :state_machine
+
+  delegate :can_transition_to?, :current_state, :history, :last_transition,
+           :transition_to!, :transition_to, :in_state?, to: :state_machine
 end
 ```
 #### Using PostgreSQL JSON column
@@ -199,13 +194,11 @@ or 5. To do that
 ```ruby
 Statesman.configure do
   storage_adapter(Statesman::Adapters::ActiveRecord)
-  # ...or
-  storage_adapter(Statesman::Adapters::Mongoid)
 end
 ```
 Statesman defaults to storing transitions in memory. If you're using rails, you
 can instead configure it to persist transitions to the database by using the
-ActiveRecord or Mongoid adapter.
+ActiveRecord adapter.
 
 Statesman will fallback to memory unless you specify a transition_class when instantiating your state machine. This allows you to only persist transitions on certain state machines in your app.
 
@@ -234,7 +227,8 @@ end
 ```
 Define a guard. `to` and `from` parameters are optional, a nil parameter means
 guard all transitions. The passed block should evaluate to a boolean and must
-be idempotent as it could be called many times.
+be idempotent as it could be called many times. The guard will pass when it
+evaluates to a truthy value and fail when it evaluates to a falsey value (`nil` or `false`).
 
 #### `Machine.before_transition`
 ```ruby
@@ -261,6 +255,35 @@ after the transition.
 If you specify `after_commit: true`, the callback will be executed once the
 transition has been committed to the database.
 
+#### `Machine.after_transition_failure`
+```ruby
+Machine.after_transition_failure(from: :some_state, to: :another_state) do |object, exception|
+  Logger.info("transition to #{exception.to} failed for #{object.id}")
+end
+```
+Define a callback to run if `Statesman::TransitionFailedError` is raised
+during the execution of transition callbacks. `to` and `from`
+parameters are optional, a nil parameter means run after all transitions.
+The model object, and exception are passed as arguments to the callback.
+This is executed outside of the transaction wrapping other callbacks.
+If using `transition!` the exception is re-raised after these callbacks are
+executed.
+
+#### `Machine.after_guard_failure`
+```ruby
+Machine.after_guard_failure(from: :some_state, to: :another_state) do |object, exception|
+  Logger.info("guard failed during transition to #{exception.to} for #{object.id}")
+end
+```
+Define a callback to run if `Statesman::GuardFailedError` is raised
+during the execution of guard callbacks. `to` and `from`
+parameters are optional, a nil parameter means run after all transitions.
+The model object, and exception are passed as arguments to the callback.
+This is executed outside of the transaction wrapping other callbacks.
+If using `transition!` the exception is re-raised after these callbacks are
+executed.
+
+
 #### `Machine.new`
 ```ruby
 my_machine = Machine.new(my_model, transition_class: MyTransitionModel)
@@ -328,43 +351,34 @@ callback code throws an exception, it will not be caught.)
 
 A mixin is provided for the ActiveRecord adapter which adds scopes to easily
 find all models currently in (or not in) a given state. Include it into your
-model and define `transition_class` and `initial_state` class methods:
+model and passing in `transition_class` and `initial_state` as options.
+
+In 4.1.2 and below, these two options had to be defined as methods on the model,
+but 5.0.0 and above allow this style of configuration as well.
+The old method pollutes the model with extra class methods, and is deprecated,
+to be removed in 6.0.0.
 
 ```ruby
 class Order < ActiveRecord::Base
-  include Statesman::Adapters::ActiveRecordQueries
-
-  def self.transition_class
-    OrderTransition
-  end
-  private_class_method :transition_class
-
-  def self.initial_state
-    OrderStateMachine.initial_state
-  end
-  private_class_method :initial_state
+  has_many :order_transitions, autosave: false
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: OrderTransition,
+    initial_state: OrderStateMachine.initial_state
+  ]
 end
 ```
 
 If the transition class-name differs from the association name, you will also
-need to define a corresponding `transition_name` class method:
+need to pass `transition_name` as an option:
 
 ```ruby
 class Order < ActiveRecord::Base
   has_many :transitions, class_name: "OrderTransition", autosave: false
-
-  def self.transition_name
-    :transitions
-  end
-
-  def self.transition_class
-    OrderTransition
-  end
-
-  def self.initial_state
-    OrderStateMachine.initial_state
-  end
-  private_class_method :initial_state
+  include Statesman::Adapters::ActiveRecordQueries[
+    transition_class: OrderTransition,
+    initial_state: OrderStateMachine.initial_state,
+    transition_name: :transitions
+  ]
 end
 ```
 
@@ -375,7 +389,7 @@ Returns all models currently in any of the supplied states.
 Returns all models not currently in any of the supplied states.
 
 
-### `Model.most_recent_transition_join`
+#### `Model.most_recent_transition_join`
 This joins the model to its most recent transition whatever that may be.
 We expose this method to ease use of ActiveRecord's `or` e.g
 
@@ -406,7 +420,7 @@ You could also use a calculated column or view in your database.
 Given a field `foo` that was stored in the metadata, you can access it like so:
 
 ```ruby
-model_instance.last_transition.metadata["foo"]
+model_instance.state_machine.last_transition.metadata["foo"]
 ```
 
 #### Events
@@ -425,6 +439,22 @@ class OrderStateMachine
 end
 ```
 
+#### Deleting records.
+
+If you need to delete the Parent model regularly you will need to change
+either the association deletion behaviour or add a `DELETE CASCADE` condition
+to foreign key in your database.
+
+E.g
+```
+has_many :order_transitions, autosave: false, dependent: :destroy
+```
+or when migrating the transition model
+```
+add_foreign_key :order_transitions, :orders, on_delete: :cascade
+```
+
+
 ## Testing Statesman Implementations
 
 This answer was abstracted from [this issue](https://github.com/gocardless/statesman/issues/77).
@@ -469,4 +499,4 @@ end
 
 ---
 
-GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/jobs/software-engineer).
+GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/careers/).

data/Rakefile

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec) do |task|
   task.rspec_opts = []
 
-  if ENV["EXCLUDE_MONGOID"]
-    task.rspec_opts += ["--tag ~mongo", "--exclude-pattern **/*mongo*"]
-  end
-
   if ENV["CIRCLECI"]
     task.rspec_opts += ["--format RspecJunitFormatter",
                         "--out /tmp/test-results/rspec.xml",

data/lib/generators/statesman/active_record_transition_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 require "generators/statesman/generator_helpers"
 

data/lib/generators/statesman/generator_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   module GeneratorHelpers
     def class_name_option

data/lib/generators/statesman/migration_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 require "generators/statesman/generator_helpers"
 

data/lib/statesman.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   autoload :Config,     "statesman/config"
   autoload :Machine,    "statesman/machine"
@@ -12,23 +14,31 @@ module Statesman
              "statesman/adapters/active_record_transition"
     autoload :ActiveRecordQueries,
              "statesman/adapters/active_record_queries"
-    autoload :Mongoid, "statesman/adapters/mongoid"
-    autoload :MongoidTransition,
-             "statesman/adapters/mongoid_transition"
   end
   require "statesman/railtie" if defined?(::Rails::Railtie)
 
   # Example:
   #   Statesman.configure do
   #     storage_adapter Statesman::ActiveRecordAdapter
+  #     enable_mysql_gaplock_protection
   #   end
   #
   def self.configure(&block)
-    config = Config.new(block)
+    @config = Config.new(block)
     @storage_adapter = config.adapter_class
   end
 
   def self.storage_adapter
     @storage_adapter || Adapters::Memory
   end
+
+  def self.mysql_gaplock_protection?
+    return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
+
+    @mysql_gaplock_protection = config.mysql_gaplock_protection?
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
 end

data/lib/statesman/adapters/active_record.rb

@@ -1,11 +1,10 @@
+# frozen_string_literal: true
+
 require_relative "../exceptions"
 
 module Statesman
   module Adapters
     class ActiveRecord
-      attr_reader :transition_class
-      attr_reader :parent_model
-
       JSON_COLUMN_TYPES = %w[json jsonb].freeze
 
       def self.database_supports_partial_indexes?
@@ -17,6 +16,10 @@ module Statesman
         end
       end
 
+      def self.adapter_name
+        ::ActiveRecord::Base.connection.adapter_name.downcase
+      end
+
       def initialize(transition_class, parent_model, observer, options = {})
         serialized = serialized?(transition_class)
         column_type = transition_class.columns_hash["metadata"].sql_type
@@ -25,17 +28,22 @@ module Statesman
         elsif serialized && JSON_COLUMN_TYPES.include?(column_type)
           raise IncompatibleSerializationError, transition_class.name
         end
+
         @transition_class = transition_class
+        @transition_table = transition_class.arel_table
         @parent_model = parent_model
         @observer = observer
         @association_name =
           options[:association_name] || @transition_class.table_name
       end
 
+      attr_reader :transition_class, :transition_table, :parent_model
+
       def create(from, to, metadata = {})
         create_transition(from.to_s, to.to_s, metadata)
       rescue ::ActiveRecord::RecordNotUnique => e
         raise TransitionConflictError, e.message if transition_conflict_error? e
+
         raise
       ensure
         @last_transition = nil
@@ -61,45 +69,152 @@ module Statesman
 
       private
 
+      # rubocop:disable Metrics/MethodLength
       def create_transition(from, to, metadata)
-        transition_attributes = { to_state: to,
-                                  sort_key: next_sort_key,
-                                  metadata: metadata }
+        transition = transitions_for_parent.build(
+          default_transition_attributes(to, metadata),
+        )
 
-        transition_attributes[:most_recent] = true
+        ::ActiveRecord::Base.transaction(requires_new: true) do
+          @observer.execute(:before, from, to, transition)
 
-        transition = transitions_for_parent.build(transition_attributes)
+          if mysql_gaplock_protection?
+            # We save the transition first with most_recent falsy, then mark most_recent
+            # true after to avoid letting MySQL acquire a next-key lock which can cause
+            # deadlocks.
+            #
+            # To avoid an additional query, we manually adjust the most_recent attribute
+            # on our transition assuming that update_most_recents will have set it to true
+
+            transition.save!
+
+            unless update_most_recents(transition.id).positive?
+              raise ActiveRecord::Rollback, "failed to update most_recent"
+            end
+
+            transition.assign_attributes(most_recent: true)
+          else
+            update_most_recents
+            transition.assign_attributes(most_recent: true)
+            transition.save!
+          end
 
-        ::ActiveRecord::Base.transaction do
-          @observer.execute(:before, from, to, transition)
-          unset_old_most_recent
-          transition.save!
           @last_transition = transition
           @observer.execute(:after, from, to, transition)
+          add_after_commit_callback(from, to, transition)
         end
-        @observer.execute(:after_commit, from, to, transition)
 
         transition
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def default_transition_attributes(to, metadata)
+        {
+          to_state: to,
+          sort_key: next_sort_key,
+          metadata: metadata,
+          most_recent: not_most_recent_value(db_cast: false),
+        }
+      end
+
+      def add_after_commit_callback(from, to, transition)
+        ::ActiveRecord::Base.connection.add_transaction_record(
+          ActiveRecordAfterCommitWrap.new do
+            @observer.execute(:after_commit, from, to, transition)
+          end,
+        )
+      end
 
       def transitions_for_parent
-        @parent_model.send(@association_name)
+        parent_model.send(@association_name)
       end
 
-      def unset_old_most_recent
-        most_recent = transitions_for_parent.where(most_recent: true)
+      # Sets the given transition most_recent = t while unsetting the most_recent of any
+      # previous transitions.
+      def update_most_recents(most_recent_id = nil)
+        update = build_arel_manager(::Arel::UpdateManager)
+        update.table(transition_table)
+        update.where(most_recent_transitions(most_recent_id))
+        update.set(build_most_recents_update_all_values(most_recent_id))
 
-        # Check whether the `most_recent` column allows null values. If it
-        # doesn't, set old records to `false`, otherwise, set them to `NULL`.
-        #
-        # Some conditioning here is required to support databases that don't
-        # support partial indexes. By doing the conditioning on the column,
-        # rather than Rails' opinion of whether the database supports partial
-        # indexes, we're robust to DBs later adding support for partial indexes.
-        if transition_class.columns_hash["most_recent"].null == false
-          most_recent.update_all(with_updated_timestamp(most_recent: false))
+        # MySQL will validate index constraints across the intermediate result of an
+        # update. This means we must order our update to deactivate the previous
+        # most_recent before setting the new row to be true.
+        update.order(transition_table[:most_recent].desc) if mysql_gaplock_protection?
+
+        ::ActiveRecord::Base.connection.update(update.to_sql)
+      end
+
+      def most_recent_transitions(most_recent_id = nil)
+        if most_recent_id
+          transitions_of_parent.and(
+            transition_table[:id].eq(most_recent_id).or(
+              transition_table[:most_recent].eq(true),
+            ),
+          )
+        else
+          transitions_of_parent.and(transition_table[:most_recent].eq(true))
+        end
+      end
+
+      def transitions_of_parent
+        transition_table[parent_join_foreign_key.to_sym].eq(parent_model.id)
+      end
+
+      # Generates update_all Arel values that will touch the updated timestamp (if valid
+      # for this model) and set most_recent to true only for the transition with a
+      # matching most_recent ID.
+      #
+      # This is quite nasty, but combines two updates (set all most_recent = f, set
+      # current most_recent = t) into one, which helps improve transition performance
+      # especially when database latency is significant.
+      #
+      # The SQL this can help produce looks like:
+      #
+      #   update transitions
+      #      set most_recent = (case when id = 'PA123' then TRUE else FALSE end)
+      #        , updated_at = '...'
+      #      ...
+      #
+      def build_most_recents_update_all_values(most_recent_id = nil)
+        [
+          [
+            transition_table[:most_recent],
+            Arel::Nodes::SqlLiteral.new(most_recent_value(most_recent_id)),
+          ],
+        ].tap do |values|
+          # Only if we support the updated at timestamps should we add this column to the
+          # update
+          updated_column, updated_at = updated_column_and_timestamp
+
+          if updated_column
+            values << [
+              transition_table[updated_column.to_sym],
+              updated_at,
+            ]
+          end
+        end
+      end
+
+      def most_recent_value(most_recent_id)
+        if most_recent_id
+          Arel::Nodes::Case.new.
+            when(transition_table[:id].eq(most_recent_id)).then(db_true).
+            else(not_most_recent_value).to_sql
         else
-          most_recent.update_all(with_updated_timestamp(most_recent: nil))
+          Arel::Nodes::SqlLiteral.new(not_most_recent_value)
+        end
+      end
+
+      # Provide a wrapper for constructing an update manager which handles a breaking API
+      # change in Arel as we move into Rails >6.0.
+      #
+      # https://github.com/rails/rails/commit/7508284800f67b4611c767bff9eae7045674b66f
+      def build_arel_manager(manager)
+        if manager.instance_method(:initialize).arity.zero?
+          manager.new
+        else
+          manager.new(::ActiveRecord::Base)
         end
       end
 
@@ -118,11 +233,48 @@ module Statesman
       end
 
       def transition_conflict_error?(err)
-        err.message.include?(@transition_class.table_name) &&
+        return true if unique_indexes.any? { |i| err.message.include?(i.name) }
+
+        err.message.include?(transition_class.table_name) &&
           (err.message.include?("sort_key") || err.message.include?("most_recent"))
       end
 
-      def with_updated_timestamp(params)
+      def unique_indexes
+        ::ActiveRecord::Base.connection.
+          indexes(transition_class.table_name).
+          select do |index|
+            next unless index.unique
+
+            # We care about the columns used in the index, but not necessarily
+            # the order, which is why we sort both sides of the comparison here
+            index.columns.sort == [parent_join_foreign_key, "sort_key"].sort ||
+              index.columns.sort == [parent_join_foreign_key, "most_recent"].sort
+          end
+      end
+
+      def parent_join_foreign_key
+        association =
+          parent_model.class.
+            reflect_on_all_associations(:has_many).
+            find { |r| r.name.to_s == @association_name.to_s }
+
+        association_join_primary_key(association)
+      end
+
+      def association_join_primary_key(association)
+        if association.respond_to?(:join_primary_key)
+          association.join_primary_key
+        elsif association.method(:join_keys).arity.zero?
+          # Support for Rails 5.1
+          association.join_keys.key
+        else
+          # Support for Rails < 5.1
+          association.join_keys(transition_class).key
+        end
+      end
+
+      # updated_column_and_timestamp should return [column_name, value]
+      def updated_column_and_timestamp
         # TODO: Once we've set expectations that transition classes should conform to
         # the interface of Adapters::ActiveRecordTransition as a breaking change in the
         # next major version, we can stop calling `#respond_to?` first and instead
@@ -130,21 +282,91 @@ module Statesman
         #
         # At the moment, most transition classes will include the module, but not all,
         # not least because it doesn't work with PostgreSQL JSON columns for metadata.
-        column = if @transition_class.respond_to?(:updated_timestamp_column)
-                   @transition_class.updated_timestamp_column
+        column = if transition_class.respond_to?(:updated_timestamp_column)
+                   transition_class.updated_timestamp_column
                  else
                    ActiveRecordTransition::DEFAULT_UPDATED_TIMESTAMP_COLUMN
                  end
 
-        return params if column.nil?
+        # No updated timestamp column, don't return anything
+        return nil if column.nil?
+
+        [
+          column, ::ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+        ]
+      end
+
+      def mysql_gaplock_protection?
+        Statesman.mysql_gaplock_protection?
+      end
+
+      def db_true
+        value = ::ActiveRecord::Base.connection.type_cast(
+          true,
+          transition_class.columns_hash["most_recent"],
+        )
+        ::ActiveRecord::Base.connection.quote(value)
+      end
+
+      def db_false
+        value = ::ActiveRecord::Base.connection.type_cast(
+          false,
+          transition_class.columns_hash["most_recent"],
+        )
+        ::ActiveRecord::Base.connection.quote(value)
+      end
+
+      def db_null
+        Arel::Nodes::SqlLiteral.new("NULL")
+      end
+
+      # Check whether the `most_recent` column allows null values. If it doesn't, set old
+      # records to `false`, otherwise, set them to `NULL`.
+      #
+      # Some conditioning here is required to support databases that don't support partial
+      # indexes. By doing the conditioning on the column, rather than Rails' opinion of
+      # whether the database supports partial indexes, we're robust to DBs later adding
+      # support for partial indexes.
+      def not_most_recent_value(db_cast: true)
+        if transition_class.columns_hash["most_recent"].null == false
+          return db_cast ? db_false : false
+        end
+
+        db_cast ? db_null : nil
+      end
+    end
+
+    class ActiveRecordAfterCommitWrap
+      def initialize(&block)
+        @callback = block
+        @connection = ::ActiveRecord::Base.connection
+      end
+
+      def self.trigger_transactional_callbacks?
+        true
+      end
+
+      def trigger_transactional_callbacks?
+        true
+      end
+
+      # rubocop: disable Naming/PredicateName
+      def has_transactional_callbacks?
+        true
+      end
+      # rubocop: enable Naming/PredicateName
+
+      def committed!(*)
+        @callback.call
+      end
+
+      def before_committed!(*); end
 
-        timestamp = if ::ActiveRecord::Base.default_timezone == :utc
-                      Time.now.utc
-                    else
-                      Time.now
-                    end
+      def rolledback!(*); end
 
-        params.merge(column => timestamp)
+      # Required for +transaction(requires_new: true)+
+      def add_to_transaction(*)
+        @connection.add_transaction_record(self)
       end
     end
   end