github-issue-tower-defence-management 1.123.2 → 1.124.0

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

@@ -0,0 +1,251 @@
+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 {
+  GITHUB_GRAPHQL_ENDPOINT,
+  RATE_LIMIT_SELECTION,
+  extractGraphqlOperationName,
+  fetchGithubGraphql,
+  injectRateLimitSelection,
+  isMutationOperation,
+  logGithubGraphqlCost,
+  postGithubGraphqlJson,
+} from './githubGraphqlClient';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const expectRecord = (value: unknown): Record<string, unknown> => {
+  if (!isRecord(value)) {
+    throw new Error(`Expected an object but got: ${String(value)}`);
+  }
+  return value;
+};
+
+const getMockCallArguments = (
+  mock: jest.Mock,
+  callIndex: number,
+): unknown[] => {
+  const call: unknown = mock.mock.calls[callIndex];
+  if (!Array.isArray(call)) {
+    throw new Error('Expected a recorded mock call');
+  }
+  return call.map((argument: unknown) => argument);
+};
+
+describe('githubGraphqlClient', () => {
+  let consoleLogSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+  });
+
+  describe('isMutationOperation', () => {
+    it('returns true for a mutation operation', () => {
+      expect(isMutationOperation('mutation AddItem { x }')).toBe(true);
+      expect(isMutationOperation('\n  mutation { x }')).toBe(true);
+    });
+
+    it('returns false for query operations', () => {
+      expect(isMutationOperation('query GetItem { x }')).toBe(false);
+      expect(isMutationOperation('\n  query($a: Int!) { x }')).toBe(false);
+    });
+  });
+
+  describe('extractGraphqlOperationName', () => {
+    it('extracts the operation name from a named query', () => {
+      expect(
+        extractGraphqlOperationName('query GetProjectItems($id: ID!) { x }'),
+      ).toBe('GetProjectItems');
+    });
+
+    it('extracts the operation name from a named mutation', () => {
+      expect(
+        extractGraphqlOperationName('mutation AddIssueToProject { x }'),
+      ).toBe('AddIssueToProject');
+    });
+
+    it('returns anonymous for an unnamed query', () => {
+      expect(extractGraphqlOperationName('query($a: Int!) { x }')).toBe(
+        'anonymous',
+      );
+    });
+  });
+
+  describe('injectRateLimitSelection', () => {
+    it('injects the rateLimit selection before the closing brace of a query', () => {
+      const injected = injectRateLimitSelection(
+        'query GetItem($id: ID!) {\n  node(id: $id) { id }\n}',
+      );
+      expect(injected).toContain(RATE_LIMIT_SELECTION);
+      expect(injected.trimEnd().endsWith('}')).toBe(true);
+      const rateLimitIndex = injected.indexOf(RATE_LIMIT_SELECTION);
+      const lastBraceIndex = injected.lastIndexOf('}');
+      expect(rateLimitIndex).toBeLessThan(lastBraceIndex);
+    });
+
+    it('does not modify a mutation', () => {
+      const mutation = 'mutation AddItem { addItem { id } }';
+      expect(injectRateLimitSelection(mutation)).toBe(mutation);
+    });
+
+    it('injects into an anonymous query', () => {
+      const injected = injectRateLimitSelection(
+        '\n  query($a: Int!) {\n    node { id }\n  }\n',
+      );
+      expect(injected).toContain(RATE_LIMIT_SELECTION);
+    });
+  });
+
+  describe('logGithubGraphqlCost', () => {
+    it('logs one line with query name, cost and remaining', () => {
+      logGithubGraphqlCost('query GetProjectItems { x }', {
+        data: { rateLimit: { cost: 3, remaining: 4200 } },
+      });
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'githubGraphqlClient: query=GetProjectItems cost=3 remaining=4200',
+      );
+    });
+
+    it('does not log when rateLimit is absent', () => {
+      logGithubGraphqlCost('query GetProjectItems { x }', {
+        data: { node: null },
+      });
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not log when the body is not an object', () => {
+      logGithubGraphqlCost('query GetProjectItems { x }', undefined);
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('postGithubGraphqlJson', () => {
+    it('sends the query with the injected rateLimit selection and logs the cost', async () => {
+      mockPost.mockReturnValue({
+        json: jest.fn().mockResolvedValue({
+          data: {
+            node: { id: 'x' },
+            rateLimit: { cost: 1, remaining: 4999 },
+          },
+        }),
+      });
+      const response = await postGithubGraphqlJson<{
+        data: { node: { id: string } };
+      }>({
+        ghToken: 'token-a',
+        query: 'query GetItem($id: ID!) { node(id: $id) { id } }',
+        variables: { id: 'x' },
+      });
+      expect(response.data.node.id).toBe('x');
+      expect(mockPost).toHaveBeenCalledTimes(1);
+      const call = getMockCallArguments(mockPost, 0);
+      expect(call[0]).toBe(GITHUB_GRAPHQL_ENDPOINT);
+      const options = expectRecord(call[1]);
+      const json = expectRecord(options.json);
+      const headers = expectRecord(options.headers);
+      expect(json.query).toContain(RATE_LIMIT_SELECTION);
+      expect(json.variables).toEqual({ id: 'x' });
+      expect(headers.Authorization).toBe('Bearer token-a');
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'githubGraphqlClient: query=GetItem cost=1 remaining=4999',
+      );
+    });
+
+    it('sends a mutation unchanged and does not log', async () => {
+      mockPost.mockReturnValue({
+        json: jest.fn().mockResolvedValue({
+          data: { addItem: { id: 'x' } },
+        }),
+      });
+      const mutation = 'mutation AddItem { addItem { id } }';
+      await postGithubGraphqlJson({
+        ghToken: 'token-a',
+        query: mutation,
+      });
+      const call = getMockCallArguments(mockPost, 0);
+      const options = expectRecord(call[1]);
+      const json = expectRecord(options.json);
+      expect(json.query).toBe(mutation);
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('fetchGithubGraphql', () => {
+    const originalFetch = global.fetch;
+
+    afterEach(() => {
+      global.fetch = originalFetch;
+    });
+
+    it('sends the query with the injected rateLimit selection and logs the cost', async () => {
+      const responseBody = {
+        data: {
+          repository: { issue: null },
+          rateLimit: { cost: 2, remaining: 4321 },
+        },
+      };
+      const fetchMock = jest
+        .fn()
+        .mockResolvedValue(
+          new Response(JSON.stringify(responseBody), { status: 200 }),
+        );
+      global.fetch = fetchMock;
+      const response = await fetchGithubGraphql({
+        ghToken: 'token-b',
+        query: 'query PullRequestStatus($a: Int!) { x }',
+        variables: { a: 1 },
+      });
+      expect(response.ok).toBe(true);
+      await expect(response.json()).resolves.toEqual(responseBody);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const call = getMockCallArguments(fetchMock, 0);
+      expect(call[0]).toBe(GITHUB_GRAPHQL_ENDPOINT);
+      const init = expectRecord(call[1]);
+      const headers = expectRecord(init.headers);
+      expect(init.method).toBe('POST');
+      expect(headers.Authorization).toBe('Bearer token-b');
+      if (typeof init.body !== 'string') {
+        throw new Error('Expected the request body to be a string');
+      }
+      const sentBody = expectRecord(JSON.parse(init.body));
+      expect(sentBody.query).toContain(RATE_LIMIT_SELECTION);
+      expect(sentBody.variables).toEqual({ a: 1 });
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'githubGraphqlClient: query=PullRequestStatus cost=2 remaining=4321',
+      );
+    });
+
+    it('returns the response without logging when the request failed', async () => {
+      const fetchMock = jest
+        .fn()
+        .mockResolvedValue(new Response('rate limited', { status: 403 }));
+      global.fetch = fetchMock;
+      const response = await fetchGithubGraphql({
+        ghToken: 'token-b',
+        query: 'query PullRequestStatus($a: Int!) { x }',
+      });
+      expect(response.status).toBe(403);
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/adapter/repositories/githubGraphqlClient.ts

@@ -0,0 +1,122 @@
+import ky from 'ky';
+
+export const GITHUB_GRAPHQL_ENDPOINT = 'https://api.github.com/graphql';
+
+export const RATE_LIMIT_SELECTION = 'rateLimit { cost remaining }';
+
+export type GithubGraphqlRateLimit = {
+  cost: number;
+  remaining: number;
+};
+
+export const isMutationOperation = (query: string): boolean =>
+  query.trimStart().startsWith('mutation');
+
+export const extractGraphqlOperationName = (query: string): string => {
+  const match = query.match(
+    /^\s*(?:query|mutation)\s+([A-Za-z_][A-Za-z0-9_]*)/,
+  );
+  return match ? match[1] : 'anonymous';
+};
+
+export const injectRateLimitSelection = (query: string): string => {
+  if (isMutationOperation(query)) {
+    return query;
+  }
+  const lastBraceIndex = query.lastIndexOf('}');
+  if (lastBraceIndex === -1) {
+    return query;
+  }
+  return `${query.slice(0, lastBraceIndex)}  ${RATE_LIMIT_SELECTION}\n${query.slice(lastBraceIndex)}`;
+};
+
+const extractRateLimit = (
+  responseBody: unknown,
+): GithubGraphqlRateLimit | null => {
+  if (
+    typeof responseBody !== 'object' ||
+    responseBody === null ||
+    !('data' in responseBody)
+  ) {
+    return null;
+  }
+  const data: unknown = responseBody.data;
+  if (typeof data !== 'object' || data === null || !('rateLimit' in data)) {
+    return null;
+  }
+  const rateLimit: unknown = data.rateLimit;
+  if (
+    typeof rateLimit !== 'object' ||
+    rateLimit === null ||
+    !('cost' in rateLimit) ||
+    !('remaining' in rateLimit)
+  ) {
+    return null;
+  }
+  const { cost, remaining } = rateLimit;
+  if (typeof cost !== 'number' || typeof remaining !== 'number') {
+    return null;
+  }
+  return { cost, remaining };
+};
+
+export const logGithubGraphqlCost = (
+  query: string,
+  responseBody: unknown,
+): void => {
+  const rateLimit = extractRateLimit(responseBody);
+  if (!rateLimit) {
+    return;
+  }
+  console.log(
+    `githubGraphqlClient: query=${extractGraphqlOperationName(query)} cost=${rateLimit.cost} remaining=${rateLimit.remaining}`,
+  );
+};
+
+export const postGithubGraphqlJson = async <T>(params: {
+  ghToken: string;
+  query: string;
+  variables?: Record<string, unknown>;
+}): Promise<T> => {
+  const response = await ky
+    .post(GITHUB_GRAPHQL_ENDPOINT, {
+      json: {
+        query: injectRateLimitSelection(params.query),
+        ...(params.variables !== undefined
+          ? { variables: params.variables }
+          : {}),
+      },
+      headers: {
+        Authorization: `Bearer ${params.ghToken}`,
+      },
+    })
+    .json<T>();
+  logGithubGraphqlCost(params.query, response);
+  return response;
+};
+
+export const fetchGithubGraphql = async (params: {
+  ghToken: string;
+  query: string;
+  variables?: Record<string, unknown>;
+}): Promise<Response> => {
+  const response = await fetch(GITHUB_GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${params.ghToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: injectRateLimitSelection(params.query),
+      variables: params.variables,
+    }),
+  });
+  if (response.ok) {
+    const responseBody: unknown = await response
+      .clone()
+      .json()
+      .catch((): null => null);
+    logGithubGraphqlCost(params.query, responseBody);
+  }
+  return response;
+};

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

@@ -20,6 +20,7 @@ import {
 import { LocalStorageCacheRepository } from '../LocalStorageCacheRepository';
 import typia from 'typia';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
+import { fetchGithubGraphql } from '../githubGraphqlClient';
 import { normalizeFieldName } from '../utils';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 import { Member } from '../../../domain/entities/Member';
@@ -1160,7 +1161,7 @@ export class ApiV3CheerioRestIssueRepository
     mergeStateStatus: string | null;
   } | null> => {
     const query = `
-      query($owner: String!, $repo: String!, $prNumber: Int!) {
+      query PullRequestMergeability($owner: String!, $repo: String!, $prNumber: Int!) {
         repository(owner: $owner, name: $repo) {
           pullRequest(number: $prNumber) {
             mergeable
@@ -1183,16 +1184,10 @@ export class ApiV3CheerioRestIssueRepository
       }
 
       const response = await this.fetchWithRateLimitRetry(() =>
-        fetch('https://api.github.com/graphql', {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${this.ghToken}`,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            query,
-            variables: { owner, repo, prNumber },
-          }),
+        fetchGithubGraphql({
+          ghToken: this.ghToken,
+          query,
+          variables: { owner, repo, prNumber },
         }),
       );
 
@@ -1244,7 +1239,7 @@ export class ApiV3CheerioRestIssueRepository
     }
 
     const query = `
-      query($owner: String!, $repo: String!, $issueNumber: Int!, $after: String) {
+      query IssueRelatedOpenPullRequests($owner: String!, $repo: String!, $issueNumber: Int!, $after: String) {
         repository(owner: $owner, name: $repo) {
           issue(number: $issueNumber) {
             timelineItems(first: 100, after: $after, itemTypes: [CROSS_REFERENCED_EVENT]) {
@@ -1348,16 +1343,10 @@ export class ApiV3CheerioRestIssueRepository
 
     while (hasNextPage) {
       const response = await this.fetchWithRateLimitRetry(() =>
-        fetch('https://api.github.com/graphql', {
-          method: 'POST',
-          headers: {
-            Authorization: `Bearer ${this.ghToken}`,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            query,
-            variables: { owner, repo, issueNumber, after },
-          }),
+        fetchGithubGraphql({
+          ghToken: this.ghToken,
+          query,
+          variables: { owner, repo, issueNumber, after },
         }),
       );
 
@@ -1488,7 +1477,7 @@ export class ApiV3CheerioRestIssueRepository
     const { owner, repo, issueNumber: prNumber } = parsedUrl;
 
     const query = `
-      query($owner: String!, $repo: String!, $prNumber: Int!) {
+      query PullRequestStatus($owner: String!, $repo: String!, $prNumber: Int!) {
         repository(owner: $owner, name: $repo) {
           pullRequest(number: $prNumber) {
             url
@@ -1565,16 +1554,10 @@ export class ApiV3CheerioRestIssueRepository
     `;
 
     const response = await this.fetchWithRateLimitRetry(() =>
-      fetch('https://api.github.com/graphql', {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${this.ghToken}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          query,
-          variables: { owner, repo, prNumber },
-        }),
+      fetchGithubGraphql({
+        ghToken: this.ghToken,
+        query,
+        variables: { owner, repo, prNumber },
       }),
     );
 

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

@@ -22,6 +22,8 @@ import { HTTPError } from 'ky';
 import {
   GraphqlProjectItemRepository,
   PAGINATION_DELAY_MS,
+  PROJECT_ITEM_ASSIGNEES_FIRST,
+  PROJECT_ITEM_LABELS_FIRST,
   RATE_LIMIT_MAX_RETRIES,
   callWithRateLimitRetry,
 } from './GraphqlProjectItemRepository';
@@ -160,6 +162,66 @@ describe('GraphqlProjectItemRepository', () => {
       mockPost.mockReset();
     });
 
+    it('requests the reduced labels and assignees selection sizes', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(makePageResponse(false, 'cursor-1', 1));
+
+      await repository.fetchProjectItems('test-project-id');
+
+      expect(PROJECT_ITEM_LABELS_FIRST).toBe(20);
+      expect(PROJECT_ITEM_ASSIGNEES_FIRST).toBe(10);
+      const sentQuery = extractRequestedQueryFromMockCall(
+        mockPost.mock.calls[0],
+      );
+      expect(sentQuery).toContain(
+        `labels(first: ${PROJECT_ITEM_LABELS_FIRST})`,
+      );
+      expect(sentQuery).toContain(
+        `assignees(first: ${PROJECT_ITEM_ASSIGNEES_FIRST})`,
+      );
+      expect(sentQuery).not.toContain('labels(first: 100)');
+      expect(sentQuery).not.toContain('assignees(first: 20)');
+    });
+
+    it('logs the rateLimit cost of the request in one line', async () => {
+      const repository = new GraphqlProjectItemRepository(
+        new LocalStorageRepository(),
+        'dummy-token',
+      );
+      mockPost.mockReturnValueOnce(
+        mockJsonResponse({
+          data: {
+            node: {
+              items: {
+                totalCount: 0,
+                pageInfo: {
+                  endCursor: 'cursor-1',
+                  startCursor: 'cursor-start',
+                  hasNextPage: false,
+                },
+                nodes: [],
+              },
+            },
+            rateLimit: { cost: 3, remaining: 4200 },
+          },
+        }),
+      );
+      const consoleLogSpy = jest
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+      try {
+        await repository.fetchProjectItems('test-project-id');
+        expect(consoleLogSpy).toHaveBeenCalledWith(
+          'githubGraphqlClient: query=GetProjectItems cost=3 remaining=4200',
+        );
+      } finally {
+        consoleLogSpy.mockRestore();
+      }
+    });
+
     it('should sleep between paginated requests to avoid 403', async () => {
       const localStorageRepository = new LocalStorageRepository();
       const repository = new GraphqlProjectItemRepository(