github-issue-tower-defence-management 1.51.0 → 1.52.1

package/src/adapter/repositories/GraphqlProjectRepository.fetchProjectId.test.ts

@@ -0,0 +1,251 @@
+const mockPost = jest.fn();
+
+jest.mock('ky', () => ({
+  default: {
+    post: mockPost,
+    get: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+    extend: jest.fn(),
+    create: jest.fn(),
+    stop: jest.fn(),
+  },
+  __esModule: true,
+}));
+
+import { GraphqlProjectRepository } from './GraphqlProjectRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+describe('GraphqlProjectRepository.fetchProjectId', () => {
+  const localStorageRepository = new LocalStorageRepository();
+  let repository: GraphqlProjectRepository;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockPost.mockReset();
+    repository = new GraphqlProjectRepository(localStorageRepository, '');
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('user-owned project', () => {
+    it('should resolve project ID from user owner when organization returns null', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            organization: null,
+            user: {
+              projectV2: {
+                id: 'PVT_user123',
+                databaseId: 999,
+              },
+            },
+          },
+        }),
+      );
+
+      const result = await repository.fetchProjectId('some-user', 1);
+
+      expect(result).toBe('PVT_user123');
+    });
+
+    it('should resolve project ID from organization owner when user returns null', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            organization: {
+              projectV2: {
+                id: 'PVT_org456',
+                databaseId: 111,
+              },
+            },
+            user: null,
+          },
+        }),
+      );
+
+      const result = await repository.fetchProjectId('some-org', 2);
+
+      expect(result).toBe('PVT_org456');
+    });
+  });
+
+  describe('memoization', () => {
+    it('should return cached project ID on subsequent calls without re-fetching', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            organization: null,
+            user: {
+              projectV2: {
+                id: 'PVT_cached',
+                databaseId: 777,
+              },
+            },
+          },
+        }),
+      );
+
+      const first = await repository.fetchProjectId('owner', 10);
+      const second = await repository.fetchProjectId('owner', 10);
+
+      expect(first).toBe('PVT_cached');
+      expect(second).toBe('PVT_cached');
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+
+    it('should use separate cache entries for different owner+projectNumber combinations', async () => {
+      mockPost
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            data: {
+              organization: null,
+              user: { projectV2: { id: 'PVT_A', databaseId: 1 } },
+            },
+          }),
+        )
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            data: {
+              organization: null,
+              user: { projectV2: { id: 'PVT_B', databaseId: 2 } },
+            },
+          }),
+        );
+
+      const resultA = await repository.fetchProjectId('ownerA', 1);
+      const resultB = await repository.fetchProjectId('ownerB', 1);
+
+      expect(resultA).toBe('PVT_A');
+      expect(resultB).toBe('PVT_B');
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('errors-only response hardening', () => {
+    it('should throw a clear error when response has no data field', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          errors: [{ message: 'Could not resolve to a User' }],
+        }),
+      );
+
+      await expect(repository.fetchProjectId('bad-owner', 1)).rejects.toThrow(
+        'Could not resolve to a User',
+      );
+    });
+
+    it('should throw a clear error when data is null', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: null,
+          errors: [{ message: 'secondary rate limit' }],
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectId('rate-limited', 1),
+      ).rejects.toThrow('secondary rate limit');
+    });
+
+    it('should throw a clear error when data has no project in either org or user', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            organization: null,
+            user: null,
+          },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectId('no-project-owner', 99),
+      ).rejects.toThrow('project not found');
+    });
+
+    it('should throw a clear error when network call fails', async () => {
+      mockPost.mockReturnValueOnce({
+        json: jest.fn().mockRejectedValue(new Error('network failure')),
+      });
+
+      await expect(repository.fetchProjectId('owner', 1)).rejects.toThrow(
+        'network failure',
+      );
+    });
+  });
+
+  describe('backoff after failure', () => {
+    it('should not re-call GraphQL within 1 hour after a failure', async () => {
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          errors: [{ message: 'auth failure' }],
+        }),
+      );
+
+      await expect(repository.fetchProjectId('owner', 5)).rejects.toThrow();
+
+      await expect(repository.fetchProjectId('owner', 5)).rejects.toThrow(
+        'backoff',
+      );
+
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry after 1 hour backoff has elapsed', async () => {
+      mockPost
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            errors: [{ message: 'temporary error' }],
+          }),
+        )
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            data: {
+              organization: null,
+              user: { projectV2: { id: 'PVT_recovered', databaseId: 42 } },
+            },
+          }),
+        );
+
+      await expect(repository.fetchProjectId('owner', 7)).rejects.toThrow();
+
+      jest.advanceTimersByTime(60 * 60 * 1000 + 1);
+
+      const result = await repository.fetchProjectId('owner', 7);
+
+      expect(result).toBe('PVT_recovered');
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+
+    it('should apply backoff independently per owner+projectNumber', async () => {
+      mockPost
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            errors: [{ message: 'error for owner A' }],
+          }),
+        )
+        .mockReturnValueOnce(
+          mockJsonResponse({
+            data: {
+              organization: null,
+              user: { projectV2: { id: 'PVT_B', databaseId: 2 } },
+            },
+          }),
+        );
+
+      await expect(repository.fetchProjectId('ownerA', 1)).rejects.toThrow();
+
+      const resultB = await repository.fetchProjectId('ownerB', 1);
+
+      expect(resultB).toBe('PVT_B');
+      expect(mockPost).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -4,6 +4,8 @@ import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/Proj
 import { FieldOption, Project } from '../../domain/entities/Project';
 import { normalizeFieldName } from './utils';
 
