active_record_compose 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 810feb87760ff992aa21ca019081e6072ec43c99387ea0ee013f767d4d2c875c
-  data.tar.gz: 7077c4d5b79d12c6c5f5a0297d0d2837c3d3c79a3b8e74a13c12e05a3511c078
+  metadata.gz: 91c3305d64d7b4e8b0cf57e127b9b1e48c0a413a5749d79f1afef5d659814271
+  data.tar.gz: 321aa91ad6500b97a38f02ea70f5904c2852016eddf7fb4388186e25c83ff825
 SHA512:
-  metadata.gz: 283b3beaab24fb19d30e134dbe543a25c730bf0d331bdd5114ae89747d0a247b8b572d7e6f2578c06d80f2f7cb4b8c6023f2640518c5b0dc21d335401e45ab5c
-  data.tar.gz: 6f55ebeb0bd4379d206f55b8dc8dc618beca9d281f0d425c0cc8d96078d60ed74fd26c67b92b2bb8c26f9cb6dd4634557ef1064990c4a7ca91bb15e99d6c381e
+  metadata.gz: ad550be47844182ac031aaa4c9df4c344e0b14a3173a3402c2e7d44123bd953c1b2ef4f62e0ff5ca8d49c17f688cb9a6c5385d1aeb810bb34263d7f2203cd943
+  data.tar.gz: a97affe0e201a77cb207ba0d013194c9b1a30a79611a80d4d0e133904bfd8f016e2f330a126428acdec22f248bfa2ed999df62db46a5174fe8deb3ec2ebaee84

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.4.0] - 2026-10-14
+
+* Use a dedicated deprecator for deprecated APIs.
+  (https://github.com/hamajyotan/active_record_compose/pull/75)
+* Fix `before_commit` callback timing for transactions spanning multiple database connections.
+  (https://github.com/hamajyotan/active_record_compose/pull/76)
+  - Ensure that `before_commit` callbacks are invoked at the appropriate point before the outermost transaction commits.
+  - Leave behavior unchanged when all models use a single database connection.
+* Perform validations outside a transaction.
+  (https://github.com/hamajyotan/active_record_compose/pull/78)
+* Execute inner models' `after_commit` callbacks before outer models' callbacks.
+  (https://github.com/hamajyotan/active_record_compose/pull/79)
+* Add `ActiveRecordCompose::UninitializedAttribute#record`.
+
+## [1.3.0] - 2026-08-09
+
+* Support secondary and multiple database
+  (https://github.com/hamajyotan/active_record_compose/pull/74)
+  - When models connecting to different databases are used together, the system behaves in a manner simulating a two-phase commit.
+  - Due to the nature of the ActiveRecord API supported by Rails, a true two-phase commit is not implemented; instead, transactions are nested when multiple database connections are involved.
+  - Note that operations remain unchanged when all models belong to a single primary database.
+
 ## [1.2.1] - 2026-03-21
 
 * Improved clarity of error when accessing uninitialized attributes.

data/README.md

@@ -59,6 +59,10 @@ $ bundle
 
 ## Quick Start
 
+For a complete runnable application, see the Sample Application section below.
+
+The examples in this section focus on ActiveRecordCompose itself and intentionally omit surrounding application code such as migrations, routes, views, and jobs.
+
 ### Basic Example
 
 Suppose you have two models:

data/lib/active_record_compose/attributes.rb

@@ -167,14 +167,16 @@ module ActiveRecordCompose
 
     private
 
-    def _write_attribute(...) = _require_attributes_initialized { super } # steep:ignore
+    # @private
+    def _write_attribute(...) = _require_attributes_initialized { super }
 
+    # @private
     def attribute(...) = _require_attributes_initialized { super }
 
+    # @private
     def _require_attributes_initialized
       unless @attributes
-        raise ActiveRecordCompose::UninitializedAttribute,
-              "No attributes have been set. Is proper initialization performed, such as calling `super` in `initialize`?"
+        raise ActiveRecordCompose::UninitializedAttribute.new(self)
       end
 
       yield

data/lib/active_record_compose/composed_collection.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "wrapped_model"
 
 module ActiveRecordCompose
@@ -117,7 +118,7 @@ module ActiveRecordCompose
     def symbol_proc_map
       @symbol_proc_map ||=
         Hash.new do |h, k|
-          h[k] = -> { owner.__send__(k) }
+          h[k] = -> { owner.__send__(k) } # steep:ignore
         end
     end
 

data/lib/active_record_compose/exceptions.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
+  # Generic Active Record Compose exception class.
+  #
+  class ActiveRecordComposeError < StandardError
+  end
+
   # Occurs when a circular reference is detected in the containing model.
   #
   # @example
@@ -25,7 +30,7 @@ module ActiveRecordCompose
   #     inner.model = outer  # There is a circular reference in the form outer > middle > inner > outer.
   #     outer.save  #=> raises ActiveRecordCompose::CircularReferenceDetected
   #
-  class CircularReferenceDetected < StandardError; end
+  class CircularReferenceDetected < ActiveRecordComposeError; end
 
   # Occurs when accessing Attributes without initializing it.
   #
@@ -40,5 +45,13 @@ module ActiveRecordCompose
   #     model = Model.new
   #     model.foo = 1  #=> raises ActiveRecordCompose::UninitializedAttribute
   #
-  class UninitializedAttribute < StandardError; end
+  class UninitializedAttribute < ActiveRecordComposeError
+    attr_reader :record
+
+    def initialize(record = nil)
+      @record = record
+      message = "No attributes have been set. Is proper initialization performed, such as calling `super` in `initialize`?"
+      super(message)
+    end
+  end
 end

data/lib/active_record_compose/model.rb

@@ -85,8 +85,8 @@ module ActiveRecordCompose
 
     include ActiveRecordCompose::Attributes
     include ActiveRecordCompose::Persistence
-    include ActiveRecordCompose::Validations
     include ActiveRecordCompose::TransactionSupport
+    include ActiveRecordCompose::Validations
     include ActiveRecordCompose::Inspectable
 
     def initialize(attributes = {})

data/lib/active_record_compose/transaction_support/active_transaction.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecordCompose
+  module TransactionSupport
+    # @private
+    # steep:ignore:start
+
+    # In older versions, the ActiveRecord::Transaction object is not passed to the block argument of #transaction.
+    # So instead, we define a transaction object that can be evaluated equivalently.
+    # This follow-up will no longer be necessary when support for Rails 7.1 is dropped.
+    #
+    class ActiveTransaction
+      def initialize(transaction)
+        @real_transaction = transaction
+      end
+
+      attr_reader :real_transaction
+
+      def open? = !closed?
+
+      def closed? = real_transaction&.state&.completed?
+
+      def ==(other)
+        return true if equal?(other)
+        return false unless self.class == other.class
+
+        real_transaction == other.real_transaction
+      end
+
+      def eql?(other)
+        return true if equal?(other)
+        return false unless self.class == other.class
+
+        real_transaction.eql?(other.real_transaction)
+      end
+
+      def hash = real_transaction.hash
+    end
+
+    # steep:ignore:end
+  end
+end

data/lib/active_record_compose/transaction_support/transaction_coordinator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ActiveRecordCompose
+  module TransactionSupport
+    # @private
+    class TransactionCoordinator
+      def add_transaction(active_transaction)
+        transactions << active_transaction
+      end
+
+      # The before_commit callback is controlled so that
+      # it runs just before the outermost transaction commits,
+      # but not just before any inner transactions commit.
+      #
+      def on_before_comitted
+        return unless final_transaction?
+
+        yield
+      end
+
+      # It processes after_commit/after_rollback only immediately
+      # after all transactions are closed.
+      #
+      def on_after_transaction
+        return unless all_finished?
+
+        with_transaction_cleanup { yield }
+      end
+
+      private
+
+      def with_transaction_cleanup
+        yield
+      ensure
+        transactions.reject! { _1.closed? }
+      end
+
+      def final_transaction? = transactions.one? { !_1.closed? }
+
+      def all_finished? = transactions.all? { _1.closed? }
+
+      def transactions = @transactions ||= Set.new
+    end
+  end
+end

data/lib/active_record_compose/transaction_support.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module"
+require_relative "transaction_support/active_transaction"
+require_relative "transaction_support/transaction_coordinator"
 
 module ActiveRecordCompose
   module TransactionSupport
@@ -13,24 +15,26 @@ module ActiveRecordCompose
     # steep:ignore:start
 
     class_methods do
-      # @private
-      # @deprecated
-      def with_connection(...)
-        ActiveRecord.deprecator.warn("`with_connection` is deprecated. Use `ActiveRecord::Base.with_connection` instead.")
-        ActiveRecord::Base.with_connection(...)
-      end
+      if ActiveRecord.version >= Gem::Version.new("7.2")
+        # @private
+        # @deprecated
+        def with_connection(...)
+          ActiveRecordCompose.deprecator.deprecation_warning(:with_connection, "Use `ActiveRecord::Base.with_connection` instead.")
+          ActiveRecord::Base.with_connection(...)
+        end
 
-      # @private
-      # @deprecated
-      def lease_connection(...)
-        ActiveRecord.deprecator.warn("`lease_connection` is deprecated. Use `ActiveRecord::Base.lease_connection` instead.")
-        ActiveRecord::Base.lease_connection(...)
+        # @private
+        # @deprecated
+        def lease_connection(...)
+          ActiveRecordCompose.deprecator.deprecation_warning(:lease_connection, "Use `ActiveRecord::Base.lease_connection` instead.")
+          ActiveRecord::Base.lease_connection(...)
+        end
       end
 
       # @private
       # @deprecated
       def connection(...)
-        ActiveRecord.deprecator.warn("`connection` is deprecated. Use `ActiveRecord::Base.connection` instead.")
+        ActiveRecordCompose.deprecator.deprecation_warning(:connection, "Use `ActiveRecord::Base.connection` instead.")
         ActiveRecord::Base.connection(...)
       end
     end
@@ -86,17 +90,17 @@ module ActiveRecordCompose
 
       # @private
       def before_committed!
-        _run_before_commit_callbacks
+        transaction_coordinator.on_before_comitted { _run_before_commit_callbacks }
       end
 
       # @private
       def committed!(should_run_callbacks: true)
-        _run_commit_callbacks if should_run_callbacks
+        transaction_coordinator.on_after_transaction { _run_commit_callbacks if should_run_callbacks }
       end
 
       # @private
       def rolledback!(force_restore_state: false, should_run_callbacks: true)
-        _run_rollback_callbacks if should_run_callbacks
+        transaction_coordinator.on_after_transaction { _run_rollback_callbacks if should_run_callbacks }
       end
     end
 
@@ -104,30 +108,59 @@ module ActiveRecordCompose
 
     def save!(**options) = with_transaction_returning_status { super }
 
-    private
-
     # @private
-    def with_transaction_returning_status
-      connection_pool.with_connection do |connection|
-        with_pool_transaction_isolation_level(connection) do
-          ensure_finalize = !connection.transaction_open?
+    def connection_pools
+      pools =
+        models.compact.flat_map do |model|
+          if model.is_a?(ActiveRecordCompose::TransactionSupport)
+            model.connection_pools
+          elsif model.is_a?(ActiveRecord::Base)
+            connection_pool(ar_class: model.class)
+          else
+            [] # : Array[ActiveRecord::ConnectionAdapters::ConnectionPool]
+          end
+        end
+      pools << connection_pool if pools.blank?
+      pools.uniq
+    end
 
-          connection.transaction do
-            connection.add_transaction_record(self, ensure_finalize || has_transactional_callbacks?)
+    private
 
-            yield.tap { raise ActiveRecord::Rollback unless _1 }
-          end || false
+    # @private
+    def with_transaction_returning_status(&block)
+      procs = connection_pools.inject(block) do |inner_proc, pool|
+        -> do
+          pool.with_connection do |connection|
+            with_pool_transaction_isolation_level(connection) do
+              ensure_finalize = !connection.transaction_open?
+
+              connection.transaction do |tran|
+                tran ||= ActiveTransaction.new(connection.current_transaction) # steep:ignore
+                transaction_coordinator.add_transaction(tran)
+
+                begin
+                  inner_proc.call.tap { raise ActiveRecord::Rollback unless _1 }
+                ensure
+                  connection.add_transaction_record(self, ensure_finalize || has_transactional_callbacks?)
+                end
+              end
+            end
+          end
         end
       end
+      procs.call || false
     end
 
+    # @private
+    def transaction_coordinator = @transaction_coordinator ||= TransactionCoordinator.new
+
     # @private
     def default_ar_class = ActiveRecord::Base
 
     # @private
     def connection_pool(ar_class: default_ar_class)
       connection_specification_name = ar_class.connection_specification_name
-      role = ar_class.current_role
+      role = ar_class.current_role # steep:ignore
       shard = ar_class.current_shard # steep:ignore
       connection_handler = ar_class.connection_handler # steep:ignore
       retrieve_options = { role:, shard: }
@@ -139,7 +172,7 @@ module ActiveRecordCompose
     # @private
     def with_pool_transaction_isolation_level(connection, &block)
       if ActiveRecord.gem_version.release >= Gem::Version.new("8.1.0")
-        isolation_level = ActiveRecord.default_transaction_isolation_level # steep:ignore
+        isolation_level = ActiveRecord.default_transaction_isolation_level
         connection.pool.with_pool_transaction_isolation_level(isolation_level, connection.transaction_open?, &block)
       else
         block.call

data/lib/active_record_compose/version.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
+
+  class << self
+    def version = Gem::Version.new(VERSION)
+
+    private
+
+    # @private
+    def next_major_version
+      version.segments.first + 1 # steep:ignore
+    end
+  end
 end

data/lib/active_record_compose.rb

@@ -11,6 +11,10 @@ require_relative "active_record_compose/model"
 # Most of the functionality resides in {ActiveRecordCompose::Model}.
 #
 module ActiveRecordCompose
+  # @private
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new(next_major_version, "ActiveRecordCompose") # steep:ignore
+  end
 end
 
 require "active_record_compose/railtie" if defined?(::Rails::Railtie)

data/sig/_internal/package_private.rbs

@@ -1,4 +1,7 @@
 module ActiveRecordCompose
+  private
+  def self.next_major_version: () -> Integer
+
   module Attributes
     extend ActiveSupport::Concern
     include ActiveModel::Attributes
@@ -118,6 +121,8 @@ module ActiveRecordCompose
     include ActiveSupport::Callbacks
     extend ActiveSupport::Callbacks::ClassMethods
 
+    @transaction_coordinator: ActiveRecordCompose::TransactionSupport::TransactionCoordinator
+
     def self.before_commit: (*untyped) -> untyped
     def self.after_commit: (*untyped) -> untyped
     def self.after_rollback: (*untyped) -> untyped
@@ -127,11 +132,28 @@ module ActiveRecordCompose
     def _run_before_commit_callbacks: () -> untyped
     def _run_commit_callbacks: () -> untyped
     def _run_rollback_callbacks: () -> untyped
+    def connection_pools: () -> Array[ActiveRecord::ConnectionAdapters::ConnectionPool]
 
     private
+    def models: -> ComposedCollection
     def default_ar_class: -> singleton(ActiveRecord::Base)
     def connection_pool: (?ar_class: singleton(ActiveRecord::Base)) -> ActiveRecord::ConnectionAdapters::ConnectionPool
     def with_pool_transaction_isolation_level: [T] (ActiveRecord::ConnectionAdapters::AbstractAdapter) { () -> T } -> T
+    def transaction_coordinator: () -> ActiveRecordCompose::TransactionSupport::TransactionCoordinator
+
+    class TransactionCoordinator
+      @transactions: Set[ActiveRecord::ConnectionAdapters::Transaction]
+
+      def add_transaction: (ActiveRecord::ConnectionAdapters::Transaction) -> void
+      def on_after_transaction: () { () -> void } -> void
+      def on_before_comitted: () { () -> void } -> void
+
+      private
+      def final_transaction?: -> bool
+      def all_finished?: -> bool
+      def transactions: () -> Set[ActiveRecord::ConnectionAdapters::Transaction]
+      def with_transaction_cleanup: () { () -> void } -> void
+    end
   end
 
   module Persistence

data/sig/active_record_compose.rbs

@@ -4,6 +4,9 @@
 module ActiveRecordCompose
   VERSION: String
 
+  def self.version: () -> Gem::Version
+  def self.deprecator: () -> ActiveSupport::Deprecation
+
   interface _ARLike
     def save: (**untyped options) -> bool
     def save!: (**untyped options) -> untyped
@@ -36,6 +39,9 @@ module ActiveRecordCompose
   type destroy_context_type = ((^() -> boolish) | (^(ar_like) -> boolish))
   type condition_type = ((^() -> boolish) | (^(ar_like) -> boolish))
 
+  class ActiveRecordComposeError < StandardError
+  end
+
   class ComposedCollection
     include ::Enumerable[ar_like]
 
@@ -47,7 +53,7 @@ module ActiveRecordCompose
     def delete: (ar_like) -> ComposedCollection?
   end
 
-  class CircularReferenceDetected < StandardError
+  class CircularReferenceDetected < ActiveRecordComposeError
   end
 
   class Model
@@ -99,6 +105,9 @@ module ActiveRecordCompose
     extend Rails::Initializable::ClassMethods
   end
 
-  class UninitializedAttribute < StandardError
+  class UninitializedAttribute < ActiveRecordComposeError
+    def initialize: (?untyped) -> void
+
+    attr_reader record: untyped
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - hamajyotan
@@ -56,6 +56,8 @@ files:
 - lib/active_record_compose/persistence.rb
 - lib/active_record_compose/railtie.rb
 - lib/active_record_compose/transaction_support.rb
+- lib/active_record_compose/transaction_support/active_transaction.rb
+- lib/active_record_compose/transaction_support/transaction_coordinator.rb
 - lib/active_record_compose/validations.rb
 - lib/active_record_compose/version.rb
 - lib/active_record_compose/wrapped_model.rb
@@ -84,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.16
 specification_version: 4
 summary: activemodel form object pattern
 test_files: []