audiences 1.6.1 → 2.0.0

data/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
@@ -17,7 +17,7 @@ module Audiences
                                limit: params[:limit],
                                offset: params[:offset])
 
-      render json: search, only: Audiences.exposed_user_attributes
+      render json: search
     end
 
   private
@@ -32,22 +32,11 @@ module Audiences
       @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] } },
-      }
-      extra_users = context.extra_users.as_json(only: Audiences.exposed_user_attributes)
-
-      render json: { extra_users: extra_users, **context.as_json(json_setting) }
-    end
-
     def context_params
       params.permit(
         :match_all,
         criteria: [groups: {}],
-        extra_users: %i[externalId]
+        extra_users: %i[id externalId]
       ).to_h.symbolize_keys
     end
   end

data/app/controllers/audiences/scim_proxy_controller.rb

@@ -3,23 +3,21 @@
 module Audiences
   class ScimProxyController < ApplicationController
     def get
-      resources = Audiences::Scim.resource(params[:scim_path].to_sym)
-                                 .query(
-                                   filter: filter_param,
-                                   startIndex: params[:startIndex], count: params[:count],
-                                   attributes: Audiences.exposed_user_attributes.join(",")
-                                 )
+      resources = scope.search(params[:query])
+                       .offset(params[:startIndex])
+                       .limit(params[:count])
 
-      render json: resources, except: %w[schemas meta]
+      render json: resources
     end
 
   private
 
-    def filter_param
-      if params[:query]
-        "displayName co \"#{params[:query]}\""
+    def scope
+      if params[:scim_path].eql?("Users")
+        Audiences::ExternalUser.instance_exec(&Audiences.default_users_scope)
       else
-        params[:filter]
+        Audiences::Group.where(resource_type: params[:scim_path])
+                        .instance_exec(&Audiences.default_groups_scope)
       end
     end
   end

data/app/models/audiences/context.rb

@@ -7,22 +7,59 @@ module Audiences
   #
   class Context < ApplicationRecord
     include Locating
-    include ::Audiences::MembershipGroup
 
     belongs_to :owner, polymorphic: true
     has_many :criteria, class_name: "Audiences::Criterion",
                         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 = []
     end
 
-    def refresh_users!
-      criteria.each(&:refresh_users!)
-      update!(users: ContextUsers.new(self).to_a)
+    after_commit :notify_subscriptions, on: :update
+
+    def users
+      matching_external_users.instance_exec(&Audiences.default_users_scope)
+    end
+
+    delegate :count, to: :users
+
+    def as_json(...)
+      {
+        match_all: match_all,
+        count: count,
+        extra_users: extra_users.instance_exec(&Audiences.default_users_scope),
+        criteria: criteria,
+      }.as_json(...)
+    end
+
+  private
+
+    def notify_subscriptions
       Notifications.publish(self)
     end
+
+    def matching_external_users
+      match_all ? ExternalUser.all : matching_extra_users.or(matching_criteria)
+    end
+
+    def matching_extra_users
+      ExternalUser.where(id: extra_users.select(:id))
+    end
+
+    def matching_criteria
+      criteria.any? ? ExternalUser.matching_any(*criteria) : ExternalUser.none
+    end
   end
 end

data/app/models/audiences/context_extra_user.rb

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

data/app/models/audiences/criterion.rb

@@ -2,19 +2,53 @@
 
 module Audiences
   class Criterion < ApplicationRecord
-    include ::Audiences::MembershipGroup
-
     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 { new(_1) }
+      Array(criteria).map do |attrs|
+        groups = attrs["groups"]&.flat_map do |resource_type, scim_groups|
+          Audiences::Group.from_scim(resource_type, *scim_groups).to_a
+        end
+        new(groups: groups)
+      end
     end
 
-    def refresh_users!
-      update!(
-        users: CriterionUsers.new(groups || {}).to_a,
-        refreshed_at: Time.current
-      )
+    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)
     end
+
+    delegate :count, to: :users
   end
 end

data/app/models/audiences/criterion_group.rb

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

data/app/models/audiences/external_user.rb

