@opentermsarchive/engine 5.0.2 → 5.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://opentermsarchive.org",
   "bugs": {

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', () => {