audiences 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a472729613c93580a6c651fd6a970868704cd3907bb9368b51bc855598b3d73b
-  data.tar.gz: 7ce7f85dc49b241fcc331d6f884b80e7ddfd5575ae93ae5fa33b14666d8d0ac9
+  metadata.gz: f4ea4e324141ab297f05ffe8089810777cb41c5ae9d2e2dc5453c930828b2856
+  data.tar.gz: 439e1e4491f03fcda92f60fecfa8254b2fe774e5bbec5b5b5266e1e145d5a4c3
 SHA512:
-  metadata.gz: b46ea33b5f2953cf2e6a67bdfe6cc4d480ea296722616f38a8554bc1860c67def0158c2e1d77916b450ab8d5ad62576ad3fae26fc256d22584caa8252c2052f2
-  data.tar.gz: 051aec8ea8523cace8fdf9f70e034e0cdeda82ec360ec0987f269b41c1d657af76b85e3432a77038228d118bff4f65b99897e24cb619825ad8f76be13d738b3c
+  metadata.gz: ae8b27668cd3aadd892bc9584db4c1ec8e9b376a14d525ecf7cf7df01a74c671a8697d222bff37b1a4f22dbc826ba3110d72895a68b17b572a2053ccfe1f4db0
+  data.tar.gz: ff5ede737617035689267d76fc42bf022e8d00347836c25cb6097749fe2b9d2c54facef9bbc25f5955ee4f921cf3232a5606dec18de6688996c3fd508ae67e90

data/app/models/audiences/external_user.rb

@@ -36,8 +36,12 @@ module Audiences
     end
 
     scope :from_scim, ->(*scim_json) do
-      where(scim_id: scim_json.pluck("id").compact)
-        .or(where(user_id: scim_json.pluck("externalId").compact))
+      # Flatten in case array is passed
+      json_array = scim_json.flatten
+      ids = json_array.filter_map { |h| h.is_a?(Hash) ? (h["id"] || h[:id]) : nil }
+      external_ids = json_array.filter_map { |h| h.is_a?(Hash) ? (h["externalId"] || h[:externalId]) : nil }
+
+      where(scim_id: ids).or(where(user_id: external_ids))
     end
 
     scope :matching, ->(criterion) do

data/docs/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Unreleased
 
+# Version 3.0.0 (2026-06-18)
+
+**Breaking Changes:**
+- Removed TwoPercent gem dependency from Gemfile - tests now use internal TestDomainEvents module
+
+**Improvements:**
+- Refactored all integration observers (UpsertUsers, DeleteUsers, UpsertGroups, DeleteGroups) to use shared block-based log_sync_operation method in ObserverBase for cleaner, more maintainable code
+- Added Ruby 3.4 compatibility via drb gem dependency
+- Fixed Rubocop violations in all observers by extracting helper methods
+
+**Code Cleanup:**
+- Removed PersistedResourceEvent and ApplicationEvent classes (dead code from old SCIM architecture)
+- Removed lib/audiences/scim/ directory containing deprecated SCIM observers (replaced by Integrations observers in v2.0)
+
 # Version 2.0.2 (2026-06-11)
 
 - Update territory name from "Raleigh" to "Raleigh-Durham"

data/lib/audiences/engine.rb

@@ -33,10 +33,11 @@ module Audiences
 
     initializer "audiences.observers" do
       if Audiences.config.observe_scim
-        Audiences::Scim::UpsertUsersObserver.start
-        Audiences::Scim::UpsertGroupsObserver.start
-        Audiences::Scim::PatchGroupsObserver.start
-        Audiences::Scim::PatchUsersObserver.start
+        # Domain event observers (provider-agnostic)
+        Audiences::Integrations::UpsertUsersObserver.start
+        Audiences::Integrations::UpsertGroupsObserver.start
+        Audiences::Integrations::DeleteUsersObserver.start
+        Audiences::Integrations::DeleteGroupsObserver.start
       end
     end
   end

