worker_plugins 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a8d25556ad9d41f62307376bf457a790ab3e67e934678cac0ad9b754112e8e
-  data.tar.gz: 2163df96c0f85a9102f1694fbeda59f06f70c296924e0a9dd9320a0b239e0f15
+  metadata.gz: 0724aebdce87819ebafc787c475284e25e7a6ee31837040e8532b0c400c95db3
+  data.tar.gz: dc8cd4edddcdce80d22c2e3c10990f4fa966f112fe67f01c1bd58443c313079b
 SHA512:
-  metadata.gz: ef92d06893d7b9a1e56ade70c4b78432c0cd3b04544db92c5827865883d97b9912fc392930e53d26324c6bb6dbec23481e101fb4ba0218c51a2e52ef1634c497
-  data.tar.gz: 24c4313891e0864b95695af807eca5586739c997039cc3bb54b82050964af2dbd92806c90b3e7077d8acdd93f5b636dd306e6300331961b41ef71d424f8a099a
+  metadata.gz: f58a6c6a65122966a57b948f78758761825e2eed97bb13fb4277b627ec4db11bade6856b2baf23e1f1056fb7169d545bfeaf6d565bbbddbb027bfb61c9d16f26
+  data.tar.gz: a4fb5385013ab116c856bd5b5986ce04bcccbfb18b342edb41f463d652e664ecdd0b01567e75cf321f0299d64d8adfff5b37c9d2ef2ed75f81da31286975884a

data/README.md

@@ -27,6 +27,59 @@ Optimally loop over resources on a workspace:
 workspace.each_resource(types: ['User']) do |user|
 ```
 
+## Scheduled cleanup of unused workplaces
+
+`WorkerPlugins::DeleteOldWorkplaces` removes workplaces that haven't seen activity in a given window — both the workplace row's `updated_at` is older than the cutoff *and* no link on it has been created or updated since. Deletion runs in batches via raw `delete_all` to skip per-row callbacks.
+
+```ruby
+result = WorkerPlugins::DeleteOldWorkplaces.execute!(older_than: 2.months)
+# => {workplaces_deleted: <N>, links_deleted: <M>}
+```
+
+Options:
+
+- `older_than:` (required) — any object that responds to `.ago` (typically an `ActiveSupport::Duration` like `2.months` or `30.days`). The service computes the cutoff at call time.
+- `batch_size:` (default `1000`) — how many stale workplaces to delete per round-trip.
+
+The gem does not register a scheduler of its own. Wire the service into your application's background queue. Example with `sidekiq-scheduler`:
+
+```ruby
+# config/sidekiq.yml
+:scheduler:
+  :schedule:
+    DeleteOldWorkplaces:
+      cron: "0 40 3 * * *"   # daily at 03:40 local time
+      args: ["WorkerPlugins::DeleteOldWorkplaces", {"older_than": "2.months"}]
+      class: ServiceScheduler  # or whatever your project's service-dispatching worker is called
+      queue: low_priority
+```
+
+If your `ServiceScheduler` only accepts YAML-serializable arguments, wrap the call in a thin application-side service:
+
+```ruby
+class Workplaces::DeleteOld < ApplicationService
+  def perform
+    WorkerPlugins::DeleteOldWorkplaces.execute!(older_than: 2.months)
+    succeed!
+  end
+end
+```
+
+and schedule `Workplaces::DeleteOld` instead.
+
+## Scheduled cleanup of orphan links
+
+`WorkerPlugins::DeleteOrphanLinks` removes `worker_plugins_workplace_links` whose target row no longer exists — i.e. links that point at a resource that was destroyed without the link being cleaned up alongside. Run it periodically from a background job to keep the links table consistent and keep probes like `QueryLinksStatus#checked_count` honest.
+
+```ruby
+result = WorkerPlugins::DeleteOrphanLinks.execute!
+# => {deleted_count: <N>}
+```
+
+Links whose `resource_type` doesn't resolve to a Ruby class (e.g. a model was renamed or removed) are left alone — cleaning those up requires human judgement.
+
+Schedule the same way as `DeleteOldWorkplaces` — typically once a day off-hours.
+
 ## Release
 
 Run the release task from a clean worktree:

data/app/services/worker_plugins/application_service.rb

@@ -36,4 +36,22 @@ class WorkerPlugins::ApplicationService < ServicePattern::Service
 
     adapter_name.include?("mysql") || adapter_name.include?("trilogy")
   end
