Sync Discord account during OAuth callback

Author: ciembor

bin/discord_sync

@@ -5,6 +5,5 @@ require_relative '../lib/polish_open_source_rank'
 
 configuration = PolishOpenSourceRank::Configuration.load
 composition = PolishOpenSourceRank::Web::Composition.new(configuration: configuration)
-period = PolishOpenSourceRank::Shared::Domain::Period.previous_month.start_date.to_s
 
-composition.community.sync_discord_connection.call(period_start: period, limit: Integer(ARGV.fetch(0, 10)))
+composition.community.sync_discord_connection.call(period_start: nil, limit: Integer(ARGV.fetch(0, 10)))

docs/deployment.md

@@ -69,6 +69,8 @@ before granting additional maintainers deploy permission.
   configured explicitly.
 - Monthly, package, and resume crawls are started by systemd one-shot services
   and use the same mounted `db/` and `log/` directories as the web app.
+- Discord account sync runs during the Discord OAuth callback; the Discord bot
+  remains responsible for gateway invite events.
 - `/internal/jobs` reflects SQLite state from that shared app database, so stale
   package sections usually mean the package crawl is still running, the process
   died and left scans in `processing`, or the last package run failed while work

docs/user-actions.md

@@ -36,6 +36,8 @@
 ## Operational Outbox Processing
 
 - `bin/discord_sync [limit]` processes pending and retryable Discord jobs.
+- Discord OAuth callbacks sync the connected account immediately after storing
+  the outbox jobs.
 - Jobs finish with status `pending`, `synced`, `failed`, or `retryable`.
 - Repeating the Discord connect flow overwrites existing intents for the same
   profile and action kind instead of creating duplicates.

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

@@ -25,6 +25,13 @@ def call(period_start:, limit: 10)
             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|
+              sync_job(SyncContext.new(job: job, period_start: period_start, prepared_roles: prepared_roles))
+            end
+          end
+
           private
 
           attr_reader :access_read_model, :member_gateway, :profile_read_model, :role_map, :sync_job_repository

lib/polish_open_source_rank/contexts/community/infrastructure/sqlite/sqlite_discord_sync_job_repository.rb

@@ -57,6 +57,20 @@ def pending(limit: 10)
               SQL
             end
 
+            def pending_for(platform, source_id)
+              database.fetch_all(<<~SQL, [platform, source_id])
+                SELECT #{pending_columns_sql}
+                FROM discord_sync_jobs
+                JOIN users
+                  ON users.platform = discord_sync_jobs.platform
+                 AND users.github_id = discord_sync_jobs.user_github_id
+                WHERE discord_sync_jobs.platform = ?
+                  AND discord_sync_jobs.user_github_id = ?
+                  AND discord_sync_jobs.status IN ('pending', 'retryable')
+                ORDER BY discord_sync_jobs.updated_at ASC
+              SQL
+            end
+
             def mark_synced(job)
               update_status(job, terminal_status_attributes(status: 'synced', error: nil, synced_at: timestamp))
             end

lib/polish_open_source_rank/web/auth/oauth_login_flow.rb

@@ -73,13 +73,14 @@ def success?
         end
 
         def initialize(github_oauth_client:, discord_oauth_client:, public_github_profile:,
-                       register_public_github_profile:, connect_discord_account:)
+                       register_public_github_profile:, connect_discord_account:, sync_discord_connection:)
           @dependencies = {
             github_oauth_client: github_oauth_client,
             discord_oauth_client: discord_oauth_client,
             public_github_profile: public_github_profile,
             register_public_github_profile: register_public_github_profile,
-            connect_discord_account: connect_discord_account
+            connect_discord_account: connect_discord_account,
+            sync_discord_connection: sync_discord_connection
           }
         end
 
@@ -101,11 +102,12 @@ def discord_authorize_url(state:, redirect_uri:)
         def finish_discord(login)
           token = login.exchange_code(discord_oauth_client)
           access_token = token.fetch('access_token')
