npm - github-issue-tower-defence-management - Versions diffs - 1.122.0 → 1.122.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-syKbd_lW.js"></script>
+    <script type="module" crossorigin src="/assets/index-CC-RYye2.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D0RwhyOM.css">
   </head>
   <body>

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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();