@opentermsarchive/engine 0.26.1 → 0.27.1

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

@@ -3,7 +3,7 @@
  * @see {@link https://martinfowler.com/eaaCatalog/repository.html|Repository}
  * @interface
  */
-export default class RepositoryInterface {
+class RepositoryInterface {
   /**
   * [Optional] Initialize repository
   * Override this method if the repository needs some asynchronous initialization code (open database connection and create collections, initialize Git…)
@@ -35,15 +35,15 @@ export default class RepositoryInterface {
   }
 
   /**
-  * Find the most recent record that matches the given service ID and terms type and optionally the page ID
-  * In case of snapshots, if the record is related to a multipage document, the page ID is required to find the corresponding snapshot
+  * 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} documentType - Terms type of record to find
-  * @param {string} [pageId] - Page ID of record to find. Used to differentiate pages of multipage document. Not necessary for single page document
+  * @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, documentType, pageId) {
+  async findLatest(serviceId, termsType, documentId) {
     throw new Error(`#findLatest method is not implemented in ${this.constructor.name}`);
   }
 
@@ -106,3 +106,5 @@ export default class RepositoryInterface {
     throw new Error(`#loadRecordContent method is not implemented in ${this.constructor.name}`);
   }
 }
+
+export default RepositoryInterface;

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

@@ -1,32 +1,39 @@
 import { ObjectId } from 'mongodb';
 
-import Record from '../../record.js';
+import Snapshot from '../../snapshot.js';
+import Version from '../../version.js';
 
 export function toPersistence(record) {
-  const documentFields = Object.fromEntries(Object.entries(record));
+  const recordFields = Object.fromEntries(Object.entries(record));
 
-  if (documentFields.snapshotIds) {
-    documentFields.snapshotIds = record.snapshotIds.map(snapshotId => new ObjectId(snapshotId));
+  if (recordFields.snapshotIds) {
+    recordFields.snapshotIds = record.snapshotIds.map(snapshotId => new ObjectId(snapshotId));
   }
 
-  documentFields.content = record.content;
-  documentFields.created_at = new Date();
+  recordFields.content = record.content;
+  recordFields.created_at = new Date();
 
-  return documentFields;
+  return recordFields;
 }
 
-export function toDomain(document) {
-  const { _id, serviceId, documentType, pageId, fetchDate, mimeType, isRefilter, isFirstRecord, snapshotIds } = document;
+export function toDomain(mongoDocument) {
+  const { _id, serviceId, termsType, documentId, fetchDate, mimeType, isExtractOnly, isRefilter, isFirstRecord, snapshotIds } = mongoDocument;
 
-  return new Record({
+  const attributes = {
     id: _id.toString(),
     serviceId,
-    documentType,
-    pageId,
+    termsType,
+    documentId,
     mimeType,
     fetchDate: new Date(fetchDate),
     isFirstRecord: Boolean(isFirstRecord),
-    isRefilter: Boolean(isRefilter),
+    isExtractOnly: Boolean(isExtractOnly) || Boolean(isRefilter),
     snapshotIds: snapshotIds?.map(snapshotId => snapshotId.toString()) || [],
-  });
+  };
+
+  if (snapshotIds) {
+    return new Version(attributes);
+  }
+
+  return new Snapshot(attributes);
 }

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

@@ -32,14 +32,14 @@ export default class MongoRepository extends RepositoryInterface {
   }
 
   async save(record) {
-    const { serviceId, documentType } = record;
+    const { serviceId, termsType } = record;
 
     if (record.isFirstRecord === undefined || record.isFirstRecord === null) {
-      record.isFirstRecord = !await this.collection.findOne({ serviceId, documentType });
+      record.isFirstRecord = !await this.collection.findOne({ serviceId, termsType });
     }
 
     const documentFields = await this.#toPersistence(record);
-    const previousRecord = await this.findLatest(serviceId, documentType);
+    const previousRecord = await this.findLatest(serviceId, termsType);
 
     if (previousRecord?.content == documentFields.content) {
       return Object(null);
@@ -52,8 +52,8 @@ export default class MongoRepository extends RepositoryInterface {
     return record;
   }
 
-  async findLatest(serviceId, documentType) {
-    const [mongoDocument] = await this.collection.find({ serviceId, documentType }).limit(1).sort({ fetchDate: -1 }).toArray(); // `findOne` doesn't support the `sort` method, so even for only one document use `find`
+  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`
 
     return this.#toDomain(mongoDocument);
   }
@@ -95,12 +95,12 @@ export default class MongoRepository extends RepositoryInterface {
     record.content = content instanceof Binary ? content.buffer : content;
   }
 
-  async #toDomain(document, { deferContentLoading } = {}) {
-    if (!document) {
+  async #toDomain(mongoDocument, { deferContentLoading } = {}) {
+    if (!mongoDocument) {
       return null;
     }
 
-    const record = DataMapper.toDomain(document);
+    const record = DataMapper.toDomain(mongoDocument);
 
     if (deferContentLoading) {
       return record;