worker_plugins 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13eab7a67becfdbd1809b1930d1314a86c6c0cb217d39ae19181e1dec7453976
-  data.tar.gz: 65b838cc21313b78f92d43b85a95adba991f50360d05be8ec11a2050b4b75133
+  metadata.gz: 343e7440c6234a58f501c96d553f019c653c7eb32c8dc07847d4f02d9ee8020b
+  data.tar.gz: 5100e6c819ee4f818082e87ef515e7362523b7e1c5b0c25ca386741e07e9d8ec
 SHA512:
-  metadata.gz: 46ebc5d54657090702d0280e72c5f0d863effcbe7ea478892f492b81bfba829a478220fddbde9f2c9df9e7dc7efc07fa3ec5518aa6b455de81be41c7297e72d9
-  data.tar.gz: 4b76bdfa275a1641d782ef84bc96e5e6658d866fb4aef3831f82986dabea510a4e61becb19179bf6a80535181b2492bd939346da8e53c7c110fd36940f181cf7
+  metadata.gz: a658e1f90e8f9c33503e526b98a59ef578e9a366dc388d79abbf8efec602c60fe5c920afa4e0772a113de5e47f4d71eba4bd7346dfc38dcbefd31ac7808deca1
+  data.tar.gz: c73827b981b2d50abc9f5bd3c388645fa382f0d052188f3ff85f5f3e0e8ac1d47e62ba01a2fa73a2d1e6d4c78475870f36cbb520723154491bffe44245536db6

data/README.md

@@ -27,6 +27,46 @@ 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.
+
 ## Release
 
 Run the release task from a clean worktree:

data/app/services/worker_plugins/add_query.rb

@@ -8,17 +8,11 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
   end
 
   def perform
-    created # Cache which are about to be created
-    add_query_to_workplace
-    succeed!(created:)
+    succeed!(affected_count: add_query_to_workplace)
   end
 
   def add_query_to_workplace
-    WorkerPlugins::WorkplaceLink.connection.execute(sql)
-  end
-
-  def created
-    @created ||= resources_to_add.pluck(primary_key.to_sym)
+    WorkerPlugins::WorkplaceLink.connection.exec_update(sql, "WorkerPlugins::AddQuery INSERT", [])
   end
 
   def ids_added_already_query
@@ -40,19 +34,25 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
   end
 
   def primary_key
-    @primary_key ||= resources_to_add.klass.primary_key
+    @primary_key ||= model_class.primary_key
   end
 
   def resources_to_add
-    # Correlate per row with NOT EXISTS instead of NOT IN + a materialized
-    # subquery. The old form expanded into a nested `resource_id IN (SELECT
-    # CAST(users.id AS CHAR) FROM users)` that did a full scan of the target
-    # table when the outer query was unfiltered — 60s+ on 340k+ users. This
-    # uses the `(workplace_id, resource_type, resource_id)` composite index
-    # for an index seek per row.
-    @resources_to_add ||= query
-      .distinct
-      .where("NOT EXISTS (#{existing_workplace_link_exists_sql})")
+    # The unique index on `(workplace_id, resource_type, resource_id)` lets us
+    # skip the `WHERE NOT EXISTS` anti-join for the common unbounded query —
+    # duplicates are rejected on INSERT by the dialect-specific conflict
+    # clause in #sql. `.distinct` still handles same-row duplicates produced
+    # by joins in the caller's query (e.g. `User.joins(:tasks)`).
+    #
+    # When the caller scopes with `.limit` / `.offset`, we keep the anti-join
+    # so already-linked rows are filtered *before* the window is applied;
+    # otherwise `Task.limit(100)` could insert fewer than 100 new rows when
+    # some of those 100 are already linked.
+    @resources_to_add ||= if query.limit_value || query.offset_value
+      query.distinct.where("NOT EXISTS (#{existing_workplace_link_exists_sql})")
+    else
+      query.distinct
+    end
   end
 
   def existing_workplace_link_exists_sql
@@ -106,7 +106,7 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
 
   def sql
     @sql ||= "
-      INSERT INTO
+      #{insert_clause} INTO
         worker_plugins_workplace_links
 
       (
@@ -118,6 +118,23 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
       )
 
       #{select_sql}
+      #{conflict_clause}
     "
   end
+
+  def insert_clause
+    if mysql?
+      "INSERT IGNORE"
+    elsif sqlite?
+      "INSERT OR IGNORE"
+    else
+      "INSERT"
+    end
+  end
+
+  def conflict_clause
+    return "" unless postgres?
+
+    "ON CONFLICT (workplace_id, resource_type, resource_id) DO NOTHING"
+  end
 end

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/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
 
     succeed!(
       all_checked: query_count == checked_count,
@@ -17,6 +13,49 @@ class WorkerPlugins::QueryLinksStatus < WorkerPlugins::ApplicationService
     )
   end
 
