statesman 13.2.0 → 13.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffe7ee5f3aa4787fccd4c325c42bd892dc475edaaabc45a4a67155ebe41d41c1
-  data.tar.gz: 1794e00cf99c34e3d84a680f409a92d2430d0ed4964d3145f7f0539d7c54ec09
+  metadata.gz: 706f8fde91c1454f1ab6a7082c1317341eb5855f4c4c418e73bca0246b677a0e
+  data.tar.gz: 6cc6d3c4c43fc38f751dd361db4a7dd622b02b4ca07afd94315bef7dc433f23d
 SHA512:
-  metadata.gz: 7fc095f7cdfec543802c1e367af567d63e8abea8e57c01bc0b1fc1a6d661ea3b187e0d9ed91457c2eecf109286879ef7bd5bf45e3fa80a44777cb326486f9007
-  data.tar.gz: e3c342d10b68eccd5d4f145079c70537582f7923cf5cf7a9c0724fb58553476ca3d4e319c993929840e7ee2d2dbfedf1634e40160647429ea7cf194574275b79
+  metadata.gz: fbcf95c6f1bfdbb867768072d5cfe47d0476d26c9f37ad038eb7563ee541cf03dd4a2e66c77fe808926732e9f51a6746be77892b171148756d07e24e3e11b368
+  data.tar.gz: b70bb3d87a2f6923a4f42b1d2fda278caae324d2339731a2abdd501ac76f4a43fd70a9128a528ae55e1e05173d944b6d328b2ebeedc6c56a8a128e0d7b48371d

data/.github/workflows/tests.yml

@@ -21,7 +21,52 @@ jobs:
           bundler-cache: true
       - run: bundle exec rubocop --extra-details --display-style-guide --parallel --force-exclusion
 
+  bundle:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ["3.3", "3.4", "4.0"]
+        rails-version:
+          - "7.2"
+          - "8.0"
+          - "8.1"
+          - "main"
+    runs-on: ubuntu-latest
+    env:
+      RAILS_VERSION: ${{ matrix.rails-version }}
+      BUNDLE_PATH: vendor/bundle
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "${{ matrix.ruby-version }}"
+      - name: Resolve gems
+        run: bundle lock
+      - name: Restore gems
+        id: cache
+        uses: actions/cache/restore@v6
+        with:
+          path: vendor/bundle
+          key: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-${{ hashFiles('Gemfile.lock') }}
+          restore-keys: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+      - name: Install gems
+        if: steps.cache.outputs.cache-hit != 'true'
+        # The lockfile is stored inside the cached path so downstream jobs, which can't
+        # compute this key, can restore the most recent entry and use the same gems.
+        run: |
+          bundle install --jobs 4
+          bundle clean
+          cp Gemfile.lock vendor/bundle/Gemfile.lock
+      - name: Save gems
+        if: steps.cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v6
+        with:
+          path: vendor/bundle
+          key: ${{ steps.cache.outputs.cache-primary-key }}
+
   sqlite:
+    needs: bundle
     strategy:
       fail-fast: false
       matrix:
@@ -37,18 +82,33 @@ jobs:
     runs-on: ubuntu-latest
     env:
       RAILS_VERSION: ${{ matrix.rails-version }}
+      BUNDLE_PATH: vendor/bundle
     steps:
       - uses: actions/checkout@v5
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          bundler-cache: true
           ruby-version: "${{ matrix.ruby-version }}"
+      # Restore-only: the bundle job owns saving, so matrix jobs never race to write
+      # the same cache entry. The most recent entry for this prefix is the one the
+      # bundle job just resolved.
+      - name: Restore gems
+        uses: actions/cache/restore@v6
+        with:
+          path: vendor/bundle
+          key: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          restore-keys: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          fail-on-cache-miss: true
+      - name: Install gems
+        run: |
+          cp vendor/bundle/Gemfile.lock Gemfile.lock
+          bundle install --local
       - name: Run specs
         run: |
           bundle exec rspec --profile --format progress --format RSpec::Github::Formatter
 
   postgres:
