github-issue-tower-defence-management 1.173.0 → 1.173.2

package/src/adapter/entry-points/console/consoleReadApi.test.ts

@@ -1,5 +1,6 @@
 import { mock } from 'jest-mock-extended';
 import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { GitHubRateLimitError } from '../../repositories/issue/githubRateLimitRetry';
 import {
   ISSUE_TITLE_CACHE_TTL_MS,
   IssueTitleStateCache,
@@ -15,6 +16,9 @@ import {
 } from './consoleReadApi';
 
 describe('consoleReadApi', () => {
+  const RATE_LIMIT_ERROR_MESSAGE =
+    'Failed to fetch body for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+
   describe('handleItemBody', () => {
     it('returns 400 when url is missing', async () => {
       const issueRepository = mock<IssueRepository>();
@@ -35,6 +39,29 @@ describe('consoleReadApi', () => {
         'https://github.com/o/r/issues/1',
       );
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestBody.mockRejectedValue(
+        new GitHubRateLimitError(RATE_LIMIT_ERROR_MESSAGE),
+      );
+      const response = await handleItemBody(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: RATE_LIMIT_ERROR_MESSAGE });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestBody.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      await expect(
+        handleItemBody(issueRepository, 'https://github.com/o/r/issues/1'),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handleComments', () => {
@@ -68,6 +95,31 @@ describe('consoleReadApi', () => {
       const response = await handleComments(issueRepository, null);
       expect(response.statusCode).toBe(400);
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch comments for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.getIssueOrPullRequestComments.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const response = await handleComments(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestComments.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      await expect(
+        handleComments(issueRepository, 'https://github.com/o/r/issues/1'),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handlePrFiles', () => {
@@ -130,6 +182,31 @@ describe('consoleReadApi', () => {
       const response = await handlePrFiles(issueRepository, null);
       expect(response.statusCode).toBe(400);
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch PR detail for https://github.com/o/r/pull/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.getPullRequestDetail.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const response = await handlePrFiles(
+        issueRepository,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getPullRequestDetail.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      await expect(
+        handlePrFiles(issueRepository, 'https://github.com/o/r/pull/1'),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handlePrCommits', () => {
@@ -165,6 +242,31 @@ describe('consoleReadApi', () => {
       const response = await handlePrCommits(issueRepository, null);
       expect(response.statusCode).toBe(400);
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch commits for https://github.com/o/r/pull/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.getPullRequestCommits.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const response = await handlePrCommits(
+        issueRepository,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getPullRequestCommits.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      await expect(
+        handlePrCommits(issueRepository, 'https://github.com/o/r/pull/1'),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handleRelatedPrs', () => {
@@ -228,6 +330,31 @@ describe('consoleReadApi', () => {
       const response = await handleRelatedPrs(issueRepository, null);
       expect(response.statusCode).toBe(400);
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch related PRs for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.findRelatedOpenPRs.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const response = await handleRelatedPrs(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.findRelatedOpenPRs.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      await expect(
+        handleRelatedPrs(issueRepository, 'https://github.com/o/r/issues/1'),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handleIssueTitle with the TTL cache', () => {
@@ -350,6 +477,61 @@ describe('consoleReadApi', () => {
         1,
       );
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error and cache is empty', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch state for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.getIssueOrPullRequestState.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const cache = new IssueTitleStateCache(() => 0);
+      const response = await handleIssueTitle(
+        issueRepository,
+        cache,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('serves the stale cached value when the repository throws a GitHub rate limit error and a cache entry exists', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const staleState = {
+        state: 'OPEN',
+        merged: false,
+        isPullRequest: false,
+        title: 'Stale title',
+      };
+      const rateLimitMessage =
+        'Failed to fetch state for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly';
+      issueRepository.getIssueOrPullRequestState
+        .mockResolvedValueOnce(staleState)
+        .mockRejectedValue(new GitHubRateLimitError(rateLimitMessage));
+      let now = 0;
+      const cache = new IssueTitleStateCache(() => now);
+      const url = 'https://github.com/o/r/issues/1';
+      await handleIssueTitle(issueRepository, cache, url);
+      now = ISSUE_TITLE_CACHE_TTL_MS + 1;
+      const response = await handleIssueTitle(issueRepository, cache, url);
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual(staleState);
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestState.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      const cache = new IssueTitleStateCache(() => 0);
+      await expect(
+        handleIssueTitle(
+          issueRepository,
+          cache,
+          'https://github.com/o/r/issues/1',
+        ),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 
   describe('handlePullRequestStatus with the TTL cache', () => {
@@ -456,5 +638,77 @@ describe('consoleReadApi', () => {
         2,
       );
     });
+
+    it('returns 429 with the error message when the repository throws a GitHub rate limit error and cache is empty', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const rateLimitMessage =
+        'Failed to fetch CI status for https://github.com/o/r/pull/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+      issueRepository.getOpenPullRequestCiStatus.mockRejectedValue(
+        new GitHubRateLimitError(rateLimitMessage),
+      );
+      const cache = new PullRequestStatusCache(() => 0);
+      const response = await handlePullRequestStatus(
+        issueRepository,
+        cache,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(429);
+      expect(response.body).toEqual({ error: rateLimitMessage });
+    });
+
+    it('serves the stale cached value when the repository throws a GitHub rate limit error and a cache entry exists', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const openPullRequest = {
+        url: 'https://github.com/o/r/pull/1',
+        isConflicted: false,
+        mergeable: 'MERGEABLE',
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      };
+      const rateLimitMessage =
+        'Failed to fetch CI status for https://github.com/o/r/pull/1: HTTP 403 GitHub rate limit exceeded, please retry shortly';
+      issueRepository.getOpenPullRequestCiStatus
+        .mockResolvedValueOnce(openPullRequest)
+        .mockRejectedValue(new GitHubRateLimitError(rateLimitMessage));
+      let now = 0;
+      const cache = new PullRequestStatusCache(() => now);
+      const url = 'https://github.com/o/r/pull/1';
+      await handlePullRequestStatus(issueRepository, cache, url);
+      now = PULL_REQUEST_STATUS_CACHE_TTL_MS + 1;
+      const response = await handlePullRequestStatus(
+        issueRepository,
+        cache,
+        url,
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        found: true,
+        status: {
+          isConflicted: false,
+          mergeableStatus: 'MERGEABLE',
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      });
+    });
+
+    it('re-throws non-rate-limit errors from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getOpenPullRequestCiStatus.mockRejectedValue(
+        new Error('Network timeout'),
+      );
+      const cache = new PullRequestStatusCache(() => 0);
+      await expect(
+        handlePullRequestStatus(
+          issueRepository,
+          cache,
+          'https://github.com/o/r/pull/1',
+        ),
+      ).rejects.toThrow('Network timeout');
+    });
   });
 });

package/src/adapter/entry-points/console/consoleReadApi.ts

@@ -3,6 +3,7 @@ import {
   IssueComment,
   PullRequestCommit,
 } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { GitHubRateLimitError } from '../../repositories/issue/githubRateLimitRetry';
 
 export const ISSUE_TITLE_CACHE_TTL_MS = 300 * 1000;
 
@@ -72,6 +73,11 @@ export class IssueTitleStateCache {
     return entry.state;
   };
 
+  getStale = (url: string): IssueOrPullRequestState | null => {
+    const entry = this.entries.get(url);
+    return entry?.state ?? null;
+  };
+
   set = (url: string, state: IssueOrPullRequestState): void => {
     this.entries.set(url, { state, fetchedAtMs: this.nowMs() });
   };
@@ -93,6 +99,11 @@ export class PullRequestStatusCache {
     return entry.status;
   };
 
+  getStale = (url: string): PullRequestStatusResponse | null => {
+    const entry = this.entries.get(url);
+    return entry?.status ?? null;
+  };
+
   set = (url: string, status: PullRequestStatusResponse): void => {
     this.entries.set(url, { status, fetchedAtMs: this.nowMs() });
   };
@@ -103,6 +114,10 @@ export type ConsoleReadApiResponse = {
   body: unknown;
 };
 
+const isGitHubRateLimitError = (
+  error: unknown,
+): error is GitHubRateLimitError => error instanceof GitHubRateLimitError;
+
 const badRequest = (message: string): ConsoleReadApiResponse => ({
   statusCode: 400,
   body: { error: message },
@@ -113,6 +128,11 @@ const ok = (body: unknown): ConsoleReadApiResponse => ({
   body,
 });
 
+const rateLimited = (error: Error): ConsoleReadApiResponse => ({
+  statusCode: 429,
+  body: { error: error.message },
+});
+
 export type RelatedPullRequestWithSummary = {
   url: string;
   branchName: string | null;
@@ -160,8 +180,15 @@ export const handleItemBody = async (
   if (!url) {
     return badRequest('url query parameter is required');
   }
-  const body = await issueRepository.getIssueOrPullRequestBody(url);
-  return ok({ body });
+  try {
+    const body = await issueRepository.getIssueOrPullRequestBody(url);
+    return ok({ body });
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };
 
 export const handleComments = async (
@@ -171,8 +198,15 @@ export const handleComments = async (
   if (!url) {
     return badRequest('url query parameter is required');
   }
-  const comments = await issueRepository.getIssueOrPullRequestComments(url);
-  return ok({ comments: serializeComments(comments) });
+  try {
+    const comments = await issueRepository.getIssueOrPullRequestComments(url);
+    return ok({ comments: serializeComments(comments) });
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };
 
 export const handlePrFiles = async (
@@ -182,11 +216,18 @@ export const handlePrFiles = async (
   if (!url) {
     return badRequest('url query parameter is required');
   }
-  const detail = await issueRepository.getPullRequestDetail(url);
-  if (detail === null) {
-    return ok({ files: null });
+  try {
+    const detail = await issueRepository.getPullRequestDetail(url);
+    if (detail === null) {
+      return ok({ files: null });
+    }
+    return ok({ files: detail.files });
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      return rateLimited(error);
+    }
+    throw error;
   }
-  return ok({ files: detail.files });
 };
 
 export const handlePrCommits = async (
@@ -196,8 +237,15 @@ export const handlePrCommits = async (
   if (!url) {
     return badRequest('url query parameter is required');
   }
-  const commits = await issueRepository.getPullRequestCommits(url);
-  return ok({ commits: serializeCommits(commits) });
+  try {
+    const commits = await issueRepository.getPullRequestCommits(url);
+    return ok({ commits: serializeCommits(commits) });
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };
 
 export const handleRelatedPrs = async (
@@ -207,30 +255,38 @@ export const handleRelatedPrs = async (
   if (!url) {
     return badRequest('url query parameter is required');
   }
-  const relatedPullRequests = await issueRepository.findRelatedOpenPRs(url);
-  const withSummaries: RelatedPullRequestWithSummary[] = await Promise.all(
-    relatedPullRequests.map(async (relatedPullRequest) => {
-      const summary = await issueRepository.getPullRequestSummary(
-        relatedPullRequest.url,
-      );
-      return {
-        url: relatedPullRequest.url,
-        branchName: relatedPullRequest.branchName,
-        createdAt: relatedPullRequest.createdAt.toISOString(),
-        isDraft: relatedPullRequest.isDraft,
-        isConflicted: relatedPullRequest.isConflicted,
-        mergeableStatus: deriveMergeableStatus(relatedPullRequest.mergeable),
-        isPassedAllCiJob: relatedPullRequest.isPassedAllCiJob,
-        isCiStateSuccess: relatedPullRequest.isCiStateSuccess,
-        isResolvedAllReviewComments:
-          relatedPullRequest.isResolvedAllReviewComments,
-        isBranchOutOfDate: relatedPullRequest.isBranchOutOfDate,
-        missingRequiredCheckNames: relatedPullRequest.missingRequiredCheckNames,
-        summary,
-      };
-    }),
-  );
-  return ok({ relatedPullRequests: withSummaries });
+  try {
+    const relatedPullRequests = await issueRepository.findRelatedOpenPRs(url);
+    const withSummaries: RelatedPullRequestWithSummary[] = await Promise.all(
+      relatedPullRequests.map(async (relatedPullRequest) => {
+        const summary = await issueRepository.getPullRequestSummary(
+          relatedPullRequest.url,
+        );
+        return {
+          url: relatedPullRequest.url,
+          branchName: relatedPullRequest.branchName,
+          createdAt: relatedPullRequest.createdAt.toISOString(),
+          isDraft: relatedPullRequest.isDraft,
+          isConflicted: relatedPullRequest.isConflicted,
+          mergeableStatus: deriveMergeableStatus(relatedPullRequest.mergeable),
+          isPassedAllCiJob: relatedPullRequest.isPassedAllCiJob,
+          isCiStateSuccess: relatedPullRequest.isCiStateSuccess,
+          isResolvedAllReviewComments:
+            relatedPullRequest.isResolvedAllReviewComments,
+          isBranchOutOfDate: relatedPullRequest.isBranchOutOfDate,
+          missingRequiredCheckNames:
+            relatedPullRequest.missingRequiredCheckNames,
+          summary,
+        };
+      }),
+    );
+    return ok({ relatedPullRequests: withSummaries });
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };
 
 export const handleIssueTitle = async (
@@ -245,10 +301,21 @@ export const handleIssueTitle = async (
   if (cached !== null) {
     return ok(cached);
   }
-  const state: IssueOrPullRequestState =
-    await issueRepository.getIssueOrPullRequestState(url);
-  cache.set(url, state);
-  return ok(state);
+  try {
+    const state: IssueOrPullRequestState =
+      await issueRepository.getIssueOrPullRequestState(url);
+    cache.set(url, state);
+    return ok(state);
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      const stale = cache.getStale(url);
+      if (stale !== null) {
+        return ok(stale);
+      }
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };
 
 export const handlePullRequestStatus = async (
@@ -263,21 +330,32 @@ export const handlePullRequestStatus = async (
   if (cached !== null) {
     return ok(cached);
   }
-  const pullRequest = await issueRepository.getOpenPullRequestCiStatus(url);
-  const response: PullRequestStatusResponse =
-    pullRequest === null
-      ? { found: false, status: null }
-      : {
-          found: true,
-          status: {
-            isConflicted: pullRequest.isConflicted,
-            mergeableStatus: deriveMergeableStatus(pullRequest.mergeable),
-            isPassedAllCiJob: pullRequest.isPassedAllCiJob,
-            isCiStateSuccess: pullRequest.isCiStateSuccess,
-            isBranchOutOfDate: pullRequest.isBranchOutOfDate,
-            missingRequiredCheckNames: pullRequest.missingRequiredCheckNames,
-          },
-        };
-  cache.set(url, response);
-  return ok(response);
+  try {
+    const pullRequest = await issueRepository.getOpenPullRequestCiStatus(url);
+    const response: PullRequestStatusResponse =
+      pullRequest === null
+        ? { found: false, status: null }
+        : {
+            found: true,
+            status: {
+              isConflicted: pullRequest.isConflicted,
+              mergeableStatus: deriveMergeableStatus(pullRequest.mergeable),
+              isPassedAllCiJob: pullRequest.isPassedAllCiJob,
+              isCiStateSuccess: pullRequest.isCiStateSuccess,
+              isBranchOutOfDate: pullRequest.isBranchOutOfDate,
+              missingRequiredCheckNames: pullRequest.missingRequiredCheckNames,
+            },
+          };
+    cache.set(url, response);
+    return ok(response);
+  } catch (error) {
+    if (isGitHubRateLimitError(error)) {
+      const stale = cache.getStale(url);
+      if (stale !== null) {
+        return ok(stale);
+      }
+      return rateLimited(error);
+    }
+    throw error;
+  }
 };

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.test.ts

@@ -284,6 +284,16 @@ describe('createConsoleApiClient', () => {
     ).rejects.toThrow('HTTP 500');
   });
 
+  it('throws the error message from the JSON body of a non-ok response instead of the HTTP status code', async () => {
+    const rateLimitMessage =
+      'Failed to fetch body for https://github.com/o/r/issues/1: HTTP 403 GitHub rate limit exceeded, please retry shortly (resets at 2026-01-01T01:00:00.000Z)';
+    mockFetchOnce({ error: rateLimitMessage }, false);
+    const client = createConsoleApiClient();
+    await expect(
+      client.fetchItemBody('https://github.com/o/r/issues/1'),
+    ).rejects.toThrow(rateLimitMessage);
+  });
+
   it('returns cached comments when the network fetch rejects', async () => {
     const cachedBody = {
       comments: [

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -80,7 +80,20 @@ const requestJson = async (
   try {
     const response = await fetch(url);
     if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
+      let errorMessage = `HTTP ${response.status}`;
+      try {
+        const payload: unknown = await response.json();
+        if (
+          isRecord(payload) &&
+          typeof payload.error === 'string' &&
+          payload.error.length > 0
+        ) {
+          errorMessage = payload.error;
+        }
+      } catch (e: unknown) {
+        console.warn('Failed to parse error body from non-ok response:', e);
+      }
+      throw new Error(errorMessage);
     }
     const payload: unknown = await response.json();
     try {