+  def count_linked_rows
+    base_scope = workplace.workplace_links.where(resource_type: query.klass.name)
+
+    # When the query applies no scoping, the original `resource_id IN (SELECT
+    # DISTINCT <target_table>.id FROM <target_table>)` subquery materialized
+    # every row of the target model just to count — 2+ seconds on a 340k-row
+    # target. We drop the DISTINCT subquery and instead `INNER JOIN` the
+    # target table on its primary key so the composite index on links drives
+    # the scan and each matching link does a cheap PK probe to confirm the
+    # target row still exists. Orphaned links (whose target has since been
+    # deleted) are correctly excluded from the count, so `checked_count`
+    # never exceeds `query_count`.
+    return base_scope.joins(unscoped_target_join_sql).count if relation_unscoped?(query)
+
+    base_scope.where(resource_id: query_with_selected_ids).count
+  end
+
+  def unscoped_target_join_sql
+    target_table = quote_table(query.klass.table_name)
+    target_pk = "#{target_table}.#{quote_column(query.klass.primary_key)}"
+    resource_id_column = "#{quote_table(WorkerPlugins::WorkplaceLink.table_name)}.#{quote_column(:resource_id)}"
+
+    "INNER JOIN #{target_table} ON #{target_pk} = #{resource_id_expression_for_join(resource_id_column)}"
+  end
+
+  # On MySQL / MariaDB and SQLite, implicit conversion handles comparing the
+  # target's primary key against the VARCHAR `resource_id` column. Postgres
+  # is strict about types and needs an explicit cast when they differ.
+  def resource_id_expression_for_join(resource_id_column)
+    return resource_id_column unless postgres?
+
+    target_pk_type = query.klass.column_for_attribute(query.klass.primary_key).type
+    resource_id_type = WorkerPlugins::WorkplaceLink.column_for_attribute(:resource_id).type
+
+    return resource_id_column if target_pk_type == resource_id_type
+
+    case target_pk_type
+    when :uuid then "CAST(#{resource_id_column} AS UUID)"
+    when :integer then "CAST(#{resource_id_column} AS BIGINT)"
+    else resource_id_column
+    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

@@ -1,17 +1,21 @@
 class WorkerPlugins::RemoveQuery < WorkerPlugins::ApplicationService
   arguments :query, :workplace
 
-  attr_reader :destroyed
-
   def perform
-    remove_query_from_workplace
-    succeed!(destroyed:, mode: :destroyed)
+    succeed!(affected_count: links_scope.delete_all)
   end
 
-  def remove_query_from_workplace
-    links_query = workplace.workplace_links.where(resource_type: model_class.name, resource_id: query_with_selected_ids)
-    @destroyed = links_query.pluck(:resource_id)
-    links_query.delete_all
+  def links_scope
+    scope = workplace.workplace_links.where(resource_type: model_class.name)
+    # 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
 
   def model_class

data/app/services/worker_plugins/select_column_with_type_cast.rb

@@ -46,14 +46,24 @@ class WorkerPlugins::SelectColumnWithTypeCast < WorkerPlugins::ApplicationServic
   end
 
   def same_type?
-    column_to_select.type == column_to_compare_with.type || mysql_string_uuid_compatible_types?
+    return true if column_to_select.type == column_to_compare_with.type
+
+    mysql_implicit_conversion_safe?
   end
 
-  def mysql_string_uuid_compatible_types?
+  # On MySQL / MariaDB, implicit conversion handles comparisons between any
+  # string-ish column types (VARCHAR, CHAR, BINARY, UUID, or types AR doesn't
+  # recognize — e.g. MariaDB's native UUID type when using an older mysql2
+  # adapter). The explicit CAST is only needed when one side is numeric,
+  # because MySQL would then force a string → number conversion that loses
+  # rows containing non-numeric values.
+  def mysql_implicit_conversion_safe?
     return false unless mysql?
 
-    types = [column_to_select.type, column_to_compare_with.type]
+    !numeric_type?(column_to_select.type) && !numeric_type?(column_to_compare_with.type)
+  end
 
-    types.include?(:string) && types.include?(:uuid)
+  def numeric_type?(type)
+    %i[integer decimal float bigint].include?(type)
   end
 end

data/app/services/worker_plugins/switch_query.rb

@@ -2,20 +2,30 @@ class WorkerPlugins::SwitchQuery < WorkerPlugins::ApplicationService
   arguments :query, :workplace
 
   def perform
-    add_query_service = WorkerPlugins::AddQuery.new(query:, workplace:)
-    created = add_query_service.created
-
-    if created.empty?
-      result = WorkerPlugins::RemoveQuery.execute!(query:, workplace:)
-      succeed!(
-        destroyed: result.fetch(:destroyed),
-        mode: :destroyed
-      )
+    # Decide mode *before* running the insert. Deciding it from AddQuery's
+    # post-insert `affected_count` would make concurrent "add" toggles
+    # destructive: if request A's INSERT commits first, overlapping
+    # request B would see `affected_count == 0` from its own (no-op)
+    # INSERT and flip to RemoveQuery, wiping out what A just added. A
+    # pre-insert EXISTS probe keeps the race window small in the same
+    # way the previous candidate-pluck approach did, without materializing
+    # any ids into Ruby.
+    if any_unlinked_candidate?
+      add_result = WorkerPlugins::AddQuery.execute!(query:, workplace:)
+      succeed!(affected_count: add_result.fetch(:affected_count), mode: :created)
     else
-      succeed!(
-        created: add_query_service.tap(&:add_query_to_workplace).created,
-        mode: :created
-      )
+      remove_result = WorkerPlugins::RemoveQuery.execute!(query:, workplace:)
+      succeed!(affected_count: remove_result.fetch(:affected_count), mode: :destroyed)
     end
   end
+
+  def any_unlinked_candidate?
+    add_service = WorkerPlugins::AddQuery.new(query:, workplace:)
+
+    add_service
+      .query
+      .distinct
+      .where("NOT EXISTS (#{add_service.existing_workplace_link_exists_sql})")
+      .exists?
+  end
 end

data/lib/worker_plugins/version.rb

@@ -1,3 +1,3 @@
 module WorkerPlugins
-  VERSION = "0.0.14".freeze
+  VERSION = "0.0.16".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_plugins
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - Kasper Stöckel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-04-23 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,7 @@ 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/query_links_status.rb
 - app/services/worker_plugins/remove_query.rb
 - app/services/worker_plugins/select_column_with_type_cast.rb