data/lib/audiences/integrations/delete_groups_observer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Audiences
+  module Integrations
+    # Observer for Group deletion domain events
+    # Consumes domain events (NOT SCIM-specific)
+    class DeleteGroupsObserver < ObserverBase
+      subscribe_to "two_percent.domain.group.deleted"
+
+      def process
+        log_sync_operation(action: "delete", resource_type: resource_type, scim_id: scim_id) do
+          delete_group
+        end
+      rescue => e
+        Audiences.logger.error e
+        raise
+      end
+
+    private
+
+      def scim_id
+        event_payload.group_id
+      end
+
+      def resource_type
+        event_payload.resource_type
+      end
+
+      def delete_group
+        Audiences.logger.info "Deleting group #{scim_id} (#{resource_type})"
+
+        group = Audiences::Group.find_by(resource_type: resource_type, scim_id: scim_id)
+
+        if group
+          group.destroy!
+          Audiences.logger.info "Group #{scim_id} deleted from Audiences cache"
+        else
+          Audiences.logger.warn "Group #{scim_id} not found in Audiences cache"
+        end
+      end
+    end
+  end
+end

data/lib/audiences/integrations/delete_users_observer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Audiences
+  module Integrations
+    # Observer for User deletion domain events
+    # Consumes domain events (NOT SCIM-specific)
+    class DeleteUsersObserver < ObserverBase
+      subscribe_to "two_percent.domain.user.deleted"
+
+      def process
+        log_sync_operation(action: "delete", resource_type: "Users", scim_id: scim_id) do
+          delete_user
+        end
+      rescue => e
+        Audiences.logger.error e
+        raise
+      end
+
+    private
+
+      def scim_id
+        event_payload.user_id
+      end
+
+      def delete_user
+        Audiences.logger.info "Deleting user #{scim_id}"
+
+        user = Audiences::ExternalUser.find_by(scim_id: scim_id)
+
+        if user
+          user.destroy!
+          Audiences.logger.info "User #{scim_id} deleted from Audiences cache"
+        else
+          Audiences.logger.warn "User #{scim_id} not found in Audiences cache"
+        end
+      end
+    end
+  end
+end

data/lib/audiences/integrations/observer_base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Audiences
+  module Integrations
+    class ObserverBase < AetherObservatory::ObserverBase
+      # Logs the start and completion of a sync operation
+      # Automatically logs "start" before yielding and "complete" in ensure block
+      #
+      # @param action [String] The action being performed (e.g., "create", "update", "delete")
+      # @param resource_type [String] The type of resource (e.g., "Users", "Groups")
+      # @param scim_id [String] The SCIM ID of the resource
+      # @param correlation_id [String] The correlation ID from the event (defaults to event_payload.correlation_id)
+      # @yield The block containing the sync operation
+      def log_sync_operation(action:, resource_type:, scim_id:, correlation_id: event_payload.correlation_id)
+        log_data = build_log_data(action: action, resource_type: resource_type, scim_id: scim_id,
+                                  correlation_id: correlation_id)
+        Audiences.logger.info({ **log_data, stage: "start" }.to_json)
+        yield
+      ensure
+        Audiences.logger.info({ **log_data, stage: "complete" }.to_json)
+      end
+
+    private
+
+      def build_log_data(action:, resource_type:, scim_id:, correlation_id:)
+        {
+          correlation_id: correlation_id,
+          scim_id: scim_id,
+          action: action,
+          resource_type: resource_type,
+          service: "audiences",
+        }
+      end
+    end
+  end
+end

data/lib/audiences/integrations/upsert_groups_observer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Audiences
+  module Integrations
+    # Observer for Group creation/update domain events
+    # Consumes domain events (NOT SCIM-specific)
+    class UpsertGroupsObserver < ObserverBase
+      subscribe_to "two_percent.domain.group.created"
+      subscribe_to "two_percent.domain.group.updated"
+
+      def process
+        log_sync_operation(action: upsert_action.downcase, resource_type: resource_type, scim_id: scim_id) do
+          upsert_group
+          sync_members_if_present
+        end
+      rescue => e
+        Audiences.logger.error e
+        raise
+      end
+
+    private
+
+      def group_attrs
+        @group_attrs ||= event_payload.group_attributes.with_indifferent_access
+      end
+
+      def correlation_id
+        event_payload.correlation_id
+      end
+
+      def scim_id
+        group_attrs[:scim_id]
+      end
+
+      def resource_type
+        event_payload.resource_type
+      end
+
+      def upsert_action
+        group.persisted? ? "Updating" : "Creating"
+      end
+
+      def group
+        @group ||= Audiences::Group.where(
+          resource_type: resource_type,
+          scim_id: scim_id
+        ).first_or_initialize
+      end
+
+      def upsert_group
+        Audiences.logger.info "#{upsert_action} group #{group_attrs[:display_name]} (#{scim_id})"
+
+        group.update!(
+          external_id: group_attrs[:external_id],
+          display_name: group_attrs[:display_name],
+          active: group_attrs.fetch(:active, true)
+        )
+      end
+
+      def sync_members_if_present
+        sync_members if group_attrs[:members].present?
+      end
+
+      def sync_members
+        member_scim_ids = group_attrs[:members].filter_map { |m| m[:scim_id] || m["scim_id"] }
+        users = Audiences::ExternalUser.where(scim_id: member_scim_ids).to_a
+        group.external_users = users
+      end
+    end
+  end
+end

