Reduce GitHub API calls in issues reporter

src/reporter/github.js

@@ -28,6 +28,9 @@ export default class GitHub {
     const [ owner, repo ] = repository.split('/');
 
     this.commonParams = { owner, repo };
+
+    this.issuesCache = new Map();
+    this.cacheLoadedPromise = null;
   }
 
   async initialize() {
@@ -53,6 +56,49 @@ export default class GitHub {
     }
   }
 
+  async loadAllIssues() {
+    try {
+      const issues = await this.octokit.paginate('GET /repos/{owner}/{repo}/issues', {
+        ...this.commonParams,
+        state: GitHub.ISSUE_STATE_ALL,
+        per_page: 100,
+      });
+
+      const onlyIssues = issues.filter(issue => !issue.pull_request); // Filter out pull requests since GitHub treats them as a special type of issue
+
+      onlyIssues.forEach(issue => {
+        const cachedIssue = this.issuesCache.get(issue.title);
+
+        if (!cachedIssue || new Date(issue.created_at) < new Date(cachedIssue.created_at)) { // Only cache the oldest issue if there are duplicates
+          this.issuesCache.set(issue.title, issue);
+        }
+      });
+
+      logger.info(`Cached ${onlyIssues.length} issues from the repository`);
+    } catch (error) {
+      logger.error(`Failed to load issues: ${error.message}`);
+    }
+  }
+
+  async refreshIssuesCache() {
+    try {
+      logger.info('Refreshing issues cache from GitHub…');
+      this.issuesCache.clear();
+      this.cacheLoadedPromise = this.loadAllIssues();
+      await this.cacheLoadedPromise;
+      logger.info('Issues cache refreshed successfully');
+    } catch (error) {
+      logger.error(`Failed to refresh issues cache: ${error.message}`);
+    }
+  }
+
+  async ensureCacheLoaded() {
+    if (!this.cacheLoadedPromise) {
+      this.cacheLoadedPromise = this.loadAllIssues();
+    }
+    await this.cacheLoadedPromise;
+  }
+
   async getRepositoryLabels() {
     const { data: labels } = await this.octokit.request('GET /repos/{owner}/{repo}/labels', { ...this.commonParams });
 
@@ -69,40 +115,42 @@ export default class GitHub {
   }
 
   async createIssue({ title, description: body, labels }) {
+    await this.ensureCacheLoaded();
+
     const { data: issue } = await this.octokit.request('POST /repos/{owner}/{repo}/issues', {
       ...this.commonParams,
       title,
       body,
       labels,
     });
 
+    this.issuesCache.set(issue.title, issue);
+
     return issue;
   }
 
   async updateIssue(issue, { state, labels }) {
+    await this.ensureCacheLoaded();
+
     const { data: updatedIssue } = await this.octokit.request('PATCH /repos/{owner}/{repo}/issues/{issue_number}', {
       ...this.commonParams,
       issue_number: issue.number,
       state,
       labels,
     });
 
+    this.issuesCache.set(updatedIssue.title, updatedIssue);
+
     return updatedIssue;
   }
 
-  async getIssue({ title, ...searchParams }) {
-    const issues = await this.octokit.paginate('GET /repos/{owner}/{repo}/issues', {
-      ...this.commonParams,
-      per_page: 100,
-      ...searchParams,
-    }, response => response.data);
-
-    const [issue] = issues.filter(item => item.title === title); // Since only one is expected, use the first one
-
-    return issue;
+  getIssue(title) {
+    return this.issuesCache.get(title) || null;
   }
 
   async addCommentToIssue({ issue, comment: body }) {
+    await this.ensureCacheLoaded();
+
     const { data: comment } = await this.octokit.request('POST /repos/{owner}/{repo}/issues/{issue_number}/comments', {
       ...this.commonParams,
       issue_number: issue.number,
@@ -114,25 +162,30 @@ export default class GitHub {
 
   async closeIssueWithCommentIfExists({ title, comment }) {
     try {
-      const openedIssue = await this.getIssue({ title, state: GitHub.ISSUE_STATE_OPEN });
+      await this.ensureCacheLoaded();
 
-      if (!openedIssue) {
+      const issue = this.getIssue(title);
+
+      if (!issue || issue.state == GitHub.ISSUE_STATE_CLOSED) {
         return;
       }
 
-      await this.addCommentToIssue({ issue: openedIssue, comment });
-      logger.info(`Added comment to issue #${openedIssue.number}: ${openedIssue.html_url}`);
+      await this.addCommentToIssue({ issue, comment });
+
+      const updatedIssue = await this.updateIssue(issue, { state: GitHub.ISSUE_STATE_CLOSED });
 
-      await this.updateIssue(openedIssue, { state: GitHub.ISSUE_STATE_CLOSED });
-      logger.info(`Closed issue #${openedIssue.number}: ${openedIssue.html_url}`);
+      this.issuesCache.set(updatedIssue.title, updatedIssue);
+      logger.info(`Closed issue with comment #${updatedIssue.number}: ${updatedIssue.html_url}`);
     } catch (error) {
-      logger.error(`Failed to update issue "${title}": ${error.message}`);
+      logger.error(`Failed to close issue with comment "${title}": ${error.stack}`);
     }
   }
 
   async createOrUpdateIssue({ title, description, label }) {
     try {
-      const issue = await this.getIssue({ title, state: GitHub.ISSUE_STATE_ALL });
+      await this.ensureCacheLoaded();
+
+      const issue = this.getIssue(title);
 
       if (!issue) {
         const createdIssue = await this.createIssue({ title, description, labels: [label] });
@@ -141,23 +194,22 @@ export default class GitHub {
       }
 
       const managedLabelsNames = this.MANAGED_LABELS.map(label => label.name);
+
       const labelsNotManagedToKeep = issue.labels.map(label => label.name).filter(label => !managedLabelsNames.includes(label));
       const [managedLabel] = issue.labels.filter(label => managedLabelsNames.includes(label.name)); // It is assumed that only one specific reason for failure is possible at a time, making managed labels mutually exclusive
 
       if (issue.state !== GitHub.ISSUE_STATE_CLOSED && managedLabel?.name === label) {
         return;
       }
 
-      await this.updateIssue(issue, {
-        state: GitHub.ISSUE_STATE_OPEN,
-        labels: [ label, ...labelsNotManagedToKeep ],
-      });
-      logger.info(`Updated issue #${issue.number}: ${issue.html_url}`);
+      const updatedIssue = await this.updateIssue(issue, { state: GitHub.ISSUE_STATE_OPEN, labels: [ label, ...labelsNotManagedToKeep ].filter(label => label) });
+
       await this.addCommentToIssue({ issue, comment: description });
 
-      logger.info(`Added comment to issue #${issue.number}: ${issue.html_url}`);
+      this.issuesCache.set(updatedIssue.title, updatedIssue);
+      logger.info(`Updated issue with comment #${updatedIssue.number}: ${updatedIssue.html_url}`);
     } catch (error) {
-      logger.error(`Failed to update issue "${title}": ${error.message}`);
+      logger.error(`Failed to update issue "${title}": ${error.stack}`);
     }
   }
 }