+    needs: bundle
     strategy:
       fail-fast: false
       matrix:
@@ -63,36 +123,37 @@ jobs:
           - ruby-version: "3.2"
             rails-version: "main"
     runs-on: ubuntu-latest
-    services:
-      postgres:
-        image: postgres:${{ matrix.postgres-version }}
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: statesman_test
-          POSTGRES_PASSWORD: statesman
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 10
     env:
-      DATABASE_URL: postgres://postgres:statesman@localhost/statesman_test
-      DATABASE_DEPENDENCY_PORT: "5432"
+      DB: postgres
+      DB_IMAGE: postgres:${{ matrix.postgres-version }}
       RAILS_VERSION: ${{ matrix.rails-version }}
+      BUNDLE_PATH: vendor/bundle
     steps:
       - uses: actions/checkout@v5
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          bundler-cache: true
           ruby-version: "${{ matrix.ruby-version }}"
+      # Restore-only: the bundle job owns saving, so matrix jobs never race to write
+      # the same cache entry. The most recent entry for this prefix is the one the
+      # bundle job just resolved.
+      - name: Restore gems
+        uses: actions/cache/restore@v6
+        with:
+          path: vendor/bundle
+          key: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          restore-keys: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          fail-on-cache-miss: true
+      - name: Install gems
+        run: |
+          cp vendor/bundle/Gemfile.lock Gemfile.lock
+          bundle install --local
       - name: Run specs
         run: |
           bundle exec rspec --profile --format progress --format RSpec::Github::Formatter
 
   mysql:
+    needs: bundle
     strategy:
       fail-fast: false
       matrix:
@@ -108,32 +169,31 @@ jobs:
             rails-version: "main"
 
     runs-on: ubuntu-latest
-    services:
-      mysql:
-        image: mysql:${{ matrix.mysql-version }}
-        env:
-          MYSQL_ROOT_PASSWORD: password
-          MYSQL_USER: foobar
-          MYSQL_PASSWORD: password
-          MYSQL_DATABASE: statesman_test
-        ports:
-          - "3306:3306"
-        options: >-
-          --health-cmd "mysqladmin ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
     env:
-      DATABASE_URL: mysql2://foobar:password@127.0.0.1/statesman_test
-      DATABASE_DEPENDENCY_PORT: "3306"
+      DB: mysql
+      DB_IMAGE: mysql:${{ matrix.mysql-version }}
       RAILS_VERSION: ${{ matrix.rails-version }}
+      BUNDLE_PATH: vendor/bundle
     steps:
       - uses: actions/checkout@v5
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          bundler-cache: true
           ruby-version: "${{ matrix.ruby-version }}"
+      # Restore-only: the bundle job owns saving, so matrix jobs never race to write
+      # the same cache entry. The most recent entry for this prefix is the one the
+      # bundle job just resolved.
+      - name: Restore gems
+        uses: actions/cache/restore@v6
+        with:
+          path: vendor/bundle
+          key: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          restore-keys: bundle-${{ runner.os }}-${{ matrix.ruby-version }}-${{ matrix.rails-version }}-
+          fail-on-cache-miss: true
+      - name: Install gems
+        run: |
+          cp vendor/bundle/Gemfile.lock Gemfile.lock
+          bundle install --local
       - name: Run specs
         run: |
           bundle exec rspec --profile --format progress --format RSpec::Github::Formatter

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.4.5

data/CHANGELOG.md

