custom_counter_cache 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b86370bc27fe59b1bafc3f2160e69843c9650e58b6c9e980010eb5f88fb229cd
-  data.tar.gz: 0aeccd374cf039a73f248fa4440f3d472859f73f83b4a0f991b432eaba7bf10e
+  metadata.gz: 56544a2488e48dc35c3ad64e7eb7cb0bc2c0be1bc3f5aa8ee5a52a349de2fcb8
+  data.tar.gz: 5d40812f87a2d9ce720e77558ac1cec17c81a607170d2a9e690b56bcc9481e29
 SHA512:
-  metadata.gz: f0de231b5e888db121d43d3a37909e37b8e3cb1fd4bf0c58ad0195bda8030f4937a1aba70729716c6c23f3ec1aa48888f68308bb998d6e50fe8bcb71529d9bde
-  data.tar.gz: 721794ae2b6cb35349209392f390d42352d3f0fa31a10599b7c13e7dd98e00bdba7c29c96ccfd9033d99e4c508aeab845ec2db9e653bd93f21238fb899892d12
+  metadata.gz: 287db2bc86cca62e838cc32849eb1bb43fe66f9d40e771981bb56df221617e6bdf4392950808cafa031afb8a90fe9682ca68053bc0867ad5df802a76ca47f073
+  data.tar.gz: e096528b08c44673508784b4faa7bdaa500d5f5f30b5844d4d2a68a1dcf77ff241df30d4805ad58eb22f126f6fb821fc9214c5114fdf4ee520eca44e15ee3981

data/CHANGELOG.md

