github-issue-tower-defence-management 1.107.0 → 1.109.0

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

@@ -0,0 +1,354 @@
+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,
+  resolveProjectCacheTtlMs,
+} from './GraphqlProjectRepository';
+import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+import { Project } from '../../domain/entities/Project';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+const projectId = 'PVT_project123';
+
+const getProjectResponse = {
+  data: {
+    node: {
+      id: projectId,
+      databaseId: 1,
+      title: 'A project',
+      shortDescription: '',
+      public: true,
+      closed: false,
+      createdAt: '2024-01-01T00:00:00.000Z',
+      updatedAt: '2024-01-01T00:00:00.000Z',
+      number: 49,
+      url: 'https://github.com/users/owner/projects/49',
+      fields: {
+        nodes: [
+          {
+            id: 'PVTSSF_status',
+            databaseId: 10,
+            name: 'Status',
+            dataType: 'SINGLE_SELECT',
+            options: [
+              { id: 'st1', name: 'Todo', description: '', color: 'GRAY' },
+            ],
+          },
+        ],
+      },
+    },
+  },
+};
+
+const expectedProject: Project = {
+  id: projectId,
+  url: 'https://github.com/users/owner/projects/49',
+  databaseId: 1,
+  name: 'A project',
+  status: {
+    name: 'Status',
+    fieldId: 'PVTSSF_status',
+    statuses: [{ id: 'st1', name: 'Todo', color: 'GRAY', description: '' }],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+};
+
+const fetchProjectIdResponse = {
+  data: {
+    organization: null,
+    user: { projectV2: { id: projectId, databaseId: 1 } },
+  },
+};
+
+type CacheEntry = { value: object; timestamp: Date } | null;
+
+const buildCacheStub = (overrides?: {
+  getLatest?: jest.Mock;
+  set?: jest.Mock;
+}): Pick<LocalStorageCacheRepository, 'getLatest' | 'set'> & {
+  getLatest: jest.Mock;
+  set: jest.Mock;
+} => ({
+  getLatest: overrides?.getLatest ?? jest.fn().mockResolvedValue(null),
+  set: overrides?.set ?? jest.fn().mockResolvedValue(undefined),
+});
+
+describe('GraphqlProjectRepository disk cache', () => {
+  const localStorageRepository = new LocalStorageRepository();
+  const thirtyMinutesMs = 30 * 60 * 1000;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockPost.mockReset();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('resolveProjectCacheTtlMs', () => {
+    it('defaults to 30 minutes when unset', () => {
+      expect(resolveProjectCacheTtlMs(undefined)).toBe(thirtyMinutesMs);
+    });
+
+    it('uses the configured millisecond value when valid', () => {
+      expect(resolveProjectCacheTtlMs('60000')).toBe(60000);
+    });
+
+    it('falls back to the default for non-numeric or negative values', () => {
+      expect(resolveProjectCacheTtlMs('abc')).toBe(thirtyMinutesMs);
+      expect(resolveProjectCacheTtlMs('-1')).toBe(thirtyMinutesMs);
+    });
+  });
+
+  describe('getProject', () => {
+    it('fetches via GraphQL and writes the cache on a cache miss', async () => {
+      const cache = buildCacheStub();
+      mockPost.mockReturnValueOnce(mockJsonResponse(getProjectResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      expect(cache.set).toHaveBeenCalledWith(
+        `project-${projectId}`,
+        expectedProject,
+      );
+    });
+
+    it('returns the cached project without any GraphQL call when the cache is fresh', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: expectedProject,
+          timestamp: new Date(),
+        } satisfies CacheEntry),
+      });
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).not.toHaveBeenCalled();
+      expect(cache.set).not.toHaveBeenCalled();
+    });
+
+    it('refetches via GraphQL when the cached entry is older than the TTL', async () => {
+      const staleTimestamp = new Date(Date.now() - thirtyMinutesMs - 1);
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: expectedProject,
+          timestamp: staleTimestamp,
+        } satisfies CacheEntry),
+      });
+      mockPost.mockReturnValueOnce(mockJsonResponse(getProjectResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      expect(cache.set).toHaveBeenCalledTimes(1);
+    });
+
+    it('falls back to a live GraphQL fetch when the cache read throws', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockRejectedValue(new Error('corrupted file')),
+      });
+      mockPost.mockReturnValueOnce(mockJsonResponse(getProjectResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+
+    it('falls back to a live GraphQL fetch when the cached value is malformed', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: { unexpected: 'shape' },
+          timestamp: new Date(),
+        } satisfies CacheEntry),
+      });
+      mockPost.mockReturnValueOnce(mockJsonResponse(getProjectResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+
+    it('respects a custom TTL passed to the constructor', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: expectedProject,
+          timestamp: new Date(Date.now() - 2000),
+        } satisfies CacheEntry),
+      });
+      mockPost.mockReturnValueOnce(mockJsonResponse(getProjectResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+        1000,
+      );
+
+      const project = await repository.getProject(projectId);
+
+      expect(project).toEqual(expectedProject);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('fetchProjectId', () => {
+    it('fetches via GraphQL and writes the cache on a cache miss', async () => {
+      const cache = buildCacheStub();
+      mockPost.mockReturnValueOnce(mockJsonResponse(fetchProjectIdResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const result = await repository.fetchProjectId('owner', 49);
+
+      expect(result).toBe(projectId);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      expect(cache.set).toHaveBeenCalledWith('projectId-owner:49', {
+        projectId,
+      });
+    });
+
+    it('returns the disk-cached project ID without any GraphQL call', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: { projectId },
+          timestamp: new Date(),
+        } satisfies CacheEntry),
+      });
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const result = await repository.fetchProjectId('owner', 49);
+
+      expect(result).toBe(projectId);
+      expect(mockPost).not.toHaveBeenCalled();
+      expect(cache.set).not.toHaveBeenCalled();
+    });
+
+    it('does not apply a TTL to the project ID cache because the mapping is static', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockResolvedValue({
+          value: { projectId },
+          timestamp: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000),
+        } satisfies CacheEntry),
+      });
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const result = await repository.fetchProjectId('owner', 49);
+
+      expect(result).toBe(projectId);
+      expect(mockPost).not.toHaveBeenCalled();
+    });
+
+    it('falls back to a live GraphQL fetch when the project ID cache read throws', async () => {
+      const cache = buildCacheStub({
+        getLatest: jest.fn().mockRejectedValue(new Error('corrupted file')),
+      });
+      mockPost.mockReturnValueOnce(mockJsonResponse(fetchProjectIdResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      const result = await repository.fetchProjectId('owner', 49);
+
+      expect(result).toBe(projectId);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+
+    it('serves the second call from the in-memory L1 cache without a disk read', async () => {
+      const cache = buildCacheStub();
+      mockPost.mockReturnValueOnce(mockJsonResponse(fetchProjectIdResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+        cache,
+      );
+
+      await repository.fetchProjectId('owner', 49);
+      await repository.fetchProjectId('owner', 49);
+
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      expect(cache.getLatest).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('without a cache repository', () => {
+    it('still works using the in-memory cache only', async () => {
+      mockPost.mockReturnValueOnce(mockJsonResponse(fetchProjectIdResponse));
+      const repository = new GraphqlProjectRepository(
+        localStorageRepository,
+        'dummy',
+      );
+
+      const result = await repository.fetchProjectId('owner', 49);
+
+      expect(result).toBe(projectId);
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -1,11 +1,32 @@
 import ky from 'ky';
+import typia from 'typia';
 import { BaseGitHubRepository } from './BaseGitHubRepository';
+import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
 import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
 import { FieldOption, Project } from '../../domain/entities/Project';
 import { normalizeFieldName } from './utils';
 
 const ONE_HOUR_MS = 60 * 60 * 1000;
 
+const DEFAULT_PROJECT_CACHE_TTL_MS = 30 * 60 * 1000;
+
+export const resolveProjectCacheTtlMs = (
+  rawValue: string | undefined,
+): number => {
+  if (rawValue === undefined) {
+    return DEFAULT_PROJECT_CACHE_TTL_MS;
+  }
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_PROJECT_CACHE_TTL_MS;
+  }
+  return parsed;
+};
+
+const PROJECT_ID_DISK_CACHE_KEY_PREFIX = 'projectId';
+const PROJECT_DISK_CACHE_KEY_PREFIX = 'project';
+
 export const convertToFieldOptionColor = (
   color: string,
 ): FieldOption['color'] => {
@@ -38,6 +59,111 @@ export class GraphqlProjectRepository
 {
   private readonly projectIdCache = new Map<string, string>();
   private readonly fetchProjectIdFailedAt = new Map<string, number>();
+  private readonly projectCache?: Pick<
+    LocalStorageCacheRepository,
+    'getLatest' | 'set'
+  >;
+  private readonly projectCacheTtlMs: number;
+
+  constructor(
+    localStorageRepository: LocalStorageRepository,
+    ghToken: string = process.env.GH_TOKEN || 'dummy',
+    projectCache?: Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>,
+    projectCacheTtlMs: number = resolveProjectCacheTtlMs(
+      process.env.TDPM_PROJECT_CACHE_TTL_MS,
+    ),
+  ) {
+    super(localStorageRepository, ghToken);
+    this.projectCache = projectCache;
+    this.projectCacheTtlMs = projectCacheTtlMs;
+  }
+
+  private readProjectIdFromDiskCache = async (
+    cacheKey: string,
+  ): Promise<string | null> => {
+    if (!this.projectCache) {
+      return null;
+    }
+    let cache: { value: object; timestamp: Date } | null;
+    try {
+      cache = await this.projectCache.getLatest(
+        `${PROJECT_ID_DISK_CACHE_KEY_PREFIX}-${cacheKey}`,
+      );
+    } catch (error) {
+      return null;
+    }
+    if (!cache) {
+      return null;
+    }
+    if (
+      'projectId' in cache.value &&
+      typeof cache.value.projectId === 'string'
+    ) {
+      return cache.value.projectId;
+    }
+    return null;
+  };
+
+  private writeProjectIdToDiskCache = async (
+    cacheKey: string,
+    projectId: string,
+  ): Promise<void> => {
+    if (!this.projectCache) {
+      return;
+    }
+    try {
+      await this.projectCache.set(
+        `${PROJECT_ID_DISK_CACHE_KEY_PREFIX}-${cacheKey}`,
+        { projectId },
+      );
+    } catch (error) {
+      return;
+    }
+  };
+
+  private readProjectFromDiskCache = async (
+    projectId: string,
+  ): Promise<Project | null> => {
+    if (!this.projectCache) {
+      return null;
+    }
+    let cache: { value: object; timestamp: Date } | null;
+    try {
+      cache = await this.projectCache.getLatest(
+        `${PROJECT_DISK_CACHE_KEY_PREFIX}-${projectId}`,
+      );
+    } catch (error) {
+      return null;
+    }
+    if (!cache) {
+      return null;
+    }
+    const age = Date.now() - cache.timestamp.getTime();
+    if (age >= this.projectCacheTtlMs) {
+      return null;
+    }
+    if (!typia.is<Project>(cache.value)) {
+      return null;
+    }
+    return cache.value;
+  };
+
+  private writeProjectToDiskCache = async (
+    projectId: string,
+    project: Project,
+  ): Promise<void> => {
+    if (!this.projectCache) {
+      return;
+    }
+    try {
+      await this.projectCache.set(
+        `${PROJECT_DISK_CACHE_KEY_PREFIX}-${projectId}`,
+        project,
+      );
+    } catch (error) {
+      return;
+    }
+  };
 
   extractProjectFromUrl = (
     projectUrl: string,
@@ -60,6 +186,11 @@ export class GraphqlProjectRepository
     if (cached) {
       return cached;
     }
+    const diskCached = await this.readProjectIdFromDiskCache(cacheKey);
+    if (diskCached) {
+      this.projectIdCache.set(cacheKey, diskCached);
+      return diskCached;
+    }
     const failedAt = this.fetchProjectIdFailedAt.get(cacheKey);
     if (failedAt !== undefined && Date.now() - failedAt < ONE_HOUR_MS) {
       throw new Error(
@@ -139,6 +270,7 @@ export class GraphqlProjectRepository
       );
     }
     this.projectIdCache.set(cacheKey, projectId);
+    await this.writeProjectIdToDiskCache(cacheKey, projectId);
     return projectId;
   };
   findProjectIdByUrl = async (
@@ -148,6 +280,10 @@ export class GraphqlProjectRepository
     return await this.fetchProjectId(owner, projectNumber);
   };
   getProject = async (projectId: Project['id']): Promise<Project | null> => {
+    const diskCached = await this.readProjectFromDiskCache(projectId);
+    if (diskCached) {
+      return diskCached;
+    }
     const query = `query GetProjectV2($projectId: ID!) {
   node(id: $projectId) {
     ... on ProjectV2 {
@@ -292,7 +428,7 @@ export class GraphqlProjectRepository
     const completionDate50PercentConfidence = project.fields.nodes.find(
       (field) => normalizeFieldName(field.name).startsWith('completiondate'),
     );
-    return {
+    const result: Project = {
       id: project.id,
       url: project.url,
       databaseId: project.databaseId,
@@ -353,6 +489,8 @@ export class GraphqlProjectRepository
           }
         : null,
     };
+    await this.writeProjectToDiskCache(projectId, result);
+    return result;
   };
   getByUrl = async (url: string): Promise<Project> => {
     const projectId = await this.findProjectIdByUrl(url);

package/src/adapter/repositories/LocalStorageCacheRepository.test.ts

@@ -15,6 +15,7 @@ describe('LocalStorageCacheRepository', () => {
       listFiles: jest.fn(),
       read: jest.fn(),
       write: jest.fn(),
+      rename: jest.fn(),
       mkdir: jest.fn(),
       remove: jest.fn(),
     };
@@ -69,6 +70,19 @@ describe('LocalStorageCacheRepository', () => {
           timestamp: new Date('2024-01-01T00:00:00.000Z'),
         },
       },
+      {
+        name: 'ignores in-progress temp files and reads the latest committed file',
+        key: 'test-key',
+        files: [
+          '2024-01-01T00:00:00.000Z.json',
+          '2024-01-01T00:00:01.000Z.json.1234.abc.tmp',
+        ],
+        fileContent: '{"test": "value"}',
+        expected: {
+          value: { test: 'value' },
+          timestamp: new Date('2024-01-01T00:00:00.000Z'),
+        },
+      },
     ];
 
     test.each(testCases)(
@@ -137,11 +151,30 @@ describe('LocalStorageCacheRepository', () => {
         expect(localStorageRepository.mkdir).toHaveBeenCalledWith(
           expectedDirPath,
         );
-        expect(localStorageRepository.write).toHaveBeenCalledWith(
+        const writeArgs = localStorageRepository.write.mock.calls[0];
+        const writtenPath = writeArgs[0];
+        expect(writtenPath.startsWith(`${expectedFilePath}.`)).toBe(true);
+        expect(writtenPath.endsWith('.tmp')).toBe(true);
+        expect(writeArgs[1]).toBe(expectedContent);
+        expect(localStorageRepository.rename).toHaveBeenCalledWith(
+          writtenPath,
           expectedFilePath,
-          expectedContent,
         );
       },
     );
+
+    test('writes to the temp file before renaming it into place', async () => {
+      const callOrder: string[] = [];
+      localStorageRepository.write.mockImplementation(() => {
+        callOrder.push('write');
+      });
+      localStorageRepository.rename.mockImplementation(() => {
+        callOrder.push('rename');
+      });
+
+      await repository.set('ordering-key', { ordered: true });
+
+      expect(callOrder).toEqual(['write', 'rename']);
+    });
   });
 });

package/src/adapter/repositories/LocalStorageCacheRepository.ts

@@ -15,6 +15,7 @@ export class LocalStorageCacheRepository {
     const dirPath = `${this.cachePath}/${key}`;
     const latestFile = this.localStorageRepository
       .listFiles(dirPath)
+      .filter((fileName) => !fileName.endsWith('.tmp'))
       .sort((a, b) => a.localeCompare(b))
       .reverse()[0];
     if (!latestFile) {
@@ -45,9 +46,9 @@ export class LocalStorageCacheRepository {
     const dirPath = `${this.cachePath}/${key}`;
     this.localStorageRepository.mkdir(dirPath);
     const timestamp = new Date().toISOString();
-    this.localStorageRepository.write(
-      `${dirPath}/${timestamp}.json`,
-      JSON.stringify(value),
-    );
+    const finalPath = `${dirPath}/${timestamp}.json`;
+    const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    this.localStorageRepository.write(tmpPath, JSON.stringify(value));
+    this.localStorageRepository.rename(tmpPath, finalPath);
   };
 }

package/src/adapter/repositories/LocalStorageRepository.test.ts

@@ -15,6 +15,7 @@ describe('LocalStorageRepository', () => {
   let mockReaddirSync: jest.SpyInstance;
   let mockMkdirSync: jest.SpyInstance;
   let mockExistsSync: jest.SpyInstance;
+  let mockRenameSync: jest.SpyInstance;
 
   beforeEach(() => {
     repository = new LocalStorageRepository();
@@ -23,6 +24,7 @@ describe('LocalStorageRepository', () => {
     mockReaddirSync = jest.spyOn(fs, 'readdirSync').mockImplementation();
     mockMkdirSync = jest.spyOn(fs, 'mkdirSync').mockImplementation();
     mockExistsSync = jest.spyOn(fs, 'existsSync').mockImplementation();
+    mockRenameSync = jest.spyOn(fs, 'renameSync').mockImplementation();
   });
 
   afterEach(() => {
@@ -59,6 +61,16 @@ describe('LocalStorageRepository', () => {
     });
   });
 
+  describe('rename', () => {
+    test('renames a file from the old path to the new path', () => {
+      repository.rename('/path/to/file.txt.tmp', '/path/to/file.txt');
+      expect(mockRenameSync).toHaveBeenCalledWith(
+        '/path/to/file.txt.tmp',
+        '/path/to/file.txt',
+      );
+    });
+  });
+
   describe('read', () => {
     const testCases: Array<{
       name: string;

package/src/adapter/repositories/LocalStorageRepository.ts

@@ -9,6 +9,9 @@ export class LocalStorageRepository {
   read = (path: string): string | null => {
     return fs.readFileSync(path, 'utf8');
   };
+  rename = (oldPath: string, newPath: string) => {
+    fs.renameSync(oldPath, newPath);
+  };
   listFiles = (dirPath: string): string[] => {
     if (!fs.existsSync(dirPath)) {
       return [];