@@ -5,6 +5,19 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v13.4.0 14th October 2026
+
+### Added
+
+- `Statesman::BulkTransition`, which transitions many parents from one state to another in a single transaction with a fixed number of queries (a flip of the current `most_recent` rows, one `insert_all!`, and one cached-current-state update if configured). Works with the `ActiveRecord` adapter on PostgreSQL, MySQL (including `mysql_gaplock_protection`) and SQLite. Like `transition_to!`, it flips the previous transition and updates the cached current state, but it does not run guards, `before`/`after` callbacks or `ActiveRecord` validations/callbacks on the transition model. Supports per-parent overrides via `metadata_per_id` and `attributes_per_id`, and an optional block that is called inside the transaction with a lazy `ActiveRecord::Relation` over the newly inserted transitions. Parents not in the `from` state are skipped, so a batch is safe to re-run. Assumes a non-STI transition table and a single-column parent primary key.
+
+## v13.3.0 4th August 2026
+
+### Added
+
+- `Statesman::Adapters::ConfigureCachedCurrentState`, a model mixin to maintain a denormalised current-state column on the parent model without a separate join or query, via `configure_cached_current_state`. The write happens inside the `ActiveRecord` storage adapter itself (shared by every `Machine` subclass and every adapter instance for a model), so it also works for models driven by several different machine classes chosen dynamically (e.g. per scheme), and fires reliably under `mysql_gaplock_protection`. Exposes the configured column via `Model.cached_state_column_name` for generic tooling. Only updates via real `transition_to!` calls - a transition row created directly, bypassing the machine, does not update the cache. The initial-state seed on create only applies if the column is nil, so a record explicitly created into a given state (e.g. a test factory) keeps that value.
+- `configure_state_machine` now exposes `transition_class` and `initial_state` as class readers.
+
 ## v13.2.0 29th July 2026
 
 ### Added

data/CONTRIBUTING.md

@@ -11,6 +11,26 @@ ways you can help make this project better!
 - No need to add to the changelog, we will take care of updating it as we make
   releases.
 