+
+  # True when a relation applies no row-narrowing scope — so filtering
+  # workplace links with `resource_id IN (SELECT ... FROM <target_table>)` adds
+  # no semantic value and just forces the database to materialize every row
+  # of the target model. Call sites (RemoveQuery, QueryLinksStatus) use this
+  # to drop the subquery and count/delete by `resource_type` alone on large
+  # target models (e.g. 340k+ users).
+  def relation_unscoped?(relation)
+    relation.where_clause.empty? &&
+      relation.joins_values.empty? &&
+      relation.left_outer_joins_values.empty? &&
+      relation.group_values.empty? &&
+      relation.having_clause.empty? &&
+      relation.limit_value.nil? &&
+      relation.offset_value.nil? &&
+      relation.from_clause.value.nil? &&
+      relation.with_values.empty?
+  end
 end

data/app/services/worker_plugins/delete_old_workplaces.rb

@@ -0,0 +1,48 @@
+class WorkerPlugins::DeleteOldWorkplaces < WorkerPlugins::ApplicationService
+  arguments :older_than
+  argument :batch_size, default: 1_000
+
+  # Deletes workplaces that haven't seen any activity since `older_than.ago` —
+  # both the workplace record itself is older than the cutoff *and* none of
+  # its links have been created / updated since. Links on deleted workplaces
+  # are removed with the parent via `dependent: :destroy`, but this service
+  # uses raw `delete_all` in batches to skip per-row callbacks and keep
+  # long-running cleanup jobs cheap.
+  #
+  # Intended to be scheduled by the consumer application from a Sidekiq
+  # worker (or equivalent) — the gem does not register a scheduler of its
+  # own.
+  def perform
+    cutoff = older_than.ago
+    workplaces_deleted = 0
+    links_deleted = 0
+
+    stale_workplaces(cutoff).in_batches(of: batch_size) do |batch|
+      batch_ids = batch.pluck(:id)
+
+      links_deleted += WorkerPlugins::WorkplaceLink
+        .where(workplace_id: batch_ids)
+        .delete_all
+      workplaces_deleted += WorkerPlugins::Workplace
+        .where(id: batch_ids)
+        .delete_all
+    end
+
+    succeed!(workplaces_deleted:, links_deleted:)
+  end
+
+  def stale_workplaces(cutoff)
+    workplaces_table = quote_table(WorkerPlugins::Workplace.table_name)
+    links_table = quote_table(WorkerPlugins::WorkplaceLink.table_name)
+
+    WorkerPlugins::Workplace
+      .where("#{workplaces_table}.#{quote_column(:updated_at)} < ?", cutoff)
+      .where(<<~SQL.squish, cutoff)
+        NOT EXISTS (
+          SELECT 1 FROM #{links_table}
+          WHERE #{links_table}.#{quote_column(:workplace_id)} = #{workplaces_table}.#{quote_column(:id)}
+            AND #{links_table}.#{quote_column(:updated_at)} >= ?
+        )
+      SQL
+  end
+end

data/app/services/worker_plugins/delete_orphan_links.rb

@@ -0,0 +1,39 @@
+class WorkerPlugins::DeleteOrphanLinks < WorkerPlugins::ApplicationService
+  # Deletes `worker_plugins_workplace_links` whose target row no longer
+  # exists — i.e. links pointing at a resource that was destroyed without
+  # the link being cleaned up alongside. Intended to be scheduled by the
+  # consumer application from a background job.
+  #
+  # Links whose `resource_type` doesn't resolve to a Ruby class (e.g. a
+  # model was renamed or removed) are left alone — cleaning those up is
+  # a separate concern that requires human judgement.
+  def perform
+    deleted_count = distinct_resource_types.sum do |resource_type|
+      delete_orphans_for(resource_type)
+    end
+
+    succeed!(deleted_count:)
+  end
+
+  def distinct_resource_types
+    WorkerPlugins::WorkplaceLink.distinct.pluck(:resource_type)
+  end
+
+  def delete_orphans_for(resource_type)
+    model_class = resource_type.safe_constantize
+    return 0 unless model_class
+
+    WorkerPlugins::WorkplaceLink
+      .where(resource_type:)
+      .where.not(resource_id: live_ids_query(model_class))
+      .delete_all
+  end
+
+  def live_ids_query(model_class)
+    WorkerPlugins::SelectColumnWithTypeCast.execute!(
+      column_name_to_select: model_class.primary_key,
+      column_to_compare_with: WorkerPlugins::WorkplaceLink.column_for_attribute(:resource_id),
+      query: model_class.all
+    )
+  end
+end

data/app/services/worker_plugins/query_links_status.rb

@@ -2,12 +2,8 @@ class WorkerPlugins::QueryLinksStatus < WorkerPlugins::ApplicationService
   arguments :query, :workplace
 
   def perform
