github-issue-tower-defence-management 1.36.3 → 1.37.1

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.test.ts

@@ -25,12 +25,16 @@ const mockJsonResponse = <T>(data: T) => ({
 });
 
 describe('GraphqlProjectItemRepository', () => {
-  const makePageResponse = (hasNextPage: boolean, endCursor: string) =>
+  const makePageResponse = (
+    hasNextPage: boolean,
+    endCursor: string,
+    totalCount = 2,
+  ) =>
     mockJsonResponse({
       data: {
         node: {
           items: {
-            totalCount: 2,
+            totalCount,
             pageInfo: {
               endCursor,
               startCursor: 'cursor-start',
@@ -101,6 +105,174 @@ describe('GraphqlProjectItemRepository', () => {
       setTimeoutSpy.mockRestore();
     });
 
+    it('should throw when response contains GraphQL errors alongside partial data', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 1,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [
+                  {
+                    id: 'item-partial',
+                    fieldValues: { nodes: [] },
+                    content: {
+                      repository: { nameWithOwner: 'owner/repo' },
+                      number: 1,
+                      title: 'Partial Issue',
+                      state: 'OPEN',
+                      url: 'https://github.com/owner/repo/issues/1',
+                      body: 'body',
+                      createdAt: '2024-01-01T00:00:00Z',
+                      labels: { nodes: [] },
+                      assignees: { nodes: [] },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          errors: [{ message: 'RATE_LIMITED' }],
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('GitHub GraphQL errors: RATE_LIMITED');
+    });
+
+    it('should throw when data is null in response', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: null,
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('No data returned from GitHub API');
+    });
+
+    it('should throw when node is null in response', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: { node: null },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow('No data returned from GitHub API');
+    });
+
+    it('should throw when accumulated nodes count does not match totalCount', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 5,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [
+                  {
+                    id: 'item-1',
+                    fieldValues: { nodes: [] },
+                    content: {
+                      repository: { nameWithOwner: 'owner/repo' },
+                      number: 1,
+                      title: 'Test Issue',
+                      state: 'OPEN',
+                      url: 'https://github.com/owner/repo/issues/1',
+                      body: 'body',
+                      createdAt: '2024-01-01T00:00:00Z',
+                      labels: { nodes: [] },
+                      assignees: { nodes: [] },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow(
+        'fetchProjectItems: expected 5 items but accumulated 1',
+      );
+    });
+
+    it('should throw when page has no nodes but totalCount is positive', async () => {
+      const localStorageRepository = new LocalStorageRepository();
+      const repository = new GraphqlProjectItemRepository(
+        localStorageRepository,
+        '',
+        'dummy-token',
+      );
+
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 2,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [],
+              },
+            },
+          },
+        }),
+      );
+
+      await expect(
+        repository.fetchProjectItems('test-project-id'),
+      ).rejects.toThrow(
+        'fetchProjectItems: expected 2 items but accumulated 0',
+      );
+    });
+
     it('should not sleep on first request when there is only one page', async () => {
       const localStorageRepository = new LocalStorageRepository();
       const repository = new GraphqlProjectItemRepository(
@@ -110,7 +282,7 @@ describe('GraphqlProjectItemRepository', () => {
       );
 
       const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1'));
+      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
 
       const result = await repository.fetchProjectItems('test-project-id');
 

package/src/adapter/repositories/issue/GraphqlProjectItemRepository.ts

@@ -281,17 +281,31 @@ query GetProjectItems($projectId: ID!, $after: String) {
                   };
                 }[];
               };
-            };
-          };
+            } | null;
+          } | null;
+          errors?: { message: string }[];
         }>();
-      if (!response.data) {
+      if (response.errors && response.errors.length > 0) {
+        throw new Error(
+          `GitHub GraphQL errors: ${response.errors.map((e) => e.message).join('; ')}`,
+        );
+      }
+      const rawData = response.data;
+      if (!rawData) {
+        throw new Error('No data returned from GitHub API');
+      }
+      const rawNode = rawData.node;
+      if (rawNode === null) {
         throw new Error('No data returned from GitHub API');
       }
-      return response.data;
+      return { node: rawNode };
     };
     const issues: ProjectItem[] = [];
     let after: string | null = null;
     let hasNextPage = true;
+    let totalCount = 0;
+    let cumulativeRawNodes = 0;
+    let pageIndex = 0;
 
     while (hasNextPage) {
       if (after !== null) {
@@ -300,6 +314,14 @@ query GetProjectItems($projectId: ID!, $after: String) {
         );
       }
       const data = await callGraphql(projectId, after);
+      const pageNodes = data.node.items.nodes;
+      const pageInfo = data.node.items.pageInfo;
+      totalCount = data.node.items.totalCount;
+      cumulativeRawNodes += pageNodes.length;
+      pageIndex++;
+      console.log(
+        `fetchProjectItems: page ${pageIndex}, nodes: ${pageNodes.length}, cumulative: ${cumulativeRawNodes}/${totalCount}`,
+      );
       const projectItems: {
         id: string;
         fieldValues: {
@@ -324,43 +346,57 @@ query GetProjectItems($projectId: ID!, $after: String) {
           labels: { nodes: { name: string }[] };
           assignees: { nodes: { login: string }[] };
         };
-      }[] = data.node.items.nodes;
-      projectItems
-        // .filter(item => item.content.repository !== undefined)
-        .forEach((item) => {
-          if (!item || !item.content || !item.content.repository) {
-            return;
-          }
-          issues.push({
-            id: item.id,
-            nameWithOwner: item.content.repository.nameWithOwner,
-            number: item.content.number,
-            title: item.content.title,
-            state: this.convertStrToState(item.content.state),
-            url: item.content.url,
-            body: item.content.body,
-            labels: item.content.labels?.nodes?.map((l) => l.name) || [],
-            assignees: item.content.assignees?.nodes?.map((a) => a.login) || [],
-            createdAt: item.content.createdAt || new Date().toISOString(),
-            customFields: item.fieldValues.nodes
-              .filter((field) => !!field.field)
-              .map((field) => {
-                return {
-                  name: field.field.name,
-                  value:
-                    field.name ??
-                    field.text ??
-                    field.number?.toString() ??
-                    field.date ??
-                    null,
-                };
-              }),
-          });
+      }[] = pageNodes;
+      projectItems.forEach((item) => {
+        if (!item || !item.content || !item.content.repository) {
+          return;
+        }
+        issues.push({
+          id: item.id,
+          nameWithOwner: item.content.repository.nameWithOwner,
+          number: item.content.number,
+          title: item.content.title,
+          state: this.convertStrToState(item.content.state),
+          url: item.content.url,
+          body: item.content.body,
+          labels: item.content.labels?.nodes?.map((l) => l.name) || [],
+          assignees: item.content.assignees?.nodes?.map((a) => a.login) || [],
+          createdAt: item.content.createdAt || new Date().toISOString(),
+          customFields: item.fieldValues.nodes
+            .filter((field) => !!field.field)
+            .map((field) => {
+              return {
+                name: field.field.name,
+                value:
+                  field.name ??
+                  field.text ??
+                  field.number?.toString() ??
+                  field.date ??
+                  null,
+              };
+            }),
         });
-      const pageInfo = data.node.items.pageInfo;
+      });
+      if (
+        pageNodes.length === 100 &&
+        !pageInfo.hasNextPage &&
+        cumulativeRawNodes < totalCount
+      ) {
+        throw new Error(
+          `fetchProjectItems: page ${pageIndex} has ${pageNodes.length} nodes with hasNextPage=false but only ${cumulativeRawNodes}/${totalCount} items accumulated`,
+        );
+      }
       hasNextPage = pageInfo.hasNextPage;
       after = pageInfo.endCursor;
     }
+    console.log(
+      `fetchProjectItems: completed, totalCount: ${totalCount}, cumulativeRawNodes: ${cumulativeRawNodes}, issues: ${issues.length}`,
+    );
+    if (cumulativeRawNodes !== totalCount) {
+      throw new Error(
+        `fetchProjectItems: expected ${totalCount} items but accumulated ${cumulativeRawNodes}`,
+      );
+    }
     return issues;
   };
   getProjectItemFieldsFromIssueUrl = async (

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

@@ -0,0 +1,325 @@
+import { mock } from 'jest-mock-extended';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ClearPastNextActionDateHourUseCase } from './ClearPastNextActionDateHourUseCase';
+import { Project } from '../entities/Project';
+import { Issue } from '../entities/Issue';
+
+describe('ClearPastNextActionDateHourUseCase', () => {
+  jest.setTimeout(60 * 1000);
+  const mockIssueRepository = mock<IssueRepository>();
+
+  const nextActionHourField = {
+    name: 'Next Action Hour',
+    fieldId: 'hourFieldId',
+  };
+  const nextActionDateField = {
+    name: 'Next Action Date',
+    fieldId: 'dateFieldId',
+  };
+
+  const basicProject = {
+    ...mock<Project>(),
+    nextActionHour: nextActionHourField,
+    nextActionDate: nextActionDateField,
+  };
+
+  const openIssueWithHour = {
+    ...mock<Issue>(),
+    state: 'OPEN' as const,
+    nextActionHour: 10,
+    nextActionDate: null,
+  };
+
+  const openIssueWithDateOnly = {
+    ...mock<Issue>(),
+    state: 'OPEN' as const,
+    nextActionHour: null,
+    nextActionDate: new Date('2026-04-01T00:00:00'),
+  };
+
+  describe('run', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    const testCases: {
+      name: string;
+      input: {
+        targetDates: Date[];
+        project: Project;
+        issues: Issue[];
+        cacheUsed: boolean;
+      };
+      expectedClearProjectFieldCalls: [Project, string, Issue][];
+    }[] = [
+      {
+        name: 'should not clear anything when targetDates is empty',
+        input: {
+          targetDates: [],
+          project: basicProject,
+          issues: [openIssueWithDateOnly],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should not clear anything when project has no nextActionDate and no nextActionHour',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: null,
+          },
+          issues: [openIssueWithDateOnly],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should clear nextActionDate for issue with only nextActionDate set and date is before today',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: nextActionDateField,
+          },
+          issues: [
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [
+          [
+            {
+              ...basicProject,
+              nextActionHour: null,
+              nextActionDate: nextActionDateField,
+            },
+            'dateFieldId',
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+        ],
+      },
+      {
+        name: 'should clear nextActionDate when date is today',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: nextActionDateField,
+          },
+          issues: [
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-02T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [
+          [
+            {
+              ...basicProject,
+              nextActionHour: null,
+              nextActionDate: nextActionDateField,
+            },
+            'dateFieldId',
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-02T00:00:00'),
+            },
+          ],
+        ],
+      },
+      {
+        name: 'should not clear nextActionDate when date is in the future',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: nextActionDateField,
+          },
+          issues: [
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-03T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should not clear nextActionDate when issue has nextActionHour set (handled by hour path)',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: nextActionDateField,
+          },
+          issues: [
+            {
+              ...mock<Issue>(),
+              state: 'OPEN' as const,
+              nextActionHour: 9,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should not clear nextActionDate when issue state is not OPEN',
+        input: {
+          targetDates: [new Date('2026-04-02T10:00:00')],
+          project: {
+            ...basicProject,
+            nextActionHour: null,
+            nextActionDate: nextActionDateField,
+          },
+          issues: [
+            {
+              ...openIssueWithDateOnly,
+              state: 'CLOSED' as const,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should clear nextActionHour and nextActionDate for issue with past nextActionHour at HH:45 target',
+        input: {
+          targetDates: [
+            new Date('2026-04-02T09:45:00'),
+            new Date('2026-04-02T09:46:00'),
+          ],
+          project: basicProject,
+          issues: [
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [
+          [
+            basicProject,
+            'hourFieldId',
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+          [
+            basicProject,
+            'dateFieldId',
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+        ],
+      },
+      {
+        name: 'should not clear nextActionHour when no HH:45 in targetDates',
+        input: {
+          targetDates: [
+            new Date('2026-04-02T09:00:00'),
+            new Date('2026-04-02T09:01:00'),
+          ],
+          project: basicProject,
+          issues: [
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [],
+      },
+      {
+        name: 'should clear both nextActionDate-only issues and nextActionHour issues in same run',
+        input: {
+          targetDates: [
+            new Date('2026-04-02T09:45:00'),
+            new Date('2026-04-02T09:46:00'),
+          ],
+          project: basicProject,
+          issues: [
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+          cacheUsed: false,
+        },
+        expectedClearProjectFieldCalls: [
+          [
+            basicProject,
+            'hourFieldId',
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+          [
+            basicProject,
+            'dateFieldId',
+            {
+              ...openIssueWithHour,
+              nextActionHour: 10,
+              nextActionDate: null,
+            },
+          ],
+          [
+            basicProject,
+            'dateFieldId',
+            {
+              ...openIssueWithDateOnly,
+              nextActionDate: new Date('2026-04-01T00:00:00'),
+            },
+          ],
+        ],
+      },
+    ];
+
+    testCases.forEach(({ name, input, expectedClearProjectFieldCalls }) => {
+      it(name, async () => {
+        jest.clearAllMocks();
+        const useCase = new ClearPastNextActionDateHourUseCase(
+          mockIssueRepository,
+        );
+        await useCase.run(input);
+        expect(mockIssueRepository.clearProjectField.mock.calls).toEqual(
+          expectedClearProjectFieldCalls,
+        );
+      });
+    });
+  });
+});