+## Running tests
+
+`bundle exec rake` runs the suite against SQLite, PostgreSQL and MySQL in
+parallel. PostgreSQL and MySQL are started as throwaway containers in Docker via
+[Testcontainers](https://github.com/testcontainers/testcontainers-ruby).
+
+```sh
+bundle exec rake                           # all databases, in parallel
+bundle exec rake spec:postgres             # a single database
+```
+
+`bundle exec rspec` runs against SQLite by default. Set `DB` to use a container,
+or point `DATABASE_URL` at an existing database:
+
+```sh
+DB=postgres bundle exec rspec              # postgres:17
+DB=mysql bundle exec rspec                 # mysql:8.4
+DB=mysql DB_IMAGE=mysql:9.4 bundle exec rspec spec/statesman/machine_spec.rb
+```
+
 ## Style
 
 We use [Rubocop](https://github.com/bbatsov/rubocop) to help maintain a

data/Gemfile

@@ -12,6 +12,9 @@ else
   gem "rails", "~> 8.0"
 end
 
+# ActiveSupport 7.2 passes `quirks_mode:` to JSON, which json 3 no longer accepts.
+gem "json", "< 3" if ENV['RAILS_VERSION'] == '7.2'
+
 group :development, :test do
   gem "ammeter", "~> 1.1"
   gem "gc_ruboconfig", "~> 6.0.0"
@@ -24,6 +27,8 @@ group :development, :test do
   gem "rspec-its", "~> 2.0"
   gem "rspec-rails", "~> 8.0"
   gem "sqlite3", "~> 2.9.0"
+  gem "testcontainers-mysql", "~> 0.2.0"
+  gem "testcontainers-postgres", "~> 0.2.0"
   gem "test-unit", "~> 3.3"
   gem "timecop", "~> 0.9.1"
 end

data/README.md

@@ -617,6 +617,123 @@ Model.in_state(:state_1).or(
 )
 ```
 
+### Caching the current state
+
+If you find yourself frequently needing the current state without wanting to
+join or query the transitions table,
+`Statesman::Adapters::ConfigureCachedCurrentState` can maintain a
+denormalised column on the parent model for you:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  extend Statesman::Adapters::TypeSafeActiveRecordQueries
+  include Statesman::Adapters::ConfigureCachedCurrentState
+
+  configure_state_machine transition_class: MyModelTransition,
+                          initial_state: :initial
+  configure_cached_current_state
+end
+```
+
+This sets the column (`cached_current_state` by default) to the initial state
+when a record is created — unless it's already been explicitly set (e.g. a
+test factory building a record straight into a given state), in which case
+that value is left alone — and updates it via `update_columns` whenever
+`transition_to!` successfully persists a new `most_recent` transition.
+Including the module by itself does nothing — the write is only wired up once
+`configure_cached_current_state` is called.
+
+The write happens inside the `ActiveRecord` storage adapter itself, right
+after a transition is persisted as the new `most_recent` row, rather than via
+an ActiveRecord callback on `transition_class`. That single code path is
+shared by every `Machine` subclass and by every adapter instance for a model,
+so it fires reliably even under Statesman's `mysql_gaplock_protection` config
+— where the `most_recent` flip happens via a raw SQL `UPDATE` that bypasses
+ActiveRecord callbacks entirely.
+
+One consequence: a transition row created directly on `transition_class`,
+bypassing the machine (e.g. `parent.transitions.create!(...)` in a test or
+backfill), does not update the cache — only real transitions performed
+through `transition_to!` do.
+
+Two further options are available:
+
+- `column:` — use a column name other than `cached_current_state`.
+- `touch_updated_at:` — also bump `updated_at` on the parent when the cached
+  column changes (defaults to `false`).
+
+Because the write happens in the shared adapter code rather than against a
+specific `Machine` subclass, this also works for models driven by several
+different machine classes chosen dynamically (e.g. per scheme). It always
+runs before any of a machine's own `after_transition` callbacks, since it
+happens as part of persisting the transition, before Statesman invokes its
+own callbacks.
+
+`configure_cached_current_state` also defines `Model.cached_state_column_name`,
+returning the configured column, for generic tooling that needs to introspect
+or repair the cached column (e.g. a cache-repair rake task working across
+several models).
+
+## Bulk transitions
+
+`Statesman::BulkTransition` moves many parents from one state to another in a
+single transaction, with a fixed number of queries however many parents there
+are, instead of the several queries per record that `transition_to!` costs. It
+works with the `ActiveRecord` adapter on PostgreSQL, MySQL and SQLite.
+
+```ruby
+bulk = Statesman::BulkTransition.new(
+  model_class: Order,
+  machine_class: OrderStateMachine,
+  from: :pending,
+  to: :confirmed,
+)
+
+transitioned_ids = bulk.call!(order_ids, metadata: { source: "import" })
+```
+
+`call!` returns the ids of the parents that were actually transitioned. Parents
+that aren't currently in the `from` state are silently skipped, so a batch is
+safe to re-run.
+
+It performs the same mechanical write as `transition_to!` — flipping the
+current `most_recent` transition, inserting the new one, and updating the
+parent's cached current state if you've called `configure_cached_current_state`
+— but it deliberately **does not run** the machine's guards, its
+`before_transition`/`after_transition` callbacks, or any validations and
+callbacks on the transition model. If you need equivalent side effects,
+reproduce them in the block (below).
+
+Options:
+
+- `metadata:` — applied to every new transition. `metadata_per_id:` overrides it
+  for individual parents, keyed by parent id (`1` and `"1"` match the same
+  parent).
+- `attributes_to_copy:` — extra transition columns to carry forward from the
+  previous transition onto the new one. The parent foreign key and `sort_key`
+  are always carried. There's no default, so you have to choose explicitly.
+  `attributes_per_id:` overrides those carried values for individual parents,
+  and may only name columns listed in `attributes_to_copy` (anything else raises
+  `Statesman::BulkTransition::ValidationError`).
+
+If you pass a block, it is called inside the same transaction with an
+`ActiveRecord::Relation` over the newly inserted transitions. The relation is
+lazy, so the block decides what to read or write:
+
+```ruby
+bulk.call!(order_ids) do |transitions|
+  rows = transitions.pluck(:order_id, :to_state)
+  AuditLog.insert_all(rows.map { |id, state| { order_id: id, state: state } })
+end
+```
+
+An exception raised in the block rolls the entire batch back. If a row
+conflicts with the unique index on the transition table, `call!` raises
+`Statesman::TransitionConflictError` and nothing is committed.
+
+Two assumptions to be aware of: the transition table must not be an STI table,
+and the parent must have a single-column primary key.
+
 ## Frequently Asked Questions
 
 ### Storing the state on the model object

data/Rakefile

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
+require "open3"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec) do |task|
@@ -13,4 +14,34 @@ RSpec::Core::RakeTask.new(:spec) do |task|
   end
 end
 
