@opentermsarchive/engine 0.31.0 → 0.32.0

package/.eslintrc.yaml

@@ -65,6 +65,12 @@ rules:
     - error
     - argsIgnorePattern: next
   no-use-before-define: 0
+  lines-between-class-members:
+    - error
+    - enforce:
+      - blankLine: always
+        prev: method
+        next: method
   padding-line-between-statements:
     - error
     - blankLine: always

package/config/default.json

@@ -54,13 +54,12 @@
       "updateTemplateId": 7
     }
   },
-  "tracker": {
+  "reporter": {
     "githubIssues": {
-      "repository": "OpenTermsArchive/sandbox",
-      "label": {
-        "name": "bot-report",
-        "color": "FEF2C0",
-        "description": "Automatically created when terms cannot be tracked"
+      "repositories": {
+        "declarations": "OpenTermsArchive/sandbox-declarations",
+        "versions": "OpenTermsArchive/sandbox-versions",
+        "snapshots": "OpenTermsArchive/sandbox-snapshots"
       }
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://github.com/OpenTermsArchive/engine#readme",
   "bugs": {

package/src/archivist/errors.js

@@ -1,9 +1,9 @@
 export class InaccessibleContentError extends Error {
-  constructor(message) {
-    if (Array.isArray(message)) {
-      message = `\n - ${message.join('\n - ')}`;
-    }
-    super(`The documents cannot be accessed or their contents can not be selected:${message}`);
+  constructor(reasonOrReasons) {
+    const reasons = [].concat(reasonOrReasons);
+
+    super(`The documents cannot be accessed or their contents can not be selected:${`\n - ${reasons.join('\n - ')}`}`);
     this.name = 'InaccessibleContentError';
+    this.reasons = reasons;
   }
 }

package/src/archivist/index.js

@@ -179,6 +179,7 @@ export default class Archivist extends events.EventEmitter {
 
       sourceDocument.content = snapshot.content;
       sourceDocument.mimeType = snapshot.mimeType;
+      sourceDocument.snapshotId = snapshot.id;
       terms.fetchDate = snapshot.fetchDate;
     }));
   }

package/src/index.js

@@ -4,7 +4,7 @@ import cron from 'croner';
 import Archivist from './archivist/index.js';
 import logger from './logger/index.js';
 import Notifier from './notifier/index.js';
-import Tracker from './tracker/index.js';
+import Reporter from './reporter/index.js';
 
 export default async function track({ services, types, extractOnly, schedule }) {
   const archivist = new Archivist({
@@ -43,10 +43,10 @@ export default async function track({ services, types, extractOnly, schedule })
   }
 
   if (process.env.GITHUB_TOKEN) {
-    const tracker = new Tracker(config.get('tracker'));
+    const reporter = new Reporter(config.get('reporter'));
 
-    await tracker.initialize();
-    archivist.attach(tracker);
+    await reporter.initialize();
+    archivist.attach(reporter);
   }
 
   if (!schedule) {

package/src/reporter/github.js

@@ -0,0 +1,206 @@
+import { createRequire } from 'module';
+
+import { Octokit } from 'octokit';
+
+import logger from '../logger/index.js';
+
+const require = createRequire(import.meta.url);
+
+export const MANAGED_BY_OTA_MARKER = '[managed by OTA]';
+
+export default class GitHub {
+  static ISSUE_STATE_CLOSED = 'closed';
+  static ISSUE_STATE_OPEN = 'open';
+  static ISSUE_STATE_ALL = 'all';
+
+  constructor(repository) {
+    const { version } = require('../../package.json');
+
+    this.octokit = new Octokit({ auth: process.env.GITHUB_TOKEN, userAgent: `opentermsarchive/${version}` });
+
+    const [ owner, repo ] = repository.split('/');
+
+    this.commonParams = { owner, repo };
+  }
+
+  async initialize() {
+    try {
+      const { data: user } = await this.octokit.request('GET /user', { ...this.commonParams });
+
+      this.authenticatedUserLogin = user.login;
+    } catch (error) {
+      logger.error(`🤖 Could not get authenticated user: ${error}`);
+    }
+
+    this.MANAGED_LABELS = require('./labels.json');
+
+    const existingLabels = await this.getRepositoryLabels();
+    const existingLabelsNames = existingLabels.map(label => label.name);
+    const missingLabels = this.MANAGED_LABELS.filter(label => !existingLabelsNames.includes(label.name));
+
+    if (missingLabels.length) {
+      logger.info(`🤖 Following required labels are not present on the repository: ${missingLabels.map(label => `"${label.name}"`).join(', ')}. Creating them…`);
+
+      for (const label of missingLabels) {
+        await this.createLabel({ /* eslint-disable-line no-await-in-loop */
+          name: label.name,
+          color: label.color,
+          description: `${label.description} ${MANAGED_BY_OTA_MARKER}`,
+        });
+      }
+    }
+  }
+
+  async getRepositoryLabels() {
+    try {
+      const { data: labels } = await this.octokit.request('GET /repos/{owner}/{repo}/labels', { ...this.commonParams });
+
+      return labels;
+    } catch (error) {
+      logger.error(`🤖 Could get labels: ${error}`);
+    }
+  }
+
+  async createLabel({ name, color, description }) {
+    try {
+      await this.octokit.request('POST /repos/{owner}/{repo}/labels', {
+        ...this.commonParams,
+        name,
+        color,
+        description,
+      });
+
+      logger.info(`🤖 Created repository label "${name}"`);
+    } catch (error) {
+      logger.error(`🤖 Could not create label "${name}": ${error}`);
+    }
+  }
+
+  async createIssue({ title, description: body, labels }) {
+    try {
+      const { data: issue } = await this.octokit.request('POST /repos/{owner}/{repo}/issues', {
+        ...this.commonParams,
+        title,
+        body,
+        labels,
+      });
+
+      logger.info(`🤖 Created GitHub issue #${issue.number} "${title}": ${issue.html_url}`);
+
+      return issue;
+    } catch (error) {
+      logger.error(`🤖 Could not create GitHub issue "${title}": ${error}`);
+    }
+  }
+
+  async setIssueLabels({ issue, labels }) {
+    try {
+      await this.octokit.request('PUT /repos/{owner}/{repo}/issues/{issue_number}/labels', {
+        ...this.commonParams,
+        issue_number: issue.number,
+        labels,
+      });
+
+      logger.info(`🤖 Updated labels to GitHub issue #${issue.number}`);
+    } catch (error) {
+      logger.error(`🤖 Could not update GitHub issue #${issue.number} "${issue.title}": ${error}`);
+    }
+  }
+
+  async openIssue(issue) {
+    try {
+      await this.octokit.request('PATCH /repos/{owner}/{repo}/issues/{issue_number}', {
+        ...this.commonParams,
+        issue_number: issue.number,
+        state: GitHub.ISSUE_STATE_OPEN,
+      });
+
+      logger.info(`🤖 Opened GitHub issue #${issue.number}`);
+    } catch (error) {
+      logger.error(`🤖 Could not update GitHub issue #${issue.number} "${issue.title}": ${error}`);
+    }
+  }
+
+  async closeIssue(issue) {
+    try {
+      await this.octokit.request('PATCH /repos/{owner}/{repo}/issues/{issue_number}', {
+        ...this.commonParams,
+        issue_number: issue.number,
+        state: GitHub.ISSUE_STATE_CLOSED,
+      });
+
+      logger.info(`🤖 Closed GitHub issue #${issue.number}`);
+    } catch (error) {
+      logger.error(`🤖 Could not update GitHub issue #${issue.number} "${issue.title}": ${error}`);
+    }
+  }
+
+  async getIssue({ title, ...searchParams }) {
+    try {
+      const issues = await this.octokit.paginate('GET /repos/{owner}/{repo}/issues', {
+        ...this.commonParams,
+        per_page: 100,
+        creator: this.authenticatedUserLogin,
+        ...searchParams,
+      }, response => response.data);
+
+      const [issue] = issues.filter(item => item.title === title); // since only one is expected, use the first one
+
+      return issue;
+    } catch (error) {
+      logger.error(`🤖 Could not find GitHub issue "${title}": ${error}`);
+    }
+  }
+
+  async addCommentToIssue({ issue, comment: body }) {
+    try {
+      const { data: comment } = await this.octokit.request('POST /repos/{owner}/{repo}/issues/{issue_number}/comments', {
+        ...this.commonParams,
+        issue_number: issue.number,
+        body,
+      });
+
+      logger.info(`🤖 Added comment to GitHub issue #${issue.number}: ${comment.html_url}`);
+
+      return comment;
+    } catch (error) {
+      logger.error(`🤖 Could not add comment to GitHub issue #${issue.number} "${issue.title}": ${error}`);
+    }
+  }
+
+  async closeIssueWithCommentIfExists({ title, comment }) {
+    const openedIssue = await this.getIssue({ title, state: GitHub.ISSUE_STATE_OPEN });
+
+    if (!openedIssue) {
+      return;
+    }
+
+    await this.addCommentToIssue({ issue: openedIssue, comment });
+
+    return this.closeIssue(openedIssue);
+  }
+
+  async createOrUpdateIssue({ title, description, label }) {
+    const issue = await this.getIssue({ title, state: GitHub.ISSUE_STATE_ALL });
+
+    if (!issue) {
+      return this.createIssue({ title, description, labels: [label] });
+    }
+
+    if (issue.state == this.ISSUE_STATE_CLOSED) {
+      await this.openIssue(issue);
+    }
+
+    const managedLabelsNames = this.MANAGED_LABELS.map(label => label.name);
+    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 (managedLabel?.name == label) { // if the label is already assigned to the issue, the error is redundant with the one already reported and no further action is necessary
+      return;
+    }
+
+    const labelsNotManagedToKeep = issue.labels.map(label => label.name).filter(label => !managedLabelsNames.includes(label));
+
+    await this.setIssueLabels({ issue, labels: [ label, ...labelsNotManagedToKeep ] });
+    await this.addCommentToIssue({ issue, comment: description });
+  }
+}

package/src/reporter/index.js

@@ -0,0 +1,144 @@
+import mime from 'mime';
+
+import GitHub from './github.js';
+
+const CONTRIBUTION_TOOL_URL = 'https://contribute.opentermsarchive.org/en/service';
+const DOC_URL = 'https://docs.opentermsarchive.org';
+
+const ERROR_MESSAGE_TO_ISSUE_LABEL_MAP = {
+  'has no match': 'selectors',
+  'HTTP code 404': 'location',
+  'HTTP code 403': '403',
+  'HTTP code 429': '429',
+  'HTTP code 500': '500',
+  'HTTP code 502': '502',
+  'HTTP code 503': '503',
+  'Timed out after': 'timeout',
+  'getaddrinfo EAI_AGAIN': 'EAI_AGAIN',
+  'getaddrinfo ENOTFOUND': 'ENOTFOUND',
+  'Response is empty': 'empty response',
+  'unable to verify the first certificate': 'first certificate',
+  'certificate has expired': 'certificate expired',
+  'maximum redirect reached': 'redirects',
+};
+
+function getLabelNameFromError(error) {
+  return ERROR_MESSAGE_TO_ISSUE_LABEL_MAP[Object.keys(ERROR_MESSAGE_TO_ISSUE_LABEL_MAP).find(substring => error.toString().includes(substring))] || 'to clarify';
+}
+
+// In the following class, it is assumed that each issue is managed using its title as a unique identifier
+export default class Reporter {
+  constructor(config) {
+    const { repositories } = config.githubIssues;
+
+    for (const repositoryType of Object.keys(repositories)) {
+      if (!repositories[repositoryType].includes('/') || repositories[repositoryType].includes('https://')) {
+        throw new Error(`Configuration entry "reporter.githubIssues.repositories.${repositoryType}" is expected to be a string in the format <owner>/<repo>, but received: "${repositories[repositoryType]}"`);
+      }
+    }
+
+    this.github = new GitHub(repositories.declarations);
+    this.repositories = repositories;
+  }
+
+  async initialize() {
+    return this.github.initialize();
+  }
+
+  async onVersionRecorded(version) {
+    await this.github.closeIssueWithCommentIfExists({
+      title: Reporter.generateTitleID(version.serviceId, version.termsType),
+      comment: `### Tracking resumed
+
+A new version has been recorded.`,
+    });
+  }
+
+  async onVersionNotChanged(version) {
+    await this.github.closeIssueWithCommentIfExists({
+      title: Reporter.generateTitleID(version.serviceId, version.termsType),
+      comment: `### Tracking resumed
+
+No changes were found in the last run, so no new version has been recorded.`,
+    });
+  }
+
+  async onFirstVersionRecorded(version) {
+    return this.onVersionRecorded(version);
+  }
+
+  async onInaccessibleContent(error, terms) {
+    await this.github.createOrUpdateIssue({
+      title: Reporter.generateTitleID(terms.service.id, terms.type),
+      description: this.generateDescription({ error, terms }),
+      label: getLabelNameFromError(error),
+    });
+  }
+
+  generateDescription({ error, terms }) {
+    const date = new Date();
+    const currentFormattedDate = date.toLocaleDateString('en-GB', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric', timeZoneName: 'short', timeZone: 'UTC' });
+    const validUntil = date.toISOString().replace(/\.\d+/, ''); // ISO date without milliseconds
+
+    const hasSnapshots = terms.sourceDocuments.every(sourceDocument => sourceDocument.snapshotId);
+
+    const contributionToolParams = new URLSearchParams({
+      json: JSON.stringify(terms.toPersistence()),
+      destination: this.repositories.declarations,
+      step: '2',
+    });
+    const contributionToolUrl = `${CONTRIBUTION_TOOL_URL}?${contributionToolParams}`;
+
+    const latestDeclarationLink = `[Latest declaration](https://github.com/${this.repositories.declarations}/blob/main/declarations/${encodeURIComponent(terms.service.name)}.json)`;
+    const latestVersionLink = `[Latest version](https://github.com/${this.repositories.versions}/blob/main/${encodeURIComponent(terms.service.name)}/${encodeURIComponent(terms.type)}.md)`;
+    const snapshotsBaseUrl = `https://github.com/${this.repositories.snapshots}/blob/main/${encodeURIComponent(terms.service.name)}/${encodeURIComponent(terms.type)}`;
+    const latestSnapshotsLink = terms.hasMultipleSourceDocuments
+      ? `Latest snapshots:\n  - ${terms.sourceDocuments.map(sourceDocument => `[${sourceDocument.id}](${snapshotsBaseUrl}.%20#${sourceDocument.id}.${mime.getExtension(sourceDocument.mimeType)})`).join('\n  - ')}`
+      : `[Latest snapshot](${snapshotsBaseUrl}.${mime.getExtension(terms.sourceDocuments[0].mimeType)})`;
+
+    /* eslint-disable no-irregular-whitespace */
+    return `
+### No version of the \`${terms.type}\` of service \`${terms.service.name}\` is recorded anymore since ${currentFormattedDate}
+
+The source document${terms.hasMultipleSourceDocuments ? 's have' : ' has'}${hasSnapshots ? ' ' : ' not '}been recorded in ${terms.hasMultipleSourceDocuments ? 'snapshots' : 'a snapshot'}, ${hasSnapshots ? 'but ' : 'thus '} no version can be [extracted](${DOC_URL}/#tracking-terms).
+${hasSnapshots ? 'After correction, it might still be possible to recover the missed versions.' : ''}
+
+### What went wrong
+
+- ${error.reasons.join('\n- ')}
+
+### How to resume tracking
+
+First of all, check if the source documents are accessible through a web browser:
+
+- [ ] ${terms.sourceDocuments.map(sourceDocument => `[${sourceDocument.location}](${sourceDocument.location})`).join('\n- [ ] ')}
+
+#### If the source documents are accessible through a web browser
+
+[Edit the declaration](${contributionToolUrl}):
+- Try updating the selectors.
+- Try switching client scripts on with expert mode.
+
+#### If the source documents are not accessible anymore
+
+- If the source documents have moved, find their new location and [update it](${contributionToolUrl}).
+- If these terms have been removed, move them from the declaration to its [history file](${DOC_URL}/contributing-terms/#service-history), using \`${validUntil}\` as the \`validUntil\` value.
+- If the service has closed, move the entire contents of the declaration to its [history file](${DOC_URL}/contributing-terms/#service-history), using \`${validUntil}\` as the \`validUntil\` value.
+
+#### If none of the above works
+
+If the source documents are accessible in a browser but fetching them always fails from the Open Terms Archive server, this is most likely because the service provider has blocked the Open Terms Archive robots from accessing its content. In this case, updating the declaration will not enable resuming tracking. Only an agreement with the service provider, an engine upgrade, or some technical workarounds provided by the administrator of this collection’s server might resume tracking.
+
+### References
+
+- ${latestDeclarationLink}
+- ${latestVersionLink}
+- ${latestSnapshotsLink}
+`;
+  /* eslint-enable no-irregular-whitespace */
+  }
+
+  static generateTitleID(serviceId, type) {
+    return `\`${serviceId}\` ‧ \`${type}\` ‧ not tracked anymore`;
+  }
+}

package/src/reporter/labels.json

@@ -0,0 +1,77 @@
+[
+  {
+    "name": "403",
+    "color": "0b08a0",
+    "description": "Fetching fails with a 403 (forbidden) HTTP code"
+  },
+  {
+    "name": "429",
+    "color": "0b08a0",
+    "description": "Fetching fails with a 429 (too many requests) HTTP code"
+  },
+  {
+    "name": "500",
+    "color": "0b08a0",
+    "description": "Fetching fails with a 500 (internal server error) HTTP code"
+  },
+  {
+    "name": "502",
+    "color": "0b08a0",
+    "description": "Fetching fails with a 502 (bad gateway) HTTP code"
+  },
+  {
+    "name": "503",
+    "color": "0b08a0",
+    "description": "Fetching fails with a 503 (service unavailable) HTTP code"
+  },
+  {
+    "name": "certificate expired",
+    "color": "0b08a0",
+    "description": "Fetching fails because the domain SSL certificate has expired"
+  },
+  {
+    "name": "EAI_AGAIN",
+    "color": "0b08a0",
+    "description": "Fetching fails because the domain fails to resolve on DNS"
+  },
+  {
+    "name": "ENOTFOUND",
+    "color": "0b08a0",
+    "description": "Fetching fails because the domain fails to resolve on DNS"
+  },
+  {
+    "name": "empty response",
+    "color": "0b08a0",
+    "description": "Fetching fails with a “response is empty” error"
+  },
+  {
+    "name": "first certificate",
+    "color": "0b08a0",
+    "description": "Fetching fails with an “unable to verify the first certificate” error"
+  },
+  {
+    "name": "redirects",
+    "color": "0b08a0",
+    "description": "Fetching fails with a “too many redirects” error"
+  },
+  {
+    "name": "timeout",
+    "color": "0b08a0",
+    "description": "Fetching fails with a timeout error"
+  },
+  {
+    "name": "to clarify",
+    "color": "0496ff",
+    "description": "Default failure label"
+  },
+  {
+    "name": "selectors",
+    "color": "FBCA04",
+    "description": "Extraction selectors are outdated"
+  },
+  {
+    "name": "location",
+    "color": "FBCA04",
+    "description": "Fetch location is outdated"
+  }
+]

package/src/reporter/labels.test.js

@@ -0,0 +1,30 @@
+import { createRequire } from 'module';
+
+import chai from 'chai';
+
+import { MANAGED_BY_OTA_MARKER } from './github.js';
+
+const require = createRequire(import.meta.url);
+
+const { expect } = chai;
+const labels = require('./labels.json');
+
+const GITHUB_LABEL_DESCRIPTION_MAX_LENGTH = 100;
+
+describe('Reporter GitHub labels', () => {
+  labels.forEach(label => {
+    describe(`"${label.name}"`, () => {
+      it('complies with the GitHub character limit for descriptions', () => {
+        const descriptionLength = label.description.length + MANAGED_BY_OTA_MARKER.length;
+
+        expect(descriptionLength).to.be.lessThan(GITHUB_LABEL_DESCRIPTION_MAX_LENGTH);
+      });
+
+      it('complies with the GitHub constraints for color', () => {
+        const validHexColorRegex = /^[0-9a-fA-F]{6}$/; // Regex for a valid 6-digit hexadecimal color code without the `#`
+
+        expect(validHexColorRegex.test(label.color)).to.be.true;
+      });
+    });
+  });
+});

package/src/tracker/index.js

@@ -1,215 +0,0 @@
-import fs from 'fs';
-
-import { Octokit } from 'octokit';
-
-import logger from '../logger/index.js';
-
-const { version } = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url)).toString());
-
-const ISSUE_STATE_CLOSED = 'closed';
-const ISSUE_STATE_OPEN = 'open';
-const ISSUE_STATE_ALL = 'all';
-
-const CONTRIBUTE_URL = 'https://contribute.opentermsarchive.org/en/service';
-const GOOGLE_URL = 'https://www.google.com/search?q=';
-
-export default class Tracker {
-  static isRepositoryValid(repository) {
-    return repository.includes('/');
-  }
-
-  constructor(trackerConfig) {
-    const { repository, label } = trackerConfig.githubIssues;
-
-    if (!Tracker.isRepositoryValid(repository)) {
-      throw new Error('tracker.githubIssues.repository should be a string with <owner>/<repo>');
-    }
-
-    const [ owner, repo ] = repository.split('/');
-
-    this.octokit = new Octokit({
-      auth: process.env.GITHUB_TOKEN,
-      userAgent: `opentermsarchive/${version}`,
-    });
-    this.cachedIssues = {};
-    this.commonParams = {
-      owner,
-      repo,
-      accept: 'application/vnd.github.v3+json',
-    };
-    this.repository = repository;
-    this.label = label;
-  }
-
-  async initialize() {
-    await this.createLabel({
-      name: this.label.name,
-      color: this.label.color,
-      description: this.label.description,
-    });
-  }
-
-  async onVersionRecorded(serviceId, type) {
-    await this.closeIssueIfExists({
-      labels: [this.label.name],
-      title: `Fix ${serviceId} - ${type}`,
-      comment: '🤖 Closed automatically as data was gathered successfully',
-    });
-  }
-
-  async onVersionNotChanged(serviceId, type) {
-    await this.closeIssueIfExists({
-      labels: [this.label.name],
-      title: `Fix ${serviceId} - ${type}`,
-      comment: '🤖 Closed automatically as version is unchanged but data has been fetched correctly',
-    });
-  }
-
-  async onFirstVersionRecorded(serviceId, type) {
-    return this.onVersionRecorded(serviceId, type);
-  }
-
-  async onInaccessibleContent(error, terms) {
-    const { title, body } = Tracker.formatIssueTitleAndBody({ message: error.toString(), repository: this.repository, terms });
-
-    await this.createIssueIfNotExists({
-      title,
-      body,
-      labels: [this.label.name],
-      comment: '🤖 Reopened automatically as an error occured',
-    });
-  }
-
-  async createLabel(params) {
-    return this.octokit.rest.issues.createLabel({ ...this.commonParams, ...params })
-      .catch(error => {
-        if (error.toString().includes('"code":"already_exists"')) {
-          return;
-        }
-        logger.error(`Could not create label "${params.name}": ${error.toString()}`);
-      });
-  }
-
-  async createIssue(params) {
-    const { data } = await this.octokit.rest.issues.create(params);
-
-    return data;
-  }
-
-  async searchIssues({ title, ...searchParams }) {
-    const request = {
-      per_page: 100,
-      ...searchParams,
-    };
-
-    const issues = await this.octokit.paginate(
-      this.octokit.rest.issues.listForRepo,
-      request,
-      response => response.data,
-    );
-
-    const issuesWithSameTitle = issues.filter(item => item.title === title);
-
-    return issuesWithSameTitle;
-  }
-
-  async addCommentToIssue(params) {
-    const { data } = await this.octokit.rest.issues.createComment(params);
-
-    return data;
-  }
-
-  async createIssueIfNotExists({ title, body, labels, comment }) {
-    try {
-      const existingIssues = await this.searchIssues({ ...this.commonParams, title, labels, state: ISSUE_STATE_ALL });
-
-      if (!existingIssues.length) {
-        const existingIssue = await this.createIssue({ ...this.commonParams, title, body, labels });
-
-        logger.info(`🤖 Creating GitHub issue for ${title}: ${existingIssue.html_url}`);
-
-        return;
-      }
-
-      const openedIssues = existingIssues.filter(existingIssue => existingIssue.state === ISSUE_STATE_OPEN);
-      const hasNoneOpened = openedIssues.length === 0;
-
-      for (const existingIssue of existingIssues) {
-        if (hasNoneOpened) {
-          try {
-            /* eslint-disable no-await-in-loop */
-            await this.octokit.rest.issues.update({
-              ...this.commonParams,
-              issue_number: existingIssue.number,
-              state: ISSUE_STATE_OPEN,
-            });
-            await this.addCommentToIssue({
-              ...this.commonParams,
-              issue_number: existingIssue.number,
-              body: `${comment}\n${body}`,
-            });
-            /* eslint-enable no-await-in-loop */
-            logger.info(`🤖 Reopened automatically as an error occured for ${title}: ${existingIssue.html_url}`);
-          } catch (e) {
-            logger.error(`🤖 Could not update GitHub issue ${existingIssue.html_url}: ${e}`);
-          }
-          break;
-        }
-      }
-    } catch (e) {
-      logger.error(`🤖 Could not create GitHub issue for ${title}: ${e}`);
-    }
-  }
-
-  async closeIssueIfExists({ title, comment, labels }) {
-    try {
-      const openedIssues = await this.searchIssues({ ...this.commonParams, title, labels, state: ISSUE_STATE_OPEN });
-
-      for (const openedIssue of openedIssues) {
-        try {
-          await this.octokit.rest.issues.update({ ...this.commonParams, issue_number: openedIssue.number, state: ISSUE_STATE_CLOSED }); // eslint-disable-line no-await-in-loop
-          await this.addCommentToIssue({ ...this.commonParams, issue_number: openedIssue.number, body: comment }); // eslint-disable-line no-await-in-loop
-          logger.info(`🤖 GitHub issue closed for ${title}: ${openedIssue.html_url}`);
-        } catch (e) {
-          logger.error(`🤖 Could not close GitHub issue ${openedIssue.html_url}: ${e.toString()}`);
-        }
-      }
-    } catch (e) {
-      logger.error(`🤖 Could not close GitHub issue for ${title}: ${e}`);
-    }
-  }
-
-  static formatIssueTitleAndBody({ message, repository, terms }) {
-    const { service: { name }, type } = terms;
-    const json = terms.toPersistence();
-    const title = `Fix ${name} - ${type}`;
-
-    const encodedName = encodeURIComponent(name);
-    const encodedType = encodeURIComponent(type);
-
-    const urlQueryParams = new URLSearchParams({
-      json: JSON.stringify(json),
-      destination: repository,
-      expertMode: 'true',
-      step: '2',
-    });
-
-    const body = `
-These terms are no longer tracked.
-
-${message}
-
-Check what's wrong by:
-- Using the [online contribution tool](${CONTRIBUTE_URL}?${urlQueryParams}).
-${message.includes('404') ? `- [Searching Google](${GOOGLE_URL}%22${encodedName}%22+%22${encodedType}%22) to get for a new URL.` : ''}
-
-And some info about what has already been tracked:
-- See [service declaration JSON file](https://github.com/${repository}/blob/main/declarations/${encodedName}.json).
-`;
-
-    return {
-      title,
-      body,
-    };
-  }
-}