Prepare only required Discord roles during sync

Author: ciembor

lib/polish_open_source_rank/contexts/community/application/sync_discord_connection.rb

@@ -19,15 +19,17 @@ def initialize(sync_job_repository:, profile_read_model:, access_read_model:, me
           end
 
           def call(period_start:, limit: 10)
-            prepared_roles = role_map.prepare(period_start: period_start)
-            sync_job_repository.pending(limit: limit).each do |job|
+            jobs = sync_job_repository.pending(limit: limit)
+            prepared_roles = prepare_roles(jobs, period_start)
+            jobs.each do |job|
               sync_job(SyncContext.new(job: job, period_start: period_start, prepared_roles: prepared_roles))
             end
           end
 
           def call_for(platform:, source_id:, period_start:)
-            prepared_roles = role_map.prepare(period_start: period_start)
-            sync_job_repository.pending_for(platform, source_id).each do |job|
+            jobs = sync_job_repository.pending_for(platform, source_id)
+            prepared_roles = prepare_roles(jobs, period_start)
+            jobs.each do |job|
               sync_job(SyncContext.new(job: job, period_start: period_start, prepared_roles: prepared_roles))
             end
           end
@@ -36,6 +38,13 @@ def call_for(platform:, source_id:, period_start:)
 
           attr_reader :access_read_model, :member_gateway, :profile_read_model, :role_map, :sync_job_repository
 
+          def prepare_roles(jobs, period_start)
+            role_map.prepare(
+              period_start: period_start,
+              role_keys: jobs.flat_map { |job| access(job, period_start).fetch(:role_keys) }.uniq
+            )
+          end
+
           def sync_job(context)
             job = context.job
             case job.fetch(:action_kind)

lib/polish_open_source_rank/contexts/community/infrastructure/discord/discord_role_map.rb

@@ -44,15 +44,19 @@ def initialize(gateway: nil, published_language_source: nil,
               @role_catalog = role_catalog
             end
 
-            def prepare(period_start:)
+            def prepare(period_start:, role_keys: nil)
               static_role_ids = static_role_ids(GLOBAL_KEYS + city_role_keys)
               return PreparedRoles.new(managed_role_ids: static_role_ids, role_ids_by_key: {}) unless gateway
 
-              languages = published_languages(period_start)
+              dynamic_role_keys = dynamic_role_keys(period_start, role_keys)
+              if dynamic_role_keys.empty?
+                return PreparedRoles.new(managed_role_ids: static_role_ids, role_ids_by_key: {})
+              end
+
               state = provisioning_state
-              ensure_language_resources(languages, state)
+              ensure_language_resources(dynamic_role_keys, state)
 
-              build_prepared_roles(static_role_ids, dynamic_role_ids_by_key(languages, state.roles))
+              build_prepared_roles(static_role_ids, dynamic_role_ids_by_key(dynamic_role_keys, state.roles))
             end
 
             def managed_role_ids(prepared: nil)
@@ -102,11 +106,14 @@ def build_prepared_roles(static_role_ids, role_ids_by_key)
               )
             end
 
-            def ensure_language_resources(languages, state)
-              languages.each do |language|
-                ensure_language_role_and_channel(Domain::DiscordLanguageRoleKey.build_open(language), state)
-                ensure_language_role_and_channel(Domain::DiscordLanguageRoleKey.build_top(language), state)
-              end
+            def dynamic_role_keys(period_start, role_keys)
+              return role_keys.filter { |key| Domain::DiscordLanguageRoleKey.new(key).dynamic? }.uniq if role_keys
+
+              language_role_keys(published_languages(period_start))
+            end
+
+            def ensure_language_resources(role_keys, state)
+              role_keys.each { |role_key| ensure_language_role_and_channel(role_key, state) }
             end
 
             def ensure_language_role_and_channel(role_key, state)
@@ -158,9 +165,9 @@ def ensure_dynamic_channel(role_key, role_id, state)
               state.channel_creation_disabled = true
             end
 
-            def dynamic_role_ids_by_key(languages, roles)
+            def dynamic_role_ids_by_key(role_keys, roles)
               roles_by_name = roles.to_h { |role| [role.fetch('name'), role.fetch('id')] }
-              language_role_keys(languages).to_h do |key|
+              role_keys.to_h do |key|
                 [key, roles_by_name[role_catalog.role_name(key)]]
               end.compact
             end

spec/polish_open_source_rank/contexts/community/application/sync_discord_connection_spec.rb

@@ -9,13 +9,18 @@ def discord_access(*) = { role_keys: %w[top] }
 end
 
 class RoleMapForSync
+  attr_reader :prepared_role_keys
+
   Prepared = Struct.new(:managed_role_ids, :role_ids_by_key, keyword_init: true) do
     def role_ids(keys)
       keys.filter_map { |key| role_ids_by_key.fetch(key, nil) }
     end
   end
 
-  def prepare(*)
+  def prepare(period_start: nil, role_keys: nil)
+    raise ArgumentError, 'missing period start' unless period_start
+
+    @prepared_role_keys = role_keys
     Prepared.new(managed_role_ids: %w[role-top role-old], role_ids_by_key: { 'top' => 'role-top' })
   end
 
@@ -73,6 +78,7 @@ def sync_joined_member(**)
   it 'syncs only the requested connected account' do
     repository = seeded_repository
     gateway = MemberGatewayForSync.new
+    role_map = RoleMapForSync.new
     repository.request_oauth_sync(
       platform: 'github',
       source_id: 1,
@@ -91,8 +97,10 @@ def sync_joined_member(**)
       welcome_channel_id: nil
     )
 
-    use_case(repository, gateway).call_for(platform: 'github', source_id: 1, period_start: '2026-04-01')
+    use_case(repository, gateway, role_map: role_map)
+      .call_for(platform: 'github', source_id: 1, period_start: '2026-04-01')
 
+    expect(role_map.prepared_role_keys).to eq(%w[top])
     expect(gateway.synced).to include(discord_user_id: 'discord-1', access_token: 'access-token')
     expect(repository.sync_status('github', 1)).to eq('synced')
     expect(repository.sync_status('github', 2)).to eq('pending')
@@ -115,13 +123,13 @@ def sync_joined_member(**)
     expect(repository.sync_status('github', 1)).to eq('failed')
   end
 
-  def use_case(repository, gateway)
+  def use_case(repository, gateway, role_map: RoleMapForSync.new)
     described_class.new(
       sync_job_repository: repository,
       profile_read_model: ProfileReadModelForSync.new,
       access_read_model: AccessReadModelForSync.new,
       member_gateway: gateway,
-      role_map: RoleMapForSync.new
+      role_map: role_map
     )
   end
 

spec/polish_open_source_rank/contexts/community/infrastructure/discord/discord_role_map_spec.rb

@@ -80,6 +80,33 @@
       end).to eq(%w[Languages ruby top-100-ruby])
     end
 