-    checked_count = workplace
-      .workplace_links
-      .where(resource_type: query.klass.name, resource_id: query_with_selected_ids)
-      .count
-
     query_count = query.count
+    checked_count = count_linked_rows(query_count)
 
     succeed!(
       all_checked: query_count == checked_count,
@@ -17,6 +13,29 @@ class WorkerPlugins::QueryLinksStatus < WorkerPlugins::ApplicationService
     )
   end
 
+  def count_linked_rows(query_count)
+    base_scope = workplace.workplace_links.where(resource_type: query.klass.name)
+
+    # Fast path for unscoped queries: a plain index-only COUNT against the
+    # `(workplace_id, resource_type, resource_id)` composite index resolves in
+    # ~50 ms even for workplaces with hundreds of thousands of links. Joining
+    # back to the target table to exclude orphaned links (whose resource row
+    # has since been destroyed) would take 10+ seconds on the same data
+    # regardless of which shape we pick — the DB still has to cross-reference
+    # every link against the target's primary key. Instead we clamp the raw
+    # count to `query_count`; `WorkerPlugins::DeleteOrphanLinks` (scheduled
+    # daily by consumers) keeps the orphan count at zero so the raw count
+    # equals the live-linked count in practice. When orphans do briefly exist
+    # between cleanup runs, clamping bounds the over-count at the query's
+    # total — `all_checked` / `some_checked` stay correct because they're
+    # computed off the clamped value.
+    if relation_unscoped?(query)
+      [base_scope.count, query_count].min
+    else
+      base_scope.where(resource_id: query_with_selected_ids).count
+    end
+  end
+
   def query_with_selected_ids
     WorkerPlugins::SelectColumnWithTypeCast.execute!(
       column_name_to_select: query.klass.primary_key,

data/app/services/worker_plugins/remove_query.rb

@@ -7,33 +7,17 @@ class WorkerPlugins::RemoveQuery < WorkerPlugins::ApplicationService
 
   def links_scope
     scope = workplace.workplace_links.where(resource_type: model_class.name)
-    return scope if unscoped_query?
+    # When the caller's query applies no scoping, the `resource_id IN (SELECT
+    # ... FROM <target_table>)` subquery would materialize every row of the
+    # target model — the `resource_type = ?` filter alone is enough. Orphaned
+    # links (whose resource row has since been deleted) are deleted alongside
+    # live ones, which matches caller intent ("remove everything matching")
+    # and is the correct thing to do with dead references anyway.
+    return scope if relation_unscoped?(@query)
 
     scope.where(resource_id: query_with_selected_ids)
   end
 
-  # If the caller's query has no meaningful scoping applied, the `resource_id
-  # IN (SELECT ... FROM <target_table>)` subquery would simply materialize
-  # every row of the target model — for 340k+ users that's a full-table scan
-  # with no semantic effect other than preserving orphaned links. The
-  # `resource_type = ?` filter alone is enough to pin the DELETE to this
-  # workplace's links of the given type, so we short-circuit the subquery in
-  # that case. Orphaned links (whose resource row has since been deleted) are
-  # deleted alongside live ones, which matches caller intent ("remove
-  # everything matching the query") and is the correct thing to do with
-  # dead references anyway.
-  def unscoped_query?
-    @query.where_clause.empty? &&
-      @query.joins_values.empty? &&
-      @query.left_outer_joins_values.empty? &&
-      @query.group_values.empty? &&
-      @query.having_clause.empty? &&
-      @query.limit_value.nil? &&
-      @query.offset_value.nil? &&
-      @query.from_clause.value.nil? &&
-      @query.with_values.empty?
-  end
-
   def model_class
     query.klass
   end

data/lib/worker_plugins/version.rb

@@ -1,3 +1,3 @@
 module WorkerPlugins
-  VERSION = "0.0.15".freeze
+  VERSION = "0.0.17".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_plugins
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.17
 platform: ruby
 authors:
 - Kasper Stöckel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-25 00:00:00.000000000 Z
 dependencies: []
 description: Rails framework for easily choosing and creating lists of objects and
   execute plugins against them.
@@ -26,6 +26,8 @@ files:
 - app/models/worker_plugins/workplace_link.rb
 - app/services/worker_plugins/add_query.rb
 - app/services/worker_plugins/application_service.rb
+- app/services/worker_plugins/delete_old_workplaces.rb
+- app/services/worker_plugins/delete_orphan_links.rb
 - app/services/worker_plugins/query_links_status.rb
 - app/services/worker_plugins/remove_query.rb
 - app/services/worker_plugins/select_column_with_type_cast.rb