@@ -0,0 +1,112 @@
+# Changelog
+
+## 0.4.0
+
+### Breaking
+
+- Requires Ruby >= 3.3 and Rails (Active Record) >= 8.0.
+- `:if`/`:unless` on `update_counter_cache` now only gate the create and update callbacks; a
+  destroy always recounts. Use `except: [:destroy]` to skip it.
+- Column counters are written with `update_column`: recounts no longer save other unsaved
+  changes on the owner, touch its `updated_at`, run its callbacks or bump `lock_version`.
+- `update_counter_cache` raises `ArgumentError` for associations other than `belongs_to`
+  (they have never worked).
+- Every model that calls `define_counter_cache` gets the `counters` association, not only models
+  with a counter that has no column.
+- Defining counters on a table that doesn't exist no longer silently defines nothing.
+- Recounts triggered by `update_counter_cache` callbacks run after the saving transaction commits
+  instead of inside it: once per owner and counter per transaction, not at all on rollback, and
+  under a short lock on the owner's row. Counting inside the transaction couldn't see a concurrent
+  save's uncommitted child, so concurrent saves to the same owner left a stale count (on
+  PostgreSQL, 399 of 400 concurrent test runs). The counter now changes at commit rather than at
+  save; call `update_<name>` directly to recount immediately inside a transaction. Rails'
+  transactional tests commit each save within the test transaction, so tests see the recount.
+- A counter stored in the counters table raises `ArgumentError` for a value that isn't a whole
+  number (e.g. `2.5`, `'many'`, infinity) instead of silently truncating it with `to_i`. `nil`
+  still means 0, and whole values like `4.0` or `BigDecimal('4')` are still accepted. Use a column
+  of a suitable type or `store: :cache` for fractional values.
+
+### Changed
+
+- Whether a counter uses a column or the counters table is decided when it's read or written, so
+  loading models never queries the database, and a column added after the model has loaded is
+  picked up. The Heroku `DATABASE_URL` workaround is gone.
+- Counter rows are deleted on destroy only when the model has a counter without a column, so
+  column-only models never touch the counters table.
+- A recount that raises after commit is passed to `ActiveSupport.error_reporter.unexpected` (with
+  the owner and counter as context) and logged, instead of propagating: the save has already
+  committed, and one failure no longer skips the other recounts queued for that commit. In
+  development and test Rails' debug mode still raises it. Direct `update_<name>` calls,
+  `recount_counter_caches` and `CustomCounterCache::RecountJob` still raise.
+- Paranoia's `restore` now recounts the owner for callbacks declared after `acts_as_paranoid`; it
+  didn't before. Add `except: [:restore]` to keep the old behavior.
+
+### Added
+
+- `CustomCounterCache.counter_class_name` (default `'Counter'`) sets the model behind the
+  counters table.
+- `define_counter_cache :name, touch: true` (or `touch: :column`) sets a timestamp on the owner
+  whenever the counter is recounted. A column counter is written in the same UPDATE, and no
+  callbacks run.
+- `define_counter_cache :name, store: :cache, expires_in:` keeps a counter in
+  `CustomCounterCache.cache_store` (defaults to `Rails.cache`). It is computed on a miss and
+  deleted after commit when a child changes, instead of being recounted. Destroying the owner
+  deletes its keys.
+- `update_counter_cache ..., on_change: [:attr]` recounts on update only when a listed attribute
+  or the association's key columns changed. Create and destroy always recount.
+- `update_counter_cache [:article, :user], :comments_count` follows a path of `belongs_to`
+  associations and recounts both the old and the new owner at the end of it (grandparent counters).
+- `update_counter_cache ..., recount: :later` recounts in `CustomCounterCache::RecountJob`
+  (Active Job), enqueued after commit, once per owner and counter per transaction.
+- `CustomCounterCache.batch { }` recounts each owner and counter once after the block ends.
+- `CustomCounterCache.skip { }` drops recounts inside the block.
+- `Model.recount_counter_caches(*names, scope:, batch_size:)` recounts every record (or a scope) in
+  batches, repairing drift from `update_all`, `delete_all` and imports.
+- The `custom_counter_cache:recount` rake task (`MODEL=`, `COUNTERS=`, `BATCH_SIZE=`) wraps
+  `recount_counter_caches`.
+- Composite primary keys: owners and `belongs_to` associations with composite keys work with
+  column and cache counters, reassignment (including a change to only some key columns),
+  `on_change:`, `recount: :later` and `recount_counter_caches`. The counters table can't hold a
+  composite key, so a counter there raises `ArgumentError` naming the alternatives.
+- `only:` and `except:` on `update_counter_cache` accept `:restore`, the event fired by Paranoia's
+  `restore`.
+
+### Upgrading
+
+- If an `:if`/`:unless` condition was meant to skip destroys, add `except: [:destroy]`.
+- If you relied on a recount updating the owner's `updated_at`, pass `touch: true` to
+  `define_counter_cache`. Owner callbacks no longer run on a recount; call them explicitly if needed.
+- If a migration adds a counter column and backfills it, call `reset_column_information` on the
+  model before backfilling.
+- Counters now change when the saving transaction commits. Code that saves a child and reads the
+  owner's counter inside the same transaction should call `update_<name>` first.
+- A counters-table counter whose block can return a fractional value (an average, a sum of
+  decimals) now raises: move it to a column of a suitable type or to `store: :cache`.
+- On a model with a string or UUID primary key, the counters table's `countable_id` must be that
+  type (`t.references :countable, polymorphic: true, type: :uuid`).
+
+## 0.3.2
+
+### Fixed
+
+- Moving a record between owners now recounts the old owner when `belongs_to` uses a custom
+  `primary_key:`.
+- Polymorphic `belongs_to` with custom `foreign_key:`/`foreign_type:` no longer raises
+  `NoMethodError` on save.
+- Moving a record away from a polymorphic type whose class no longer exists no longer raises
+  `NameError`; the new owner is still recounted.
+- With `includes(:counters)`, counters stay current after an update, and a missing counter
+  returns 0 without a query.
+- Two saves creating the same virtual counter at once no longer fail with
+  `ActiveRecord::RecordNotUnique`; the second updates the row instead.
+- `update_counter_cache` without its `belongs_to` raises a clear `ArgumentError` instead of
+  `NoMethodError ... for nil`.
+
+### Changed
+
+- Depend on `activerecord` and `activesupport` instead of all of `rails`.
+- Require Ruby >= 3.1 in the gemspec, matching the README and Rails 7.2.
+- Test against every non-EOL Ruby (3.3, 3.4, 4.0) and Rails (8.0, 8.1).
+- Expand the test suite to cover all branches.
+- README: fix the `:if` example (`state_changed?` is always false in after callbacks)
+  and note that `:if` also applies to `after_destroy`.

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2011-2026 Cedric Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,261 @@
+{rdoc-image:https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml/badge.svg}[https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml]
+
+== Custom Counter Cache
+
+This is a simple approach to creating a custom counter cache in Rails that can be used across multiple models.
+
+=== Requirements
+
+* Ruby >= 3.3
+* Rails (Active Record) >= 8.0
+
+CI covers the Ruby and Rails versions that are not yet end-of-life.
+
+=== Installation
+
+Add the following to your Gemfile:
+
+  gem 'custom_counter_cache'
+
+== Defining a counter
+
+The block calculates the counter's value from its owner. It is called whenever a model that
+declares +update_counter_cache+ (see below) changes.
+
+  include CustomCounterCache::Model
+  define_counter_cache :articles_count do |user|
+    user.articles.where(state: 'published').count
+  end
+
+Pass <tt>touch: true</tt> (or a column name, e.g. <tt>touch: :counted_at</tt>) to also set that
+timestamp, <tt>updated_at</tt> for +true+, on every recount. A column counter is written in the same
+UPDATE. No callbacks run.
+
+Where the value is kept depends on the counter: a column of the same name, a row in a shared
+counters table, or a cache store (<tt>store: :cache</tt>). See Choosing storage below.
+
+== Triggering recounts
+
+Declare which models change the counter with +update_counter_cache+, naming a +belongs_to+
+association and the counter on its owner. It defines the after_create, after_update and
+after_destroy callbacks (plus after_restore for Paranoia, see Soft deletes).
+
+  include CustomCounterCache::Model
+  update_counter_cache :user, :articles_count, if: -> (article) { article.saved_change_to_state? }
+
+These callbacks can be added to any number of models that might need to change the counter.
+When a record moves to another owner, both the old and the new owner are recounted.
+
+Options:
+
+* <tt>:if</tt>, <tt>:unless</tt>: limit when the create and update callbacks run. The callbacks
+  run after the record is saved, so use <tt>saved_change_to_state?</tt> rather than
+  <tt>state_changed?</tt>, which is always false by then. They don't apply to destroy or restore:
+  those have no saved changes, and an extra recount is never wrong.
+* <tt>on_change:</tt>: an attribute or an array. Recount on update only when one of them changed;
+  prefer it to +:if+ for plain attribute checks. Create and destroy always recount. It combines
+  with +:if+ and +:unless+ (both must allow the update).
+* <tt>only:</tt>, <tt>except:</tt>: limit the events, any of <tt>:create</tt>, <tt>:update</tt>,
+  <tt>:destroy</tt> and <tt>:restore</tt>, e.g. <tt>only: [:create, :destroy]</tt> or
+  <tt>except: [:destroy]</tt>.
+* <tt>:prepend</tt>: prepend the callbacks instead of appending them.
+* <tt>recount: :later</tt>: recount in a background job instead of right after commit. See
+  When recounts run.
+
+For example, to recount only when the state changes:
+
+  update_counter_cache :user, :articles_count, on_change: [:state]
+
+The association's key columns (plus the type column for a polymorphic one) are always watched
+by +on_change+, so moving the record to another owner recounts both owners.
+
+== Grandparent counters
+
+Pass a path of +belongs_to+ associations to recount an owner further up. For a
+<tt>comments_count</tt> on User across all of a user's articles:
+
+  class User < ApplicationRecord
+    include CustomCounterCache::Model
+    has_many :articles
+    has_many :comments, through: :articles
+    define_counter_cache(:comments_count) { |user| user.comments.count }
+  end
+
+  class Comment < ApplicationRecord
+    include CustomCounterCache::Model
+    belongs_to :article
+    update_counter_cache [:article, :user], :comments_count
+  end
+
+  class Article < ApplicationRecord
+    include CustomCounterCache::Model
+    belongs_to :user
+    update_counter_cache :user, :comments_count # an article moving users changes both counts
+  end
+
+Moving a comment recounts the old and the new user, once if they're the same user. The second
+declaration is needed because an Article changing user also changes both users' counts, and only
+Article's own callbacks see that. A step after a polymorphic one is skipped for records whose
+class has no such association; any other missing or non-+belongs_to+ step raises ArgumentError.
+
+== Soft deletes
+
+Discard soft-deletes with an ordinary update, so the callbacks already fire: filter with
+<tt>.kept</tt> in the counter block, and if you use <tt>on_change:</tt> include
+<tt>:discarded_at</tt> in it, or discarding won't recount.
+
+  define_counter_cache(:pages_count) { |notebook| notebook.pages.kept.count }
+  update_counter_cache :notebook, :pages_count, on_change: [:state, :discarded_at]
+
+Paranoia's +destroy+ runs the destroy callbacks, and +restore+ is recounted too, provided
++acts_as_paranoid+ is declared before +update_counter_cache+. Skip it with <tt>except: [:restore]</tt>
+(<tt>:restore</tt> is also accepted by <tt>only:</tt>).
+
+  class Parcel < ApplicationRecord
+    acts_as_paranoid
+    belongs_to :crate
+    update_counter_cache :crate, :parcels_count
+  end
+
+== Batching and skipping
+
+Every triggering save recounts its owner. For bulk work, batch the recounts so each owner and
+counter is recounted once, when the block ends (or when its transaction commits):
+
+  CustomCounterCache.batch do
+    rows.each { |row| article.comments.create!(row) } # one recount of article.comments_count
+  end
+
+Batches nest (the outermost one flushes) and still flush if the block raises, since a recount
+reflects whatever is in the database. To skip recounts entirely, e.g. for an import you'll
+recount afterwards:
+
+  CustomCounterCache.skip { import_comments }
+
+Both are per thread (and per fiber).
+
+== When recounts run
+
+Recounts triggered by these callbacks run after the saving transaction commits, once per owner
+and counter per transaction, and not at all if it rolls back. Each takes a short lock on the
+owner's row while it counts, so two saves committing at once can't leave a stale value: the
+later recount always counts after the earlier commit. (Counting inside the saving transaction
+can't see a concurrent save's uncommitted child, so one of them would overwrite the other.)
+
+The counter therefore changes when the transaction commits, not when the child is saved. Inside
+a transaction, call the update method yourself if you need the new value straight away:
+
+  Article.transaction do
+    user.articles.create!(attrs)
+    user.update_articles_count # recounts now; update_* and recount_counter_caches never wait
+  end
+
+If a recount raises after commit, the save has already succeeded and the count can be rebuilt, so
+the error doesn't propagate to the caller or stop the other recounts queued for that commit. It's
+passed to <tt>Rails.error.unexpected</tt>, which raises in development and test (with
+<tt>consider_all_requests_local</tt>, as by default) and in production reports it to your error
+tracker with the owner and counter in the context. It's also logged. Calling
+<tt>update_<name></tt> or <tt>recount_counter_caches</tt> yourself raises as usual, and so does
+<tt>CustomCounterCache::RecountJob</tt>, so your queue's retries apply.
+
+To recount in a background job instead, enqueued after commit:
+
+  update_counter_cache :user, :articles_count, recount: :later # CustomCounterCache::RecountJob (Active Job)
+
+To pick a queue, <tt>CustomCounterCache::RecountJob.queue_as :low</tt>. Rails' transactional
+tests commit each save within the test transaction, so recounts happen there as they do in
+production.
+
+== Choosing storage
+
+[Column]         Add a column with the counter's name. Fastest to read, and you can sort and
+                 filter by it in SQL. Needs a migration per counter.
+[Counters table] Used automatically when there's no column. One shared table, no migration per
+                 counter; preload with <tt>includes(:counters)</tt>. See The counters table.
+[Cache]          <tt>define_counter_cache :x, store: :cache, expires_in: 12.hours</tt>. Kept in
+                 <tt>CustomCounterCache.cache_store</tt> (defaults to Rails.cache: Redis,
+                 Memcached, Solid Cache...). Reads compute on a miss; a child change deletes the
+                 key after commit instead of recounting, so writes are cheap and never lock the
+                 owner's row. Destroying the owner deletes its keys. Not visible to SQL, and a
+                 delete racing a concurrent read can leave a stale value for up to +expires_in+.
+
+Column or counters table is decided when the counter is read or written, not when the model
+loads, so defining counters never touches the database, and a column added later is picked up.
+
+To use a column, add one:
+
+  def change
+    add_column :users, :articles_count, :integer, default: 0, null: false
+  end
+
+== The counters table
+
+To store counters in a single shared table instead, use this migration:
+
+  create_table :counters do |t|
+    t.references :countable, polymorphic: true
+    t.string :key, null: false
+    t.integer :value, null: false, default: 0
+    t.timestamps
+  end
+  add_index :counters, [ :countable_id, :countable_type, :key ], unique: true
+
+The table holds whole numbers. A block result of +nil+ is stored as 0, and whole values such as
+<tt>4.0</tt> or <tt>BigDecimal('4')</tt> are converted, but a fractional result such as an average
+raises ArgumentError rather than being truncated: give that counter a column of a suitable type
+(e.g. decimal) or use <tt>store: :cache</tt>.
+
++countable_id+ must match your models' primary key type: for string or UUID keys, use
+<tt>t.references :countable, polymorphic: true, type: :uuid</tt> (or <tt>:string</tt>). A model
+with a composite primary key can't use this table, since +countable_id+ holds one value: give its
+counters a column or <tt>store: :cache</tt> (it raises ArgumentError otherwise). Composite keys
+work everywhere else, including composite foreign keys on the +belongs_to+ side.
+
+Here is the example model to go with:
+
+  class Counter < ActiveRecord::Base
+    belongs_to :countable, polymorphic: true
+    validates :countable, presence: true
+  end
+
+To use a different model name (for example if +Counter+ is already taken), set
+<tt>CustomCounterCache.counter_class_name</tt> (see Configuration).
+
+When a record is destroyed, its counter rows are removed with a single DELETE, without loading
+them or running Counter's callbacks. Do not add <tt>dependent: :destroy</tt> to the +belongs_to+
+above: on a +belongs_to+ it means "destroying this Counter also destroys its owner".
+
+== Backfilling and repairing
+
+To backfill your counters, or repair them later, recount every record from the console or a migration:
+
+  User.recount_counter_caches
+
+or only some counters and records:
+
+  User.recount_counter_caches(:articles_count, scope: User.where(id: 1..1000), batch_size: 500)
+
+It returns the number of records processed. The same is available as a rake task:
+
+  bin/rails custom_counter_cache:recount MODEL=User COUNTERS=articles_count
+
++COUNTERS+ (comma-separated, default all) and +BATCH_SIZE+ (default 1000) are optional.
+
+Callbacks can't see +update_all+, +delete_all+, +insert_all+ or SQL imports, so counts drift after
+them. Run the recount periodically, or after an import, to repair that. It calls +update_<name>+
+directly, so it also works inside <tt>CustomCounterCache.skip { }</tt>.
+
+In a migration that also adds the column, call <tt>User.reset_column_information</tt> first so the
+backfill writes to the new column.
+
+== Configuration
+
+Set these in an initializer (<tt>config/initializers/custom_counter_cache.rb</tt>):
+
+* <tt>CustomCounterCache.counter_class_name</tt>: the model behind the counters table. Default
+  <tt>'Counter'</tt>. Must be set before your models load.
+* <tt>CustomCounterCache.cache_store</tt>: the store for <tt>store: :cache</tt> counters. Defaults
+  to Rails.cache.
+
+  CustomCounterCache.counter_class_name = 'CounterCache'
+  CustomCounterCache.cache_store = ActiveSupport::Cache::MemoryStore.new

