github-issue-tower-defence-management 1.39.0 → 1.41.0

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

@@ -18,6 +18,250 @@ import { normalizeFieldName } from '../utils';
 import { LocalStorageRepository } from '../LocalStorageRepository';
 import { Member } from '../../../domain/entities/Member';
 
+type TimelineItem = {
+  __typename: string;
+  willCloseTarget?: boolean;
+  source?: {
+    __typename: string;
+    url?: string;
+    number?: number;
+    state?: string;
+    mergeable?: string;
+    headRefName?: string;
+    baseRefName?: string;
+    baseRepository?: {
+      branchProtectionRules?: {
+        nodes: Array<{
+          pattern: string;
+          requiredStatusCheckContexts: string[];
+        }>;
+      };
+      defaultBranchRef?: {
+        name: string;
+      } | null;
+      rulesets?: {
+        nodes: Array<{
+          name: string;
+          enforcement: string;
+          conditions: {
+            refName: {
+              include: string[];
+              exclude: string[];
+            };
+          };
+          rules: {
+            nodes: Array<{
+              type: string;
+              parameters:
+                | {
+                    requiredStatusChecks: Array<{
+                      context: string;
+                    }>;
+                  }
+                | Record<string, never>;
+            }>;
+          };
+        }>;
+      };
+    };
+    commits?: {
+      nodes: Array<{
+        commit: {
+          statusCheckRollup?: {
+            state: string;
+            contexts?: {
+              nodes: Array<
+                | {
+                    __typename: 'CheckRun';
+                    name: string;
+                    conclusion: string | null;
+                  }
+                | {
+                    __typename: 'StatusContext';
+                    context: string;
+                    state: string;
+                  }
+              >;
+            };
+          } | null;
+        };
+      }>;
+    };
+    reviewThreads?: {
+      nodes: Array<{
+        isResolved: boolean;
+      }>;
+    };
+    baseRef?: {
+      name: string;
+    } | null;
+  };
+};
+
+type IssueTimelineResponse = {
+  data?: {
+    repository?: {
+      issue?: {
+        timelineItems: {
+          pageInfo: {
+            endCursor: string;
+            hasNextPage: boolean;
+          };
+          nodes: TimelineItem[];
+        };
+      };
+    };
+  };
+  errors?: Array<{ message: string }>;
+};
+
+type PrStatusComputationData = {
+  mergeable?: string;
+  baseRepository?: {
+    branchProtectionRules?: {
+      nodes: Array<{
+        pattern: string;
+        requiredStatusCheckContexts: string[];
+      }>;
+    };
+    defaultBranchRef?: {
+      name: string;
+    } | null;
+    rulesets?: {
+      nodes: Array<{
+        name: string;
+        enforcement: string;
+        conditions: {
+          refName: {
+            include: string[];
+            exclude: string[];
+          };
+        };
+        rules: {
+          nodes: Array<{
+            type: string;
+            parameters:
+              | {
+                  requiredStatusChecks: Array<{
+                    context: string;
+                  }>;
+                }
+              | Record<string, never>;
+          }>;
+        };
+      }>;
+    };
+  };
+  commits?: {
+    nodes: Array<{
+      commit: {
+        statusCheckRollup?: {
+          state: string;
+          contexts?: {
+            nodes: Array<
+              | {
+                  __typename: 'CheckRun';
+                  name: string;
+                  conclusion: string | null;
+                }
+              | {
+                  __typename: 'StatusContext';
+                  context: string;
+                  state: string;
+                }
+            >;
+          };
+        } | null;
+      };
+    }>;
+  };
+  reviewThreads?: {
+    nodes: Array<{
+      isResolved: boolean;
+    }>;
+  };
+};
+
+type DirectPullRequestResponse = {
+  data?: {
+    repository?: {
+      pullRequest?: {
+        url: string;
+        state: string;
+        headRefName?: string;
+        baseRefName?: string;
+      } & PrStatusComputationData;
+    };
+  };
+  errors?: Array<{ message: string }>;
+};
+
+function isIssueTimelineResponse(
+  value: unknown,
+): value is IssueTimelineResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return true;
+}
+
+function isDirectPullRequestResponse(
+  value: unknown,
+): value is DirectPullRequestResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return true;
+}
+
+const fnmatch = (pattern: string, str: string): boolean => {
+  let regexStr = '^';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '*') {
+      if (pattern[i + 1] === '*') {
+        regexStr += '.*';
+        i += 2;
+        if (pattern[i] === '/') {
+          i++;
+        }
+      } else {
+        regexStr += '[^/]*';
+        i++;
+      }
+    } else if (c === '?') {
+      regexStr += '[^/]';
+      i++;
+    } else if (c === '[') {
+      let j = i + 1;
+      while (j < pattern.length && pattern[j] !== ']') {
+        j++;
+      }
+      if (j >= pattern.length) {
+        regexStr += '\\[';
+        i++;
+        continue;
+      }
+      const content = pattern.slice(i + 1, j);
+      if (content.length > 0 && (content[0] === '!' || content[0] === '^')) {
+        const body = content.slice(1).replace(/\\/g, '\\\\');
+        regexStr += '[^' + body + ']';
+      } else {
+        const escapedContent = content.replace(/\\/g, '\\\\');
+        regexStr += '[' + escapedContent + ']';
+      }
+      i = j + 1;
+    } else {
+      regexStr += c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      i++;
+    }
+  }
+  regexStr += '$';
+  try {
+    const regex = new RegExp(regexStr);
+    return regex.test(str);
+  } catch {
+    return pattern === str;
+  }
+};
+
 export class ApiV3CheerioRestIssueRepository
   extends BaseGitHubRepository
   implements IssueRepository
