@opentermsarchive/engine 0.28.0 → 0.29.1

package/bin/ota-serve.js

@@ -0,0 +1,9 @@
+#! /usr/bin/env node
+import './env.js';
+
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+await import(pathToFileURL(path.resolve(__dirname, '../src/api/server.js'))); // load asynchronously to ensure env.js is loaded before

package/bin/ota.js

@@ -14,4 +14,5 @@ program
   .command('validate', 'Run a series of tests to check the validity of terms declarations')
   .command('lint', 'Check format and stylistic errors in declarations and auto fix them')
   .command('dataset', 'Export the versions dataset into a ZIP file and optionally publish it to GitHub releases')
+  .command('serve', 'Start the collection metadata API server')
   .parse(process.argv);

package/config/default.json

@@ -67,5 +67,9 @@
   "dataset": {
     "title": "sandbox",
     "versionsRepositoryURL": "https://github.com/OpenTermsArchive/sandbox"
+  },
+  "api": {
+    "port": 3000,
+    "basePath": "/api"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "0.28.0",
+  "version": "0.29.1",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://github.com/OpenTermsArchive/engine#readme",
   "bugs": {
@@ -39,6 +39,7 @@
     "lint": "eslint src test scripts bin",
     "lint:fix": "npm run lint -- --fix",
     "start": "node --max-http-header-size=32768 bin/ota.js track",
+    "start:api": "node bin/ota.js serve",
     "start:scheduler": "npm start -- --schedule",
     "test": "cross-env NODE_ENV=test mocha --recursive \"./src/**/*.test.js\" \"./scripts/**/*.test.js\" --exit",
     "posttest": "npm run lint",
@@ -68,7 +69,9 @@
     "eslint-plugin-chai-friendly": "^0.7.2",
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-json-format": "^2.0.1",
+    "express": "^4.18.2",
     "fs-extra": "^10.0.0",
+    "helmet": "^6.0.1",
     "http-proxy-agent": "^5.0.0",
     "https": "^1.0.0",
     "https-proxy-agent": "^5.0.0",
@@ -80,6 +83,7 @@
     "mime": "^2.5.2",
     "mocha": "^9.1.3",
     "mongodb": "^4.9.0",
+    "morgan": "^1.10.0",
     "node-fetch": "^3.1.0",
     "octokit": "^1.7.0",
     "pdfjs-dist": "^2.9.359",
@@ -88,6 +92,7 @@
     "puppeteer-extra-plugin-stealth": "^2.9.0",
     "sib-api-v3-sdk": "^8.2.1",
     "simple-git": "^3.8.0",
+    "swagger-jsdoc": "^6.2.8",
     "winston": "^3.3.3",
     "winston-mail": "^2.0.0"
   },
@@ -97,7 +102,8 @@
     "node-stream-zip": "^1.15.0",
     "prettier": "^2.2.1",
     "sinon": "^12.0.1",
-    "sinon-chai": "^3.7.0"
+    "sinon-chai": "^3.7.0",
+    "supertest": "^6.3.3"
   },
   "peerDependencies": {
     "@opentermsarchive/terms-types": "~0.1.1"

package/scripts/declarations/validate/index.mocha.js

@@ -90,7 +90,7 @@ export default async options => {
             })
             .forEach(type => {
               describe(type, () => {
-                const terms = service.getTerms(type);
+                const terms = service.getTerms({ type });
 
                 terms.sourceDocuments.forEach(sourceDocument => {
                   let filteredContent;

package/scripts/rewrite/rewrite-versions.js

@@ -95,10 +95,10 @@ let recorder;
       continue;
     }
 
-    const terms = servicesDeclarations[serviceId].getTerms(
-      termsType,
-      commit.date,
-    );
+    const terms = servicesDeclarations[serviceId].getTerms({
+      type: termsType,
+      date: commit.date,
+    });
 
     if (!terms) {
       console.log(`⌙ Skip unknown terms type "${termsType}" for service "${serviceId}"`);

package/src/api/logger.js

@@ -0,0 +1,40 @@
+import os from 'os';
+
+import config from 'config';
+import dotenv from 'dotenv';
+import winston from 'winston';
+import 'winston-mail';
+
+dotenv.config();
+
+const { combine, timestamp, printf, colorize } = winston.format;
+
+const transports = [new winston.transports.Console()];
+
+if (config.get('logger.sendMailOnError')) {
+  transports.push(new winston.transports.Mail({
+    to: config.get('logger.sendMailOnError.to'),
+    from: config.get('logger.sendMailOnError.from'),
+    host: config.get('logger.smtp.host'),
+    username: config.get('logger.smtp.username'),
+    password: process.env.SMTP_PASSWORD,
+    ssl: true,
+    timeout: 30 * 1000,
+    formatter: args => args[Object.getOwnPropertySymbols(args)[1]], // Returns the full error message, the same visible in the console. It is referenced in the argument object with a Symbol of which we do not have the reference but we know it is the second one.
+    exitOnError: true,
+    level: 'error',
+    subject: `[OTA API] Error Report — ${os.hostname()}`,
+  }));
+}
+
+const logger = winston.createLogger({
+  format: combine(
+    colorize(),
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    printf(({ level, message, timestamp }) => `${timestamp} ${level.padEnd(15)} ${message}`),
+  ),
+  transports,
+  rejectionHandlers: transports,
+});
+
+export default logger;

package/src/api/middlewares/errors.js

@@ -0,0 +1,6 @@
+import logger from '../logger.js';
+
+export default function errorsMiddleware(err, req, res, next) {
+  logger.error(err.stack);
+  res.status(500).send('Something went wrong!');
+}

package/src/api/middlewares/logger.js

@@ -0,0 +1,7 @@
+import morgan from 'morgan';
+
+import logger from '../logger.js';
+
+const middleware = morgan('tiny', { stream: { write: message => logger.info(message.trim()) } });
+
+export default middleware;

package/src/api/routes/index.js

@@ -0,0 +1,11 @@
+import express from 'express';
+
+import servicesRouter from './services.js';
+import specsRouter from './specs.js';
+
+const apiRouter = express.Router();
+
+apiRouter.use('/specs', specsRouter);
+apiRouter.use('/services', servicesRouter);
+
+export default apiRouter;

package/src/api/routes/services.js

@@ -0,0 +1,142 @@
+import express from 'express';
+
+import * as Services from '../../archivist/services/index.js';
+
+const services = await Services.load();
+
+/**
+ * @swagger
+ * tags:
+ *   name: Services
+ *   description: Services API
+ * components:
+ *   schemas:
+ *     Service:
+ *       type: object
+ *       description: Definition of a service and the agreements its provider sets forth. While the information is the same, the format differs from the JSON declaration files that are designed for readability by contributors.
+ *       properties:
+ *         id:
+ *           type: string
+ *           description: The ID of the service.
+ *         name:
+ *           type: string
+ *           description: The name of the service.
+ *         terms:
+ *           type: array
+ *           description: Information that enables tracking the content of agreements defined by the service provider.
+ *           items:
+ *             type: object
+ *             properties:
+ *               type:
+ *                 type: string
+ *                 description: The type of terms.
+ *               sourceDocuments:
+ *                 type: array
+ *                 items:
+ *                   type: object
+ *                   properties:
+ *                     location:
+ *                       type: string
+ *                       format: uri
+ *                       description: The URL of the source document.
+ *                     executeClientScripts:
+ *                       type: boolean
+ *                       description: Whether client-side scripts should be executed.
+ *                     contentSelectors:
+ *                       type: string
+ *                       description: The CSS selectors for selecting significant content.
+ *                     insignificantContentSelectors:
+ *                       type: string
+ *                       description: The CSS selectors for selecting insignificant content.
+ *                     filters:
+ *                       type: array
+ *                       description: The names of filters to apply to the content.
+ *                       items:
+ *                         type: string
+ */
+const router = express.Router();
+
+/**
+ * @swagger
+ * /services:
+ *   get:
+ *     summary: Enumerate all services.
+ *     tags: [Services]
+ *     produces:
+ *       - application/json
+ *     responses:
+ *       200:
+ *         description: A JSON array of all services.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/Service'
+ */
+router.get('/', (req, res) => {
+  res.status(200).json(Object.values(services).map(service => ({
+    id: service.id,
+    name: service.name,
+  })));
+});
+
+/**
+ * @swagger
+ * /service/{serviceId}:
+ *   get:
+ *     summary: Retrieve the declaration of a specific service through its ID.
+ *     tags: [Services]
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - in: path
+ *         name: serviceId
+ *         description: The ID of the service.
+ *         schema:
+ *           type: string
+ *         required: true
+ *         examples:
+ *             service-1:
+ *               value: service-1
+ *               summary: Simple service ID
+ *             service-2:
+ *               value: Service 2!
+ *               summary: Service ID with spaces and special characters
+ *     responses:
+ *       200:
+ *         description: The full JSON declaration of the service with the given ID.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/Service'
+ *       404:
+ *         description: No service matching the provided ID is found.
+ */
+router.get('/:serviceId', (req, res) => {
+  const matchedServiceID = Object.keys(services).find(key => key.toLowerCase() === req.params.serviceId?.toLowerCase());
+  const service = services[matchedServiceID];
+
+  if (!service) {
+    res.status(404).send('Service not found');
+
+    return;
+  }
+
+  res.status(200).json({
+    id: service.id,
+    name: service.name,
+    terms: service.getTerms().map(terms => ({
+      type: terms.type,
+      sourceDocuments: terms.sourceDocuments.map(({ location, contentSelectors, insignificantContentSelectors, filters, executeClientScripts }) => ({
+        location,
+        contentSelectors,
+        insignificantContentSelectors,
+        executeClientScripts,
+        filters: filters?.map(filter => filter.name),
+      })),
+    })),
+  });
+});
+
+export default router;

package/src/api/routes/services.test.js

@@ -0,0 +1,151 @@
+import { expect } from 'chai';
+import config from 'config';
+import request from 'supertest';
+
+import app from '../server.js';
+
+const basePath = config.get('api.basePath');
+
+describe('Services API', () => {
+  describe('GET /services', () => {
+    let response;
+
+    before(async () => {
+      response = await request(app).get(`${basePath}/v1/services`);
+    });
+
+    it('responds with 200 status code', () => {
+      expect(response.status).to.equal(200);
+    });
+
+    it('responds with Content-Type application/json', () => {
+      expect(response.type).to.equal('application/json');
+    });
+
+    it('returns an array of services', () => {
+      expect(response.body).to.be.an('array');
+    });
+
+    it('each service should have an id', () => {
+      response.body.forEach(service => {
+        expect(service).to.have.property('id');
+      });
+    });
+
+    it('each service should have a name', () => {
+      response.body.forEach(service => {
+        expect(service).to.have.property('name');
+      });
+    });
+  });
+
+  describe('GET /services/:serviceId', () => {
+    let response;
+    const SERVICE_ID = 'Service B!';
+    const CASE_INSENSITIVE_SERVICE_ID = 'service b!';
+
+    before(async () => {
+      response = await request(app).get(`${basePath}/v1/services/${encodeURI(SERVICE_ID)}`);
+    });
+
+    it('responds with 200 status code', () => {
+      expect(response.status).to.equal(200);
+    });
+
+    it('responds with Content-Type application/json', () => {
+      expect(response.type).to.equal('application/json');
+    });
+
+    it('returns a service object with id', () => {
+      expect(response.body).to.have.property('id');
+    });
+
+    it('returns the proper service object', () => {
+      expect(response.body.id).to.equal(SERVICE_ID);
+    });
+
+    it('returns a service object with name', () => {
+      expect(response.body).to.have.property('name');
+    });
+
+    it('returns a service object with an array of terms', () => {
+      expect(response.body).to.have.property('terms').that.is.an('array');
+    });
+
+    it('each terms should have a type property', () => {
+      response.body.terms.forEach(terms => {
+        expect(terms).to.have.property('type');
+      });
+    });
+
+    it('each terms should have an array of source documents', () => {
+      response.body.terms.forEach(terms => {
+        expect(terms).to.have.property('sourceDocuments').that.is.an('array');
+      });
+    });
+
+    it('each source document should have a location', () => {
+      response.body.terms.forEach(terms => {
+        terms.sourceDocuments.forEach(sourceDocument => {
+          expect(sourceDocument).to.have.property('location');
+        });
+      });
+    });
+
+    context('With a case-insensitive service ID parameter', () => {
+      before(async () => {
+        response = await request(app).get(`${basePath}/v1/services/${encodeURI(CASE_INSENSITIVE_SERVICE_ID)}`);
+      });
+
+      it('responds with 200 status code', () => {
+        expect(response.status).to.equal(200);
+      });
+
+      it('returns a service object with id', () => {
+        expect(response.body).to.have.property('id');
+      });
+
+      it('returns the proper service object', () => {
+        expect(response.body.id).to.equal(SERVICE_ID);
+      });
+
+      it('returns a service object with name', () => {
+        expect(response.body).to.have.property('name');
+      });
+
+      it('returns a service object with an array of terms', () => {
+        expect(response.body).to.have.property('terms').that.is.an('array');
+      });
+
+      it('each terms should have a type property', () => {
+        response.body.terms.forEach(terms => {
+          expect(terms).to.have.property('type');
+        });
+      });
+
+      it('each terms should have an array of source documents', () => {
+        response.body.terms.forEach(terms => {
+          expect(terms).to.have.property('sourceDocuments').that.is.an('array');
+        });
+      });
+
+      it('each source document should have a location', () => {
+        response.body.terms.forEach(terms => {
+          terms.sourceDocuments.forEach(sourceDocument => {
+            expect(sourceDocument).to.have.property('location');
+          });
+        });
+      });
+    });
+
+    context('When no matching service is found', () => {
+      before(async () => {
+        response = await request(app).get(`${basePath}/v1/nonExistentService`);
+      });
+
+      it('responds with 404 status code', () => {
+        expect(response.status).to.equal(404);
+      });
+    });
+  });
+});

package/src/api/routes/specs.js

@@ -0,0 +1,28 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import express from 'express';
+import swaggerJsdoc from 'swagger-jsdoc';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const router = express.Router();
+
+router.get('/', (req, res) => {
+  res.json(swaggerJsdoc({
+    definition: {
+      swagger: '2.0',
+      openapi: '3.1.0',
+      info: {
+        title: 'Open Terms Archive API',
+        version: '1.0.0',
+        license: {
+          name: 'EUPL-1.2',
+          url: 'https://eupl.eu/1.2/',
+        },
+      },
+    },
+    apis: [`${__dirname}/*.js`],
+  }));
+});
+
+export default router;

package/src/api/routes/specs.test.js

@@ -0,0 +1,59 @@
+import { expect } from 'chai';
+import config from 'config';
+import request from 'supertest';
+
+import app from '../server.js';
+
+const basePath = config.get('api.basePath');
+
+describe('Specs API', () => {
+  describe('GET /specs', () => {
+    let response;
+
+    before(async () => {
+      response = await request(app).get(`${basePath}/v1/specs`);
+    });
+
+    it('responds with 200 status code', () => {
+      expect(response.status).to.equal(200);
+    });
+
+    it('responds with Content-Type application/json', () => {
+      expect(response.type).to.equal('application/json');
+    });
+
+    describe('body response defines', () => {
+      let subject;
+
+      before(async () => {
+        subject = response.body;
+      });
+
+      it('openapi version', () => {
+        expect(subject).to.have.property('openapi');
+      });
+
+      it('swagger version', () => {
+        expect(subject).to.have.property('swagger');
+      });
+
+      it('paths', () => {
+        expect(subject).to.have.property('paths');
+      });
+
+      describe('with endpoints', () => {
+        before(async () => {
+          subject = response.body.paths;
+        });
+
+        it('/services', () => {
+          expect(subject).to.have.property('/services');
+        });
+
+        it('/service/{serviceId}', () => {
+          expect(subject).to.have.property('/service/{serviceId}');
+        });
+      });
+    });
+  });
+});

package/src/api/server.js

@@ -0,0 +1,24 @@
+import config from 'config';
+import express from 'express';
+import helmet from 'helmet';
+
+import logger from './logger.js';
+import errorsMiddleware from './middlewares/errors.js';
+import loggerMiddleware from './middlewares/logger.js';
+import apiRouter from './routes/index.js';
+
+const app = express();
+
+app.use(helmet());
+
+if (process.env.NODE_ENV !== 'test') {
+  app.use(loggerMiddleware);
+}
+
+app.use(`${config.get('api.basePath')}/v1`, apiRouter);
+app.use(errorsMiddleware);
+
+app.listen(config.get('api.port'));
+logger.info('Start Open Terms Archive API\n');
+
+export default app;

package/src/archivist/index.js

@@ -65,6 +65,8 @@ export default class Archivist extends events.EventEmitter {
       await this.recorder.finalize().then(() => console.log('Recorder finalized'));
       process.exit(1);
     });
+
+    return this;
   }
 
   initQueue() {
@@ -106,7 +108,7 @@ export default class Archivist extends events.EventEmitter {
           return;
         }
 
-        this.trackingQueue.push({ terms: this.services[serviceId].getTerms(termsType), extractOnly });
+        this.trackingQueue.push({ terms: this.services[serviceId].getTerms({ type: termsType }), extractOnly });
       });
     });
 

package/src/archivist/index.test.js

@@ -42,14 +42,14 @@ describe('Archivist', function () {
   let serviceASnapshotExpectedContent;
   let serviceAVersionExpectedContent;
 
-  const SERVICE_B_ID = 'service_B';
+  const SERVICE_B_ID = 'Service B!';
   const SERVICE_B_TYPE = 'Privacy Policy';
   const SERVICE_B_EXPECTED_SNAPSHOT_FILE_PATH = `${SNAPSHOTS_PATH}/${SERVICE_B_ID}/${SERVICE_B_TYPE}.pdf`;
   const SERVICE_B_EXPECTED_VERSION_FILE_PATH = `${VERSIONS_PATH}/${SERVICE_B_ID}/${SERVICE_B_TYPE}.md`;
   let serviceBSnapshotExpectedContent;
   let serviceBVersionExpectedContent;
 
-  const services = [ 'service_A', 'service_B' ];
+  const services = [ 'service_A', 'Service B!' ];
 
   before(async () => {
     gitVersion = new Git({
@@ -164,9 +164,9 @@ describe('Archivist', function () {
 
             serviceBCommits = await gitVersion.log({ file: SERVICE_B_EXPECTED_VERSION_FILE_PATH });
 
-            app.services[SERVICE_A_ID].getTerms(SERVICE_A_TYPE).sourceDocuments[0].contentSelectors = 'h1';
+            app.services[SERVICE_A_ID].getTerms({ type: SERVICE_A_TYPE }).sourceDocuments[0].contentSelectors = 'h1';
 
-            await app.track({ services: [ 'service_A', 'service_B' ], extractOnly: true });
+            await app.track({ services: [ 'service_A', 'Service B!' ], extractOnly: true });
 
             const [reExtractedVersionCommit] = await gitVersion.log({ file: SERVICE_A_EXPECTED_VERSION_FILE_PATH });
 
@@ -218,12 +218,12 @@ describe('Archivist', function () {
 
             await app.initialize();
             await app.track({ services });
-            app.services[SERVICE_A_ID].getTerms(SERVICE_A_TYPE).sourceDocuments[0].contentSelectors = 'inexistant-selector';
+            app.services[SERVICE_A_ID].getTerms({ type: SERVICE_A_TYPE }).sourceDocuments[0].contentSelectors = 'inexistant-selector';
             inaccessibleContentSpy = sinon.spy();
             versionNotChangedSpy = sinon.spy();
             app.on('inaccessibleContent', inaccessibleContentSpy);
             app.on('versionNotChanged', record => {
-              if (record.serviceId == 'service_B') {
+              if (record.serviceId == 'Service B!') {
                 versionB = record;
               }
               versionNotChangedSpy(record);
@@ -282,7 +282,7 @@ describe('Archivist', function () {
       let snapshot;
 
       before(async () => {
-        terms = app.services.service_A.getTerms(SERVICE_A_TYPE);
+        terms = app.services.service_A.getTerms({ type: SERVICE_A_TYPE });
         terms.fetchDate = FETCH_DATE;
         terms.sourceDocuments.forEach(async sourceDocument => {
           sourceDocument.content = serviceASnapshotExpectedContent;
@@ -364,7 +364,7 @@ describe('Archivist', function () {
       let version;
 
       before(async () => {
-        terms = app.services.service_A.getTerms(SERVICE_A_TYPE);
+        terms = app.services.service_A.getTerms({ type: SERVICE_A_TYPE });
         terms.fetchDate = FETCH_DATE;
         terms.sourceDocuments.forEach(async sourceDocument => {
           sourceDocument.content = serviceASnapshotExpectedContent;

package/src/archivist/services/index.test.js

@@ -22,7 +22,7 @@ describe('Services', () => {
           let actualInsignificantContentSelectors;
           let actualExecuteClientScripts;
 
-          const expectedTerms = expected.getTerms(termsType);
+          const expectedTerms = expected.getTerms({ type: termsType });
 
           const { sourceDocuments } = expectedTerms;
 
@@ -36,7 +36,7 @@ describe('Services', () => {
 
             context(`source document: ${sourceDocument.id}`, () => {
               before(() => {
-                actualTerms = result[serviceId].getTerms(termsType);
+                actualTerms = result[serviceId].getTerms({ type: termsType });
                 const { sourceDocuments: actualDocuments } = actualTerms;
 
                 ({
@@ -102,7 +102,7 @@ describe('Services', () => {
     });
 
     describe('Service B', async () => {
-      await validateServiceWithoutHistory('service_B', expectedServices.service_B);
+      await validateServiceWithoutHistory('Service B!', expectedServices['Service B!']);
     });
 
     describe('Service without history', async () => {
@@ -127,11 +127,11 @@ describe('Services', () => {
 
     context('when specifying services to load', async () => {
       before(async () => {
-        result = await services.load([ 'service_A', 'service_B' ]);
+        result = await services.load([ 'service_A', 'Service B!' ]);
       });
 
       it('loads only the given services', async () => {
-        expect(result).to.have.all.keys('service_A', 'service_B');
+        expect(result).to.have.all.keys('service_A', 'Service B!');
       });
     });
   });
@@ -148,12 +148,12 @@ describe('Services', () => {
 
           let actualTerms;
           let actualFilters;
-          const expectedTerms = expected.getTerms(termsType);
+          const expectedTerms = expected.getTerms({ type: termsType });
 
           const { sourceDocuments } = expectedTerms;
 
           before(() => {
-            actualTerms = result[serviceId].getTerms(termsType);
+            actualTerms = result[serviceId].getTerms({ type: termsType });
           });
 
           it('has the proper service name', () => {
@@ -182,7 +182,7 @@ describe('Services', () => {
                     let insignificantContentSelectorsForThisDate;
                     let actualExecuteClientScriptsForThisDate;
 
-                    const { sourceDocuments: documentsForThisDate } = expected.getTerms(termsType, date);
+                    const { sourceDocuments: documentsForThisDate } = expected.getTerms({ type: termsType, date });
                     const {
                       filters: expectedFiltersForThisDate,
                       contentSelectors: expectedContentSelectors,
@@ -191,7 +191,7 @@ describe('Services', () => {
                     } = documentsForThisDate[index];
 
                     before(() => {
-                      const { sourceDocuments: actualDocumentsForThisDate } = result[serviceId].getTerms(termsType, date);
+                      const { sourceDocuments: actualDocumentsForThisDate } = result[serviceId].getTerms({ type: termsType, date });
 
                       ({
                         filters: actualFiltersForThisDate,
@@ -271,7 +271,7 @@ describe('Services', () => {
     });
 
     describe('Service B', async () => {
-      await validateServiceWithHistory('service_B', expectedServices.service_B);
+      await validateServiceWithHistory('Service B!', expectedServices['Service B!']);
     });
 
     describe('Service without history', async () => {
@@ -296,11 +296,11 @@ describe('Services', () => {
 
     context('when specifying services to load', async () => {
       before(async () => {
-        result = await services.loadWithHistory([ 'service_A', 'service_B' ]);
+        result = await services.loadWithHistory([ 'service_A', 'Service B!' ]);
       });
 
       it('loads only the given services', async () => {
-        expect(result).to.have.all.keys('service_A', 'service_B');
+        expect(result).to.have.all.keys('service_A', 'Service B!');
       });
     });
   });

package/src/archivist/services/service.js

@@ -6,21 +6,26 @@ export default class Service {
     this.name = name;
   }
 
-  getTerms(termsType, date) {
-    if (!this.terms[termsType]) {
-      return null;
-    }
+  getTerms({ type, date } = {}) {
+    if (type) {
+      if (date) {
+        return this.#getTermsAtDate(type, date);
+      }
 
-    const { latest: currentlyValidTerms, history } = this.terms[termsType];
+      return this.#getTermsAtDate(type, new Date());
+    }
 
-    if (!date) {
-      return currentlyValidTerms;
+    if (date) {
+      return this.getTermsTypes().map(termsType => this.#getTermsAtDate(termsType, date));
     }
 
-    return (
-      history?.find(entry => new Date(date) <= new Date(entry.validUntil))
-      || currentlyValidTerms
-    );
+    return this.getTermsTypes().map(termsType => this.#getTermsAtDate(termsType, new Date()));
+  }
+
+  #getTermsAtDate(termsType, date) {
+    const { latest: currentlyValidTerms, history } = this.terms[termsType];
+
+    return history?.find(entry => new Date(date) <= new Date(entry.validUntil)) || currentlyValidTerms;
   }
 
   getTermsTypes() {

package/src/archivist/services/service.test.js

@@ -19,18 +19,18 @@ describe('Service', () => {
       });
     });
 
-    context('when terms declaration has no validity date', () => {
+    context('when terms have no validity date', () => {
       before(async () => {
         subject = new Service({ id: 'serviceID', name: 'serviceName' });
         subject.addTerms(terms);
       });
 
-      it('adds the terms as the last valid terms declaration', async () => {
-        expect(subject.getTerms(TERMS_TYPE)).to.deep.eql(terms);
+      it('adds the terms as the last valid terms', async () => {
+        expect(subject.getTerms({ type: TERMS_TYPE })).to.deep.eql(terms);
       });
     });
 
-    context('when terms declaration has a validity date', () => {
+    context('when terms have a validity date', () => {
       let expiredTerms;
       const VALIDITY_DATE = new Date('2020-07-22T11:30:21.000Z');
 
@@ -46,7 +46,7 @@ describe('Service', () => {
       });
 
       it('adds the terms with the proper validity date', async () => {
-        expect(subject.getTerms(TERMS_TYPE, VALIDITY_DATE)).to.deep.eql(expiredTerms);
+        expect(subject.getTerms({ type: TERMS_TYPE, date: VALIDITY_DATE })).to.deep.eql(expiredTerms);
       });
     });
   });
@@ -54,59 +54,76 @@ describe('Service', () => {
   describe('#getTerms', () => {
     let subject;
 
-    const lastDeclaration = new Terms({ type: TERMS_TYPE });
+    const EARLIEST_DATE = '2020-06-21T11:30:21.000Z';
+    const DATE = '2020-07-22T11:30:21.000Z';
+    const LATEST_DATE = '2020-08-21T11:30:21.000Z';
 
-    context('when there is no history', () => {
-      before(async () => {
-        subject = new Service({ id: 'serviceID', name: 'serviceName' });
-        subject.addTerms(lastDeclaration);
-      });
+    const firstTermsOfService = new Terms({ type: TERMS_TYPE, validUntil: DATE });
+    const firstPrivacyPolicy = new Terms({ type: 'Privacy Policy', validUntil: DATE });
 
-      context('without given date', () => {
-        it('returns the last terms declaration', async () => {
-          expect(subject.getTerms(TERMS_TYPE)).to.eql(lastDeclaration);
-        });
-      });
+    const latestTermsOfService = new Terms({ type: TERMS_TYPE });
+    const latestPrivacyPolicy = new Terms({ type: 'Privacy Policy' });
 
-      context('with a date', () => {
-        it('returns the last terms declaration', async () => {
-          expect(subject.getTerms(TERMS_TYPE, '2020-08-21T11:30:21.000Z')).to.eql(lastDeclaration);
-        });
-      });
+    const latestDeveloperTerms = new Terms({ type: 'Developer Terms' });
+
+    before(async () => {
+      subject = new Service({ id: 'serviceID', name: 'serviceName' });
+      subject.addTerms(firstTermsOfService);
+      subject.addTerms(firstPrivacyPolicy);
+      subject.addTerms(latestTermsOfService);
+      subject.addTerms(latestPrivacyPolicy);
+      subject.addTerms(latestDeveloperTerms);
     });
 
-    context('when the terms have a history', () => {
-      const firstDeclaration = new Terms({
-        type: TERMS_TYPE,
-        validUntil: '2020-07-22T11:30:21.000Z',
+    context('when no params are given', () => {
+      it('returns all latest terms', async () => {
+        expect(subject.getTerms()).to.deep.eql([ latestTermsOfService, latestPrivacyPolicy, latestDeveloperTerms ]);
       });
+    });
 
-      const secondDeclaration = new Terms({
-        type: TERMS_TYPE,
-        validUntil: '2020-08-22T11:30:21.000Z',
+    context('when a terms type is given', () => {
+      context('when a date is given', () => {
+        context('when the terms has no history', () => {
+          it('returns the latest terms according to the given type', async () => {
+            expect(subject.getTerms({ type: 'Developer Terms', date: LATEST_DATE })).to.eql(latestDeveloperTerms);
+          });
+        });
+
+        context('when the terms have a history', () => {
+          it('returns the terms according to the given type and date', async () => {
+            expect(subject.getTerms({ type: TERMS_TYPE, date: EARLIEST_DATE })).to.eql(firstTermsOfService);
+          });
+
+          context('when the given date is strictly equal to a terms validity date', () => {
+            it('returns the terms according to the given type with the validity date equal to the given date', async () => {
+              expect(subject.getTerms({ type: TERMS_TYPE, date: DATE })).to.eql(firstTermsOfService);
+            });
+          });
+        });
       });
 
-      before(async () => {
-        subject = new Service({ id: 'serviceID', name: 'serviceName' });
-        subject.addTerms(lastDeclaration);
-        subject.addTerms(firstDeclaration);
-        subject.addTerms(secondDeclaration);
+      context('without a given date', () => {
+        it('returns the latest terms of given type', async () => {
+          expect(subject.getTerms({ type: TERMS_TYPE })).to.eql(latestTermsOfService);
+        });
       });
+    });
 
-      context('without given date', () => {
-        it('returns the last terms declaration', async () => {
-          expect(subject.getTerms(TERMS_TYPE)).to.eql(lastDeclaration);
+    context('when only a date is given', () => {
+      context('when there is no history', () => {
+        it('returns all latest terms', async () => {
+          expect(subject.getTerms({ date: LATEST_DATE })).to.deep.eql([ latestTermsOfService, latestPrivacyPolicy, latestDeveloperTerms ]);
         });
       });
 
-      context('with a date', () => {
-        it('returns the terms declaration according to the given date', async () => {
-          expect(subject.getTerms(TERMS_TYPE, '2020-08-21T11:30:21.000Z')).to.eql(secondDeclaration);
+      context('when the terms have a history', () => {
+        it('returns all the terms according to the given date', async () => {
+          expect(subject.getTerms({ date: EARLIEST_DATE })).to.deep.eql([ firstTermsOfService, firstPrivacyPolicy, latestDeveloperTerms ]);
         });
 
-        context('strictly equal to a terms declaration validity date', () => {
-          it('returns the terms declaration with the validity date equal to the given date', async () => {
-            expect(subject.getTerms(TERMS_TYPE, secondDeclaration.validUntil)).to.eql(secondDeclaration);
+        context('when the given date is strictly equal to a terms validity date', () => {
+          it('returns all the terms with the validity date equal to the given date', async () => {
+            expect(subject.getTerms({ date: DATE })).to.deep.eql([ firstTermsOfService, firstPrivacyPolicy, latestDeveloperTerms ]);
           });
         });
       });
@@ -115,27 +132,27 @@ describe('Service', () => {
 
   describe('#getTermsTypes', () => {
     let subject;
-    let termsOfServiceDeclaration;
-    let privacyPolicyDeclaration;
+    let termsOfService;
+    let privacyPolicy;
 
     before(async () => {
       subject = new Service({ id: 'serviceID', name: 'serviceName' });
 
-      termsOfServiceDeclaration = new Terms({ type: TERMS_TYPE });
+      termsOfService = new Terms({ type: TERMS_TYPE });
 
-      privacyPolicyDeclaration = new Terms({
+      privacyPolicy = new Terms({
         type: 'Privacy Policy',
         validUntil: '2020-07-22T11:30:21.000Z',
       });
 
-      subject.addTerms(termsOfServiceDeclaration);
-      subject.addTerms(privacyPolicyDeclaration);
+      subject.addTerms(termsOfService);
+      subject.addTerms(privacyPolicy);
     });
 
     it('returns the service terms types', async () => {
       expect(subject.getTermsTypes()).to.have.members([
-        termsOfServiceDeclaration.type,
-        privacyPolicyDeclaration.type,
+        termsOfService.type,
+        privacyPolicy.type,
       ]);
     });
   });

package/src/tracker/index.js

@@ -69,7 +69,7 @@ export default class Tracker {
     return this.onVersionRecorded(serviceId, type);
   }
 
-  async onInaccessibleContent(error, serviceId, type, terms) {
+  async onInaccessibleContent(error, terms) {
     const { title, body } = Tracker.formatIssueTitleAndBody({ message: error.toString(), repository: this.repository, terms });
 
     await this.createIssueIfNotExists({