+    it 'provisions only requested dynamic language roles when role keys are provided' do
+      prepared = map.prepare(
+        period_start: '2026-04-01',
+        role_keys: ['DISCORD_ROLE_LANGUAGE:ruby:Ruby']
+      )
+
+      expect(prepared.role_ids_by_key).to eq('DISCORD_ROLE_LANGUAGE:ruby:Ruby' => 'role-1')
+      expect(gateway_data.fetch(:created_roles).map { |role| role.fetch('name') }).to eq(['Ruby'])
+      expect(gateway_data.fetch(:created_channels).map do |channel|
+        channel.fetch('name')
+      end).to eq(%w[Languages ruby])
+    end
+
+    it 'skips dynamic provisioning when requested role keys are static' do
+      ENV['DISCORD_ROLE_TOP_100_PL'] = 'country-role'
+
+      prepared = map.prepare(
+        period_start: '2026-04-01',
+        role_keys: ['DISCORD_ROLE_TOP_100_PL']
+      )
+
+      expect(prepared.managed_role_ids).to include('country-role')
+      expect(prepared.role_ids_by_key).to be_empty
+      expect(gateway_data.fetch(:created_roles)).to be_empty
+      expect(gateway_data.fetch(:created_channels)).to be_empty
+    end
+
     context 'when the Languages category already exists' do
       let(:initial_channels) do
         [{ 'id' => 'category-1', 'name' => 'Languages', 'type' => 4, 'permission_overwrites' => [] }]