@@ -2,6 +2,12 @@
 
 module Audiences
   class ExternalUser < ApplicationRecord
+    has_many :group_memberships, dependent: :destroy
+    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
                             primary_key: Audiences.config.identity_key,
@@ -10,28 +16,100 @@ module Audiences
                             inverse_of: false
     end
 
-    def self.fetch(external_ids, count: 100)
-      return [] unless external_ids.any?
-
-      Array(external_ids).in_groups_of(count, false).flat_map do |ids|
-        filter = Array(ids).map { "externalId eq #{_1}" }.join(" OR ")
-        Audiences::Scim.resource(:Users).all(count: count, filter: filter).to_a
+    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 :active, -> { where(active: true) }
+
+    scope :members_of, ->(groups) do
+      where(id: Audiences::GroupMembership.where(group: groups).select(:external_user_id))
+    end
+
+    scope :search, ->(display_name) do
+      where(arel_table[:display_name].matches("%#{display_name}%"))
     end
 
-    def self.wrap(resources)
-      return [] unless resources&.any?
+    scope :from_scim, ->(*scim_json) do
+      where(scim_id: scim_json.pluck("id").compact)
+        .or(where(user_id: scim_json.pluck("externalId").compact))
+    end
+
+    scope :matching, ->(criterion) do
+      return none if criterion.groups.empty?
 
-      attrs = resources.map do |data|
-        { user_id: data["externalId"], data: data, created_at: Time.current, updated_at: Time.current }
+      criterion.groups
+               .group_by(&:resource_type)
+               .values
+               .reduce(self) do |scope, groups|
+        scope.members_of(groups)
       end
-      unique_by = :user_id if connection.supports_insert_conflict_target?
-      upsert_all(attrs, unique_by: unique_by) # rubocop:disable Rails/SkipsModelValidations
-      where(user_id: attrs.pluck(:user_id))
+    end
+
+    scope :matching_any, ->(first, *others) do
+      others.reduce(matching(first)) do |scope, criterion|
+        scope.or matching(criterion)
+      end
+    end
+
+    def picture_urls = [picture_url]
+
+    def picture_urls=(urls)
+      self.picture_url = urls&.first
     end
 
     def as_json(...)
-      data.as_json(...)
+      as_scim.slice(*Audiences.exposed_user_attributes)
     end
+
+    def as_scim(...)
+      (data || {}).merge(groups_as_scim)
+    end
+
+    def groups_as_scim
+      names = groups.reduce({}) { |nam, group| nam.merge(group.resource_type => group.display_name) }
+
+      {
+        "groups" => groups.map { |g| { "value" => g.scim_id, "display" => g.display_name } },
+        "title" => names["Titles"],
+        "urn:ietf:params:scim:schemas:extension:authservice:2.0:User" => {
+          "role" => names["Roles"], "department" => names["Departments"],
+          "territory" => names["Territories"], "territoryAbbr" => TERRITORY_ABBRS[names["Territories"]]
+        },
+      }
+    end
+
+    TERRITORY_ABBRS = {
+      "Philadelphia" => "PHL",
+      "New Jersey" => "NJ",
+      "Maryland" => "MD",
+      "Connecticut" => "CT",
+      "Long Island" => "LI",
+      "Boston" => "BOS",
+      "Atlanta" => "ATL",
+      "Chicago" => "CHI",
+      "Detroit" => "DET",
+      "Houston" => "HOU",
+      "Dallas" => "DAL",
+      "Denver" => "DEN",
+      "Tampa" => "TPA",
+      "Austin" => "AUS",
+      "Charlotte" => "CLT",
+      "Nashville" => "NSH",
+      "Phoenix" => "PHX",
+      "Pittsburgh" => "PIT",
+      "San Antonio" => "SAO",
+      "Fort Lauderdale" => "FLL",
+      "Las Vegas" => "LVS",
+      "Orlando" => "ORL",
+      "Cincinnati" => "CIN",
+      "Columbus" => "CLB",
+      "Jacksonville" => "JAX",
+    }.freeze
   end
 end