+const ONE_HOUR_MS = 60 * 60 * 1000;
+
 export class GraphqlProjectRepository
   extends BaseGitHubRepository
   implements
@@ -16,6 +18,9 @@ export class GraphqlProjectRepository
       | 'updateStatusList'
     >
 {
+  private readonly projectIdCache = new Map<string, string>();
+  private readonly fetchProjectIdFailedAt = new Map<string, number>();
+
   extractProjectFromUrl = (
     projectUrl: string,
   ): {
@@ -32,6 +37,17 @@ export class GraphqlProjectRepository
     login: string,
     projectNumber: number,
   ): Promise<string> => {
+    const cacheKey = `${login}:${projectNumber}`;
+    const cached = this.projectIdCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const failedAt = this.fetchProjectIdFailedAt.get(cacheKey);
+    if (failedAt !== undefined && Date.now() - failedAt < ONE_HOUR_MS) {
+      throw new Error(
+        `fetchProjectId for ${login}/${projectNumber} is in backoff after a recent failure`,
+      );
+    }
     const graphqlQuery = {
       query: `query GetProjectID($login: String!, $number: Int!) {
   organization(login: $login) {
@@ -53,32 +69,41 @@ export class GraphqlProjectRepository
       },
     };
 
-    const response = await ky
-      .post('https://api.github.com/graphql', {
-        json: graphqlQuery,
-        headers: {
-          Authorization: `Bearer ${this.ghToken}`,
-        },
-      })
-      .json<{
-        data?: {
-          organization: {
-            projectV2: {
-              id: string;
-              databaseId: number;
-            };
-          };
-          user: {
-            projectV2: {
-              id: string;
-              databaseId: number;
-            };
-          };
-        };
-        errors?: { message: string }[];
-      }>();
+    let response: {
+      data?: {
+        organization?: {
+          projectV2?: {
+            id: string;
+            databaseId: number;
+          } | null;
+        } | null;
+        user?: {
+          projectV2?: {
+            id: string;
+            databaseId: number;
+          } | null;
+        } | null;
+      } | null;
+      errors?: { message: string }[];
+    };
+    try {
+      response = await ky
+        .post('https://api.github.com/graphql', {
+          json: graphqlQuery,
+          headers: {
+            Authorization: `Bearer ${this.ghToken}`,
+          },
+        })
+        .json();
+    } catch (error) {
+      this.fetchProjectIdFailedAt.set(cacheKey, Date.now());
+      throw new Error(
+        `fetchProjectId network error for ${login}/${projectNumber}: ${String(error)}`,
+      );
+    }
 
     if (!response.data) {
+      this.fetchProjectIdFailedAt.set(cacheKey, Date.now());
       const errorMessages = response.errors
         ? response.errors.map((e) => e.message).join('; ')
         : 'no data field in response';
@@ -90,8 +115,12 @@ export class GraphqlProjectRepository
       response.data.organization?.projectV2?.id ||
       response.data.user?.projectV2?.id;
     if (!projectId) {
-      throw new Error('projectId is not found');
+      this.fetchProjectIdFailedAt.set(cacheKey, Date.now());
+      throw new Error(
+        `fetchProjectId: project not found for ${login}/${projectNumber}`,
+      );
     }
+    this.projectIdCache.set(cacheKey, projectId);
     return projectId;
   };
   findProjectIdByUrl = async (

package/src/domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase.test.ts

@@ -129,18 +129,146 @@ describe('ConvertCheckboxToIssueInStoryIssueUseCase', () => {
         expectedGetIssueByUrlCalls: [],
       },
       {
-        name: 'should not process when cache is used',
+        name: 'should process story issues even when cache is used',
         input: {
           project: basicProject,
-          issues: [basicStoryIssue1],
+          issues: [basicStoryIssue1, basicStoryIssue2],
           cacheUsed: true,
           urlOfStoryView: 'https://example.com',
           storyObjectMap: basicStoryObjectMap,
         },
-        expectedCreateNewIssueCalls: [],
-        expectedUpdateIssueCalls: [],
-        expectedUpdateStoryCalls: [],
-        expectedGetIssueByUrlCalls: [],
+        expectedCreateNewIssueCalls: [
+          [
+            'org',
+            'repo',
+            'Task 1',
+            '- Parent issue: https://github.com/org/repo/issues/123',
+            [],
+            [],
+          ],
+          [
+            'org',
+            'repo',
+            'Task 2',
+            '- Parent issue: https://github.com/org/repo/issues/123',
+            [],
+            [],
+          ],
+          [
+            'org',
+            'repo',
+            'Task 3',
+            '- Parent issue: https://github.com/org/repo/issues/456',
+            [],
+            [],
+          ],
+          [
+            'org',
+            'repo',
+            'Task 4',
+            '- Parent issue: https://github.com/org/repo/issues/456',
+            [],
+            [],
+          ],
+        ],
+        expectedUpdateIssueCalls: [
+          [
+            {
+              ...basicStoryIssue1,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%201
+
+- [ ] Task 1
+- [ ] Task 2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue1,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%201
+
+- [ ] https://github.com/org/repo/issues/1
+- [ ] Task 2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue1,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%201
+
+- [ ] https://github.com/org/repo/issues/1
+- [ ] https://github.com/org/repo/issues/2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%202
+
+- [ ] Task 3
+- [ ] Task 4`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%202
+
+- [ ] https://github.com/org/repo/issues/3
+- [ ] Task 4`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `https://example.com?sliceBy%5Bvalue%5D=Story%202
+
+- [ ] https://github.com/org/repo/issues/3
+- [ ] https://github.com/org/repo/issues/4`,
+            },
+          ],
+        ],
+        expectedUpdateStoryCalls: [
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/org/repo/issues/1',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/org/repo/issues/2',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/org/repo/issues/3',
+            },
+            'story2',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/org/repo/issues/4',
+            },
+            'story2',
+          ],
+        ],
+        expectedGetIssueByUrlCalls: [
+          ['https://github.com/org/repo/issues/123'],
+          ['https://github.com/org/repo/issues/1'],
+          ['https://github.com/org/repo/issues/2'],
+          ['https://github.com/org/repo/issues/456'],
+          ['https://github.com/org/repo/issues/3'],
+          ['https://github.com/org/repo/issues/4'],
+        ],
       },
       {
         name: 'should skip regular stories',
@@ -767,10 +895,16 @@ Some description without checkboxes`,
           const storyIssuesByUrl = new Map(
             input.issues.map((issue) => [issue.url, issue]),
           );
-          mockIssueRepository.getIssueByUrl.mockImplementation(
-            async (url) =>
-              storyIssuesByUrl.get(url) ?? { ...mock<Issue>(), url },
-          );
+          mockIssueRepository.getIssueByUrl.mockImplementation(async (url) => {
+            const storyIssue = storyIssuesByUrl.get(url);
+            if (storyIssue) {
+              return storyIssue;
+            }
+            return {
+              ...mock<Issue>(),
+              url,
+            };
+          });
 
           const useCase = new ConvertCheckboxToIssueInStoryIssueUseCase(
             mockIssueRepository,

package/src/domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase.ts

@@ -21,7 +21,7 @@ export class ConvertCheckboxToIssueInStoryIssueUseCase {
     storyObjectMap: StoryObjectMap;
   }): Promise<void> => {
     const story = input.project.story;
-    if (!story || input.cacheUsed) {
+    if (!story) {
       return;
     }