[SHD-1959] Reactive audience recalculation (#535)

[SHD-1359](https://runway.powerhrg.com/backlog_items/SHD-1359)

This pull request introduces significant changes to the audiences
context and criteria/group association logic, refactoring how group
criteria are handled, stored, and queried. Here’s a summary of the main
changes:

- Moves from storing group info as JSON directly on criteria to a proper
join table (audiences_criterion_groups).
- Refactors queries, associations, and serialization to use ActiveRecord
associations.
- Updates controller, model, and test code accordingly.
- Adds new database migrations for the join table and column rename.
- Cleans up and improves group membership notification logic.

Author: xjunior

audiences/app/controllers/audiences/contexts_controller.rb

@@ -3,11 +3,11 @@
 module Audiences
   class ContextsController < ApplicationController
     def show
-      render_context Audiences::Context.load(params.require(:key))
+      render json: Audiences::Context.load(params.require(:key))
     end
 
     def update
-      render_context Audiences.update(params.require(:key), **context_params)
+      render json: Audiences.update(params.require(:key), **context_params)
     end
 
     def users
@@ -32,18 +32,6 @@ def current_criterion
       @current_criterion ||= current_context.criteria.find(params[:criterion_id])
     end
 
-    def render_context(context)
-      json_setting = {
-        only: %i[match_all],
-        methods: %i[count],
-        include: {
-          criteria: { only: %i[id groups], methods: %i[count] },
-        },
-      }
-
-      render json: { extra_users: context.extra_users, **context.as_json(json_setting) }
-    end
-
     def context_params
       params.permit(
         :match_all,

audiences/app/jobs/audiences/application_job.rb

@@ -13,6 +13,15 @@ class Context < ApplicationRecord
                         autosave: true,
                         dependent: :destroy
 
+    has_many :context_extra_users, class_name: "Audiences::ContextExtraUser"
+    has_many :extra_users, class_name: "Audiences::ExternalUser",
+                           through: :context_extra_users,
+                           source: :external_user
+
+    scope :relevant_to, ->(group) do
+      joins(:criteria).merge(Criterion.relevant_to(group))
+    end
+
     before_save if: :match_all do
       self.criteria = []
       self.extra_users = []
@@ -26,17 +35,31 @@ def users
 
     delegate :count, to: :users
 
+    def as_json(...)
+      {
+        match_all: match_all,
+        count: count,
+        extra_users: extra_users,
+        criteria: criteria,
+      }.as_json(...)
+    end
+
   private
 
     def notify_subscriptions
       Notifications.publish(self)
     end
 
     def matching_external_users
-      return ExternalUser.all if match_all
+      match_all ? ExternalUser.all : matching_extra_users.or(matching_criteria)
+    end
+
+    def matching_extra_users
+      ExternalUser.where(id: extra_users.select(:id))
+    end
 
-      criteria_scope = criteria.any? ? ExternalUser.matching_any(*criteria) : ExternalUser.none
-      ExternalUser.from_scim(*extra_users).or(criteria_scope)
+    def matching_criteria
+      criteria.any? ? ExternalUser.matching_any(*criteria) : ExternalUser.none
     end
   end
 end

audiences/app/models/audiences/context.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Audiences
+  class ContextExtraUser < ApplicationRecord
+    belongs_to :context
+    belongs_to :external_user
+  end
+end

audiences/app/models/audiences/context_extra_user.rb

@@ -5,15 +5,45 @@ class Criterion < ApplicationRecord
     belongs_to :context, class_name: "Audiences::Context"
     validates :groups, presence: true
 
+    has_many :criterion_groups, autosave: true, dependent: :destroy
+    has_many :groups, through: :criterion_groups
+
+    scope :relevant_to, ->(group) do
+      joins(:criterion_groups).where(criterion_groups: { group: group })
+    end
+
+    # Maps an array of attribute hashes to Criterion objects.
+    #
+    # Each attribute hash should have a :groups key, whose value is a hash
+    # mapping resource types (e.g., "Departments", "Territories") to arrays of group hashes,
+    # each containing an :id key (the SCIM group ID).
+    #
+    # Example input:
+    #
+    #   [
+    #     { groups: { Departments: [{ id: "1" }] } },
+    #     { groups: { Territories: [{ id: "2" }], Departments: [{ id: "3" }] } },
+    #   ]
+    #
+    # Returns an array of new Criterion objects, each initialized with the corresponding group criterion.
+    #
+    # @param [Array<Hash>] criteria Array of attribute hashes describing groups
+    # @return [Array<Criterion>] Array of Criterion objects
     def self.map(criteria)
       Array(criteria).map do |attrs|
-        attrs["groups"] = attrs["groups"]&.to_h do |resource_type, groups|
-          [resource_type, Audiences::Group.from_scim(resource_type, *groups).as_json]
+        groups = attrs["groups"]&.flat_map do |resource_type, scim_groups|
+          Audiences::Group.from_scim(resource_type, *scim_groups).to_a
         end
-        new(attrs)
+        new(groups: groups)
       end
     end
 
+    def as_json(...)
+      groups = self.groups.group_by(&:resource_type)
+
+      { id: id, count: count, groups: groups }.as_json(...)
+    end
+
     def users
       Audiences::ExternalUser.matching(self)
                              .instance_exec(&Audiences.default_users_scope)

audiences/app/models/audiences/criterion.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Audiences
+  class CriterionGroup < ApplicationRecord
+    belongs_to :group
+    belongs_to :criterion
+  end
+end

audiences/app/models/audiences/criterion_group.rb

@@ -3,7 +3,10 @@
 module Audiences
   class ExternalUser < ApplicationRecord
     has_many :group_memberships, dependent: :destroy
-    has_many :groups, through: :group_memberships
+    has_many :groups, through: :group_memberships, dependent: :destroy
+
+    has_many :context_extra_users, class_name: "Audiences::ContextExtraUser", dependent: :destroy
+    has_many :contexts, through: :context_extra_users, source: :context
 
     if Audiences.config.identity_class
       belongs_to :identity, class_name: Audiences.config.identity_class, # rubocop:disable Rails/ReflectionClassName
@@ -13,6 +16,15 @@ class ExternalUser < ApplicationRecord
                             inverse_of: false
     end
 
+    after_commit if: :active_previously_changed?, on: %i[create update destroy] do
+      group_contexts = groups.flat_map do |group|
+        Audiences::Context.relevant_to(group).to_a
+      end
+      match_all_contexts = Audiences::Context.where(match_all: true)
+
+      Audiences::Notifications.publish(*[*contexts, *group_contexts, *match_all_contexts].uniq)
+    end
+
     scope :search, ->(display_name) do
       where(arel_table[:display_name].matches("%#{display_name}%"))
     end
@@ -23,12 +35,13 @@ class ExternalUser < ApplicationRecord
     end
 
     scope :matching, ->(criterion) do
-      groups = (criterion.try(:groups) || criterion).values.reject(&:empty?)
-      return none if groups.empty?
+      return none if criterion.groups.empty?
 
-      groups.reduce(self) do |scope, group|
-        group_ids = Audiences::Group.where(scim_id: group.pluck("id")).pluck(:id)
-        scope.where(id: Audiences::GroupMembership.where(group_id: group_ids).select(:external_user_id))
+      criterion.groups
+               .group_by(&:resource_type)
+               .values
+               .reduce(self) do |scope, groups|
+        scope.where(id: Audiences::GroupMembership.where(group_id: groups.pluck(:id)).select(:external_user_id))
       end
     end
 

audiences/app/models/audiences/external_user.rb

@@ -3,7 +3,7 @@
 module Audiences
   class Group < ApplicationRecord
     has_many :group_memberships, dependent: :destroy
-    has_many :external_users, through: :group_memberships
+    has_many :external_users, through: :group_memberships, dependent: :destroy
 
     validates :display_name, presence: true
     validates :external_id, presence: true

audiences/app/models/audiences/group.rb

@@ -4,5 +4,11 @@ module Audiences
   class GroupMembership < ApplicationRecord
     belongs_to :external_user
     belongs_to :group
+
+    after_commit on: %i[create destroy] do
+      relevant_groups = Audiences::Context.relevant_to(group)
+
+      Audiences::Notifications.publish(*relevant_groups.to_a)
+    end
   end
 end

audiences/app/models/audiences/group_membership.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class CreateAudiencesCriterionGroups < ActiveRecord::Migration[6.1]
+  def change
+    create_table :audiences_criterion_groups do |t|
+      t.references :criterion, foreign_key: false
+      t.references :group, foreign_key: false
+
+      t.timestamps
+    end
+  end
+end