refactor: decouple auth from GithubService

UserAvatar called GithubService.validateToken() directly, coupling
it to a specific forge implementation. The createLazyAuth strategy
used Object.assign with untyped hook plumbing to support lazy token
resolution.

Replace the static validateToken with fetchUserInfo on the
SourceControlService interface. UserAvatar now calls the interface
method via useSourceControlService, making it forge-agnostic.

Replace createLazyAuth with a getter that caches the Octokit
instance and re-creates it only when the token changes.

Rename GitHubUser to ForgeUser with a simplified shape.

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: Stanislav Jakuschevskij <sjakusch@redhat.com>

Author: twoGiants

src/components/UserAvatar.test.tsx

@@ -1,7 +1,6 @@
 import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { UserAvatar } from './UserAvatar';
-import { GithubService } from '../services/source-control/GithubService';
 import { PAT_KEY, USER_KEY } from '../services/types';
 import { ForgeConnectionContext } from '../context/ForgeConnectionProvider';
 import { ReactNode } from 'react';
@@ -10,13 +9,14 @@ jest.mock('react-i18next', () => ({
   useTranslation: () => ({ t: (key: string) => key }),
 }));
 
-jest.mock('../services/source-control/GithubService', () => ({
-  GithubService: { validateToken: jest.fn() },
+const mockFetchUserInfo = jest.fn();
+jest.mock('../services/source-control/useSourceControlService', () => ({
+  useSourceControlService: () => ({
+    fetchUserInfo: mockFetchUserInfo,
+  }),
 }));
 
-const mockValidateToken = GithubService.validateToken as jest.Mock;
-
-const testUser = { login: 'twoGiants', avatarUrl: 'https://example.com/avatar.png' };
+const testUser = { name: 'twoGiants' };
 
 function renderWithContext(
   ui: ReactNode,
@@ -39,6 +39,7 @@ describe('UserAvatar', () => {
   afterAll(() => {
     sessionStorage.clear();
   });
+
   describe('rendering', () => {
     it('renders "Connect to GitHub" when no user is stored', () => {
       renderWithContext(<UserAvatar enableReconnect={false} />);
@@ -111,18 +112,18 @@ describe('UserAvatar', () => {
       expect(screen.getByRole('button', { name: 'Connect' })).toBeDisabled();
     });
 
-    it('calls validateToken with PAT and updates UI on successful connect', async () => {
+    it('calls fetchUserInfo with PAT and updates UI on successful connect', async () => {
       const user = userEvent.setup();
       const connectToForge = jest.fn();
-      mockValidateToken.mockResolvedValue(testUser);
+      mockFetchUserInfo.mockResolvedValue(testUser);
 
       renderWithContext(<UserAvatar enableReconnect />, { isActive: false, connectToForge });
 
       await user.type(screen.getByLabelText('Personal Access Token'), 'ghp_valid');
       await user.click(screen.getByRole('button', { name: 'Connect' }));
 
       await waitFor(() => {
-        expect(mockValidateToken).toHaveBeenCalledWith('ghp_valid');
+        expect(mockFetchUserInfo).toHaveBeenCalledWith('ghp_valid');
       });
 
       expect(screen.getByText('twoGiants')).toBeInTheDocument();
@@ -131,9 +132,9 @@ describe('UserAvatar', () => {
       expect(connectToForge).toHaveBeenCalled();
     });
 
-    it('shows error alert when validateToken rejects', async () => {
+    it('shows error alert when fetchUserInfo rejects', async () => {
       const user = userEvent.setup();
-      mockValidateToken.mockRejectedValue(new Error('Bad credentials'));
+      mockFetchUserInfo.mockRejectedValue(new Error('Bad credentials'));
 
       renderWithContext(<UserAvatar enableReconnect />);
 

src/components/UserAvatar.tsx

@@ -11,10 +11,10 @@ import {
 } from '@patternfly/react-core';
 import { KeyIcon, UserIcon } from '@patternfly/react-icons';
 import { useTranslation } from 'react-i18next';
-import { GitHubUser, PAT_KEY, USER_KEY } from '../services/types';
+import { ForgeUser, PAT_KEY, USER_KEY } from '../services/types';
 import { useCallback, useContext, useState } from 'react';
-import { GithubService } from '../services/source-control/GithubService';
 import { ForgeConnectionContext } from '../context/ForgeConnectionProvider';
+import { useSourceControlService } from '../services/source-control/useSourceControlService';
 
 interface UserAvatarProps {
   enableReconnect: boolean;
@@ -25,7 +25,7 @@ export function UserAvatar({ enableReconnect }: UserAvatarProps) {
   const { user, isModalOpen, openModal, closeModal, login } = useUserAvatar(enableReconnect);
 
   const icon = user ? <UserIcon /> : <KeyIcon />;
-  const label = user ? user.login : t('Connect to GitHub');
+  const label = user ? user.name : t('Connect to GitHub');
 
   return (
     <>
@@ -44,19 +44,18 @@ export function UserAvatar({ enableReconnect }: UserAvatarProps) {
 }
 
 function useUserAvatar(enableReconnect: boolean) {
+  const sourceControlService = useSourceControlService();
   const connectToForge = useContext(ForgeConnectionContext).connectToForge;
-  const [user, setUser] = useState<GitHubUser | null>(() => readStoredUser());
+  const [user, setUser] = useState<ForgeUser | null>(() => readStoredUser());
   const [isModalOpen, setIsModalOpen] = useState(
     () => enableReconnect && !sessionStorage.getItem(PAT_KEY),
   );
 
-  // TODO(twoGiants): remove useCallback here and below => it has no effect
   const login = useCallback(async (pat: string) => {
-    // TODO(twoGiants): use useSourceControlService hook => don't use GithubService directly
-    const githubUser = await GithubService.validateToken(pat);
+    const forgeUser = await sourceControlService.fetchUserInfo(pat);
     sessionStorage.setItem(PAT_KEY, pat);
-    sessionStorage.setItem(USER_KEY, JSON.stringify(githubUser));
-    setUser(githubUser);
+    sessionStorage.setItem(USER_KEY, JSON.stringify(forgeUser));
+    setUser(forgeUser);
     setIsModalOpen(false);
     connectToForge();
   }, []);
@@ -74,12 +73,12 @@ function useUserAvatar(enableReconnect: boolean) {
   return { user, isModalOpen, openModal, closeModal, login, logout };
 }
 
-function readStoredUser(): GitHubUser | null {
+function readStoredUser(): ForgeUser | null {
   const pat = sessionStorage.getItem(PAT_KEY);
   const userJson = sessionStorage.getItem(USER_KEY);
   if (pat && userJson) {
     try {
-      return JSON.parse(userJson) as GitHubUser;
+      return JSON.parse(userJson) as ForgeUser;
     } catch {
       return null;
     }

src/services/source-control/GithubService.ts

@@ -1,46 +1,29 @@
 import { Octokit } from '@octokit/rest';
-import { FileEntry, GitHubUser, RepoInfo, SourceRepo } from '../types';
+import { FileEntry, ForgeUser, RepoInfo, SourceRepo } from '../types';
 import { SourceControlService } from './SourceControlService';
 
-/**
- * Custom Octokit auth strategy that reads the token lazily via a callback.
- * The callback is invoked on every request, so the token can change at runtime
- * (e.g. after the user enters a PAT in sessionStorage).
- *
- * Follows the same shape as @octokit/auth-token's createTokenAuth, but defers
- * token resolution to call-time instead of binding a static string.
- */
-function createLazyAuth(getToken: () => string) {
-  return Object.assign(
-    async () => {
-      const token = getToken();
-      return { type: 'token' as const, tokenType: 'oauth' as const, token };
-    },
-    {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      hook: async (request: any, route: any, parameters?: any) => {
-        const token = getToken();
-        const endpoint = request.endpoint.merge(route, parameters);
-        if (token) {
-          endpoint.headers.authorization = `token ${token}`;
-        }
-        return request(endpoint);
-      },
-    },
-  );
-}
-
 export class GithubService implements SourceControlService {
-  private octokit: Octokit;
+  private getToken: () => string;
+  private cachedOctokit: Octokit | null = null;
+  private cachedToken: string = '';
 
   constructor(getToken: () => string) {
-    this.octokit = new Octokit({ authStrategy: () => createLazyAuth(getToken) });
+    this.getToken = getToken;
+  }
+
+  private get octokit(): Octokit {
+    const token = this.getToken();
+    if (token !== this.cachedToken) {
+      this.cachedToken = token;
+      this.cachedOctokit = new Octokit({ auth: token });
+    }
+    return this.cachedOctokit!;
   }
 
-  static async validateToken(pat: string): Promise<GitHubUser> {
+  async fetchUserInfo(pat: string): Promise<ForgeUser> {
     const octokit = new Octokit({ auth: pat });
     const { data } = await octokit.users.getAuthenticated();
-    return { login: data.login, avatarUrl: data.avatar_url };
+    return { name: data.login };
   }
 
   async listFunctionRepos(): Promise<SourceRepo[]> {

src/services/source-control/SourceControlService.test.ts

@@ -139,20 +139,19 @@ describe('GithubService', () => {
     });
   });
 
-  describe('validateToken', () => {
-    it('returns GitHubUser on valid token', async () => {
-      const user = await GithubService.validateToken('valid-token');
+  describe('fetchUserInfo', () => {
+    it('returns ForgeUser on valid token', async () => {
+      const svc = new GithubService(() => '');
+      const user = await svc.fetchUserInfo('valid-token');
 
-      expect(user).toEqual({
-        login: 'twoGiants',
-        avatarUrl: 'https://avatars.githubusercontent.com/u/123',
-      });
+      expect(user).toEqual({ name: 'twoGiants' });
     });
 
     it('throws on invalid token', async () => {
       mockGetAuthenticated.mockRejectedValue(new Error('Bad credentials'));
+      const svc = new GithubService(() => '');
 
-      await expect(GithubService.validateToken('bad-token')).rejects.toThrow('Bad credentials');
+      await expect(svc.fetchUserInfo('bad-token')).rejects.toThrow('Bad credentials');
     });
   });
 });

src/services/source-control/SourceControlService.ts

@@ -1,7 +1,8 @@
-import { FileEntry, RepoInfo, SourceRepo } from '../types';
+import { FileEntry, ForgeUser as ForgeUserInfo, RepoInfo, SourceRepo } from '../types';
 
 export interface SourceControlService {
   listFunctionRepos(): Promise<SourceRepo[]>;
   fetchFileContent(repo: SourceRepo, path: string): Promise<string>;
   push(repo: RepoInfo, files: FileEntry[], message: string): Promise<void>;
+  fetchUserInfo(pat: string): Promise<ForgeUserInfo>;
 }

src/services/types.ts

@@ -31,7 +31,6 @@ export interface SourceRepo {
   defaultBranch: string;
 }
 
-export interface GitHubUser {
-  login: string;
-  avatarUrl: string;
+export interface ForgeUser {
+  name: string;
 }