worker_plugins 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a8d25556ad9d41f62307376bf457a790ab3e67e934678cac0ad9b754112e8e
-  data.tar.gz: 2163df96c0f85a9102f1694fbeda59f06f70c296924e0a9dd9320a0b239e0f15
+  metadata.gz: 343e7440c6234a58f501c96d553f019c653c7eb32c8dc07847d4f02d9ee8020b
+  data.tar.gz: 5100e6c819ee4f818082e87ef515e7362523b7e1c5b0c25ca386741e07e9d8ec
 SHA512:
-  metadata.gz: ef92d06893d7b9a1e56ade70c4b78432c0cd3b04544db92c5827865883d97b9912fc392930e53d26324c6bb6dbec23481e101fb4ba0218c51a2e52ef1634c497
-  data.tar.gz: 24c4313891e0864b95695af807eca5586739c997039cc3bb54b82050964af2dbd92806c90b3e7077d8acdd93f5b636dd306e6300331961b41ef71d424f8a099a
+  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/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

@@ -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.16".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worker_plugins
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Kasper Stöckel
@@ -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