data/lib/audiences/integrations/upsert_users_observer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Audiences
+  module Integrations
+    # Observer for User creation/update domain events
+    # Consumes domain events (NOT SCIM-specific)
+    class UpsertUsersObserver < ObserverBase
+      subscribe_to "two_percent.domain.user.created"
+      subscribe_to "two_percent.domain.user.updated"
+
+      def process
+        log_sync_operation(action: upsert_action.downcase, resource_type: "Users", scim_id: scim_id) do
+          upsert_user
+          sync_groups
+        end
+      rescue => e
+        Audiences.logger.error e
+        raise
+      end
+
+    private
+
+      def user_attrs
+        @user_attrs ||= event_payload.user_attributes.with_indifferent_access
+      end
+
+      def scim_id
+        user_attrs[:scim_id]
+      end
+
+      def correlation_id
+        event_payload.correlation_id
+      end
+
+      def external_user
+        @external_user ||= Audiences::ExternalUser.where(scim_id: scim_id).first_or_initialize
+      end
+
+      def upsert_action
+        external_user.persisted? ? "Updating" : "Creating"
+      end
+
+      def updated_attributes
+        {
+          user_id: user_attrs[:external_id],
+          display_name: user_attrs[:display_name],
+          picture_urls: extract_picture_urls,
+          data: build_data_hash,
+          active: user_attrs.fetch(:active, false),
+        }
+      end
+
+      def extract_picture_urls
+        photos = user_attrs[:photos]
+        return [] unless photos.is_a?(Array)
+
+        photos.filter_map { |photo| photo["value"] || photo[:value] }
+      end
+
+      def find_associated_groups
+        groups_data = user_attrs[:groups]
+        return [] unless groups_data.is_a?(Array)
+
+        group_scim_ids = groups_data.filter_map { |g| g[:scim_id] || g["scim_id"] }
+        Audiences::Group.where(scim_id: group_scim_ids).to_a
+      end
+
+      def upsert_user
+        Audiences.logger.info "#{upsert_action} user #{user_attrs[:display_name]} (#{scim_id})"
+        external_user.update!(updated_attributes)
+      end
+
+      def sync_groups
+        found_groups = find_associated_groups
+        external_user.groups = found_groups
+      end
+
+      # Build minimal data hash for Audiences API responses
+      # Group-derived attributes (title, department, territory, role) are built dynamically
+      # in ExternalUser#groups_as_scim from GroupMembership associations
+      def build_data_hash
+        {
+          "id" => scim_id,
+          "externalId" => user_attrs[:external_id],
+          "displayName" => user_attrs[:display_name],
+          "userName" => user_attrs[:user_name],
+          "photos" => user_attrs[:photos],
+          "active" => user_attrs[:active],
+        }.compact
+      end
+    end
+  end
+end

data/lib/audiences/integrations.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Audiences
+  # Integration observers for syncing domain events from external identity providers
+  # This module does NOT contain SCIM protocol logic (e.g., RFC 7644 operations)
+  # It only contains observers that react to domain events and sync data to Audiences cache
+  module Integrations
+    # Domain event observers
+    autoload :ObserverBase, "audiences/integrations/observer_base"
+    autoload :UpsertGroupsObserver, "audiences/integrations/upsert_groups_observer"
+    autoload :UpsertUsersObserver, "audiences/integrations/upsert_users_observer"
+    autoload :DeleteGroupsObserver, "audiences/integrations/delete_groups_observer"
+    autoload :DeleteUsersObserver, "audiences/integrations/delete_users_observer"
+  end
+end

