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

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

@@ -0,0 +1,277 @@
+const mockGet = 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,
+}));
+
+import {
+  RestProjectRepository,
+  projectLocationFromUrl,
+  projectUrlFromLocation,
+} from './RestProjectRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+const projectResponse = {
+  id: 1403371,
+  node_id: 'PVT_kwHOAGJHa84AFWnr',
+  title: 'UMINO',
+};
+
+const fieldsResponse = [
+  {
+    id: 12940049,
+    node_id: 'PVTSSF_status',
+    name: 'Status',
+    options: [
+      {
+        id: 'f75ad846',
+        name: { html: 'Unread', raw: 'Unread' },
+        description: { html: '', raw: '' },
+        color: 'ORANGE',
+      },
+      {
+        id: 'e9931e57',
+        name: { html: 'Todo by human', raw: 'Todo by human' },
+        description: { html: 'own queue', raw: 'own queue' },
+        color: 'PINK',
+      },
+    ],
+  },
+  {
+    id: 133939017,
+    node_id: 'PVTSSF_story',
+    name: 'story',
+    options: [
+      {
+        id: '6dc26727',
+        name: {
+          html: 'regular / workflow management',
+          raw: 'regular / workflow management',
+        },
+        description: { html: '', raw: '' },
+        color: 'BLUE',
+      },
+    ],
+  },
+  {
+    id: 35978365,
+    node_id: 'PVTF_nextactiondate',
+    name: 'nextactiondate',
+  },
+];
+
+describe('RestProjectRepository', () => {
+  const localStorageRepository = new LocalStorageRepository();
+  const repository = new RestProjectRepository(
+    localStorageRepository,
+    'dummy-token',
+  );
+  const location = {
+    owner: 'HiromiShikata',
+    ownerType: 'users' as const,
+    projectNumber: 48,
+  };
+
+  afterEach(() => {
+    mockGet.mockReset();
+  });
+
+  describe('listFieldDefinitions', () => {
+    it('should read the fields from the projects REST endpoint and convert the option colors', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse(fieldsResponse));
+
+      const fields = await repository.listFieldDefinitions(location);
+
+      expect(mockGet).toHaveBeenCalledTimes(1);
+      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(fields).toEqual([
+        {
+          fieldId: 'PVTSSF_status',
+          databaseId: 12940049,
+          name: 'Status',
+          options: [
+            {
+              id: 'f75ad846',
+              name: 'Unread',
+              color: 'ORANGE',
+              description: '',
+            },
+            {
+              id: 'e9931e57',
+              name: 'Todo by human',
+              color: 'PINK',
+              description: 'own queue',
+            },
+          ],
+        },
+        {
+          fieldId: 'PVTSSF_story',
+          databaseId: 133939017,
+          name: 'story',
+          options: [
+            {
+              id: '6dc26727',
+              name: 'regular / workflow management',
+              color: 'BLUE',
+              description: '',
+            },
+          ],
+        },
+        {
+          fieldId: 'PVTF_nextactiondate',
+          databaseId: 35978365,
+          name: 'nextactiondate',
+          options: [],
+        },
+      ]);
+    });
+
+    it('should address the organization route for an organization owned project', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse([]));
+
+      await repository.listFieldDefinitions({
+        owner: 'X-Mile',
+        ownerType: 'orgs',
+        projectNumber: 7,
+      });
+
+      expect(mockGet).toHaveBeenCalledWith(
+        'https://api.github.com/orgs/X-Mile/projectsV2/7/fields',
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('listFieldNames', () => {
+    it('should return every field name including the ones the project entity does not keep', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse(fieldsResponse));
+
+      const names = await repository.listFieldNames(location);
+
+      expect(names).toEqual(['Status', 'story', 'nextactiondate']);
+    });
+  });
+
+  describe('getProject', () => {
+    it('should build the project from the REST project and field responses', async () => {
+      mockGet.mockImplementation((url: string) =>
+        url.endsWith('/fields')
+          ? mockJsonResponse(fieldsResponse)
+          : mockJsonResponse(projectResponse),
+      );
+
+      const project = await repository.getProject(location);
+
+      expect(project?.id).toEqual('PVT_kwHOAGJHa84AFWnr');
+      expect(project?.databaseId).toEqual(1403371);
+      expect(project?.name).toEqual('UMINO');
+      expect(project?.url).toEqual(
+        'https://github.com/users/HiromiShikata/projects/48',
+      );
+      expect(project?.status.fieldId).toEqual('PVTSSF_status');
+      expect(project?.status.statuses.map((status) => status.name)).toEqual([
+        'Unread',
+        'Todo by human',
+      ]);
+      expect(project?.story?.workflowManagementStory).toEqual({
+        id: '6dc26727',
+        name: 'regular / workflow management',
+        color: 'BLUE',
+        description: '',
+      });
+      expect(project?.nextActionDate).toEqual({
+        name: 'nextactiondate',
+        fieldId: 'PVTF_nextactiondate',
+      });
+    });
+
+    it('should return null when the project no longer exists at that owner and number', async () => {
+      mockGet.mockImplementation(() => {
+        throw Object.assign(new Error('Not Found'), {
+          response: { status: 404 },
+        });
+      });
+
+      expect(await repository.getProject(location)).toBeNull();
+    });
+
+    it('should rethrow a failure that is not a not found response', async () => {
+      mockGet.mockImplementation(() => {
+        throw Object.assign(new Error('Bad Gateway'), {
+          response: { status: 502 },
+        });
+      });
+
+      await expect(repository.getProject(location)).rejects.toThrow(
+        'Bad Gateway',
+      );
+    });
+  });
+});
+
+describe('projectLocationFromUrl', () => {
+  it('should read the owner and the number from a user owned project url', () => {
+    expect(
+      projectLocationFromUrl(
+        'https://github.com/users/HiromiShikata/projects/48',
+      ),
+    ).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+  });
+
+  it('should read the owner and the number from an organization owned project url', () => {
+    expect(
+      projectLocationFromUrl('https://github.com/orgs/X-Mile/projects/7'),
+    ).toEqual({
+      owner: 'X-Mile',
+      ownerType: 'orgs',
+      projectNumber: 7,
+    });
+  });
+
+  it('should return null for a url that is not a project url', () => {
+    expect(
+      projectLocationFromUrl(
+        'https://github.com/HiromiShikata/secretary/issues/1',
+      ),
+    ).toBeNull();
+  });
+});
+
+describe('projectUrlFromLocation', () => {
+  it('should rebuild the project url the GraphQL API returns', () => {
+    expect(
+      projectUrlFromLocation({
+        owner: 'HiromiShikata',
+        ownerType: 'users',
+        projectNumber: 48,
+      }),
+    ).toEqual('https://github.com/users/HiromiShikata/projects/48');
+  });
+});