-          login.connect_account(
+          connection = login.connect_account(
             use_case: connect_discord_account,
             discord_user: discord_oauth_client.user(access_token),
             access_token: access_token
           )
+          sync_connected_account(connection)
           DiscordResult.success
         rescue DiscordOAuthClient::Error
           DiscordResult.failure('oauth')
@@ -156,6 +158,19 @@ def register_public_github_profile
         def connect_discord_account
           dependencies.fetch(:connect_discord_account)
         end
+
+        def sync_discord_connection
+          dependencies.fetch(:sync_discord_connection)
+        end
+
+        def sync_connected_account(connection)
+          profile = connection.profile
+          sync_discord_connection.call_for(
+            platform: profile.fetch(:platform),
+            source_id: profile.fetch(:source_id),
+            period_start: nil
+          )
+        end
       end
     end
   end

lib/polish_open_source_rank/web/routes/auth_flow.rb

@@ -73,7 +73,8 @@ def login_flow
             discord_oauth_client: community.discord_oauth_client,
             public_github_profile: method(:public_github_profile),
             register_public_github_profile: context_call(:publication).register_public_github_profile,
-            connect_discord_account: community.connect_discord_account
+            connect_discord_account: community.connect_discord_account,
+            sync_discord_connection: community.sync_discord_connection
           )
         end
 

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

@@ -70,6 +70,34 @@ def sync_joined_member(**)
     expect(repository.sync_status('github', 1)).to eq('synced')
   end
 