@@ -131,6 +375,7 @@ export class ApiV3CheerioRestIssueRepository
       isInProgress: normalizeFieldName(status || '').includes('progress'),
       isClosed: item.state !== 'OPEN',
       createdAt: new Date(item.createdAt || '2000-01-01'),
+      author: '',
     };
   };
   getAllIssuesFromCache = async (
@@ -239,18 +484,23 @@ export class ApiV3CheerioRestIssueRepository
     return this.convertProjectItemToIssue(projectItem);
   };
   updateNextActionDate = async (
-    project: Project & { nextActionDate: Required<Project['nextActionDate']> },
-    issue: Issue,
+    issueUrl: string,
+    project: Project,
     date: Date,
   ): Promise<void> => {
-    if (project.nextActionDate === null) {
-      throw new Error('nextActionDate is not defined');
+    if (!project.nextActionDate) {
+      return;
+    }
+    const projectItem =
+      await this.graphqlProjectItemRepository.fetchProjectItemByUrl(issueUrl);
+    if (!projectItem) {
+      return;
     }
     return this.graphqlProjectItemRepository.updateProjectField(
       project.id,
       project.nextActionDate.fieldId,
-      issue.itemId,
-      { date: date.toISOString() },
+      projectItem.id,
+      { date: date.toISOString().split('T')[0] },
     );
   };
   updateNextActionHour = async (
@@ -326,15 +576,442 @@ export class ApiV3CheerioRestIssueRepository
   update = async (issue: Issue, _project: Project): Promise<void> => {
     await this.updateIssue(issue);
   };
+  private parseIssueUrl = (
+    issueUrl: string,
+  ): {
+    owner: string;
+    repo: string;
+    issueNumber: number;
+    isPr: boolean;
+  } => {
+    const urlMatch = issueUrl.match(
+      /github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/,
+    );
+    if (!urlMatch) {
+      throw new Error(`Invalid GitHub issue URL: ${issueUrl}`);
+    }
+    return {
+      owner: urlMatch[1],
+      repo: urlMatch[2],
+      issueNumber: parseInt(urlMatch[4], 10),
+      isPr: urlMatch[3] === 'pull',
+    };
+  };
+
+  private computePrStatus = (
+    prUrl: string,
+    headRefName: string | undefined,
+    baseRefName: string | undefined,
+    data: PrStatusComputationData,
+  ): RelatedPullRequest => {
+    const isConflicted = data.mergeable === 'CONFLICTING';
+    const lastCommit = data.commits?.nodes[0]?.commit;
+    const ciState = lastCommit?.statusCheckRollup?.state;
+    const contexts = lastCommit?.statusCheckRollup?.contexts?.nodes || [];
+
+    const branchProtectionRules =
+      data.baseRepository?.branchProtectionRules?.nodes || [];
+    const matchingRules = baseRefName
+      ? branchProtectionRules.filter(
+          (rule) =>
+            rule.pattern === baseRefName || fnmatch(rule.pattern, baseRefName),
+        )
+      : [];
+    const requiredCheckNamesSet = new Set<string>();
+    for (const rule of matchingRules) {
+      for (const name of rule.requiredStatusCheckContexts) {
+        requiredCheckNamesSet.add(name);
+      }
+    }
+
+    const rulesets = data.baseRepository?.rulesets?.nodes || [];
+    const defaultBranchName = data.baseRepository?.defaultBranchRef?.name || '';
+    for (const ruleset of rulesets) {
+      if (ruleset.enforcement !== 'ACTIVE') continue;
+      const refIncludes = ruleset.conditions.refName.include;
+      const refExcludes = ruleset.conditions.refName.exclude;
+      const matchesInclude =
+        baseRefName !== undefined &&
+        refIncludes.some((pattern) => {
+          if (pattern === '~DEFAULT_BRANCH') {
+            return baseRefName === defaultBranchName;
+          }
+          if (pattern === '~ALL') {
+            return true;
+          }
+          const branchPattern = pattern.replace(/^refs\/heads\//, '');
+          return (
+            branchPattern === baseRefName || fnmatch(branchPattern, baseRefName)
+          );
+        });
+      if (!matchesInclude) continue;
+      const matchesExclude =
+        baseRefName !== undefined &&
+        refExcludes.some((pattern) => {
+          if (pattern === '~DEFAULT_BRANCH') {
+            return baseRefName === defaultBranchName;
+          }
+          const branchPattern = pattern.replace(/^refs\/heads\//, '');
+          return (
+            branchPattern === baseRefName || fnmatch(branchPattern, baseRefName)
+          );
+        });
+      if (matchesExclude) continue;
+      for (const rule of ruleset.rules.nodes) {
+        if (rule.type !== 'REQUIRED_STATUS_CHECKS') continue;
+        if ('requiredStatusChecks' in rule.parameters) {
+          for (const check of rule.parameters.requiredStatusChecks) {
+            requiredCheckNamesSet.add(check.context);
+          }
+        }
+      }
+    }
+
+    const requiredCheckNames = Array.from(requiredCheckNamesSet);
+    const seenContextNames = new Set<string>();
+    for (const ctx of contexts) {
+      if ('name' in ctx) {
+        seenContextNames.add(ctx.name);
+      }
+      if ('context' in ctx) {
+        seenContextNames.add(ctx.context);
+      }
+    }
+
+    const missingRequiredCheckNames = requiredCheckNames.filter(
+      (name) => !seenContextNames.has(name),
+    );
+    const allRequiredChecksPassed = missingRequiredCheckNames.length === 0;
+    const isCiStateSuccess = ciState === 'SUCCESS';
+    const isPassedAllCiJob = isCiStateSuccess && allRequiredChecksPassed;
+
+    const reviewThreads = data.reviewThreads?.nodes || [];
+    const isResolvedAllReviewComments =
+      reviewThreads.length === 0 ||
+      reviewThreads.every((thread) => thread.isResolved);
+
+    return {
+      url: prUrl,
+      branchName: headRefName ?? null,
+      isConflicted,
+      isPassedAllCiJob,
+      isCiStateSuccess,
+      isResolvedAllReviewComments,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames,
+    };
+  };
+
   findRelatedOpenPRs = async (
-    _issueUrl: string,
+    issueUrl: string,
   ): Promise<RelatedPullRequest[]> => {
-    throw new Error('findRelatedOpenPRs is not implemented');
+    const { owner, repo, issueNumber, isPr } = this.parseIssueUrl(issueUrl);
+    if (isPr) {
+      throw new Error(
+        'findRelatedOpenPRs only supports issue URLs, not pull request URLs',
+      );
+    }
+
+    const query = `
+      query($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]) {
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              nodes {
+                __typename
+                ... on CrossReferencedEvent {
+                  willCloseTarget
+                  source {
+                    __typename
+                    ... on PullRequest {
+                      url
+                      number
+                      state
+                      mergeable
+                      headRefName
+                      baseRefName
+                      baseRepository {
+                        branchProtectionRules(first: 100) {
+                          nodes {
+                            pattern
+                            requiredStatusCheckContexts
+                          }
+                        }
+                        defaultBranchRef {
+                          name
+                        }
+                        rulesets(first: 100) {
+                          nodes {
+                            name
+                            enforcement
+                            conditions {
+                              refName {
+                                include
+                                exclude
+                              }
+                            }
+                            rules(first: 100) {
+                              nodes {
+                                type
+                                parameters {
+                                  ... on RequiredStatusChecksParameters {
+                                    requiredStatusChecks {
+                                      context
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                      commits(last: 1) {
+                        nodes {
+                          commit {
+                            statusCheckRollup {
+                              state
+                              contexts(first: 100) {
+                                nodes {
+                                  __typename
+                                  ... on CheckRun {
+                                    name
+                                    conclusion
+                                  }
+                                  ... on StatusContext {
+                                    context
+                                    state
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                      reviewThreads(first: 100) {
+                        nodes {
+                          isResolved
+                        }
+                      }
+                      baseRef {
+                        name
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    const relatedPRsMap: Map<string, RelatedPullRequest> = new Map();
+    let after: string | null = null;
+    let hasNextPage = true;
+
+    while (hasNextPage) {
+      const response = await 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 },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch issue timeline from GitHub GraphQL API: HTTP ${response.status}`,
+        );
+      }
+
+      const responseData: unknown = await response.json();
+      if (!isIssueTimelineResponse(responseData)) {
+        throw new Error(
+          'Unexpected response shape when fetching issue timeline',
+        );
+      }
+
+      const issueData = responseData.data?.repository?.issue;
+      if (!issueData) {
+        throw new Error(
+          'Issue not found when fetching timeline from GitHub GraphQL API',
+        );
+      }
+
+      for (const item of issueData.timelineItems.nodes) {
+        if (item.__typename !== 'CrossReferencedEvent') continue;
+        if (!item.source || item.source.__typename !== 'PullRequest') continue;
+        if (item.source.state !== 'OPEN') continue;
+        if (!item.willCloseTarget) continue;
+
+        const pr = item.source;
+        const prUrl = pr.url || '';
+        const baseRefName = pr.baseRefName ?? pr.baseRef?.name;
+
+        relatedPRsMap.set(
+          prUrl,
+          this.computePrStatus(prUrl, pr.headRefName, baseRefName, pr),
+        );
+      }
+
+      hasNextPage = issueData.timelineItems.pageInfo.hasNextPage;
+      after = issueData.timelineItems.pageInfo.endCursor;
+    }
+
+    return Array.from(relatedPRsMap.values());
   };
-  getAllOpened = async (_project: Project): Promise<Issue[]> => {
-    throw new Error('getAllOpened is not implemented');
+
+  getAllOpened = async (project: Project): Promise<Issue[]> => {
+    const { issues } = await this.getAllIssues(project.id, 0);
+    return issues.filter((issue) => !issue.isClosed);
   };
-  getStoryObjectMap = async (_project: Project): Promise<StoryObjectMap> => {
-    throw new Error('getStoryObjectMap is not implemented');
+
+  getStoryObjectMap = async (project: Project): Promise<StoryObjectMap> => {
+    const { issues } = await this.getAllIssues(project.id, 0);
+    const storyObjectMap: StoryObjectMap = new Map();
+    const targetStories = project.story?.stories || [];
+    for (const story of targetStories) {
+      const storyIssue = issues.find((issue) =>
+        story.name.startsWith(issue.title),
+      );
+      storyObjectMap.set(story.name, {
+        story,
+        storyIssue: storyIssue || null,
+        issues: [],
+      });
+      for (const issue of issues) {
+        if (issue.story !== story.name) continue;
+        storyObjectMap.get(story.name)?.issues.push(issue);
+      }
+    }
+    return storyObjectMap;
+  };
+
+  getOpenPullRequest = async (
+    prUrl: string,
+  ): Promise<RelatedPullRequest | null> => {
+    const parsedUrl = this.parseIssueUrl(prUrl);
+    if (!parsedUrl.isPr) {
+      return null;
+    }
+    const { owner, repo, issueNumber: prNumber } = parsedUrl;
+
+    const query = `
+      query($owner: String!, $repo: String!, $prNumber: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $prNumber) {
+            url
+            state
+            headRefName
+            baseRefName
+            mergeable
+            baseRepository {
+              branchProtectionRules(first: 100) {
+                nodes {
+                  pattern
+                  requiredStatusCheckContexts
+                }
+              }
+              defaultBranchRef {
+                name
+              }
+              rulesets(first: 100) {
+                nodes {
+                  name
+                  enforcement
+                  conditions {
+                    refName {
+                      include
+                      exclude
+                    }
+                  }
+                  rules(first: 100) {
+                    nodes {
+                      type
+                      parameters {
+                        ... on RequiredStatusChecksParameters {
+                          requiredStatusChecks {
+                            context
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            commits(last: 1) {
+              nodes {
+                commit {
+                  statusCheckRollup {
+                    state
+                    contexts(first: 100) {
+                      nodes {
+                        __typename
+                        ... on CheckRun {
+                          name
+                          conclusion
+                        }
+                        ... on StatusContext {
+                          context
+                          state
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            reviewThreads(first: 100) {
+              nodes {
+                isResolved
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    const response = await 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 },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch pull request from GitHub GraphQL API: HTTP ${response.status}`,
+      );
+    }
+
+    const responseData: unknown = await response.json();
+    if (!isDirectPullRequestResponse(responseData)) {
+      throw new Error('Unexpected response shape when fetching pull request');
+    }
+
+    if (responseData.errors && responseData.errors.length > 0) {
+      throw new Error(`GraphQL errors: ${JSON.stringify(responseData.errors)}`);
+    }
+
+    const pr = responseData.data?.repository?.pullRequest;
+    if (!pr || pr.state !== 'OPEN') {
+      return null;
+    }
+
+    return this.computePrStatus(pr.url, pr.headRefName, pr.baseRefName, pr);
   };
 }