-task default: :spec
+DATABASES = %w[sqlite postgres mysql].freeze
+RSPEC_COMMAND = %w[bundle exec rspec].freeze
+
+# DB_IMAGE and DATABASE_URL are cleared so each run gets its own database rather than all of them
+# sharing whichever one the caller's environment points at.
+database_env = ->(db) { { "DB" => (db unless db == "sqlite"), "DB_IMAGE" => nil, "DATABASE_URL" => nil } }
+
+namespace :spec do
+  DATABASES.each do |db|
+    desc "Run specs against #{db}"
+    task(db) { sh(database_env.call(db), *RSPEC_COMMAND) }
+  end
+
+  desc "Run specs against all databases in parallel"
+  task :all do
+    output_lock = Mutex.new
+
+    results = DATABASES.map do |db|
+      Thread.new do
+        output, status = Open3.capture2e(database_env.call(db), *RSPEC_COMMAND)
+        output_lock.synchronize { puts "==> #{db}", output }
+        [db, status.success?]
+      end
+    end.map(&:value)
+
+    failed = results.reject { |_, success| success }.map(&:first)
+    abort "Specs failed for: #{failed.join(', ')}" if failed.any?
+  end
+end
+
+task default: "spec:all"

data/lib/statesman/adapters/active_record.rb

@@ -108,6 +108,8 @@ module Statesman
             transition.save!
           end
 
+          maintain_cached_current_state(transition)
+
           @last_transition = transition
           @observer.execute(:after, from, to, transition)
           add_after_commit_callback(from, to, transition)
@@ -116,6 +118,30 @@ module Statesman
         transition
       end
 
