github-issue-tower-defence-management 1.153.6 → 1.154.1

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -5,36 +5,23 @@ import { ProjectIssuesCacheRepository } from './ProjectIssuesCacheRepository';
 import { LocalStorageRepository } from './LocalStorageRepository';
 import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
 import { FieldOption, Project } from '../../domain/entities/Project';
+import { RequiredProjectFieldDefinition } from '../../domain/entities/RequiredProjectField';
 import {
-  DEPENDED_ISSUE_URL_FIELD_NAME,
-  NEXT_ACTION_DATE_FIELD_NAME,
-  NEXT_ACTION_HOUR_FIELD_NAME,
-  RequiredProjectFieldDefinition,
-  STORY_FIELD_NAME,
-} from '../../domain/entities/RequiredProjectField';
-import { normalizeFieldName } from './utils';
+  ProjectFieldDefinition,
+  convertToFieldOptionColor,
+  projectFromDefinition,
+} from './projectFieldDefinition';
+import {
+  ProjectLocation,
+  RestProjectRepository,
+  projectLocationFromUrl,
+} from './RestProjectRepository';
 
 const ONE_HOUR_MS = 60 * 60 * 1000;
 
 const PROJECT_ID_DISK_CACHE_KEY_PREFIX = 'projectId';
 
-export const convertToFieldOptionColor = (
-  color: string,
-): FieldOption['color'] => {
-  switch (color) {
-    case 'RED':
-    case 'YELLOW':
-    case 'GREEN':
-    case 'BLUE':
-    case 'PURPLE':
-    case 'ORANGE':
-    case 'PINK':
-    case 'GRAY':
-      return color;
-    default:
-      return 'GRAY';
-  }
-};
+const PROJECT_LOCATION_DISK_CACHE_KEY_PREFIX = 'projectLocation';
 
 export class GraphqlProjectRepository
   extends BaseGitHubRepository
@@ -52,11 +39,13 @@ export class GraphqlProjectRepository
 {
   private readonly projectIdCache = new Map<string, string>();
   private readonly fetchProjectIdFailedAt = new Map<string, number>();
+  private readonly projectLocationCache = new Map<string, ProjectLocation>();
   private readonly projectCache?: Pick<
     LocalStorageCacheRepository,
     'getLatest' | 'set'
   >;
   private readonly projectIssuesCacheRepository: ProjectIssuesCacheRepository | null;
+  private readonly restProjectRepository: RestProjectRepository;
 
   constructor(
     localStorageRepository: LocalStorageRepository,
@@ -72,8 +61,87 @@ export class GraphqlProjectRepository
       projectCache === undefined
         ? null
         : new ProjectIssuesCacheRepository(projectCache);
+    this.restProjectRepository = new RestProjectRepository(
+      localStorageRepository,
+      ghToken,
+    );
   }
 
+  private readProjectLocationFromDiskCache = async (
+    projectId: Project['id'],
+  ): Promise<ProjectLocation | null> => {
+    if (!this.projectCache) {
+      return null;
+    }
+    let cache: { value: object; timestamp: Date } | null;
+    try {
+      cache = await this.projectCache.getLatest(
+        `${PROJECT_LOCATION_DISK_CACHE_KEY_PREFIX}-${projectId}`,
+      );
+    } catch (error) {
+      console.warn(
+        `GraphqlProjectRepository: reading the project location disk cache failed, falling back to the GraphQL project query. projectId: ${projectId}, error: ${String(error)}`,
+      );
+      return null;
+    }
+    if (!cache) {
+      return null;
+    }
+    const value: unknown = cache.value;
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      !('owner' in value) ||
+      !('ownerType' in value) ||
+      !('projectNumber' in value) ||
+      typeof value.owner !== 'string' ||
+      typeof value.projectNumber !== 'number' ||
+      (value.ownerType !== 'users' && value.ownerType !== 'orgs')
+    ) {
+      return null;
+    }
+    return {
+      owner: value.owner,
+      ownerType: value.ownerType,
+      projectNumber: value.projectNumber,
+    };
+  };
+
+  private rememberProjectLocation = async (
+    projectId: Project['id'],
+    location: ProjectLocation,
+  ): Promise<void> => {
+    this.projectLocationCache.set(projectId, location);
+    if (!this.projectCache) {
+      return;
+    }
+    try {
+      await this.projectCache.set(
+        `${PROJECT_LOCATION_DISK_CACHE_KEY_PREFIX}-${projectId}`,
+        location,
+      );
+    } catch (error) {
+      console.warn(
+        `GraphqlProjectRepository: writing the project location disk cache failed, every later process will fall back to the GraphQL project query. projectId: ${projectId}, error: ${String(error)}`,
+      );
+    }
+  };
+
+  private findProjectLocation = async (
+    projectId: Project['id'],
+  ): Promise<ProjectLocation | null> => {
+    const cached = this.projectLocationCache.get(projectId);
+    if (cached) {
+      return cached;
+    }
+    const diskCached = await this.readProjectLocationFromDiskCache(projectId);
+    if (diskCached) {
+      this.projectLocationCache.set(projectId, diskCached);
+      return diskCached;
+    }
+    return null;
+  };
+
   private readProjectIdFromDiskCache = async (
     cacheKey: string,
   ): Promise<string | null> => {
@@ -237,6 +305,11 @@ export class GraphqlProjectRepository
     }
     this.projectIdCache.set(cacheKey, projectId);
     await this.writeProjectIdToDiskCache(cacheKey, projectId);
