github-issue-tower-defence-management 1.119.4 → 1.121.0

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

@@ -9,6 +9,66 @@ import {
 import { LocalStorageCacheRepository } from '../LocalStorageCacheRepository';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 import { Project } from '../../../domain/entities/Project';
+import { ProjectRepository } from '../../../domain/usecases/adapter-interfaces/ProjectRepository';
+import { DateRepository } from '../../../domain/usecases/adapter-interfaces/DateRepository';
+
+const buildTestProject = (id: string): Project => ({
+  id,
+  url: 'https://github.com/orgs/o/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  status: { name: 'Status', fieldId: 'f-status', statuses: [] },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+const buildCachedIssueRecord = (url: string, title: string) => ({
+  nameWithOwner: 'o/r',
+  url,
+  title,
+  number: 1,
+  state: 'OPEN',
+  labels: [],
+  assignees: [],
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  status: null,
+  story: null,
+  org: 'o',
+  repo: 'r',
+  body: '',
+  itemId: 'item-cached',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: '2026-07-01T00:00:00.000Z',
+  author: '',
+  closingIssueReferenceUrls: [],
+});
+
+const buildProjectItem = (url: string, title: string): ProjectItem => ({
+  id: `item-${title}`,
+  nameWithOwner: 'o/r',
+  number: 1,
+  title,
+  state: 'OPEN',
+  url,
+  body: null,
+  labels: [],
+  assignees: [],
+  createdAt: '2026-07-01T00:00:00.000Z',
+  updatedAt: '2026-07-06T00:00:00.000Z',
+  author: '',
+  closingIssueReferenceUrls: [],
+  customFields: [],
+});
 
 describe('ApiV3CheerioRestIssueRepository', () => {
   describe('convertProjectItemToIssue', () => {
@@ -35,6 +95,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
             labels: [],
             assignees: [],
             createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-02T00:00:00Z',
             author: 'test-author',
             closingIssueReferenceUrls: [
               'https://github.com/HiromiShikata/test-repository/issues/7',
@@ -91,6 +152,7 @@ describe('ApiV3CheerioRestIssueRepository', () => {
             labels: [],
             assignees: [],
             createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-02T00:00:00Z',
             author: '',
             closingIssueReferenceUrls: [],
             customFields: [
@@ -139,57 +201,133 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       expect(result).toEqual(arg.expected);
     });
   });
-  describe('getAllIssuesFromCache', () => {
-    const testCases: {
-      name: string;
-      params: Parameters<
-        ApiV3CheerioRestIssueRepository['getAllIssuesFromCache']
-      >;
-      expected: Awaited<
-        ReturnType<ApiV3CheerioRestIssueRepository['getAllIssuesFromCache']>
-      >;
-    }[] = [
-      {
-        name: 'normal case',
-        params: ['test-key', 1],
-        expected: null,
-      },
-    ];
-    test.each(testCases)('%s', async (arg) => {
-      const { repository, localStorageCacheRepository } =
-        createApiV3CheerioRestIssueRepository();
-      localStorageCacheRepository.getLatest.mockResolvedValue({
-        timestamp: new Date('2000-01-01'),
-        value: [],
-      });
-      const result = await repository.getAllIssuesFromCache(...arg.params);
-      expect(result).toEqual(arg.expected);
+  describe('getAllIssues full fetch', () => {
+    it('fetches the project and all items when no cache exists', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      const project = buildTestProject('test-project-id');
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+      projectRepository.getProject.mockResolvedValue(project);
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('test-project-id');
+
+      expect(result.issues).toEqual([]);
+      expect(result.project).toBe(project);
+      expect(result.cacheUsed).toBe(false);
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).toHaveBeenCalledWith('test-project-id');
+      expect(localStorageCacheRepository.setSingle).toHaveBeenCalledTimes(1);
+    });
+
+    it('memoizes the refresh so a second call does not fetch again', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('test-project-id'),
+      );
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      await repository.getAllIssues('test-project-id');
+      await repository.getAllIssues('test-project-id');
+
+      expect(
+        graphqlProjectItemRepository.fetchProjectItems,
+      ).toHaveBeenCalledTimes(1);
     });
   });
-  describe('getAllIssues', () => {
-    const testCases: {
-      name: string;
-      params: Parameters<ApiV3CheerioRestIssueRepository['getAllIssues']>;
-      expected: Awaited<
-        ReturnType<ApiV3CheerioRestIssueRepository['getAllIssues']>
-      >;
-    }[] = [
-      {
-        name: 'normal case',
-        params: ['test-project-id', 1],
-        expected: { issues: [], cacheUsed: false },
-      },
-    ];
-    test.each(testCases)('%s', async (arg) => {
+
+  describe('getAllIssues incremental fetch', () => {
+    it('reuses the cached project, upserts changed issues by url, and marks cacheUsed', async () => {
       const {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
       } = createApiV3CheerioRestIssueRepository();
+      const cachedProject = buildTestProject('cached-project');
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:30:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:00:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: cachedProject,
+        issues: [
+          buildCachedIssueRecord(
+            'https://github.com/o/r/issues/1',
+            'stale title',
+          ),
+        ],
+      });
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([
+        buildProjectItem('https://github.com/o/r/issues/1', 'fresh title'),
+        buildProjectItem('https://github.com/o/r/issues/2', 'new issue'),
+      ]);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      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 titlesByUrl = new Map(
+        result.issues.map((issue) => [issue.url, issue.title]),
+      );
+      expect(titlesByUrl.get('https://github.com/o/r/issues/1')).toBe(
+        'fresh title',
+      );
+      expect(titlesByUrl.get('https://github.com/o/r/issues/2')).toBe(
+        'new issue',
+      );
+      expect(result.issues).toHaveLength(2);
+    });
+
+    it('performs a full fetch when the hourly gate has elapsed', async () => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T02:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue({
+        lastFetchedAt: '2026-07-07T00:50:00.000Z',
+        lastFullFetchAt: '2026-07-07T00:00:00.000Z',
+        project: buildTestProject('cached-project'),
+        issues: [],
+      });
+      const freshProject = buildTestProject('fresh-project');
+      projectRepository.getProject.mockResolvedValue(freshProject);
       graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
-      localStorageCacheRepository.set.mockResolvedValue();
-      const result = await repository.getAllIssues(...arg.params);
-      expect(result).toEqual(arg.expected);
+      localStorageCacheRepository.setSingle.mockResolvedValue();
+
+      const result = await repository.getAllIssues('cached-project');
+
+      expect(result.cacheUsed).toBe(false);
+      expect(result.project).toBe(freshProject);
+      expect(projectRepository.getProject).toHaveBeenCalledWith(
+        'cached-project',
+      );
     });
   });
 
@@ -199,7 +337,14 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         repository,
         graphqlProjectItemRepository,
         localStorageCacheRepository,
+        projectRepository,
+        dateRepository,
       } = createApiV3CheerioRestIssueRepository();
+      dateRepository.now.mockResolvedValue(new Date('2026-07-07T00:00:00Z'));
+      localStorageCacheRepository.getSingle.mockResolvedValue(null);
+      projectRepository.getProject.mockResolvedValue(
+        buildTestProject('test-project-id'),
+      );
       const fetchError = new Error(
         'fetchProjectItems: expected 5 items but accumulated 1',
       );
@@ -207,10 +352,10 @@ describe('ApiV3CheerioRestIssueRepository', () => {
         fetchError,
       );
 
-      await expect(
-        repository.getAllIssues('test-project-id', 1),
-      ).rejects.toThrow(fetchError);
-      expect(localStorageCacheRepository.set).not.toHaveBeenCalled();
+      await expect(repository.getAllIssues('test-project-id')).rejects.toThrow(
+        fetchError,
+      );
+      expect(localStorageCacheRepository.setSingle).not.toHaveBeenCalled();
     });
   });
 
@@ -1979,6 +2124,8 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     const restIssueRepository = mock<RestIssueRepository>();
     const graphqlProjectItemRepository = mock<GraphqlProjectItemRepository>();
     const localStorageCacheRepository = mock<LocalStorageCacheRepository>();
+    const projectRepository = mock<ProjectRepository>();
+    const dateRepository = mock<DateRepository>();
     const localStorageRepository = mock<LocalStorageRepository>();
     const sleep = jest.fn().mockResolvedValue(undefined);
 
@@ -1987,6 +2134,8 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       restIssueRepository,
       graphqlProjectItemRepository,
       localStorageCacheRepository,
+      projectRepository,
+      dateRepository,
       localStorageRepository,
       'dummy',
       sleep,
@@ -2006,6 +2155,8 @@ describe('ApiV3CheerioRestIssueRepository', () => {
       restIssueRepository,
       graphqlProjectItemRepository,
       localStorageCacheRepository,
+      projectRepository,
+      dateRepository,
       sleep,
     };
   };

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

@@ -23,6 +23,8 @@ import { BaseGitHubRepository } from '../BaseGitHubRepository';
 import { normalizeFieldName } from '../utils';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 import { Member } from '../../../domain/entities/Member';
+import { ProjectRepository } from '../../../domain/usecases/adapter-interfaces/ProjectRepository';
+import { DateRepository } from '../../../domain/usecases/adapter-interfaces/DateRepository';
 import {
   Sleep,
   realSleep,
@@ -31,6 +33,15 @@ import {
   hasRateLimitSignals,
 } from './githubRateLimitRetry';
 
+export const FULL_ISSUE_FETCH_INTERVAL_MS = 60 * 60 * 1000;
+
+export type CachedProjectIssues = {
+  lastFetchedAt: string;
+  lastFullFetchAt: string;
+  project: Project;
+  issues: Issue[];
+};
+
 type TimelineItem = {
   __typename: string;
   willCloseTarget?: boolean;
@@ -494,8 +505,10 @@ export class ApiV3CheerioRestIssueRepository
     >,
     readonly localStorageCacheRepository: Pick<
       LocalStorageCacheRepository,
-      'getLatest' | 'set'
+      'getSingle' | 'setSingle'
     >,
+    readonly projectRepository: Pick<ProjectRepository, 'getProject'>,
+    readonly dateRepository: DateRepository,
     readonly localStorageRepository: LocalStorageRepository,
     readonly ghToken: string = process.env.GH_TOKEN || 'dummy',
     readonly sleep: Sleep = realSleep,
@@ -503,6 +516,11 @@ export class ApiV3CheerioRestIssueRepository
     super(localStorageRepository, ghToken);
   }
 
+  private readonly getAllIssuesRefreshMemo = new Map<
+    Project['id'],
+    { issues: Issue[]; project: Project; cacheUsed: boolean }
+  >();
+
   private fetchWithRateLimitRetry = (
     request: () => Promise<Response>,
   ): Promise<Response> => fetchWithGitHubRateLimitRetry(request, this.sleep);
@@ -578,91 +596,158 @@ export class ApiV3CheerioRestIssueRepository
       closingIssueReferenceUrls: item.closingIssueReferenceUrls,
     };
   };
-  getAllIssuesFromCache = async (
-    cacheKey: string,
-    allowCacheMinutes: number,
-  ): Promise<Issue[] | null> => {
-    const cache = await this.localStorageCacheRepository.getLatest(cacheKey);
-    if (cache) {
-      const now = new Date();
-      const cacheTimestamp = cache.timestamp;
-      const diff = now.getTime() - cacheTimestamp.getTime();
-      if (diff < allowCacheMinutes * 60 * 1000) {
-        if (!Array.isArray(cache.value)) {
-          return null;
-        }
-        const issues = cache.value
-          .filter(
-            (issue: unknown): issue is object => typeof issue === 'object',
+  private restoreIssuesFromCache = (rawIssues: unknown): Issue[] | null => {
+    if (!Array.isArray(rawIssues)) {
+      return null;
+    }
+    const issues = rawIssues
+      .filter(
+        (issue: unknown): issue is object =>
+          typeof issue === 'object' && issue !== null,
+      )
+      .map((issue: object): object => {
+        const nextActionDate =
+          !('nextActionDate' in issue) ||
+          typeof issue.nextActionDate !== 'string' ||
+          issue.nextActionDate === null
+            ? null
+            : new Date(issue.nextActionDate);
+        const completionDate50PercentConfidence =
+          !('completionDate50PercentConfidence' in issue) ||
+          typeof issue.completionDate50PercentConfidence !== 'string'
+            ? null
+            : new Date(issue.completionDate50PercentConfidence);
+        const createdAt =
+          !('createdAt' in issue) || typeof issue.createdAt !== 'string'
+            ? new Date()
+            : new Date(issue.createdAt);
+        const closingIssueReferenceUrls =
+          'closingIssueReferenceUrls' in issue &&
+          Array.isArray(issue.closingIssueReferenceUrls) &&
+          issue.closingIssueReferenceUrls.every(
+            (url): url is string => typeof url === 'string',
           )
-          .map((issue: object): object => {
-            const nextActionDate =
-              !('nextActionDate' in issue) ||
-              typeof issue.nextActionDate !== 'string' ||
-              issue.nextActionDate === null
-                ? null
-                : new Date(issue.nextActionDate);
-            const completionDate50PercentConfidence =
-              !('completionDate50PercentConfidence' in issue) ||
-              typeof issue.completionDate50PercentConfidence !== 'string'
-                ? null
-                : new Date(issue.completionDate50PercentConfidence);
-            const createdAt =
-              !('createdAt' in issue) || typeof issue.createdAt !== 'string'
-                ? new Date()
-                : new Date(issue.createdAt);
-            const closingIssueReferenceUrls =
-              'closingIssueReferenceUrls' in issue &&
-              Array.isArray(issue.closingIssueReferenceUrls) &&
-              issue.closingIssueReferenceUrls.every(
-                (url): url is string => typeof url === 'string',
-              )
-                ? issue.closingIssueReferenceUrls
-                : [];
-
-            return {
-              ...issue,
-              nextActionDate: nextActionDate,
-              completionDate50PercentConfidence:
-                completionDate50PercentConfidence,
-              createdAt: createdAt,
-              closingIssueReferenceUrls: closingIssueReferenceUrls,
-            };
-          });
+            ? issue.closingIssueReferenceUrls
+            : [];
+
+        return {
+          ...issue,
+          nextActionDate: nextActionDate,
+          completionDate50PercentConfidence: completionDate50PercentConfidence,
+          createdAt: createdAt,
+          closingIssueReferenceUrls: closingIssueReferenceUrls,
+        };
+      });
 
-        if (typia.is<Issue[]>(issues)) {
-          return issues;
-        }
-      }
+    if (typia.is<Issue[]>(issues)) {
+      return issues;
     }
     return null;
   };
 
+  private readCachedProjectIssues = async (
+    cacheKey: string,
+  ): Promise<CachedProjectIssues | null> => {
+    const raw = await this.localStorageCacheRepository.getSingle(cacheKey);
+    if (typeof raw !== 'object' || raw === null) {
+      return null;
+    }
+    if (
+      !('lastFetchedAt' in raw) ||
+      typeof raw.lastFetchedAt !== 'string' ||
+      !('lastFullFetchAt' in raw) ||
+      typeof raw.lastFullFetchAt !== 'string' ||
+      !('project' in raw) ||
+      !('issues' in raw)
+    ) {
+      return null;
+    }
+    if (!typia.is<Project>(raw.project)) {
+      return null;
+    }
+    const issues = this.restoreIssuesFromCache(raw.issues);
+    if (!issues) {
+      return null;
+    }
+    return {
+      lastFetchedAt: raw.lastFetchedAt,
+      lastFullFetchAt: raw.lastFullFetchAt,
+      project: raw.project,
+      issues,
+    };
+  };
+
+  private toDateString = (date: Date): string =>
+    `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`;
+
   getAllIssues = async (
     projectId: Project['id'],
-    allowCacheMinutes: number,
   ): Promise<{
     issues: Issue[];
+    project: Project;
     cacheUsed: boolean;
   }> => {
-    const cacheKey = `allIssues-${projectId}`;
-    const cachedIssues = await this.getAllIssuesFromCache(
-      cacheKey,
-      allowCacheMinutes,
-    );
-    if (cachedIssues) {
-      return { issues: cachedIssues, cacheUsed: true };
+    const memoized = this.getAllIssuesRefreshMemo.get(projectId);
+    if (memoized) {
+      return memoized;
     }
-    const issues = await this.getAllIssuesFromGitHub(projectId);
-    await this.localStorageCacheRepository.set(cacheKey, issues);
-    return { issues, cacheUsed: false };
+    const result = await this.refreshAllIssues(projectId);
+    this.getAllIssuesRefreshMemo.set(projectId, result);
+    return result;
   };
-  getAllIssuesFromGitHub = async (
+
+  private refreshAllIssues = async (
     projectId: Project['id'],
-  ): Promise<Issue[]> => {
-    const items =
-      await this.graphqlProjectItemRepository.fetchProjectItems(projectId);
-    return items.map((item) => this.convertProjectItemToIssue(item));
+  ): Promise<{ issues: Issue[]; project: Project; cacheUsed: boolean }> => {
+    const cacheKey = `allIssues-${projectId}`;
+    const now = await this.dateRepository.now();
+    const cache = await this.readCachedProjectIssues(cacheKey);
+    const isFullFetch =
+      cache === null ||
+      now.getTime() - new Date(cache.lastFullFetchAt).getTime() >=
+        FULL_ISSUE_FETCH_INTERVAL_MS;
+
+    if (isFullFetch) {
+      const project = await this.projectRepository.getProject(projectId);
+      if (!project) {
+        throw new Error(`Project not found. projectId: ${projectId}`);
+      }
+      const items =
+        await this.graphqlProjectItemRepository.fetchProjectItems(projectId);
+      const issues = items.map((item) => this.convertProjectItemToIssue(item));
+      const nowIso = now.toISOString();
+      await this.localStorageCacheRepository.setSingle(cacheKey, {
+        lastFetchedAt: nowIso,
+        lastFullFetchAt: nowIso,
+        project,
+        issues,
+      } satisfies CachedProjectIssues);
+      return { issues, project, cacheUsed: false };
+    }
+
+    const project = cache.project;
+    const overlapStartDate = new Date(cache.lastFetchedAt);
+    overlapStartDate.setUTCDate(overlapStartDate.getUTCDate() - 1);
+    const changedItems =
+      await this.graphqlProjectItemRepository.fetchProjectItems(
+        projectId,
+        `updated:>=${this.toDateString(overlapStartDate)}`,
+      );
+    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);
+    }
+    const issues = Array.from(issuesByUrl.values());
+    await this.localStorageCacheRepository.setSingle(cacheKey, {
+      lastFetchedAt: now.toISOString(),
+      lastFullFetchAt: cache.lastFullFetchAt,
+      project,
+      issues,
+    } satisfies CachedProjectIssues);
+    return { issues, project, cacheUsed: true };
   };
   createNewIssue = async (
     org: string,
@@ -1307,19 +1392,13 @@ export class ApiV3CheerioRestIssueRepository
     return Array.from(relatedPRsMap.values());
   };
 
-  getAllOpened = async (
-    project: Project,
-    allowCacheMinutes: number,
-  ): Promise<Issue[]> => {
-    const { issues } = await this.getAllIssues(project.id, allowCacheMinutes);
+  getAllOpened = async (project: Project): Promise<Issue[]> => {
+    const { issues } = await this.getAllIssues(project.id);
     return issues.filter((issue) => !issue.isClosed);
   };
 
-  getStoryObjectMap = async (
-    project: Project,
-    allowCacheMinutes: number,
-  ): Promise<StoryObjectMap> => {
-    const { issues } = await this.getAllIssues(project.id, allowCacheMinutes);
+  getStoryObjectMap = async (project: Project): Promise<StoryObjectMap> => {
+    const { issues } = await this.getAllIssues(project.id);
     const storyObjectMap: StoryObjectMap = new Map();
     const targetStories = project.story?.stories || [];
     for (const story of targetStories) {