+      # Writes the cached current state column configured via
+      # Statesman::Adapters::ConfigureCachedCurrentState#configure_cached_current_state,
+      # if the parent model opted in. Done here, rather than via an ActiveRecord
+      # callback on transition_class, so it fires reliably even under
+      # mysql_gaplock_protection - where most_recent is flipped to true via a raw SQL
+      # UPDATE that bypasses ActiveRecord callbacks entirely (see above). This method
+      # always runs after most_recent has been set on `transition` (in both branches
+      # above), and before the machine's own after_transition callbacks are invoked.
+      def maintain_cached_current_state(transition)
+        model_class = parent_model.class
+        return unless model_class.respond_to?(:cached_state_column_name)
+
+        column = model_class.cached_state_column_name
+        unless model_class.column_names.include?(column.to_s)
+          raise ArgumentError,
+                "cache_current_state_column: #{column.inspect} is not a column " \
+                "on #{model_class.name}"
+        end
+
+        attributes = { column => transition.to_state }
+        attributes[:updated_at] = Time.current if model_class.cached_current_state_touch_updated_at?
+        parent_model.update_columns(attributes)
+      end
+
       def default_transition_attributes(from, to, metadata)
         attributes = {
           to_state: to,

data/lib/statesman/adapters/active_record_queries.rb

@@ -33,6 +33,18 @@ module Statesman
         ClassMethods.new(**args)
       end
 
+      # Finds the has_many association on model that targets transition_class -
+      # matching by klass rather than by name, since callers (e.g.
+      # ConfigureCachedCurrentState) may not know what the association was named.
+      def self.transition_reflection_for(model, transition_class)
+        model.reflect_on_all_associations(:has_many).find do |reflection|
+          reflection.klass == transition_class
+        end || raise(
+          MissingTransitionAssociation,
+          "Could not find has_many association between #{model} and #{transition_class}.",
+        )
+      end
+
       class ClassMethods < Module
         def initialize(**args)
           @args = args
@@ -41,7 +53,13 @@ module Statesman
         def included(base)
           ensure_inheritance(base) if base.respond_to?(:subclasses) && base.subclasses.any?
 
-          query_builder = QueryBuilder.new(base, **@args)
+          query_builder = QueryBuilder.new(
+            base,
+            transition_class: @args[:transition_class],
+            initial_state: @args[:initial_state],
+            most_recent_transition_alias: @args[:most_recent_transition_alias],
+            transition_name: @args[:transition_name],
+          )
 
           base.define_singleton_method(:most_recent_transition_join) do
             query_builder.most_recent_transition_join
@@ -126,13 +144,7 @@ module Statesman
         end
 
         def transition_reflection
-          model.reflect_on_all_associations(:has_many).each do |value|
-            return value if value.klass == transition_class
-          end
-
-          raise MissingTransitionAssociation,
-                "Could not find has_many association between #{self.class} " \
-                "and #{transition_class}."
+          ActiveRecordQueries.transition_reflection_for(model, transition_class)
         end
 
         def model_primary_key

data/lib/statesman/adapters/configure_cached_current_state.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Statesman
+  module Adapters
+    # Include on an ActiveRecord model configured with
+    # Statesman::Adapters::TypeSafeActiveRecordQueries#configure_state_machine (only
+    # transition_class: is required) to cache the current state on a column on the
+    # model. Including this module does nothing on its own - the model must also call
+    # `configure_cached_current_state` to wire up the write, which also exposes the
+    # configured column name via `cached_state_column_name`, for generic tooling that
+    # needs to introspect or repair the cached column (e.g. a cache-repair rake task).
+    #
+    # The write itself happens inside Statesman::Adapters::ActiveRecord#create_transition
+    # (see `maintain_cached_current_state` there), not via a callback registered by this
+    # module - that single code path is shared by every Machine subclass and every
+    # storage adapter instance for a model, so this works even when a model is driven by
+    # several different machine classes (e.g. chosen dynamically per scheme), and it
+    # fires reliably under Statesman's mysql_gaplock_protection config, where the DB-level
+    # most_recent flip happens via a raw SQL UPDATE that bypasses ActiveRecord callbacks
+    # entirely.
+    #
+    # Caveat: because the write only happens as part of `transition_to!` (via the
+    # adapter), a transition row created directly on transition_class - bypassing the
+    # machine entirely, e.g. `parent.transitions.create!(...)` - does not update the
+    # cache. Only real transitions performed through the machine do.
+    #
+    # The initial-state seed on create only applies when the column is nil - if it's
+    # already been explicitly set (e.g. a test factory building a record straight into a
+    # given state, without a real transition history), that value is left alone.
+    module ConfigureCachedCurrentState
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def configure_cached_current_state(column: :cached_current_state, touch_updated_at: false)
+          unless respond_to?(:transition_class) && transition_class
+            raise ArgumentError,
+                  "transition_class: must be configured via configure_state_machine " \
+                  "before calling configure_cached_current_state"
+          end
+
+          initial = initial_state
+
+          define_singleton_method(:cached_state_column_name) { column }
+          define_singleton_method(:cached_current_state_touch_updated_at?) { touch_updated_at }
+
+          before_create do
+            next unless respond_to?(:"#{column}=")
+            next unless send(column).nil?
+
+            send(:"#{column}=", initial.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/statesman/adapters/type_safe_active_record_queries.rb

@@ -15,6 +15,9 @@ module Statesman
             transition_name: try(:transition_name),
           ),
         )
+
+        define_singleton_method(:initial_state) { initial_state }
+        define_singleton_method(:transition_class) { transition_class }
       end
     end
   end