package/src/adapter/repositories/RestProjectRepository.ts

@@ -0,0 +1,129 @@
+import ky from 'ky';
+import { BaseGitHubRepository } from './BaseGitHubRepository';
+import {
+  ProjectDefinition,
+  ProjectFieldDefinition,
+  convertToFieldOptionColor,
+  projectFromDefinition,
+} from './projectFieldDefinition';
+import { Project } from '../../domain/entities/Project';
+
+export type ProjectLocation = {
+  owner: string;
+  ownerType: 'users' | 'orgs';
+  projectNumber: number;
+};
+
+type RestProjectResponse = {
+  id: number;
+  node_id: string;
+  title: string;
+};
+
+type RestProjectFieldResponse = {
+  id: number;
+  node_id: string;
+  name: string;
+  options?: {
+    id: string;
+    name: { raw: string };
+    description: { raw: string };
+    color: string;
+  }[];
+};
+
+const isNotFoundResponse = (error: unknown): boolean => {
+  if (typeof error !== 'object' || error === null || !('response' in error)) {
+    return false;
+  }
+  const response = error.response;
+  return (
+    typeof response === 'object' &&
+    response !== null &&
+    'status' in response &&
+    response.status === 404
+  );
+};
+
+export const projectUrlFromLocation = (location: ProjectLocation): string =>
+  `https://github.com/${location.ownerType}/${location.owner}/projects/${location.projectNumber}`;
+
+export const projectLocationFromUrl = (
+  projectUrl: string,
+): ProjectLocation | null => {
+  const match = projectUrl.match(
+    /https:\/\/github\.com\/(users|orgs)\/([^/]+)\/projects\/(\d+)/,
+  );
+  if (!match) {
+    return null;
+  }
+  const [, ownerType, owner, projectNumberText] = match;
+  return {
+    owner,
+    ownerType: ownerType === 'orgs' ? 'orgs' : 'users',
+    projectNumber: parseInt(projectNumberText, 10),
+  };
+};
+
+export class RestProjectRepository extends BaseGitHubRepository {
+  private projectApiUrl = (location: ProjectLocation): string =>
+    `https://api.github.com/${location.ownerType}/${location.owner}/projectsV2/${location.projectNumber}`;
+
+  private requestHeaders = (): Record<string, string> => ({
+    Authorization: `token ${this.ghToken}`,
+    Accept: 'application/vnd.github+json',
+  });
+
+  listFieldDefinitions = async (
+    location: ProjectLocation,
+  ): Promise<ProjectFieldDefinition[]> => {
+    const fields = await ky
+      .get(`${this.projectApiUrl(location)}/fields`, {
+        searchParams: { per_page: 100 },
+        headers: this.requestHeaders(),
+      })
+      .json<RestProjectFieldResponse[]>();
+    return fields.map((field) => ({
+      fieldId: field.node_id,
+      databaseId: field.id,
+      name: field.name,
+      options: (field.options ?? []).map((option) => ({
+        id: option.id,
+        name: option.name.raw,
+        color: convertToFieldOptionColor(option.color),
+        description: option.description.raw,
+      })),
+    }));
+  };
+
+  listFieldNames = async (location: ProjectLocation): Promise<string[]> => {
+    const fields = await this.listFieldDefinitions(location);
+    return fields.map((field) => field.name);
+  };
+
+  getProject = async (location: ProjectLocation): Promise<Project | null> => {
+    let project: RestProjectResponse;
+    let fields: ProjectFieldDefinition[];
+    try {
+      [project, fields] = await Promise.all([
+        ky
+          .get(this.projectApiUrl(location), { headers: this.requestHeaders() })
+          .json<RestProjectResponse>(),
+        this.listFieldDefinitions(location),
+      ]);
+    } catch (error) {
+      if (isNotFoundResponse(error)) {
+        return null;
+      }
+      throw error;
+    }
+    const definition: ProjectDefinition = {
+      id: project.node_id,
+      url: projectUrlFromLocation(location),
+      databaseId: project.id,
+      name: project.title,
+      fields,
+    };
+    return projectFromDefinition(definition);
+  };
+}

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