data/lib/audiences/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Audiences
-  VERSION = "2.0.2"
+  VERSION = "3.0.0"
 end

data/lib/audiences.rb

@@ -3,13 +3,13 @@
 require "aether_observatory"
 
 # Audiences system
-# Audiences pushes notifications to your rails app when a
-# SCIM backend updates a user, notifying matching audiences.
+# Audiences pushes notifications to your rails app when an
+# identity provider updates a user, notifying matching audiences.
 #
 module Audiences
   autoload :Model, "audiences/model"
   autoload :Notifications, "audiences/notifications"
-  autoload :Scim, "audiences/scim"
+  autoload :Integrations, "audiences/integrations"
   autoload :VERSION, "audiences/version"
 
 module_function

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: audiences
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Carlos Palhares
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 2026-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aether_observatory
@@ -51,8 +51,6 @@ files:
 - app/controllers/audiences/application_controller.rb
 - app/controllers/audiences/contexts_controller.rb
 - app/controllers/audiences/scim_proxy_controller.rb
-- app/events/audiences/application_event.rb
-- app/events/audiences/persisted_resource_event.rb
 - app/models/audiences/application_record.rb
 - app/models/audiences/context.rb
 - app/models/audiences/context/locating.rb
@@ -94,17 +92,14 @@ files:
 - lib/audiences/configuration.rb
 - lib/audiences/editor_helper.rb
 - lib/audiences/engine.rb
+- lib/audiences/integrations.rb
+- lib/audiences/integrations/delete_groups_observer.rb
+- lib/audiences/integrations/delete_users_observer.rb
+- lib/audiences/integrations/observer_base.rb
+- lib/audiences/integrations/upsert_groups_observer.rb
+- lib/audiences/integrations/upsert_users_observer.rb
 - lib/audiences/model.rb
 - lib/audiences/notifications.rb
-- lib/audiences/scim.rb
-- lib/audiences/scim/field_mapping.rb
-- lib/audiences/scim/observer_base.rb
-- lib/audiences/scim/patch_groups_observer.rb
-- lib/audiences/scim/patch_op.rb
-- lib/audiences/scim/patch_users_observer.rb
-- lib/audiences/scim/scim_data.rb
-- lib/audiences/scim/upsert_groups_observer.rb
-- lib/audiences/scim/upsert_users_observer.rb
 - lib/audiences/version.rb
 - lib/tasks/audiences_tasks.rake
 homepage: https://github.com/powerhome/audiences

data/app/events/audiences/application_event.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  class ApplicationEvent < AetherObservatory::EventBase
-    event_prefix "audiences"
-  end
-end

data/app/events/audiences/persisted_resource_event.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  class PersistedResourceEvent < ApplicationEvent
-    event_name { "persisted.#{resource_type}" }
-
-    attribute :params
-    attribute :resource_type
-  end
-end

data/lib/audiences/scim/field_mapping.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class FieldMapping
-      def initialize(mapping)
-        @map = mapping
-      end
-
-      def remove(object, path, val)
-        return unless @map.key?(path)
-
-        case @map[path]
-        in { to: to, find: find }
-          remove_from_association(object, to, find, val)
-        else
-          current = object.send to(path)
-          _set object, path, current - value(path, val)
-        end
-      end
-
-      def add(object, path, val)
-        return unless @map.key?(path)
-
-        case @map[path]
-        in { to: to, find: find }
-          add_to_association(object, to, find, val)
-        else
-          current = object.send to(path)
-          _set object, path, current + value(path, val)
-        end
-      end
-
-      def replace(object, path, val)
-        _set object, path, value(path, val)
-      end
-
-    private
-
-      def _set(object, path, val)
-        return unless @map.key?(path)
-
-        object.send :"#{to(path)}=", val if @map[path]
-      end
-
-      def has?(...) = @map.key?(...)
-
-      def to(path)
-        case @map[path]
-        in { to: to } then to
-        in Symbol then @map[path]
-        end
-      end
-
-      def value(path, val)
-        case @map[path]
-        in { find: find } then [val].flatten.pluck("value").map(&find)
-        else val
-        end
-      end
-
-      def add_to_association(object, to, find, val)
-        # Use << operator to avoid loading all records
-        collection = object.send(to)
-        new_items = [val].flatten.pluck("value").filter_map(&find)
-        new_items.each { |item| collection << item unless collection.include?(item) }
-      end
-
-      def remove_from_association(object, to, find, val)
-        # Use delete operator to avoid loading all records
-        collection = object.send(to)
-        items_to_remove = [val].flatten.pluck("value").filter_map(&find)
-        collection.delete(*items_to_remove)
-      end
-    end
-  end
-end

