has_helpers 5.0.2

data/app/workers/good_job/cron_denormalization_stats_manager.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class CronDenormalizationStatsManager < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 5.minutes
+    queue_as :dn
+
+    def perform
+      classes_including_module("::HasHelpers::DNUtils").each do |clazz|
+        dependencies_class_name = "#{clazz.table_name.camelize}Dependencies"
+        dependencies = dependencies_class_name.safe_constantize
+        next unless dependencies
+
+        error_query =
+          if dependencies.respond_to?(:error_check_with_limit)
+            batch_size = dependencies.const_defined?(:ERROR_UPDATE_BATCH_SIZE) ? dependencies::ERROR_UPDATE_BATCH_SIZE : 1000
+            dependencies.error_check_with_limit(batch_size)
+          elsif dependencies.respond_to?(:error_check)
+            dependencies.error_check
+          end
+
+        next unless error_query
+        ::GoodJob::DenormalizationStatsWorker.perform_later(clazz.table_name, error_query)
+      end
+    end
+
+    def classes_including_module(module_name)
+      # Ensure the module is a constant
+      target_module = module_name.constantize
+
+      # Get all classes that include the specified module
+      ObjectSpace.each_object(Class).select do |klass|
+        klass.included_modules.include?(target_module)
+      end
+    end
+  end
+end

data/app/workers/good_job/denormalization_stats_worker.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# You can use to run this -> ::GoodJob::DenormalizationStatsWorker.perform_async([:policies])
+# todo use denormalized files to create the queries and the tables to update
+module GoodJob
+  class DenormalizationStatsWorker < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+    attr_reader :stat, :starting_time
+    STARTED = "STARTED"
+    FINISHED = "FINISHED"
+    LOCKED = "LOCKED"
+    STAT_TYPE = "denormalization"
+    STAT_SUBTYPE = "denormalization_errors"
+
+    self.unique_for = 10.minutes
+    queue_as :dn
+
+    good_job_control_concurrency_with(
+      key: -> { "db-denormalization-stats" },
+      perform_limit: 10
+    )
+
+    def perform(table_name, error_query)
+      result = { count: 0, ids: [] }
+      starting_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      save_to_stats(table_name, STAT_TYPE, STAT_SUBTYPE, { table: table_name, count: result[:count], status: STARTED, errors: nil }, starting_time, starting_time)
+      begin
+        result = process_table(table_name, error_query)
+      rescue => e
+        save_to_stats(table_name, STAT_TYPE, STAT_SUBTYPE, { table: table_name, count: result[:count], status: LOCKED, errors: e&.message }, starting_time, ::Process.clock_gettime(::Process::CLOCK_MONOTONIC))
+        return
+      end
+      save_to_stats(table_name, STAT_TYPE, STAT_SUBTYPE, { table: table_name, count: result[:count], status: FINISHED, errors: nil }, starting_time, ::Process.clock_gettime(::Process::CLOCK_MONOTONIC))
+
+      # In case error counts are greater than zero, fix the related records
+      if result[:count].present? && result[:ids].present? && result[:count] > 0
+        ::GoodJob::ConfigurableBackfill.perform_later([table_name.to_sym], ids_to_update: result[:ids])
+      end
+    end
+
+    def process_table(_table_name, error_query)
+      count_result = ::ActiveRecord::Base.connection.execute(error_query)
+      count = count_result&.values&.size
+      ids = count_result&.values&.flatten
+      { count: count, ids: ids }
+    end
+
+    def save_to_stats(name, _type, subtype, data, _starting_time, _ending_time = 0)
+      stat = ::HasHelpers::Stat.new
+      stat.name = name
+      stat.maintype = "denormalization"
+      stat.subtype = subtype
+      stat.data = data
+      stat.save!
+    end
+  end
+end