+  it 'syncs only the requested connected account' do
+    repository = seeded_repository
+    gateway = MemberGatewayForSync.new
+    repository.request_oauth_sync(
+      platform: 'github',
+      source_id: 1,
+      discord_user_id: 'discord-1',
+      discord_username: 'Alice',
+      access_token: 'access-token',
+      welcome_channel_id: nil
+    )
+    insert_user(2, 'bob')
+    repository.request_oauth_sync(
+      platform: 'github',
+      source_id: 2,
+      discord_user_id: 'discord-2',
+      discord_username: 'Bob',
+      access_token: 'bob-token',
+      welcome_channel_id: nil
+    )
+
+    use_case(repository, gateway).call_for(platform: 'github', source_id: 1, period_start: '2026-04-01')
+
+    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')
+  end
+
   it 'retries invite sync failures and marks repeated failures as failed' do
     repository = seeded_repository
     repository.request_invite_sync(
@@ -98,14 +126,18 @@ def use_case(repository, gateway)
   end
 
   def seeded_repository
-    database = PolishOpenSourceRank::Shared::Infrastructure::SQLite::Database.open(
+    @database = PolishOpenSourceRank::Shared::Infrastructure::SQLite::Database.open(
       File.join(Dir.mktmpdir, 'rank.sqlite3')
     )
-    database.execute_batch(PolishOpenSourceRank::Infrastructure::SQLiteSchema.sql)
-    database.execute(
+    @database.execute_batch(PolishOpenSourceRank::Infrastructure::SQLiteSchema.sql)
+    insert_user(1, 'alice')
+    PolishOpenSourceRank::Contexts::Community::Infrastructure::SQLite::SQLiteDiscordSyncJobRepository.new(@database)
+  end
+
+  def insert_user(source_id, login)
+    @database.execute(
       'INSERT INTO users(platform, github_id, login, html_url, updated_at) VALUES (?, ?, ?, ?, ?)',
-      ['github', 1, 'alice', 'https://github.com/alice', '2026-05-01T00:01:00Z']
+      ['github', source_id, login, "https://github.com/#{login}", '2026-05-01T00:01:00Z']
     )
-    PolishOpenSourceRank::Contexts::Community::Infrastructure::SQLite::SQLiteDiscordSyncJobRepository.new(database)
   end
 end

spec/polish_open_source_rank/contexts/community/infrastructure/sqlite/sqlite_discord_sync_job_repository_spec.rb

@@ -27,6 +27,27 @@
     expect(repository.pending(limit: 1).first).to include(discord_username: 'Alice D', login: 'alice', source_id: 1)
   end
 
+  it 'returns pending jobs scoped to one connected account' do
+    request_oauth_sync
+    database.execute(
+      'INSERT INTO users(platform, github_id, login, html_url, updated_at) VALUES (?, ?, ?, ?, ?)',
+      ['github', 2, 'bob', 'https://github.com/bob', '2026-05-01T00:01:00Z']
+    )
+    repository.request_oauth_sync(
+      platform: 'github',
+      source_id: 2,
+      discord_user_id: 'discord-2',
+      discord_username: 'Bob',
+      access_token: 'bob-token',
+      welcome_channel_id: nil
+    )
+
+    jobs = repository.pending_for('github', 1)
+
+    expect(jobs.map { |job| job.fetch(:discord_user_id) }).to all(eq('discord-1'))
+    expect(jobs.map { |job| job.fetch(:action_kind) }).to contain_exactly('member_sync', 'welcome_message')
+  end
+
   it 'skips welcome messages when OAuth sync has no welcome channel' do
     request_oauth_sync(welcome_channel_id: nil)
 

spec/polish_open_source_rank/web/app_spec.rb

@@ -76,6 +76,40 @@ def sync_joined_member(**attributes)
   def post_welcome_message(**attributes)
     @welcome = attributes
   end
+
+  def guild_roles
+    @guild_roles ||= [
+      { 'id' => 'role-top-100', 'name' => 'Polish Elite' },
+      { 'id' => 'role-krakow', 'name' => 'Kraków Elite' },
+      { 'id' => 'role-gold', 'name' => 'Top 1' }
+    ]
+  end
+
+  def guild_channels
+    @guild_channels ||= [{ 'id' => 'language-category', 'name' => 'Languages', 'type' => 4 }]
+  end
+
+  def create_role(name:, color: nil)
+    { 'id' => "role-#{name.downcase.tr(' ', '-')}", 'name' => name, 'color' => color }.tap do |role|
+      guild_roles << role
+    end
+  end
+
+  def create_channel(name:, type:, parent_id: nil, permission_overwrites: nil)
+    {
+      'id' => "channel-#{name}",
+      'name' => name,
+      'type' => type,
+      'parent_id' => parent_id,
+      'permission_overwrites' => permission_overwrites || []
+    }.tap do |channel|
+      guild_channels << channel
+    end
+  end
+
+  def private_channel_overwrites(role_id)
+    [{ id: role_id, type: 0, allow: '3072', deny: '0' }]
+  end
 end
 
 class FailingDiscordGateway
@@ -444,7 +478,7 @@ def user(_access_token)
 
     discord_callback = finish_discord_auth(request, github_callback)
 
-    expect_queued_discord_sync(request, discord_callback)
+    expect_synced_discord_account(request, discord_callback, discord_gateway)
     expect(github_client.exchanged).to eq(['github-code'])
     expect(discord_client.exchanged).to eq(['discord-code'])
   end
@@ -577,7 +611,7 @@ def user(_access_token)
     expect(profile.body).to include('Nie udało się zsynchronizować konta Discord')
   end
 
-  it 'queues Discord member sync without waiting for the gateway' do
+  it 'returns to the profile with retry status when immediate Discord member sync fails' do
     ENV['DATABASE_URL'] = "sqlite://#{seed_database}"
     ENV['DISCORD_GUILD_ID'] = '1505949566229286972'
     ENV['DISCORD_INVITE_CHANNEL_ID'] = '1505949566699176050'
@@ -597,7 +631,7 @@ def user(_access_token)
 
     expect(discord_callback.status).to eq(302)
     expect(discord_callback.location).to eq('https://discord.com/channels/1505949566229286972/1505949566699176050')
-    expect(profile.body).to include('Synchronizacja Discord jest w kolejce')
+    expect(profile.body).to include('Synchronizacja Discord ponawia się po tymczasowym błędzie')
   end
 
   it 'rejects Discord sync when the logged-in GitHub profile is no longer ranked' do
@@ -2178,12 +2212,18 @@ def expect_signed_in_profile(github_callback, profile)
     expect(profile.body).not_to include('Discord niepołączony')
   end
 
-  def expect_queued_discord_sync(request, discord_callback)
+  def expect_synced_discord_account(request, discord_callback, discord_gateway)
     expect(discord_callback.status).to eq(302)
     expect(discord_callback.location).to eq('https://discord.com/channels/guild-1/invite-channel')
     profile = request.get('/users/github/alice', 'HTTP_COOKIE' => cookie_header(discord_callback))
     expect(profile.body).to include('Alice Discord')
-    expect(profile.body).to include('Synchronizacja Discord jest w kolejce')
+    expect(profile.body).not_to include('Synchronizacja Discord jest w kolejce')
+    expect(discord_gateway.synced).to include(
+      discord_user_id: 'discord-1',
+      access_token: 'discord-access',
+      github_login: 'alice'
+    )
+    expect(discord_gateway.welcome).to include(channel_id: 'invite-channel', discord_user_id: 'discord-1')
   end
 
   def expect_repository_profile_page(**responses)