+    await this.rememberProjectLocation(projectId, {
+      owner: login,
+      ownerType: response.data.organization?.projectV2?.id ? 'orgs' : 'users',
+      projectNumber,
+    });
     return projectId;
   };
   findProjectIdByUrl = async (
@@ -246,6 +319,23 @@ export class GraphqlProjectRepository
     return await this.fetchProjectId(owner, projectNumber);
   };
   getProject = async (projectId: Project['id']): Promise<Project | null> => {
+    const location = await this.findProjectLocation(projectId);
+    if (location) {
+      const project = await this.restProjectRepository.getProject(location);
+      if (project) {
+        return project;
+      }
+      console.warn(
+        `GraphqlProjectRepository: the recorded project location no longer resolves over REST, re-reading the project over GraphQL. projectId: ${projectId}, owner: ${location.owner}, projectNumber: ${location.projectNumber}`,
+      );
+      this.projectLocationCache.delete(projectId);
+    }
+    return await this.fetchProjectByGraphql(projectId);
+  };
+
+  private fetchProjectByGraphql = async (
+    projectId: Project['id'],
+  ): Promise<Project | null> => {
     const query = `query GetProjectV2($projectId: ID!) {
   node(id: $projectId) {
     ... on ProjectV2 {
@@ -328,7 +418,7 @@ export class GraphqlProjectRepository
                   title: string;
                 }[];
               };
-              options: {
+              options?: {
                 id: string;
                 name: string;
                 description: string;
@@ -356,103 +446,30 @@ export class GraphqlProjectRepository
     if (!project) {
       return null;
     }
-    const nextActionDate = project.fields.nodes.find(
-      (field) =>
-        normalizeFieldName(field.name) ===
-        normalizeFieldName(NEXT_ACTION_DATE_FIELD_NAME),
-    );
-    const nextActionHour = project.fields.nodes.find(
-      (field) =>
-        normalizeFieldName(field.name) ===
-        normalizeFieldName(NEXT_ACTION_HOUR_FIELD_NAME),
-    );
-    const status = project.fields.nodes.find(
-      (field) => normalizeFieldName(field.name) === 'status',
+    const fields: ProjectFieldDefinition[] = project.fields.nodes.map(
+      (field) => ({
+        fieldId: field.id,
+        databaseId: field.databaseId,
+        name: field.name,
+        options: (field.options ?? []).map((option) => ({
+          id: option.id,
+          name: option.name,
+          color: convertToFieldOptionColor(option.color),
+          description: option.description,
+        })),
+      }),
     );
-    if (!status) {
-      throw new Error('status field is not found');
+    const location = projectLocationFromUrl(project.url);
+    if (location) {
+      await this.rememberProjectLocation(project.id, location);
     }
-    const story = project.fields.nodes.find(
-      (field) =>
-        normalizeFieldName(field.name) === normalizeFieldName(STORY_FIELD_NAME),
-    );
-    const workflowManagementStory = story?.options.find((option) =>
-      normalizeFieldName(option.name).includes('workflowmanagement'),
-    );
-    const remainignEstimationMinutes = project.fields.nodes.find(
-      (field) =>
-        normalizeFieldName(field.name) === 'remainingestimationminutes',
-    );
-    const dependedIssueUrlSeparatedByComma = project.fields.nodes.find(
-      (field) =>
-        normalizeFieldName(field.name).startsWith(
-          normalizeFieldName(DEPENDED_ISSUE_URL_FIELD_NAME),
-        ),
-    );
-    const completionDate50PercentConfidence = project.fields.nodes.find(
-      (field) => normalizeFieldName(field.name).startsWith('completiondate'),
-    );
-    return {
+    return projectFromDefinition({
       id: project.id,
       url: project.url,
       databaseId: project.databaseId,
       name: project.title,
-      status: {
-        name: status.name,
-        fieldId: status.id,
-        statuses: status.options.map((option) => ({
-          id: option.id,
-          name: option.name,
-          color: convertToFieldOptionColor(option.color),
-          description: option.description,
-        })),
-      },
-      nextActionDate: nextActionDate
-        ? {
-            name: nextActionDate.name,
-            fieldId: nextActionDate.id,
-          }
-        : null,
-      nextActionHour: nextActionHour
-        ? {
-            name: nextActionHour.name,
-            fieldId: nextActionHour.id,
-          }
-        : null,
-      story:
-        story && workflowManagementStory
-          ? {
-              name: story.name,
-              fieldId: story.id,
-              databaseId: story.databaseId,
-              stories: story.options.map((option) => ({
-                id: option.id,
-                name: option.name,
-                color: convertToFieldOptionColor(option.color),
-                description: option.description,
-              })),
-              workflowManagementStory,
-            }
-          : null,
-      remainingEstimationMinutes: remainignEstimationMinutes
-        ? {
-            name: remainignEstimationMinutes.name,
-            fieldId: remainignEstimationMinutes.id,
-          }
-        : null,
-      dependedIssueUrlSeparatedByComma: dependedIssueUrlSeparatedByComma
-        ? {
-            name: dependedIssueUrlSeparatedByComma.name,
-            fieldId: dependedIssueUrlSeparatedByComma.id,
-          }
-        : null,
-      completionDate50PercentConfidence: completionDate50PercentConfidence
-        ? {
-            name: completionDate50PercentConfidence.name,
-            fieldId: completionDate50PercentConfidence.id,
-          }
-        : null,
-    };
+      fields,
+    });
   };
   getByUrl = async (url: string): Promise<Project> => {
     const projectId = await this.findProjectIdByUrl(url);
@@ -466,44 +483,15 @@ export class GraphqlProjectRepository
     return project;
   };
   listFieldNames = async (project: Project): Promise<string[]> => {
-    const query = `query ListProjectV2FieldNames($projectId: ID!) {
-  node(id: $projectId) {
-    ... on ProjectV2 {
-      fields(first: 100) {
-        nodes {
-          ... on ProjectV2FieldCommon {
-            name
-          }
-        }
-      }
-    }
-  }
-}`;
-    const response = await postGithubGraphqlJson<{
-      data?: {
-        node: {
-          fields: {
-            nodes: { name?: string }[];
-          };
-        } | null;
-      };
-      errors?: { message: string }[];
-    }>({
-      ghToken: this.ghToken,
-      query,
-      variables: { projectId: project.id },
-    });
-    if (!response.data || !response.data.node) {
-      const errorMessages = response.errors
-        ? response.errors.map((e) => e.message).join('; ')
-        : 'no data field in response';
+    const location =
+      projectLocationFromUrl(project.url) ??
+      (await this.findProjectLocation(project.id));
+    if (!location) {
       throw new Error(
-        `GitHub GraphQL API returned no data for listFieldNames: ${errorMessages}`,
+        `listFieldNames: project location is unknown for ${project.id}`,
       );
     }
-    return response.data.node.fields.nodes
-      .map((field) => field.name)
-      .filter((name): name is string => typeof name === 'string');
+    return await this.restProjectRepository.listFieldNames(location);
   };
   createField = async (
     project: Project,

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

@@ -0,0 +1,296 @@
+const mockGet = jest.fn();
+const mockPostGithubGraphqlJson = jest.fn();
+
+jest.mock('ky', () => ({
+  default: {
+    get: mockGet,
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+    extend: jest.fn(),
+    create: jest.fn(),
+    stop: jest.fn(),
+  },
+  __esModule: true,
+}));
+
+jest.mock('./githubGraphqlClient', () => ({
+  postGithubGraphqlJson: mockPostGithubGraphqlJson,
+}));
+
+import { GraphqlProjectRepository } from './GraphqlProjectRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+const projectId = 'PVT_kwHOAGJHa84AFWnr';
+const projectUrl = 'https://github.com/users/HiromiShikata/projects/48';
+
+const restProjectResponse = {
+  id: 1403371,
+  node_id: projectId,
+  title: 'UMINO',
+};
+
+const restFieldsResponse = [
+  {
+    id: 12940049,
+    node_id: 'PVTSSF_status',
+    name: 'Status',
+    options: [
+      {
+        id: 'f75ad846',
+        name: { html: 'Unread', raw: 'Unread' },
+        description: { html: '', raw: '' },
+        color: 'ORANGE',
+      },
+    ],
+  },
+];
+
+const graphqlProjectResponse = {
+  data: {
+    node: {
+      id: projectId,
+      databaseId: 1403371,
+      title: 'UMINO',
+      shortDescription: '',
+      public: true,
+      closed: false,
+      createdAt: '2022-08-27T01:26:40Z',
+      updatedAt: '2026-07-24T08:49:59Z',
+      number: 48,
+      url: projectUrl,
+      fields: {
+        nodes: [
+          {
+            id: 'PVTSSF_status',
+            databaseId: 12940049,
+            name: 'Status',
+            dataType: 'SINGLE_SELECT',
+            options: [
+              {
+                id: 'f75ad846',
+                name: 'Unread',
+                description: '',
+                color: 'ORANGE',
+              },
+            ],
+          },
+        ],
+      },
+    },
+  },
+};
+
+const buildProjectCache = () => {
+  const stored = new Map<string, unknown>();
+  return {
+    stored,
+    getLatest: jest.fn(async (key: string) => {
+      const value = stored.get(key);
+      if (typeof value !== 'object' || value === null) {
+        return null;
+      }
+      return { value, timestamp: new Date('2026-08-15T00:00:00Z') };
+    }),
+    set: jest.fn(async (key: string, value: unknown) => {
+      stored.set(key, value);
+    }),
+    getSingle: jest.fn(async () => null),
+    setSingle: jest.fn(async () => undefined),
+  };
+};
+
+describe('GraphqlProjectRepository project location', () => {
+  const localStorageRepository = new LocalStorageRepository();
+
+  beforeEach(() => {
+    mockGet.mockReset();
+    mockPostGithubGraphqlJson.mockReset();
+    mockGet.mockImplementation((url: string) =>
+      url.endsWith('/fields')
+        ? mockJsonResponse(restFieldsResponse)
+        : mockJsonResponse(restProjectResponse),
+    );
+  });
+
+  it('should read the project over REST and issue no GraphQL query when the location is already recorded', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.stored.set(`projectLocation-${projectId}`, {
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).not.toHaveBeenCalled();
+    expect(mockGet).toHaveBeenCalledWith(
+      'https://api.github.com/users/HiromiShikata/projectsV2/48',
+      expect.anything(),
+    );
+    expect(project?.id).toEqual(projectId);
+    expect(project?.status.statuses).toEqual([
+      { id: 'f75ad846', name: 'Unread', color: 'ORANGE', description: '' },
+    ]);
+  });
+
+  it('should record the location from the project url on the cold start read so the next read goes over REST', async () => {
+    const projectCache = buildProjectCache();
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(projectCache.stored.get(`projectLocation-${projectId}`)).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+
+    const second = await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(second?.id).toEqual(projectId);
+  });
+
+  it('should list the field names over REST from the project url without any GraphQL query', async () => {
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+    );
+
+    const names = await repository.listFieldNames({
+      id: projectId,
+      url: projectUrl,
+      databaseId: 1403371,
+      name: 'UMINO',
+      status: { name: 'Status', fieldId: 'PVTSSF_status', statuses: [] },
+      nextActionDate: null,
+      nextActionHour: null,
+      story: null,
+      remainingEstimationMinutes: null,
+      dependedIssueUrlSeparatedByComma: null,
+      completionDate50PercentConfidence: null,
+    });
+
+    expect(mockPostGithubGraphqlJson).not.toHaveBeenCalled();
+    expect(mockGet).toHaveBeenCalledWith(
+      'https://api.github.com/users/HiromiShikata/projectsV2/48/fields',
+      {
+        searchParams: { per_page: 100 },
+        headers: {
+          Authorization: 'token dummy-token',
+          Accept: 'application/vnd.github+json',
+        },
+      },
+    );
+    expect(names).toEqual(['Status']);
+  });
+
+  it('should warn and fall back to the GraphQL project query when the location cache read throws', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.getLatest.mockRejectedValue(new Error('corrupted file'));
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'reading the project location disk cache failed, falling back to the GraphQL project query',
+      ),
+    );
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('corrupted file'),
+    );
+    warn.mockRestore();
+  });
+
+  it('should warn and still return the project when the location cache write throws', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.set.mockRejectedValue(new Error('disk full'));
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'writing the project location disk cache failed, every later process will fall back to the GraphQL project query',
+      ),
+    );
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('disk full'));
+    warn.mockRestore();
+  });
+
+  it('should discard a recorded location that no longer resolves and re-read the project over GraphQL', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.stored.set(`projectLocation-${projectId}`, {
+      owner: 'RenamedAway',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    mockGet.mockImplementation(() => {
+      throw Object.assign(new Error('Not Found'), {
+        response: { status: 404 },
+      });
+    });
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'the recorded project location no longer resolves over REST, re-reading the project over GraphQL',
+      ),
+    );
+    expect(projectCache.stored.get(`projectLocation-${projectId}`)).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    warn.mockRestore();
+  });
+});