data/app/workers/good_job/dn_update_worker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Worker used by the backfills to update denormalized columns
+module GoodJob
+  class DNUpdateWorker < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 5.minutes
+    queue_as :dn
+
+    good_job_control_concurrency_with(
+      key: -> { "dn-update" },
+      perform_limit: 100
+    )
+
+    def perform(table_name, ids, update_statement, disable_triggers = true)
+      disable_trigger_statement = disable_triggers ? "SELECT set_config('psql_hq.skip_triggers.ALL', 'true', true);" : nil
+      inner_id_clause = "'#{ids.join("','")}'"
+      sql = <<~SQL
+        #{disable_trigger_statement}
+        UPDATE #{table_name}
+        SET #{update_statement}
+        WHERE #{table_name}.id IN (
+          #{inner_id_clause}
+        );
+      SQL
+      ActiveRecord::Base.connection.execute(sql)
+    end
+  end
+end

data/app/workers/good_job/dn_worker.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Worker utilized in the after commit to do the denormalization of columns
+module GoodJob
+  class DNWorker < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+    DN_REFRESH_ERROR = "dn_refresh_error"
+    DN_SIDEKIQ_CONCURRENCY_ERROR = "dn_refresh_concurrent_error"
+
+    queue_as :dn
+    self.unique_for = 10.minutes
+
+    good_job_control_concurrency_with(
+      key: -> { "dn-refresh" },
+      perform_limit: 5
+    )
+
+    def perform(main_table, dependent_tables_and_columns, class_name, record_id, changes, change_log_id)
+      raw_table_name = main_table
+      begin
+        ::HasHelpers::DN::Refresh.refresh(
+          table_name: raw_table_name,
+          table_and_columns: dependent_tables_and_columns,
+          class_name: class_name,
+          record_id: record_id,
+          changes: changes,
+          change_log_id: change_log_id
+        )
+      rescue => e
+        save_to_stats(raw_table_name, DN_REFRESH_ERROR, e)
+      end
+    end
+
+    def save_to_stats(table_name, subtype, error)
+      stat = ::HasHelpers::Stat.new
+      stat.name = table_name
+      stat.maintype = "denormalization"
+      stat.subtype = subtype
+      stat.data = {
+        table: table_name,
+        error_type: error&.class&.name,
+        errors: error&.message
+      }
+      stat.save!
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_old_index_cleaner_worker.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchOldIndexCleanerWorker < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 1.hour
+    queue_as :elasticsearch
+
+    def perform
+      # Record the starting time of the process
+      starting_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+      # Iterate over each index class and attempt to clean old indices
+      ::HasHelpers::Index.indices&.each do |index_class|
+        clean_old_indices(index_class, starting_time)
+      rescue StandardError => e
+        handle_error(index_class.name, starting_time, e)
+      end
+    end
+
+    private
+
+    def clean_old_indices(index_class, starting_time)
+      # Initialize the options hash with the class name and starting time
+      options = { index_class_name: index_class.name, start_time: starting_time }
+
+      # Select indices to delete based on indices that do not have aliases, meaning, old indices
+      indices_to_delete = index_class.old_indices
+
+      # Preserve recent indices by removing them from the indices_to_delete list
+      preserve_recent_indices!(indices_to_delete, index_class)
+
+      # Delete the selected indices
+      delete_indices(index_class, indices_to_delete, starting_time)
+
+      # Obtain the old indices remaining
+      remaining_indices = index_class.old_indices
+
+      # Check the status based on the count of remaining indices compared to indices to delete
+      if indices_to_delete.length == remaining_indices.length
+        options[:status] = "NOT_SUCCESS" # All indices intended for deletion are still present
+        options[:count] = "0"
+      elsif remaining_indices.empty?
+        options[:status] = "COMPLETE_SUCCESS" # No indices remain
+        options[:count] = indices_to_delete.length
+      else
+        options[:status] = "PARTIAL_SUCCESS" # Some indices remain
+        options[:count] = remaining_indices.length
+      end
+
+      # Save the status and other options to the stats
+      save_to_stats(options)
+    end
+
+    def preserve_recent_indices!(indices_to_delete, index_class)
+      most_recent_indices = most_recent_index_names(index_class.indices)
+      # Get the most recent index names from indices
+      most_recent_indices.each do |most_recent_name|
+        next unless most_recent_name&.match?(/20\d{15}/)
+
+        indices_to_delete.reject! { |non_aliased_index_name, _| non_aliased_index_name == most_recent_name }
+      end
+    end
+
+    def most_recent_index_names(indices)
+      # Separate keyword indices from non-keyword indices
+      keyword_indices = indices.keys.select { |idx_name| idx_name.include?("keyword") }
+      non_keyword_indices = indices.keys - keyword_indices
+
+      # Return the most recent keyword index and the most recent non-keyword index
+      [keyword_indices.sort.last, non_keyword_indices.sort.last].compact
+    end
+
+    def delete_indices(index_class, indices_to_delete, starting_time)
+      indices_to_delete.each do |name, _|
+        index_class.delete(name)
+      rescue StandardError => e
+        error = "Failed to delete index #{name}: #{e.message}"
+        handle_error(index_class, starting_time, error)
+      end
+    end
+
+    def handle_error(index_class_name, starting_time, error)
+      options = { index_class_name: index_class_name, start_time: starting_time, status: "ERROR", count: nil }
+      # Save the error details to stats
+      save_to_stats(options, error)
+    end
+
+    def save_to_stats(options, error = nil)
+      index_class_name = options[:index_class_name]
+      main_type = "Elasticsearch"
+      sub_type = "old_index_cleaner"
+      data = {
+        index_resource: index_class_name.constantize.model.table_name,
+        old_indexes_deleted: options[:count],
+        status: options[:status],
+        error_type: error&.class&.name,
+        errors: error&.message
+      }
+
+      ::HasHelpers::Stat.save_to_stats(
+        ::HasHelpers::Stat.new,
+        index_class_name,
+        main_type,
+        sub_type,
+        data,
+        options[:start_time],
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      ) if ::HasHelpers::Feature.active?(:elasticsearch_reindex_stat)
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_on_finish_reindex.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchOnFinishReindex < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 1.hour
+    queue_as :elasticsearch
+
+    def perform(index_class_name, index_name, start_time)
+      index_class = index_class_name.constantize
+      is_keyword_index = index_name.include?("keyword")
+      index_class.promote(index_name)
+
+      queue = is_keyword_index ? index_class.keyword_reindex_queue : index_class.reindex_queue
+
+      # Index all records updated during the reindex
+      index_class.active_record.where("updated_at + INTERVAL '1 second' >= ?", start_time).find_each do |record|
+        queue.push(record.id.to_s)
+      end
+
+      GoodJob::ElasticsearchProcessQueue.perform_later(index_class.name, index_name)
+      index_class.update_settings(index_name, index: { refresh_interval: "1s" })
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_process_batch.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchProcessBatch < HasUtils::GoodJob::BaseWorker
+    queue_as :elasticsearch
+
+    def perform(index_class_name, index_name, record_ids, routing_map = {})
+      index_klass = index_class_name.constantize
+      is_keyword_index = index_name.include?("keyword")
+
+      records = ActiveRecord::Base.connection.select_all <<~SQL
+        SELECT * FROM #{index_klass.view_name} WHERE id IN (#{record_ids.map { |id| "'#{id}'" }.join(",")})
+      SQL
+
+      # Converts PG arrays to Ruby arrays
+      records.each do |record|
+        record.each do |k, v|
+          if records.column_types[k].is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array)
+            record[k] = records.column_types[k].deserialize(v)
+          end
+        end
+      end.map(&:symbolize_keys!)
+
+      record_type = index_klass.type
+
+      indexes = records.map do |record|
+        attributes = ::HasHelpers::Index.default_attributes.merge(record.except(index_klass.active_record.primary_key))
+
+        if is_keyword_index
+          data = attributes
+          data.each do |field, field_value|
+            data[field] = field_value&.to_s if field_value.is_a?(::Integer) || field_value.is_a?(::Float) # Storing text instead of numbers allows for easier wildcard searching
+          end
+        else
+          # Exclude fields that are large, display-only, and non-searchable to prevent bloat in full-text aggregation.
+          # `:result_type` is marked `enabled: false` in the mapping and thus excluded from indexing.
+          excluded_fields = [:result_type]
+          all_fields = index_klass.all_values_from_attributes(attributes.except(*excluded_fields))
+          data = attributes.merge(all_fields: all_fields)
+        end
+        routing = index_klass.is_global? ? 0 : record[:organization_id]
+
+        {
+          index: {
+            routing: routing,
+            _index: index_name,
+            _id: record[index_klass.active_record.primary_key.to_sym],
+            _type: record_type,
+            data: data
+          }
+        }
+      end
+
+      found_ids = records.map { |r| r[index_klass.active_record.primary_key.to_sym].to_s }
+      delete_ids = record_ids.map(&:to_s) - found_ids
+      deletes = delete_ids.filter_map do |record_id|
+        routing = index_klass.is_global? ? 0 : routing_map[record_id]
+        next if routing.blank?
+
+        {
+          delete: {
+            routing: routing,
+            _index: index_name,
+            _id: record_id,
+            _type: record_type
+          }
+        }
+      end
+
+      if (index_klass.index_name != index_name && index_klass.keyword_search_index_name != index_name) ||
+         ::Searchkick.client.indices.exists_alias?(name: index_name)
+        ::Searchkick.indexer.queue([*indexes, *deletes])
+      else
+        retry_job(wait: 1.minute)
+      end
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_process_change_logs_master_worker.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchProcessChangeLogsMasterWorker < HasUtils::GoodJob::BaseWorker
+    queue_as :elasticsearch
+
+    def perform
+      unique_classes.each do |klass|
+        GoodJob::ElasticsearchProcessChangeLogsWorker.perform_later(klass.name)
+      rescue StandardError => e
+        Rails.logger.error("Failed to enqueue Elasticsearch change-log processor for #{klass}: #{e.message}")
+      end
+    end
+
+    def self.dependencies
+      ::HasHelpers::Index.indices.to_a.flat_map(&:depends_on).flat_map do |dependency|
+        dependency.respond_to?(:keys) ? dependency.keys : []
+      end.compact.uniq.filter_map { |klass_name| klass_name.to_s.safe_constantize }
+    end
+
+    private
+
+    def unique_classes
+      (::HasHelpers::Index.indices.to_a.map(&:model) + self.class.dependencies).compact.uniq
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_process_change_logs_worker.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchProcessChangeLogsWorker < HasUtils::GoodJob::BaseWorker
+    queue_as :elasticsearch
+
+    MAX_PROCESSING_TIME = 30.seconds
+    BATCH_SIZE = 100
+
+    def perform(klass_name)
+      return if klass_name.blank?
+      return unless defined?(::ChangeLog)
+
+      klass = klass_name.constantize
+      start_time = Time.current
+      index_klass = constantize_index_class(klass)
+
+      build_query(klass).find_each(batch_size: BATCH_SIZE) do |change_log|
+        break if exceeded_max_processing_time?(start_time)
+
+        define_inheritance_search(klass) if index_klass
+        instance = klass.find_by(id: change_log.record_id)
+        next unless instance
+
+        process_dependencies_for(instance, change_log, klass) if has_dependencies?(change_log)
+        reindex_record(index_klass, instance, change_log.id) if index_klass
+      end
+    end
+
+    private
+
+    def constantize_index_class(klass)
+      index_class_name = "#{klass.name.demodulize}Index"
+      index_class_name.constantize if Object.const_defined?(index_class_name)
+    end
+
+    def build_query(klass)
+      ::ChangeLog.
+        where(indexed_at: nil, table_name: klass.table_name).
+        where.not(type: "delete").
+        order(:created_at, :record_id)
+    end
+
+    def exceeded_max_processing_time?(start_time)
+      Time.current - start_time >= MAX_PROCESSING_TIME
+    end
+
+    def process_dependencies_for(instance, change_log, model_class)
+      audit = fetch_audit(change_log)
+      return if audit.nil?
+
+      ::HasHelpers::Index.indices.each do |index|
+        dependencies = index.depends_on
+        next if dependencies.blank?
+
+        dependencies.each do |dependency|
+          process_single_dependency(instance, model_class, index, dependency, audit)
+        end
+      end
+    end
+
+    def keys_valid?(keys)
+      keys && keys[:from] && keys[:to]
+    end
+
+    def build_audit_changes(audit)
+      return {} if audit.nil?
+
+      if audit.changed_fields.nil?
+        return audit.row_data.each_with_object({}) do |(key, new_value), changes|
+          changes[key] = [nil, new_value]
+        end
+      end
+
+      audit.changed_fields.each_with_object({}) do |(key, new_value), changes|
+        old_value = audit.row_data[key]
+        changes[key] = [old_value, new_value]
+      end
+    end
+
+    def reindex_record(index_klass, instance, change_log_id)
+      routing_key = index_klass.is_global? ? 0 : instance.try(:organization_id)
+      record_id = instance.id.to_s
+
+      index_klass.reindex_queue.push(record_id, change_log_id, routing_key: routing_key)
+      index_klass.keyword_reindex_queue.push(record_id, change_log_id, routing_key: routing_key)
+
+      ::GoodJob::ElasticsearchProcessQueue.perform_later(index_klass.name, index_klass.index_name)
+      ::GoodJob::ElasticsearchProcessQueue.perform_later(index_klass.name, index_klass.keyword_search_index_name)
+    end
+
+    def define_inheritance_search(model_class)
+      return if model_class.method_defined?(:inheritance_search)
+
+      model_class.define_inheritance_search(model_class)
+    end
+
+    def fetch_audit(change_log)
+      return unless defined?(::Audit)
+
+      audit = ::Audit.find_by(change_log_id: change_log.id)
+      log_missing_audit_info(change_log.id) if audit.blank?
+      audit
+    end
+
+    def log_missing_audit_info(change_log_id)
+      Rails.logger.warn("Audit not found for change_log_id: #{change_log_id}")
+    end
+
+    def process_single_dependency(instance, model_class, index, dependency, audit)
+      _klass_name, keys = dependency.first
+      return unless keys_valid?(keys)
+
+      model_class.process_dependencies(
+        instance,
+        keys[:from],
+        keys[:to],
+        index.model,
+        keys[:dependent_attributes],
+        keys[:dependency_inheritance],
+        build_audit_changes(audit)
+      )
+
+      ::ChangeLog.find(audit.change_log_id).update(indexed_at: Time.current)
+    end
+
+    def dependent_attributes
+      ::HasHelpers::Index.indices.to_a.flat_map(&:depends_on).flat_map do |dependency|
+        next [] unless dependency.respond_to?(:map)
+
+        dependency.map do |key, value|
+          { key: key, dependent_attributes: value[:dependent_attributes] }
+        end
+      end
+    end
+
+    def has_dependencies?(change_log)
+      dependent_attributes.any? do |dependency|
+        key_string = dependency[:key].to_s
+        table_match = key_string.demodulize.tableize == change_log.table_name
+        attrs = dependency[:dependent_attributes]
+
+        if table_match && change_log.type == "insert"
+          true
+        elsif table_match && attrs.blank?
+          true
+        else
+          table_match && attrs.any? do |attr|
+            Array(change_log.changed_columns).include?(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_process_queue.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchProcessQueue < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 10.minutes
+    self.unique_until_start = true
+    queue_as :elasticsearch
+
+    def perform(index_class_name, index_name)
+      starting_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      index_klass = index_class_name.constantize
+      limit = 100
+      is_keyword_search = index_name.include?("keyword")
+      reindex_queue = is_keyword_search ? index_klass.keyword_reindex_queue : index_klass.reindex_queue
+      records = reindex_queue.reserve(limit: limit)
+
+      if records.any?
+        record_ids = records.map { |record| record[:record_id] }
+        key = records.map { |record| record[:key] }.uniq
+        routing_map = records.each_with_object({}) { |record, h| h[record[:record_id]] = record[:routing_key] }
+
+        batch = new_batch(on_success: true)
+        batch.properties[:index_class_name] = index_class_name
+        batch.properties[:record_ids_count] = record_ids.size
+        batch.properties[:key] = key
+        batch.properties[:starting_time] = starting_time
+
+        batch.add do
+          GoodJob::ElasticsearchProcessBatch.perform_later(index_klass.name, index_name, record_ids, routing_map) if ::Searchkick.client.indices.exists_alias?(name: index_name)
+        end
+        batch.enqueue
+
+        if record_ids.size == limit
+          GoodJob::ElasticsearchProcessQueue.perform_later(index_class_name, index_name)
+        end
+      end
+    end
+
+    def self.on_success(batch, _context)
+      index_class_name = batch.properties[:index_class_name]
+      record_ids_count = batch.properties[:record_ids_count]
+      key = batch.properties[:key]
+      starting_time = batch.properties[:starting_time]
+      ::Stat.save_to_stats(Stat.new, "::GoodJob::ElasticsearchProcessQueue", "elasticsearch", index_class_name, { record_ids_count: record_ids_count }, starting_time, ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)) if ::HasHelpers::Feature.active?(:elasticsearch_reindex_stat)
+      ::HasHelpers::Index.after_index(key)
+    end
+  end
+end

