github-issue-tower-defence-management 1.122.0 → 1.122.1

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

@@ -5,6 +5,7 @@ import { RestIssueRepository } from './RestIssueRepository';
 import {
   GraphqlProjectItemRepository,
   ProjectItem,
+  ProjectItemLight,
 } from './GraphqlProjectItemRepository';
 import { LocalStorageCacheRepository } from '../LocalStorageCacheRepository';
 import { LocalStorageRepository } from '../LocalStorageRepository';
@@ -70,6 +71,17 @@ const buildProjectItem = (url: string, title: string): ProjectItem => ({
   customFields: [],
 });
 
+const buildLightItem = (
+  id: string,
+  url: string,
+  updatedAt: string,
+): ProjectItemLight => ({
+  id,
+  updatedAt,
+  url,
+  number: 1,
+});
+
 describe('ApiV3CheerioRestIssueRepository', () => {
   describe('convertProjectItemToIssue', () => {
     const testCases: {
@@ -254,7 +266,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
   });
 
   describe('getAllIssues incremental fetch', () => {
-    it('reuses the cached project, upserts changed issues by url, and marks cacheUsed', async () => {
+    it('light-scans the lastFetchedAt UTC day with no previous-day overlap, detail-fetches changed items by id, and upserts by url', async () => {
       const {
         repository,
         graphqlProjectItemRepository,
@@ -263,9 +275,9 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         dateRepository,
       } = createApiV3CheerioRestIssueRepository();
       const cachedProject = buildTestProject('cached-project');
-      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:30:00Z'));
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
       localStorageCacheRepository.getSingle.mockResolvedValue({
-        lastFetchedAt: '2026-07-07T00:00:00.000Z',
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
         lastFullFetchAt: '2026-07-07T00:00:00.000Z',
         project: cachedProject,
         issues: [
@@ -275,7 +287,19 @@ describe('ApiV3CheerioRestIssueRepository', () => {
           ),
         ],
       });
-      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
+        buildLightItem(
+          'item-fresh',
+          'https://github.com/o/r/issues/1',
+          '2026-07-07T00:40:00.000Z',
+        ),
+        buildLightItem(
+          'item-new',
+          'https://github.com/o/r/issues/2',
+          '2026-07-07T00:44:00.000Z',
+        ),
+      ]);
+      graphqlProjectItemRepository.fetchProjectItemsByIds.mockResolvedValue([
         buildProjectItem('https://github.com/o/r/issues/1', 'fresh title'),
         buildProjectItem('https://github.com/o/r/issues/2', 'new issue'),
       ]);
@@ -286,9 +310,16 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       expect(result.cacheUsed).toBe(true);
       expect(result.project).toBe(cachedProject);
       expect(projectRepository.getProject).not.toHaveBeenCalled();
-      const call = graphqlProjectItemRepository.fetchProjectItems.mock.calls[0];
-      expect(call[0]).toBe('cached-project');
-      expect(call[1]).toBe('updated:>=2026-07-06');
+      const lightCall =
+        graphqlProjectItemRepository.fetchProjectItemsLight.mock.calls[0];
+      expect(lightCall[0]).toBe('cached-project');
+      expect(lightCall[1]).toBe('updated:>=2026-07-07');
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).not.toHaveBeenCalled();
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemsByIds,
+      ).toHaveBeenCalledWith(['item-fresh', 'item-new']);
       const titlesByUrl = new Map(
         result.issues.map((issue) => [issue.url, issue.title]),
       );
@@ -299,6 +330,143 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         'new issue',
       );
       expect(result.issues).toHaveLength(2);
+      const cacheWrite = localStorageCacheRepository.setSingle.mock.calls[0][1];
+      expect(cacheWrite).toEqual(
+        expect.objectContaining({
+          lastFetchedAt: '2026-07-07T00:45:00.000Z',
+          lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        }),
+      );
+    });
+
+    it('includes items within the clock-skew buffer before lastFetchedAt and excludes items older than the buffer', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: buildTestProject('cached-project'),
+        issues: [],
+      });
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
+        buildLightItem(
+          'wellBefore',
+          'https://github.com/o/r/issues/1',
+          '2026-07-07T00:20:00.000Z',
+        ),
+        buildLightItem(
+          'withinBuffer',
+          'https://github.com/o/r/issues/2',
+          '2026-07-07T00:27:00.000Z',
+        ),
+        buildLightItem(
+          'atLastFetched',
+          'https://github.com/o/r/issues/3',
+          '2026-07-07T00:30:00.000Z',
+        ),
+        buildLightItem(
+          'after',
+          'https://github.com/o/r/issues/4',
+          '2026-07-07T00:40:00.000Z',
+        ),
+      ]);
+      graphqlProjectItemRepository.fetchProjectItemsByIds.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      await repository.getAllIssues('cached-project');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemsByIds,
+      ).toHaveBeenCalledWith(['withinBuffer', 'atLastFetched', 'after']);
+    });
+
+    it('applies the skew buffer across a UTC-midnight boundary, scanning the previous UTC day rather than today', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:30:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:02:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: buildTestProject('cached-project'),
+        issues: [],
+      });
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
+        buildLightItem(
+          'previousDay',
+          'https://github.com/o/r/issues/1',
+          '2026-07-06T23:58:00.000Z',
+        ),
+        buildLightItem(
+          'beforeBuffer',
+          'https://github.com/o/r/issues/2',
+          '2026-07-06T23:55:00.000Z',
+        ),
+      ]);
+      graphqlProjectItemRepository.fetchProjectItemsByIds.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      await repository.getAllIssues('cached-project');
+
+      const lightCall =
+        graphqlProjectItemRepository.fetchProjectItemsLight.mock.calls[0];
+      expect(lightCall[1]).toBe('updated:>=2026-07-06');
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemsByIds,
+      ).toHaveBeenCalledWith(['previousDay']);
+    });
+
+    it('skips the detail fetch entirely when no light item changed since lastFetchedAt', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:45:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:30:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: buildTestProject('cached-project'),
+        issues: [
+          buildCachedIssueRecord(
+            'https://github.com/o/r/issues/1',
+            'unchanged title',
+          ),
+        ],
+      });
+      graphqlProjectItemRepository.fetchProjectItemsLight.mockResolvedValue([
+        buildLightItem(
+          'stale',
+          'https://github.com/o/r/issues/1',
+          '2026-07-07T00:10:00.000Z',
+        ),
+      ]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItemsByIds,
+      ).not.toHaveBeenCalled();
+      expect(result.cacheUsed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].title).toBe('unchanged title');
+      const cacheWrite = localStorageCacheRepository.setSingle.mock.calls[0][1];
+      expect(cacheWrite).toEqual(
+        expect.objectContaining({
+          lastFetchedAt: '2026-07-07T00:45:00.000Z',
+          lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        }),
+      );
     });
 
     it('performs a full fetch when the hourly gate has elapsed', async () => {

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

@@ -34,6 +34,7 @@ import {
 } from './githubRateLimitRetry';
 
 export const FULL_ISSUE_FETCH_INTERVAL_MS = 60 * 60 * 1000;
+export const INCREMENTAL_FETCH_SKEW_BUFFER_MS = 5 * 60 * 1000;
 
 export type CachedProjectIssues = {
   lastFetchedAt: string;
@@ -497,6 +498,8 @@ export class ApiV3CheerioRestIssueRepository
     readonly graphqlProjectItemRepository: Pick<
       GraphqlProjectItemRepository,
       | 'fetchProjectItems'
+      | 'fetchProjectItemsLight'
+      | 'fetchProjectItemsByIds'
       | 'fetchProjectItemByUrl'
       | 'updateProjectField'
       | 'clearProjectField'
@@ -726,19 +729,30 @@ export class ApiV3CheerioRestIssueRepository
     }
 
     const project = cache.project;
-    const overlapStartDate = new Date(cache.lastFetchedAt);
-    overlapStartDate.setUTCDate(overlapStartDate.getUTCDate() - 1);
-    const changedItems =
-      await this.graphqlProjectItemRepository.fetchProjectItems(
+    const lastFetchedAt = new Date(cache.lastFetchedAt);
+    const cutoff = new Date(
+      lastFetchedAt.getTime() - INCREMENTAL_FETCH_SKEW_BUFFER_MS,
+    );
+    const lightItems =
+      await this.graphqlProjectItemRepository.fetchProjectItemsLight(
         projectId,
-        `updated:>=${this.toDateString(overlapStartDate)}`,
+        `updated:>=${this.toDateString(cutoff)}`,
       );
+    const changedItemIds = lightItems
+      .filter((item) => new Date(item.updatedAt).getTime() >= cutoff.getTime())
+      .map((item) => item.id);
     const issuesByUrl = new Map<string, Issue>(
       cache.issues.map((issue) => [issue.url, issue]),
     );
-    for (const item of changedItems) {
-      const issue = this.convertProjectItemToIssue(item);
-      issuesByUrl.set(issue.url, issue);
+    if (changedItemIds.length > 0) {
+      const changedItems =
+        await this.graphqlProjectItemRepository.fetchProjectItemsByIds(
+          changedItemIds,
+        );
+      for (const item of changedItems) {
+        const issue = this.convertProjectItemToIssue(item);
+        issuesByUrl.set(issue.url, issue);
+      }
     }
     const issues = Array.from(issuesByUrl.values());
     await this.localStorageCacheRepository.setSingle(cacheKey, {

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

@@ -604,6 +604,300 @@ describe('GraphqlProjectItemRepository', () => {
     }, 30000);
   });
 
+  const extractRequestedVariablesFromMockCall = (
+    call: unknown,
+  ): Record<string, unknown> | undefined => {
+    if (!Array.isArray(call)) {
+      return undefined;
+    }
+    const second: unknown = call[1];
+    if (!isRecord(second)) {
+      return undefined;
+    }
+    const json: unknown = second.json;
+    if (!isRecord(json)) {
+      return undefined;
+    }
+    const variables: unknown = json.variables;
+    return isRecord(variables) ? variables : undefined;
+  };
+
+  describe('fetchProjectItemsLight', () => {
+    const makeLightPageResponse = (
+      hasNextPage: boolean,
+      endCursor: string,
+      nodes: {
+        id: string;
+        updatedAt: string;
+        content: { url: string; number: number } | null;
+      }[],
+      totalCount = nodes.length,
+    ) =>
+      mockJsonResponse({
+        data: {
+          node: {
+            items: {
+              totalCount,
+              pageInfo: { endCursor, hasNextPage },
+              nodes,
+            },
+          },
+        },
+      });
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+      mockPost.mockReset();
+    });
+
+    it('requests only id, updatedAt and content url/number without fieldValues and passes the query filter', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(
+        makeLightPageResponse(false, 'cursor-1', [
+          {
+            id: 'PVTI_1',
+            updatedAt: '2026-07-07T10:00:00Z',
+            content: {
+              url: 'https://github.com/o/r/issues/1',
+              number: 1,
+            },
+          },
+        ]),
+      );
+
+      const result = await repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+
+      const sentQuery = extractRequestedQueryFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentQuery).toContain('updatedAt');
+      expect(sentQuery).toContain('url');
+      expect(sentQuery).toContain('number');
+      expect(sentQuery).not.toContain('fieldValues');
+      const sentVariables = extractRequestedVariablesFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentVariables?.query).toBe('updated:>=2026-07-07');
+      expect(result).toEqual([
+        {
+          id: 'PVTI_1',
+          updatedAt: '2026-07-07T10:00:00Z',
+          url: 'https://github.com/o/r/issues/1',
+          number: 1,
+        },
+      ]);
+    });
+
+    it('paginates all pages and accumulates every light item', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            true,
+            'cursor-1',
+            [
+              {
+                id: 'PVTI_1',
+                updatedAt: '2026-07-07T10:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+              },
+            ],
+            2,
+          ),
+        )
+        .mockReturnValueOnce(
+          makeLightPageResponse(
+            false,
+            'cursor-2',
+            [
+              {
+                id: 'PVTI_2',
+                updatedAt: '2026-07-07T11:00:00Z',
+                content: { url: 'https://github.com/o/r/issues/2', number: 2 },
+              },
+            ],
+            2,
+          ),
+        );
+
+      const resultPromise = repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+      await jest.advanceTimersByTimeAsync(PAGINATION_DELAY_MS);
+      const result = await resultPromise;
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      expect(result.map((item) => item.id)).toEqual(['PVTI_1', 'PVTI_2']);
+    });
+
+    it('skips nodes whose content has no url (draft items) but still counts them for totalCount', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(
+        makeLightPageResponse(
+          false,
+          'cursor-1',
+          [
+            {
+              id: 'PVTI_draft',
+              updatedAt: '2026-07-07T10:00:00Z',
+              content: null,
+            },
+            {
+              id: 'PVTI_1',
+              updatedAt: '2026-07-07T10:00:00Z',
+              content: { url: 'https://github.com/o/r/issues/1', number: 1 },
+            },
+          ],
+          2,
+        ),
+      );
+
+      const result = await repository.fetchProjectItemsLight(
+        'test-project-id',
+        'updated:>=2026-07-07',
+      );
+
+      expect(result.map((item) => item.id)).toEqual(['PVTI_1']);
+    });
+  });
+
+  describe('fetchProjectItemsByIds', () => {
+    const makeByIdsResponse = (nodes: (Record<string, unknown> | null)[]) =>
+      mockJsonResponse({
+        data: {
+          nodes,
+        },
+      });
+
+    const makeDetailNode = (id: string, url: string, title: string) => ({
+      id,
+      fieldValues: {
+        nodes: [
+          {
+            name: 'In Progress',
+            field: { name: 'Status' },
+          },
+        ],
+      },
+      content: {
+        repository: { nameWithOwner: 'o/r' },
+        number: 1,
+        title,
+        state: 'OPEN',
+        url,
+        createdAt: '2026-07-01T00:00:00Z',
+        updatedAt: '2026-07-07T10:00:00Z',
+        author: { login: 'octocat' },
+        labels: { nodes: [{ name: 'bug' }] },
+        assignees: { nodes: [{ login: 'octocat' }] },
+      },
+    });
+
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+      mockPost.mockReset();
+    });
+
+    it('returns an empty array and makes no request when ids is empty', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+
+      const result = await repository.fetchProjectItemsByIds([]);
+
+      expect(result).toEqual([]);
+      expect(mockPost).not.toHaveBeenCalled();
+    });
+
+    it('fetches full detail via nodes(ids:) and maps each to a ProjectItem', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(
+        makeByIdsResponse([
+          makeDetailNode('PVTI_1', 'https://github.com/o/r/issues/1', 'first'),
+          null,
+        ]),
+      );
+
+      const result = await repository.fetchProjectItemsByIds(['PVTI_1', 'bad']);
+
+      const sentQuery = extractRequestedQueryFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentQuery).toContain('nodes(ids: $ids)');
+      expect(sentQuery).toContain('... on ProjectV2Item');
+      expect(sentQuery).toContain('fieldValues');
+      const sentVariables = extractRequestedVariablesFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentVariables?.ids).toEqual(['PVTI_1', 'bad']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual(
+        expect.objectContaining({
+          id: 'PVTI_1',
+          url: 'https://github.com/o/r/issues/1',
+          title: 'first',
+          body: null,
+          labels: ['bug'],
+          assignees: ['octocat'],
+          customFields: [{ name: 'Status', value: 'In Progress' }],
+        }),
+      );
+    });
+
+    it('batches ids into groups of at most 100', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      const ids = Array.from(
+        { length: 150 },
+        (_unused, index) => `PVTI_${index}`,
+      );
+      mockPost
+        .mockReturnValueOnce(makeByIdsResponse([]))
+        .mockReturnValueOnce(makeByIdsResponse([]));
+
+      const resultPromise = repository.fetchProjectItemsByIds(ids);
+      await jest.advanceTimersByTimeAsync(PAGINATION_DELAY_MS);
+      await resultPromise;
+
+      expect(mockPost).toHaveBeenCalledTimes(2);
+      const firstBatch = extractRequestedVariablesFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      const secondBatch = extractRequestedVariablesFromMockCall(
+        mockPost.mock.calls[1],
+      );
+      expect(firstBatch?.ids).toHaveLength(100);
+      expect(secondBatch?.ids).toHaveLength(50);
+    });
+  });
+
   describe('callWithRateLimitRetry', () => {
     beforeEach(() => {
       jest.useFakeTimers();