data/lib/audiences/scim/observer_base.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class ObserverBase < AetherObservatory::ObserverBase
-    end
-  end
-end

data/lib/audiences/scim/patch_groups_observer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class PatchGroupsObserver < ObserverBase
-      Audiences.config.group_types.each do |group_type|
-        subscribe_to "two_percent.scim.update.#{group_type}"
-      end
-
-      def process
-        Audiences.logger.info "Patching group #{group.display_name} (#{group.scim_id})"
-
-        patch_op.process(group, attributes_mapping)
-
-        group.save!
-
-        propagate_changes_to_users!
-      rescue => e
-        Audiences.logger.error e
-        raise
-      end
-
-    private
-
-      def patch_op = PatchOp.new(event_payload.params)
-
-      def attributes_mapping
-        FieldMapping.new("displayName" => :display_name,
-                         "externalId" => :external_id,
-                         "urn:ietf:params:scim:schemas:extension:authservice:2.0:Group:active" => :active,
-                         "members" => { to: :external_users,
-                                        find: ->(value) { ExternalUser.find_by(user_id: value) } })
-      end
-
-      def group
-        @group ||= Group.find_by!(resource_type: event_payload.resource,
-                                  scim_id: event_payload.id)
-      end
-
-      def propagate_changes_to_users!
-        patch_op.operations.each do |operation|
-          next unless operation.path == "members"
-
-          ExternalUser.where(user_id: operation.value.pluck("value")).find_each do |user|
-            TwoPercent::ReplaceEvent.create(resource: "Users", id: user.scim_id, params: user.as_scim)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/audiences/scim/patch_op.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class PatchOp
-      attr_reader :operations
-
-      def initialize(patch_op)
-        @operations = patch_op["Operations"].flat_map do |operation|
-          derive_operation(operation)
-        end
-      end
-
-      def process(object, operator)
-        @operations.each { _1.process(object, operator) }
-      end
-
-    private
-
-      Operation = Struct.new(:op, :path, :value) do
-        def process(object, operator)
-          raise "Operation #{op} is unknown to #{operator.class}" unless operator.respond_to?(op)
-
-          operator.public_send(op, object, path, value)
-        end
-      end
-
-      def derive_operation(operation)
-        case operation["value"]
-        when Hash
-          operation["value"].flat_map do |key, value|
-            derive_operation("op" => operation["op"],
-                             "path" => [operation["path"], key].compact.join("."),
-                             "value" => value)
-          end
-        else
-          [Operation.new(operation["op"], operation["path"], operation["value"])]
-        end
-      end
-    end
-  end
-end

data/lib/audiences/scim/patch_users_observer.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class PatchUsersObserver < ObserverBase
-      subscribe_to "two_percent.scim.update.Users"
-
-      def process
-        Audiences.logger.info "Patching user #{user.display_name} (#{user.scim_id})"
-
-        process_attributes!
-        process_data!
-
-        user.save!
-      rescue => e
-        Audiences.logger.error e
-        raise
-      end
-
-    private
-
-      def patch_op = PatchOp.new(event_payload.params)
-
-      def process_data! = patch_op.process(user, ScimData.new)
-
-      def process_attributes!
-        patch_op.process user, FieldMapping.new("externalId" => :user_id,
-                                                "displayName" => :display_name,
-                                                "active" => :active,
-                                                "photos" => { to: :picture_urls, find: :itself })
-      end
-
-      def user
-        @user ||= Audiences::ExternalUser.find_by!(scim_id: event_payload.id)
-      end
-    end
-  end
-end