data/app/workers/good_job/elasticsearch_reindex.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ElasticsearchReindex < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+
+    self.unique_for = 6.hours
+    queue_as :elasticsearch_reindex
+
+    def perform(index_class_name, index_name)
+      batch_size = (Rails.application.config.x.full_reindex_batch_size&.to_i).presence || 100
+      index_class = index_class_name.constantize
+      start_time = Time.current
+
+      ActiveRecord::Base.transaction do
+        Cursor.execute(name: index_name, sql: index_class.active_record.select(:id).to_sql) do |cursor|
+          while (records = cursor.next(10_000)) do
+            record_ids = records.map { |record| record["id"] }
+            args = record_ids.each_slice(batch_size).map do |ids|
+              [index_class_name, index_name, ids]
+            end
+
+            GoodJob::ElasticsearchProcessBatch.perform_deferred_bulk(args)
+          end
+        end
+      end
+
+      GoodJob::ElasticsearchOnFinishReindex.perform_deferred(index_class_name, index_name, start_time)
+    end
+  end
+end

data/app/workers/has_helpers/cards/orphan_card_sweeper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+
+module HasHelpers
+  module Cards
+    class OrphanCardSweeper < HasUtils::GoodJob::BaseWorker
+      queue_as :default
+
+      def perform
+        return unless HasHelpers::Cards.config.mode == :client
+
+        valid_ids = HasHelpers::Cards::Roles.all(force: true).map(&:id).map(&:to_s).to_set
+        if valid_ids.empty?
+          Rails.logger.warn("HasHelpers::Cards::OrphanCardSweeper: upstream returned no roles; skipping sweep to avoid disabling everything")
+          return
+        end
+
+        scope = HasHelpers::Cards::RoleResourceCard.where(disabled_at: nil).where.not(role_id: valid_ids.to_a)
+
+        scope.find_each(batch_size: 1000) do |card|
+          # rubocop:disable Rails/SkipsModelValidations
+          card.update_columns(disabled_at: Time.current)
+          # rubocop:enable Rails/SkipsModelValidations
+        end
+      end
+    end
+  end
+end