data/lib/custom_counter_cache/dispatcher.rb

@@ -0,0 +1,101 @@
+require 'active_support/isolated_execution_state'
+
+module CustomCounterCache
+  # Recounts each owner and counter once after the outermost batch ends (after commit, if inside a transaction).
+  def self.batch(&block)
+    Dispatcher.batch(&block)
+  end
+
+  # Drops recounts inside the block, e.g. for an import followed by recount_counter_caches.
+  def self.skip(&block)
+    Dispatcher.skip(&block)
+  end
+
+  # Single path from update_counter_cache's callbacks to an owner's recount.
+  module Dispatcher
+    # Always after commit: inside the saving transaction a recount can't see a concurrent save's
+    # uncommitted child, and the later of the two overwrites the count with a stale one.
+    def self.recount(owner, name, timing = :after_commit)
+      return if state[:skip]
+      # A cached counter is invalidated after commit, never recounted in place.
+      timing = :invalidate if owner.class.custom_counter_cache_storage(name) == :cache
+      # Keep the first instance seen, so loaded counters on it stay current.
+      return state[:batch][[owner.class, owner.id, name]] ||= [owner, timing] if state[:batch]
+      defer(owner, name, timing)
+    end
+
+    # Serializes recounts of one owner on its row, so each counts after any concurrent commit.
+    # Locks by query rather than with_lock, which would reload the owner and drop its unsaved changes.
+    def self.locked_recount(owner, name)
+      klass = owner.class
+      klass.transaction do
+        # Owner deleted meanwhile: nothing left to recount.
+        next unless klass.where(CustomCounterCache.key_conditions(klass.primary_key, owner.id)).lock.pick(*Array(klass.primary_key).first(1))
+        owner.public_send("update_#{name}")
+      end
+    end
+
+    def self.batch
+      outermost = state[:batch].nil?
+      state[:batch] ||= {}
+      yield
+    ensure
+      # A recount reflects whatever is in the database, so flushing after an exception is still correct.
+      if outermost
+        pending = state.delete(:batch)
+        pending.each { |(_, _, name), (owner, timing)| recount(owner, name, timing) }
+      end
+    end
+
+    def self.skip
+      skipping = state[:skip]
+      state[:skip] = true
+      yield
+    ensure
+      state[:skip] = skipping
+    end
+
+    # Once per owner and counter per transaction. A recount reads committed state, so running it late is still correct.
+    def self.defer(owner, name, timing)
+      key = [owner.class, owner.id, name, timing]
+      deferred = state[:deferred] ||= {}
+      return if deferred.key?(key)
+
+      transaction = owner.class.current_transaction
+      deferred[key] = true if transaction.open?
+      # A rolled-back savepoint drops its after_commit, so forget the key and let a later save schedule it again.
+      transaction.after_rollback { deferred.delete(key) }
+      transaction.after_commit do
+        deferred.delete(key)
+        perform(owner, name, timing)
+      rescue StandardError => error
+        failed(error, owner, name)
+      end
+    end
+
+    # The save has committed and the count can be rebuilt, so don't make the save look failed or
+    # stop the other recounts queued for this commit. unexpected still raises in development and test.
+    def self.failed(error, owner, name)
+      context = { owner: owner.class.name, owner_id: owner.id, counter: name.to_s }
+      owner.class.logger&.error("custom_counter_cache: recount of #{context[:owner]} #{context[:owner_id].inspect} " \
+                                "#{context[:counter]} failed: #{error.class}: #{error.message}")
+      ActiveSupport.error_reporter.unexpected(error, context: context, source: 'custom_counter_cache')
+    end
+
+    def self.perform(owner, name, timing)
+      case timing
+      when :later then RecountJob.perform_later(owner.class.name, owner.id, name.to_s)
+      when :invalidate
+        CustomCounterCache.cache_store.delete(CustomCounterCache.cache_key(owner, name))
+        touch_column = owner.class.custom_counter_cache_touch_column(name)
+        # A cascade destroy invalidates after the owner is gone; there's nothing left to touch.
+        owner.update_column(touch_column, Time.current) if touch_column && !owner.destroyed?
+      else locked_recount(owner, name)
+      end
+    end
+
+    def self.state
+      ActiveSupport::IsolatedExecutionState[:custom_counter_cache] ||= {}
+    end
+  end
+end