data/app/models/audiences/group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Audiences
+  class Group < ApplicationRecord
+    has_many :group_memberships, dependent: :destroy
+    has_many :external_users, through: :group_memberships, dependent: :destroy
+
+    validates :display_name, presence: true
+    validates :external_id, presence: true
+    validates :scim_id, presence: true
+
+    scope :active, -> { where(active: true) }
+
+    scope :search, ->(display_name) do
+      where(arel_table[:display_name].matches("%#{display_name}%"))
+    end
+
+    scope :from_scim, ->(resource_type, *scim_json) do
+      where(scim_id: scim_json.pluck("id"))
+        .or(where(resource_type: resource_type, external_id: scim_json.pluck("externalId")))
+    end
+
+    def as_json(...)
+      { "id" => scim_id, "externalId" => external_id, "displayName" => display_name }.as_json(...)
+    end
+  end
+end

data/app/models/audiences/group_membership.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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

data/db/migrate/20250520181229_create_audiences_groups.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateAudiencesGroups < ActiveRecord::Migration[6.1]
+  def change
+    create_table :audiences_groups do |t|
+      t.string :external_id
+      t.string :scim_id
+      t.string :display_name
+      t.string :resource_type
+
+      t.timestamps
+
+      t.index %i[resource_type external_id], unique: true
+      t.index %i[resource_type scim_id], unique: true
+    end
+  end
+end

data/db/migrate/20250521173148_add_scim_id_to_audiences_external_users.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddScimIdToAudiencesExternalUsers < ActiveRecord::Migration[6.1]
+  def change
+    add_column :audiences_external_users, :scim_id, :string
+    add_index :audiences_external_users, :scim_id, unique: true
+  end
+end

data/db/migrate/20250521182852_create_audiences_group_memberships.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class CreateAudiencesGroupMemberships < ActiveRecord::Migration[6.1]
+  def change
+    create_table :audiences_group_memberships do |t|
+      t.belongs_to :external_user, null: false, foreign_key: false, table: :audiences_external_users
+      t.belongs_to :group, null: false, foreign_key: false, table: :audiences_external_users
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250527203948_populate_external_users_scim_id.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class PopulateExternalUsersScimId < ActiveRecord::Migration[6.1]
+  def down; end
+
+  def up
+    Audiences::ExternalUser.unscoped.find_each do |user|
+      user.update!(
+        scim_id: user.data&.fetch("id", nil),
+        display_name: user.data&.fetch("displayName", nil),
+        picture_urls: user.data&.fetch("photos", [])&.pluck("value")
+      )
+    end
+  end
+end

data/db/migrate/20250528130640_add_display_name_to_audiences_external_users.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddDisplayNameToAudiencesExternalUsers < ActiveRecord::Migration[6.1]
+  def change
+    add_column :audiences_external_users, :display_name, :string
+    add_column :audiences_external_users, :picture_url, :string
+  end
+end

data/db/migrate/20250618184332_add_active_flag_to_external_users_and_groups.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddActiveFlagToExternalUsersAndGroups < ActiveRecord::Migration[6.1]
+  def change
+    add_column :audiences_external_users, :active, :boolean, default: true, null: false
+    add_column :audiences_groups, :active, :boolean, default: true, null: false
+  end
+end

data/db/migrate/20250620005528_create_audiences_criterion_groups.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

data/db/migrate/20250620005800_rename_audiences_criterion_groups_to_groups_json.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RenameAudiencesCriterionGroupsToGroupsJson < ActiveRecord::Migration[6.1]
+  def change
+    rename_column :audiences_criterions, :groups, :groups_json
+  end
+end

