@opentermsarchive/engine 5.0.2 → 5.0.4

package/.eslintrc.yaml

@@ -1,5 +1,6 @@
 extends:
   - airbnb-base
+  - plugin:jsdoc/recommended-error
 parserOptions:
   ecmaVersion: 2022
 env:
@@ -11,7 +12,16 @@ plugins:
   - import
   - json-format
   - no-only-tests
+  - jsdoc
 rules:
+  jsdoc/require-jsdoc: 0
+  jsdoc/check-tag-names:
+    - error
+    - definedTags:
+      - swagger
+  jsdoc/check-line-alignment: 
+    - error
+    - always
   arrow-parens:
     - error
     - as-needed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "5.0.2",
+  "version": "5.0.4",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://opentermsarchive.org",
   "bugs": {
@@ -108,6 +108,7 @@
   "devDependencies": {
     "@commitlint/cli": "^19.0.3",
     "dir-compare": "^4.0.0",
+    "eslint-plugin-jsdoc": "^50.6.9",
     "keep-a-changelog": "^2.5.3",
     "nock": "^13.2.1",
     "node-stream-zip": "^1.15.0",

package/src/archivist/extract/index.js

@@ -5,6 +5,8 @@ import turndownPluginGithubFlavouredMarkdown from 'joplin-turndown-plugin-gfm';
 import jsdom from 'jsdom';
 import mime from 'mime';
 
+import SourceDocument from '../services/sourceDocument.js';
+
 import { ExtractDocumentError } from './errors.js';
 
 export { ExtractDocumentError } from './errors.js';
@@ -23,11 +25,11 @@ const ciceroMarkTransformer = new CiceroMarkTransformer();
 
 /**
  * Extract content from source document and convert it to Markdown
- *
  * @function extract
- * @param {string} sourceDocument - Source document from which to extract content, see {@link ./src/archivist/services/sourceDocument.js}
- * @returns {Promise<string>} Promise which is fulfilled once the content is extracted and converted in Markdown. The promise will resolve into a string containing the extracted content in Markdown format
-*/
+ * @param   {string}          sourceDocument Source document from which to extract content, see {@link SourceDocument}
+ * @returns {Promise<string>}                Promise which is fulfilled once the content is extracted and converted in Markdown. The promise will resolve into a string containing the extracted content in Markdown format
+ * @async
+ */
 export default async function extract(sourceDocument) {
   try {
     if (sourceDocument.mimeType == mime.getType('pdf')) {

package/src/archivist/fetcher/fullDomFetcher.js

@@ -62,6 +62,12 @@ export default async function fetch(url, cssSelectors, config) {
   }
 }
 
+/**
+ * Launches a headless browser instance using Puppeteer if one is not already running. Returns the existing browser instance if one is already running, otherwise creates and returns a new instance.
+ * @function launchHeadlessBrowser
+ * @returns {Promise<puppeteer.Browser>} The Puppeteer browser instance.
+ * @async
+ */
 export async function launchHeadlessBrowser() {
   if (browser) {
     return browser;
@@ -72,6 +78,12 @@ export async function launchHeadlessBrowser() {
   return browser;
 }
 
+/**
+ * Stops the headless browser instance if one is running. If no instance exists, it does nothing.
+ * @function stopHeadlessBrowser
+ * @returns {Promise<void>}
+ * @async
+ */
 export async function stopHeadlessBrowser() {
   if (!browser) {
     return;

package/src/archivist/fetcher/index.js

@@ -9,17 +9,17 @@ export { FetchDocumentError } from './errors.js';
 
 /**
  * Fetch a resource from the network, returning a promise which is fulfilled once the response is available
- *
  * @function fetch
- * @param {Object} params - Fetcher parameters
- * @param {string} params.url - URL of the resource you want to fetch
- * @param {boolean} [params.executeClientScripts] - Enable execution of client scripts. When set to `true`, this property loads the page in a headless browser to load all assets and execute client scripts before returning its content
- * @param {string|Array} [params.cssSelectors] - List of CSS selectors to await when loading the resource in a headless browser. Can be a CSS selector or an array of CSS selectors. Only relevant when `executeClientScripts` is enabled
- * @param {Object} [params.config] - Fetcher configuration
- * @param {number} [params.config.navigationTimeout] - Maximum time (in milliseconds) to wait before considering the fetch failed
- * @param {string} [params.config.language] - Language (in [ISO 639-1 format](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) to be passed in request headers
- * @param {number} [params.config.waitForElementsTimeout] - Maximum time (in milliseconds) to wait for selectors to exist on page before considering the fetch failed. Only relevant when `executeClientScripts` is enabled
- * @returns {Promise} @returns {Promise<Object>} Promise which will be resolved with an object containing the `mimeType` and the `content` of the URL as string or Buffer
+ * @param   {object}                                                  params                                 Fetcher parameters
+ * @param   {string}                                                  params.url                             URL of the resource you want to fetch
+ * @param   {boolean}                                                 [params.executeClientScripts]          Enable execution of client scripts. When set to `true`, this property loads the page in a headless browser to load all assets and execute client scripts before returning its content
+ * @param   {string|Array}                                            [params.cssSelectors]                  List of CSS selectors to await when loading the resource in a headless browser. Can be a CSS selector or an array of CSS selectors. Only relevant when `executeClientScripts` is enabled
+ * @param   {object}                                                  [params.config]                        Fetcher configuration
+ * @param   {number}                                                  [params.config.navigationTimeout]      Maximum time (in milliseconds) to wait before considering the fetch failed
+ * @param   {string}                                                  [params.config.language]               Language (in [ISO 639-1 format](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) to be passed in request headers
+ * @param   {number}                                                  [params.config.waitForElementsTimeout] Maximum time (in milliseconds) to wait for selectors to exist on page before considering the fetch failed. Only relevant when `executeClientScripts` is enabled
+ * @returns {Promise<{ mimeType: string, content: string | Buffer }>}                                        Promise containing the fetched resource's MIME type and content
+ * @async
  */
 export default async function fetch({
   url, executeClientScripts, cssSelectors,

package/src/archivist/recorder/record.js

@@ -1,7 +1,7 @@
 /**
  * Abstract Class Record.
- *
  * @class Record
+ * @private
  */
 export default class Record {
   #content;

package/src/archivist/recorder/repositories/interface.js

@@ -4,120 +4,113 @@
  * @interface
  */
 
+import Record from '../record.js';
+
 /* eslint-disable require-await */
 class RepositoryInterface {
   /**
-  * [Optional] Initialize repository
-  * Override this method if the repository needs some asynchronous initialization code (open database connection and create collections, initialize Git…)
-  *
-  * @returns {Promise<Repository>} Promise that will be resolved with the current repository instance
-  */
+   * [Optional] Initialize repository
+   * Override this method if the repository needs some asynchronous initialization code (open database connection and create collections, initialize Git…)
+   * @returns {Promise<RepositoryInterface>} Promise that will be resolved with the current repository instance
+   */
   async initialize() {
     return this;
   }
 
   /**
-  * [Optional] Finalize repository
-  * Override this method if the repository needs some asynchronous code to properly close the repository (close database connection, push changes on Git remote…)
-  *
-  * @returns {Promise<Repository>} Promise that will be resolved with the current repository instance
-  */
+   * [Optional] Finalize repository
+   * Override this method if the repository needs some asynchronous code to properly close the repository (close database connection, push changes on Git remote…)
+   * @returns {Promise<RepositoryInterface>} Promise that will be resolved with the current repository instance
+   */
   async finalize() {
     return this;
   }
 
   /**
-  * Persist the given record if it does not already exist in repository
-  *
-  * @param {Record} record - Record to persist
-  * @returns {Promise<Record>} Promise that will be resolved with the given record when it has been persisted
-  */
+   * Persist the given record if it does not already exist in repository
+   * @param   {Record}          record - Record to persist
+   * @returns {Promise<Record>}        Promise that will be resolved with the given record when it has been persisted
+   */
   async save(record) {
     throw new Error(`#save method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Find the most recent record that matches the given service ID and terms type and optionally the document ID
-  * In case of snapshots, if the record is related to terms extracted from multiple source documents, the document ID is required to find the source snapshot
-  *
-  * @param {string} serviceId - Service ID of record to find
-  * @param {string} termsType - Terms type of record to find
-  * @param {string} [documentId] - Document ID of record to find. Used to identify the source in terms extracted from multiple source documents. Not necessary for terms with a single source document
-  * @returns {Promise<Record>} Promise that will be resolved with the found record or an empty object if none match the given criteria
-  */
+   * Find the most recent record that matches the given service ID and terms type and optionally the document ID
+   * In case of snapshots, if the record is related to terms extracted from multiple source documents, the document ID is required to find the source snapshot
+   * @param   {string}          serviceId    - Service ID of record to find
+   * @param   {string}          termsType    - Terms type of record to find
+   * @param   {string}          [documentId] - Document ID of record to find. Used to identify the source in terms extracted from multiple source documents. Not necessary for terms with a single source document
+   * @returns {Promise<Record>}              Promise that will be resolved with the found record or an empty object if none match the given criteria
+   */
   async findLatest(serviceId, termsType, documentId) {
     throw new Error(`#findLatest method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Find the record that was valid on the given date and that matches the given service ID and terms type and optionally the document ID
-  * In case of snapshots, if the record is related to terms extracted from multiple source documents, the document ID is required to find the source snapshot
-  *
-  * @param {string} serviceId - Service ID of record to find
-  * @param {string} termsType - Terms type of record to find
-  * @param {date} date - Datetime on which the record to find was valid
-  * @param {string} [documentId] - Document ID of record to find. Used to identify the source in terms extracted from multiple source documents. Not necessary for terms with a single source document
-  * @returns {Promise<Record>} Promise that will be resolved with the found record or an empty object if none match the given criteria
-  */
+   * Find the record that was valid on the given date and that matches the given service ID and terms type and optionally the document ID
+   * In case of snapshots, if the record is related to terms extracted from multiple source documents, the document ID is required to find the source snapshot
+   * @param   {string}          serviceId    - Service ID of record to find
+   * @param   {string}          termsType    - Terms type of record to find
+   * @param   {Date}            date         - Datetime on which the record to find was valid
+   * @param   {string}          [documentId] - Document ID of record to find. Used to identify the source in terms extracted from multiple source documents. Not necessary for terms with a single source document
+   * @returns {Promise<Record>}              Promise that will be resolved with the found record or an empty object if none match the given criteria
+   */
   async findByDate(serviceId, termsType, date, documentId) {
     throw new Error(`#findByDate method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Find the record that matches the given record ID
-  *
-  * @param {string} recordId - Record ID of the record to find
-  * @returns {Promise<Record>} Promise that will be resolved with the found record or an empty object if none match the given ID
-  */
+   * Find the record that matches the given record ID
+   * @param   {string}          recordId - Record ID of the record to find
+   * @returns {Promise<Record>}          Promise that will be resolved with the found record or an empty object if none match the given ID
+   */
   async findById(recordId) {
     throw new Error(`#findById method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Find all records
-  * For performance reasons, the content of the records will not be loaded by default. Use #loadRecordContent to load the content of individual records
-  *
-  * @see RepositoryInterface#loadRecordContent
-  * @returns {Promise<Array<Record>>} Promise that will be resolved with an array of all records
-  */
+   * Find all records
+   * For performance reasons, the content of the records will not be loaded by default. Use #loadRecordContent to load the content of individual records
+   * @see RepositoryInterface#loadRecordContent
+   * @returns {Promise<Array<Record>>} Promise that will be resolved with an array of all records
+   */
   async findAll() {
     throw new Error(`#findAll method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Count the total number of records in the repository
-  * For performance reasons, use this method rather than counting the number of entries returned by #findAll if you only need the size of a repository
-  *
-  * @returns {Promise<number>} Promise that will be resolved with the total number of records
-  */
+   * Count the total number of records in the repository
+   * For performance reasons, use this method rather than counting the number of entries returned by #findAll if you only need the size of a repository
+   * @returns {Promise<number>} Promise that will be resolved with the total number of records
+   */
   async count() {
     throw new Error(`#count method is not implemented in ${this.constructor.name}`);
   }
 
+  /* eslint-disable jsdoc/require-yields-check */
   /**
-  * Iterate over all records in the repository, from oldest to most recent
-  *
-  * @yields {Record}
-  */
+   * Iterate over all records in the repository, from oldest to most recent
+   * @yields {Record}
+   */
   async* iterate() {
     throw new Error(`#iterate method is not implemented in ${this.constructor.name}`);
   }
+  /* eslint-enable jsdoc/require-yields-check */
 
   /**
-  * Remove all records
-  *
-  * @returns {Promise} Promise that will be resolved when all records are removed
-  */
+   * Remove all records
+   * @returns {Promise} Promise that will be resolved when all records are removed
+   */
   async removeAll() {
     throw new Error(`#removeAll method is not implemented in ${this.constructor.name}`);
   }
 
   /**
-  * Load content of the given record
-  *
-  * @param {Record} record - Record of which to populate content
-  * @returns {Promise<Record>} Promise that will be resolved with the given record when its content has been loaded
-  */
+   * Load content of the given record
+   * @param   {Record}          record - Record of which to populate content
+   * @returns {Promise<Record>}        Promise that will be resolved with the given record when its content has been loaded
+   */
   async loadRecordContent(record) {
     throw new Error(`#loadRecordContent method is not implemented in ${this.constructor.name}`);
   }

package/src/archivist/recorder/repositories/mongo/index.js

@@ -34,14 +34,14 @@ export default class MongoRepository extends RepositoryInterface {
   }
 
   async save(record) {
-    const { serviceId, termsType } = record;
+    const { serviceId, termsType, documentId } = record;
 
     if (record.isFirstRecord === undefined || record.isFirstRecord === null) {
-      record.isFirstRecord = !await this.collection.findOne({ serviceId, termsType });
+      record.isFirstRecord = !await this.collection.findOne({ serviceId, termsType, documentId });
     }
 
     const documentFields = await this.#toPersistence(record);
-    const previousRecord = await this.findLatest(serviceId, termsType);
+    const previousRecord = await this.findLatest(serviceId, termsType, documentId);
 
     if (previousRecord?.content == documentFields.content) {
       return Object(null);
@@ -54,14 +54,26 @@ export default class MongoRepository extends RepositoryInterface {
     return record;
   }
 
-  async findLatest(serviceId, termsType) {
-    const [mongoDocument] = await this.collection.find({ serviceId, termsType }).limit(1).sort({ fetchDate: -1 }).toArray(); // `findOne` doesn't support the `sort` method, so even for only one mongo document use `find`
+  async findLatest(serviceId, termsType, documentId) {
+    const query = { serviceId, termsType };
+
+    if (documentId !== undefined) {
+      query.documentId = documentId;
+    }
+
+    const [mongoDocument] = await this.collection.find(query).limit(1).sort({ fetchDate: -1 }).toArray(); // `findOne` doesn't support the `sort` method, so even for only one mongo document use `find`
 
     return this.#toDomain(mongoDocument);
   }
 
-  async findByDate(serviceId, termsType, date) {
-    const [mongoDocument] = await this.collection.find({ serviceId, termsType, fetchDate: { $lte: new Date(date) } }).limit(1).sort({ fetchDate: -1 }).toArray(); // `findOne` doesn't support the `sort` method, so even for only one mongo document use `find`
+  async findByDate(serviceId, termsType, date, documentId) {
+    const query = { serviceId, termsType, fetchDate: { $lte: new Date(date) } };
+
+    if (documentId !== undefined) {
+      query.documentId = documentId;
+    }
+
+    const [mongoDocument] = await this.collection.find(query).limit(1).sort({ fetchDate: -1 }).toArray(); // `findOne` doesn't support the `sort` method, so even for only one mongo document use `find`
 
     return this.#toDomain(mongoDocument);
   }

package/src/archivist/recorder/repositories/mongo/index.test.js

@@ -332,6 +332,30 @@ describe('MongoRepository', () => {
           expect(mongoDocument.termsType).to.include(TERMS_TYPE);
         });
       });
+
+      context('when document ID is specified', () => {
+        before(async () => {
+          (record = await subject.save(new Version({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+            documentId: DOCUMENT_ID,
+            content: CONTENT,
+            fetchDate: FETCH_DATE,
+            snapshotIds: [SNAPSHOT_ID],
+          })));
+
+          (mongoDocument = await collection.findOne({
+            serviceId: SERVICE_PROVIDER_ID,
+            termsType: TERMS_TYPE,
+          }));
+        });
+
+        after(() => subject.removeAll());
+
+        it('stores the document ID', () => {
+          expect(mongoDocument.documentId).to.equal(DOCUMENT_ID);
+        });
+      });
     });
 
     describe('#findById', () => {
@@ -439,6 +463,46 @@ describe('MongoRepository', () => {
             expect(recordFound.id).to.include(recordToFindId);
           });
         });
+
+        context('when document ID is specified', () => {
+          let recordFound;
+          const DIFFERENT_DOCUMENT_ID = 'other-document';
+          const UPDATED_CONTENT = `${CONTENT} (with additional content)`;
+
+          before(async () => {
+            await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DOCUMENT_ID,
+              content: CONTENT,
+              fetchDate: FETCH_DATE,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DIFFERENT_DOCUMENT_ID,
+              content: UPDATED_CONTENT,
+              fetchDate: FETCH_DATE_LATER,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            recordFound = await subject.findByDate(
+              SERVICE_PROVIDER_ID,
+              TERMS_TYPE,
+              FETCH_DATE_LATER,
+              DOCUMENT_ID,
+            );
+          });
+
+          after(() => subject.removeAll());
+
+          it('returns only records matching the document ID', () => {
+            expect(recordFound.documentId).to.equal(DOCUMENT_ID);
+            expect(recordFound.content).to.equal(CONTENT);
+          });
+        });
       });
     });
 
@@ -580,6 +644,44 @@ describe('MongoRepository', () => {
             expect((await latestRecord.content).toString('utf8')).to.equal(UPDATED_CONTENT);
           });
         });
+
+        context('when document ID is specified', () => {
+          let latestRecord;
+          const DIFFERENT_DOCUMENT_ID = 'other-document';
+
+          before(async () => {
+            await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DOCUMENT_ID,
+              content: CONTENT,
+              fetchDate: FETCH_DATE_LATER,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            await subject.save(new Version({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DIFFERENT_DOCUMENT_ID,
+              content: CONTENT,
+              fetchDate: FETCH_DATE,
+              snapshotIds: [SNAPSHOT_ID],
+            }));
+
+            latestRecord = await subject.findLatest(
+              SERVICE_PROVIDER_ID,
+              TERMS_TYPE,
+              DIFFERENT_DOCUMENT_ID,
+            );
+          });
+
+          after(() => subject.removeAll());
+
+          it('returns only records matching the document ID', () => {
+            expect(latestRecord.documentId).to.equal(DIFFERENT_DOCUMENT_ID);
+            expect(latestRecord.fetchDate).to.deep.equal(FETCH_DATE);
+          });
+        });
       });
 
       context('when there are no records for the given service', () => {
@@ -1119,6 +1221,44 @@ describe('MongoRepository', () => {
             expect(latestRecord.mimeType).to.equal(PDF_MIME_TYPE);
           });
         });
+
+        context('when document ID is specified', () => {
+          let latestRecord;
+          const DIFFERENT_DOCUMENT_ID = 'other-document';
+
+          before(async () => {
+            await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DOCUMENT_ID,
+              content: CONTENT,
+              fetchDate: FETCH_DATE_LATER,
+              mimeType: HTML_MIME_TYPE,
+            }));
+
+            await subject.save(new Snapshot({
+              serviceId: SERVICE_PROVIDER_ID,
+              termsType: TERMS_TYPE,
+              documentId: DIFFERENT_DOCUMENT_ID,
+              content: CONTENT,
+              fetchDate: FETCH_DATE,
+              mimeType: HTML_MIME_TYPE,
+            }));
+
+            latestRecord = await subject.findLatest(
+              SERVICE_PROVIDER_ID,
+              TERMS_TYPE,
+              DIFFERENT_DOCUMENT_ID,
+            );
+          });
+
+          after(() => subject.removeAll());
+
+          it('returns only records matching the document ID', () => {
+            expect(latestRecord.documentId).to.equal(DIFFERENT_DOCUMENT_ID);
+            expect(latestRecord.fetchDate).to.deep.equal(FETCH_DATE);
+          });
+        });
       });
 
       context('when there are no records for the given service', () => {

package/src/archivist/services/sourceDocument.js

@@ -1,4 +1,18 @@
 export default class SourceDocument {
+  /**
+   * Represents a source document containing web content and metadata for extraction.
+   * Includes the document location, selectors for content inclusion/exclusion,
+   * content filters, raw content data, and MIME type information.
+   * @class SourceDocument
+   * @param {object}                    params                               The source document parameters
+   * @param {string}                    params.location                      The URL location of the document
+   * @param {boolean}                   params.executeClientScripts          Whether to execute client-side scripts
+   * @param {(string | object | Array)} params.contentSelectors              CSS selectors for content to include
+   * @param {(string | object | Array)} params.insignificantContentSelectors CSS selectors for content to exclude
+   * @param {Array}                     params.filters                       Array of filters to apply
+   * @param {string}                    params.content                       The document content
+   * @param {string}                    params.mimeType                      The MIME type of the content
+   */
   constructor({ location, executeClientScripts, contentSelectors, insignificantContentSelectors, filters, content, mimeType }) {
     this.location = location;
     this.executeClientScripts = executeClientScripts;

package/src/collection-api/routes/metadata.js

@@ -10,6 +10,9 @@ const METADATA_FILENAME = 'metadata.yml';
 const PACKAGE_JSON_PATH = '../../../package.json';
 
 /**
+ * @param   {string}         collectionPath The path to the collection
+ * @param   {object}         services       The services of the collection
+ * @returns {express.Router}                The router instance
  * @swagger
  * tags:
  *   name: Metadata

package/src/collection-api/routes/services.js

@@ -1,6 +1,8 @@
 import express from 'express';
 
 /**
+ * @param   {object}         services The services to be exposed by the API
+ * @returns {express.Router}          The router instance
  * @swagger
  * tags:
  *   name: Services

package/src/collection-api/routes/versions.js

@@ -5,6 +5,7 @@ import RepositoryFactory from '../../archivist/recorder/repositories/factory.js'
 import { toISODateWithoutMilliseconds } from '../../archivist/utils/date.js';
 
 /**
+ * @private
  * @swagger
  * tags:
  *   name: Versions
@@ -24,13 +25,14 @@ import { toISODateWithoutMilliseconds } from '../../archivist/utils/date.js';
  *           description: The ID of the version.
  *         content:
  *           type: string
- *           description: The JSON-escaped Markdown content of the version.
+ *           description: The JSON-escaped Markdown content of the version
  */
 const router = express.Router();
 
 const versionsRepository = await RepositoryFactory.create(config.get('@opentermsarchive/engine.recorder.versions.storage')).initialize();
 
 /**
+ * @private
  * @swagger
  * /version/{serviceId}/{termsType}/{date}:
  *   get:

package/src/reporter/github/index.js

@@ -99,7 +99,10 @@ export default class GitHub {
   }
 
   async getRepositoryLabels() {
-    const { data: labels } = await this.octokit.request('GET /repos/{owner}/{repo}/labels', { ...this.commonParams });
+    const labels = await this.octokit.paginate('GET /repos/{owner}/{repo}/labels', {
+      ...this.commonParams,
+      per_page: 100,
+    });
 
     return labels;
   }

package/src/reporter/github/index.test.js

@@ -33,6 +33,7 @@ describe('GitHub', function () {
 
       nock('https://api.github.com')
         .get('/repos/owner/repo/labels')
+        .query(true)
         .reply(200, existingLabels);
 
       const missingLabels = MANAGED_LABELS.slice(-2);
@@ -61,6 +62,7 @@ describe('GitHub', function () {
     before(async () => {
       scope = nock('https://api.github.com')
         .get('/repos/owner/repo/labels')
+        .query(true)
         .reply(200, LABELS);
 
       result = await github.getRepositoryLabels();

package/src/reporter/index.js

@@ -44,8 +44,7 @@ export default class Reporter {
 
   /**
    * Support for legacy config format where reporter configuration was nested under `githubIssues`
-   * Example:
-   *
+   * @example
    * ```json
    * {
    *   "githubIssues": {
@@ -55,8 +54,10 @@ export default class Reporter {
    *   }
    * }
    * ```
-   *
+   * @param   {object} config - The configuration object to normalize
+   * @returns {object}        The normalized configuration object
    * @deprecated
+   * @private
    */
   static normalizeConfig(config) {
     if (config.githubIssues) {