@@ -1668,6 +1668,64 @@ describe('ApiV3CheerioRestIssueRepository', () => {
     });
   });
 
+  describe('getIssueBodyByUrl', () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('reads the body over the REST issue endpoint', async () => {
+      const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce(
+        new Response(JSON.stringify({ body: 'story issue body' }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.getIssueBodyByUrl(
+        'https://github.com/HiromiShikata/test-repository/issues/42',
+      );
+
+      expect(result).toBe('story issue body');
+      expect(fetchSpy).toHaveBeenCalledWith(
+        'https://api.github.com/repos/HiromiShikata/test-repository/issues/42',
+        expect.objectContaining({ method: 'GET' }),
+      );
+    });
+
+    it('returns null when the issue no longer exists', async () => {
+      jest.spyOn(global, 'fetch').mockResolvedValueOnce(
+        new Response('Not Found', {
+          status: 404,
+          statusText: 'Not Found',
+        }),
+      );
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.getIssueBodyByUrl(
+        'https://github.com/HiromiShikata/test-repository/issues/42',
+      );
+
+      expect(result).toBeNull();
+    });
+
+    it('throws when the API fails for a reason other than the issue being absent', async () => {
+      jest.spyOn(global, 'fetch').mockResolvedValueOnce(
+        new Response('Bad Gateway', {
+          status: 502,
+          statusText: 'Bad Gateway',
+        }),
+      );
+
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      await expect(
+        repository.getIssueBodyByUrl(
+          'https://github.com/HiromiShikata/test-repository/issues/42',
+        ),
+      ).rejects.toThrow('502');
+    });
+  });
+
   describe('getIssueOrPullRequestComments', () => {
     afterEach(() => {
       jest.restoreAllMocks();

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

@@ -467,6 +467,7 @@ export class ApiV3CheerioRestIssueRepository
       RestIssueRepository,
       | 'createNewIssue'
       | 'updateIssue'
+      | 'updateIssueBody'
       | 'createComment'
       | 'getIssue'
       | 'updateLabels'
@@ -803,6 +804,12 @@ export class ApiV3CheerioRestIssueRepository
   updateIssue = async (issue: Issue): Promise<void> => {
     await this.restIssueRepository.updateIssue(issue);
   };
+  updateIssueBody = async (
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
+    body: string,
+  ): Promise<void> => {
+    await this.restIssueRepository.updateIssueBody(issue, body);
+  };
   getIssueByUrl = async (url: string): Promise<Issue | null> => {
     const projectItem =
       await this.graphqlProjectItemRepository.fetchProjectItemByUrl(url);
@@ -2296,9 +2303,9 @@ export class ApiV3CheerioRestIssueRepository
     await this.restIssueRepository.createComment(issueOrPrUrl, commentBody);
   };
 
-  getIssueOrPullRequestBody = async (url: string): Promise<string> => {
+  private fetchIssueBodyResponse = (url: string): Promise<Response> => {
     const { owner, repo, issueNumber } = this.parseIssueUrl(url);
-    const response = await this.fetchWithRateLimitRetry(() =>
+    return this.fetchWithRateLimitRetry(() =>
       fetch(
         `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`,
         {
@@ -2310,10 +2317,12 @@ export class ApiV3CheerioRestIssueRepository
         },
       ),
     );
-    if (!response.ok) {
-      const reason = await this.formatGitHubErrorWithStatus(response);
-      throw new Error(`Failed to fetch body for ${url}: ${reason}`);
-    }
+  };
+
+  private parseIssueBodyResponse = async (
+    url: string,
+    response: Response,
+  ): Promise<string> => {
     const body: unknown = await response.json();
     if (!isIssueOrPullRequestBodyResponse(body)) {
       throw new Error(
@@ -2323,6 +2332,27 @@ export class ApiV3CheerioRestIssueRepository
     return body.body ?? '';
   };
 
+  getIssueOrPullRequestBody = async (url: string): Promise<string> => {
+    const response = await this.fetchIssueBodyResponse(url);
+    if (!response.ok) {
+      const reason = await this.formatGitHubErrorWithStatus(response);
+      throw new Error(`Failed to fetch body for ${url}: ${reason}`);
+    }
+    return this.parseIssueBodyResponse(url, response);
+  };
+
+  getIssueBodyByUrl = async (url: string): Promise<string | null> => {
+    const response = await this.fetchIssueBodyResponse(url);
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok) {
+      const reason = await this.formatGitHubErrorWithStatus(response);
+      throw new Error(`Failed to fetch body for ${url}: ${reason}`);
+    }
+    return this.parseIssueBodyResponse(url, response);
+  };
+
   getIssueOrPullRequestComments = async (
     url: string,
   ): Promise<IssueComment[]> => {

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

@@ -263,6 +263,25 @@ describe('RestIssueRepository', () => {
     });
   });
 
+  describe('updateIssueBody', () => {
+    it('sends only the body so the title, labels, assignees and state are left untouched', async () => {
+      const issue = buildIssue();
+
+      mockPatch.mockResolvedValue(undefined);
+
+      await restIssueRepository.updateIssueBody(issue, 'rewritten body');
+
+      expect(mockPatch).toHaveBeenCalledTimes(1);
+      expect(mockPatch).toHaveBeenCalledWith(
+        'https://api.github.com/repos/HiromiShikata/test-repository/issues/40',
+        {
+          json: { body: 'rewritten body' },
+          headers: { Authorization: 'token dummy-token' },
+        },
+      );
+    });
+  });
+
   describe('searchIssues', () => {
     const buildSearchItem = (
       overrides: Partial<{

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

@@ -105,6 +105,19 @@ export class RestIssueRepository
     );
   };
 
+  updateIssueBody = async (
+    issue: Pick<Issue, 'org' | 'repo' | 'number'>,
+    body: string,
+  ): Promise<void> => {
+    await ky.patch(
+      `https://api.github.com/repos/${issue.org}/${issue.repo}/issues/${issue.number}`,
+      {
+        json: { body },
+        headers: { Authorization: `token ${this.ghToken}` },
+      },
+    );
+  };
+
   updateLabels = async (
     issue: Issue,
     labels: Issue['labels'],