data/lib/audiences/scim/scim_data.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class ScimData
-      def replace(object, key, value) = _replace(object.data || {}, key.split("."), value)
-
-      def add(object, key, val)
-        value = object.data&.dig(*key.split(".")) || []
-        replace(key, [...value, val])
-      end
-
-      def remove(object, key, val)
-        values = object.data&.dig(*key.split(".")) || []
-        to_remove = [val].flatten.pluck("value")
-        replace(key, values&.reject { |value| to_remove.include?(value["value"]) })
-      end
-
-    private
-
-      def _replace(data, key, val)
-        first_key, *rest_keys = key
-        if rest_keys.empty?
-          data[first_key] = val
-        else
-          _replace(data[first_key] ||= {}, rest_keys, val)
-        end
-      end
-    end
-  end
-end

data/lib/audiences/scim/upsert_groups_observer.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class UpsertGroupsObserver < ObserverBase
-      Audiences.config.group_types.each do |group_type|
-        subscribe_to "two_percent.scim.create.#{group_type}"
-        subscribe_to "two_percent.scim.replace.#{group_type}"
-      end
-
-      def process
-        Audiences.logger.info "#{upsert_action} group #{new_display_name} (#{new_external_id})"
-
-        group.update! external_id: new_external_id, display_name: new_display_name, active: new_active
-        Audiences::PersistedResourceEvent.create(resource_type: "Groups", params: event_payload.params)
-      rescue => e
-        Audiences.logger.error e
-        raise
-      end
-
-    private
-
-      def upsert_action = group.persisted? ? "Updating" : "Creating"
-
-      def new_external_id = event_payload.params["externalId"]
-
-      def new_display_name = event_payload.params["displayName"]
-
-      def new_active
-        active = event_payload.params.dig("urn:ietf:params:scim:schemas:extension:authservice:2.0:Group", "active")
-        active.nil? || active
-      end
-
-      def group
-        @group ||= Audiences::Group.where(resource_type: event_payload.resource,
-                                          scim_id: event_payload.params["id"])
-                                   .first_or_initialize
-      end
-    end
-  end
-end

data/lib/audiences/scim/upsert_users_observer.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    class UpsertUsersObserver < ObserverBase
-      subscribe_to "two_percent.scim.create.Users"
-      subscribe_to "two_percent.scim.replace.Users"
-
-      def process
-        log_upsert_action
-        external_user.update! updated_attributes
-        return unless valid_group_types?
-
-        Audiences::PersistedResourceEvent.create(resource_type: "Users", params: event_payload.params)
-      rescue => e
-        Audiences.logger.error e
-        raise
-      end
-
-    private
-
-      def log_upsert_action
-        Audiences.logger.info "#{upsert_action} user #{event_payload.params['displayName']} (#{scim_id})"
-      end
-
-      def scim_id = event_payload.params["id"]
-
-      def external_user
-        @external_user ||= Audiences::ExternalUser.where(scim_id: scim_id).first_or_initialize
-      end
-
-      def upsert_action = external_user.persisted? ? "Updating" : "Creating"
-
-      def updated_attributes
-        {
-          user_id: event_payload.params["externalId"],
-          display_name: event_payload.params["displayName"],
-          picture_urls: new_picture_urls,
-          data: event_payload.params,
-          groups: new_groups,
-          active: event_payload.params.fetch("active", false),
-        }
-      end
-
-      def new_picture_urls = event_payload.params["photos"]&.pluck("value")
-
-      def new_groups
-        event_payload.params.fetch("groups", []).filter_map do |group|
-          Audiences::Group.find_by(scim_id: group["value"])
-        end
-      end
-
-      def valid_group_types?
-        missing = external_user.missing_group_types
-        return true if missing.empty?
-
-        Audiences.logger.warn "Provisioning event for user #{scim_id} with missing group types: #{missing.join(', ')}"
-        false
-      end
-    end
-  end
-end

data/lib/audiences/scim.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Audiences
-  module Scim
-    autoload :ScimData, "audiences/scim/scim_data"
-    autoload :FieldMapping, "audiences/scim/field_mapping"
-    autoload :PatchOp, "audiences/scim/patch_op"
-
-    autoload :ObserverBase, "audiences/scim/observer_base"
-    autoload :PatchGroupsObserver, "audiences/scim/patch_groups_observer"
-    autoload :PatchUsersObserver, "audiences/scim/patch_users_observer"
-    autoload :UpsertGroupsObserver, "audiences/scim/upsert_groups_observer"
-    autoload :UpsertUsersObserver, "audiences/scim/upsert_users_observer"
-  end
-end