data/db/migrate/20250623131202_move_group_criterion_to_criterion_groups.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class MoveGroupCriterionToCriterionGroups < ActiveRecord::Migration[6.1]
+  def up
+    Audiences::Criterion.find_each do |criterion|
+      next if criterion.groups_json.blank?
+
+      groups = criterion.groups_json.values.flat_map do |scim_groups|
+        scim_groups.pluck("id")
+      end
+
+      criterion.update!(groups: Audiences::Group.where(scim_id: groups))
+    end
+  end
+
+  def down
+    Audiences::Criterion.find_each do |criterion|
+      next if criterion.groups.blank?
+
+      groups_json = criterion.groups.group_by(&:resource_type).transform_values do |groups|
+        groups.map(&:as_json)
+      end
+
+      criterion.update!(groups_json: groups_json)
+    end
+  end
+end

data/db/migrate/20250624171247_create_audiences_context_extra_users.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class CreateAudiencesContextExtraUsers < ActiveRecord::Migration[6.1]
+  def change
+    create_table :audiences_context_extra_users do |t|
+      t.references :external_user, foreign_key: false
+      t.references :context, foreign_key: false
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250624171706_rename_audiences_context_extra_users_to_extra_users_json.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RenameAudiencesContextExtraUsersToExtraUsersJson < ActiveRecord::Migration[6.1]
+  def change
+    rename_column :audiences_contexts, :extra_users, :extra_users_json
+  end
+end

data/db/migrate/20250701173946_move_extra_users_to_context_extra_users.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class MoveExtraUsersToContextExtraUsers < ActiveRecord::Migration[6.1]
+  def up
+    Audiences::Context.find_each do |context|
+      next if context.extra_users_json.blank?
+
+      users = Audiences::ExternalUser.from_scim(*context.extra_users_json)
+
+      context.update!(extra_users: users)
+    end
+  end
+
+  def down
+    Audiences::Context.find_each do |context|
+      next if context.extra_users.blank?
+
+      context.update!(extra_users_json: context.extra_users.map(&:as_json))
+    end
+  end
+end

data/docs/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Unreleased
 
+# Version 2.0 (2025-08-25)
+
+The all new 2.0 release inverts the SCIM logic, where now Audiences no longer pulls data from SCIM, but rather it will receive and cache SCIM data, allowing for an in database calculation of audiences. This improved process allows audiences to be more independent from SCIM, while still compatible with the protocol.
+
+- Update ExternalUser on membership changeas [#541](https://github.com/powerhome/audiences/pull/541)
+- Filter extra_users in context JSON [#540](https://github.com/powerhome/audiences/pull/540)
+- Introduce helpful scopes [#538](https://github.com/powerhome/audiences/pull/538)
+- Allow inactive groups in criteria [#537](https://github.com/powerhome/audiences/pull/537)
+- Allow creating external users and groups with internal and external ids [#536](https://github.com/powerhome/audiences/pull/536)
+- Reactive audience recalculation [#535](https://github.com/powerhome/audiences/pull/535)
+- match group criteria [#534](https://github.com/powerhome/audiences/pull/534)
+- Configurable default user and groups scope [#533](https://github.com/powerhome/audiences/pull/533)
+- Default authentication to reject requests [#532](https://github.com/powerhome/audiences/pull/532)
+- scim proxy with local data [#531](https://github.com/powerhome/audiences/pull/531)
+- Local audience calculations [#530](https://github.com/powerhome/audiences/pull/530)
+- Local user and group info updated with TwoPercent [#519](https://github.com/powerhome/audiences/pull/519)
+
 # Version 1.6 (2025-03-19)
 
 - Prepackaged audiences-react in UJS [#510](https://github.com/powerhome/audiences/pull/510)

data/docs/README.md

@@ -42,17 +42,6 @@ For more details, refer to [editor_helper](../lib/audiences/editor_helper.rb).
 
 ### Configuring Audiences
 
-The `Audience.config.scim` should point to the SCIM endpoint. Configure the endpoint and the credentials/headers as follows:
-
-```ruby
-Audiences.configure do |config|
-  config.scim = {
-    uri: ENV.fetch("SCIM_V2_API"),
-    headers: { "Authorization" => "Bearer #{ENV.fetch('SCIM_V2_TOKEN')}" }
-  }
-end
-```
-
 ### Adding Audiences to a Model
 
 A model object can contain multiple audience contexts using the `has_audience` module helper, which is added to ActiveRecord automatically when configured: