@paulhectork/aiiinotate 0.12.0

package/src/data/collectionAbstract.js

@@ -0,0 +1,283 @@
+import { maybeToArray, inspectObj } from "#utils/utils.js"
+import { formatInsertResponse, formatDeleteResponse, formatUpdateResponse } from "#utils/routeUtils.js";
+
+/** @typedef {import("#types").MongoDbType} MongoDbType */
+/** @typedef {import("#types").MongoClientType} MongoClientType */
+/** @typedef {import("#types").IiifPresentationVersionType} IiifPresentationVersionType */
+/** @typedef {import("#types").MongoCollectionType} MongoCollectionType */
+/** @typedef {import("#types").CollectionNamesType} CollectionNamesType */
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").DataOperationsType } DataOperationsType */
+
+const allowedCollectionNames = [ "manifests2", "manifests3", "annotations2", "annotations3" ];
+
+class CollectionAbstractError extends Error {
+  /**
+   * @param {string?} collectionName: name of the collection we're working on
+   * @param {string} message: error message
+   * @param {DataOperationsType} operation: to describe the type of database interaction
+   * @param {object} errInfo: extra info to display for the error
+   */
+  constructor(collectionName, operation, message, errInfo) {
+    const
+      collInfo = collectionName ? `on collection '${collectionName}'` : "",
+      operationInfo = operation ? `, when performing operation '${operation.toLocaleLowerCase()}'`: "";
+    super(`CollectionAbstractError: ${collInfo} ${operationInfo}: ${message}`);
+    this.info = errInfo;
+  }
+}
+
+/**
+ * @param {string?} collectionName
+ * @returns {Function}
+ */
+const errorConstructor = (collectionName) =>
+  /**
+   * @param {string?} operation
+   * @returns {Function}
+   */
+  (operation) =>
+    /**
+     *
+     * @param {string} message
+     * @param {object} errInfo
+     * @returns {CollectionAbstractError}
+     */
+    (message, errInfo) =>
+      new CollectionAbstractError(collectionName, operation, message, errInfo);
+
+// an error with no collection name or info.
+const abstractError = errorConstructor(undefined)(undefined);
+
+/**
+ * abstract class defining common processes to interact with a mongo collectios: inserts, updates, errors...
+ * this class contains agnostic methods and data that can be applied to any collection.
+ * @class
+ * @constructor
+ * @public
+ */
+class CollectionAbstract {
+  /**
+   * @param {FastifyInstanceType} fastify
+   * @param {CollectionNamesType} collectionName
+   */
+  constructor(fastify, collectionName) {
+
+    if (!allowedCollectionNames.includes(collectionName)) {
+      throw new abstractError(`invalid 'collectionName': expected one of ${allowedCollectionNames}, got '${collectionName}'`);
+    }
+
+    const collectionOptions =
+      collectionName === "annotations2"
+        ? { validator: { $jsonSchema: fastify.schemasPresentation2.getSchema("annotation") } }
+        : collectionName === "annotations3"
+          ? { validator: { /** TODO */ } }
+          : collectionName === "manifests2"
+            ? { validator: { $jsonSchema: fastify.schemasPresentation2.getSchema("manifestMongo") } }
+          // else: manifets3.
+            : { validator: { /** TODO */ } };
+
+    const iiifPresentationVersion = collectionName.endsWith("2") ? 2 : 3;
+
+    /** @type {FastifyInstanceType} */
+    this.fastify = fastify;
+    /** @type {MongoClientType} */
+    this.client = fastify.mongo.client;
+    /** @type {MongoDbType} */
+    this.db = fastify.mongo.db;
+    /** @type {MongoCollectionType} */
+    this.collection = this.db.collection(collectionName, collectionOptions);
+    /** @type {IiifPresentationVersionType} */
+    this.iiifPresentationVersion = iiifPresentationVersion;
+
+    /** @type {Function(string?) => Function(string, object) => Error} */
+    this.errorConstructor = errorConstructor(collectionName);
+    /** @type {Function(string, object?) => Error} */
+    this.errorNoAction = this.errorConstructor(undefined);
+    // create this.(read|insert|update|delete)Error, properties that will be used to throw the proper error.
+    [ "read", "insert", "update", "delete" ].forEach((op) =>
+      /** @type {Function(string,object?) => Error} */
+      this[`${op}Error`] = errorConstructor(collectionName)(op)
+    )
+  }
+
+  //////////////////////////////////////
+  // UTILS
+
+  /** @returns {string} */
+  className() {
+    return this.constructor.name;
+  }
+
+  /** @param {Function} func */
+  funcName(func) {
+    if (typeof func !== "function") {
+      throw new Error(`${this.className()}.${this.funcName.name} : expected 'func' to be a function, got '${typeof func}' (func = ${func})`);
+    }
+    return `${this.className()}.${func.name}`
+  }
+
+  /**
+   * resolve internal mongo '_id' fields to iiif '@id' fields
+   * @param {MongoCollectionType} collection
+   * @param {string | string[]} mongoIds
+   * @returns {Promise<string[]>}
+   */
+  async getIiifIdsFromMongoIds(mongoIds) {
+    mongoIds = maybeToArray(mongoIds);
+    const key = this.iiifPresentationVersion === 2 ? "@id" : "id";
+    const collectionIds = await this.collection.find(
+      { _id: { $in: mongoIds } },
+      { projection: { [key]: 1 } }
+    ).toArray();
+    return collectionIds.map(a => a[key]);
+  }
+
+  //////////////////////////////////////
+  // RESPONSES: what is sent from collection classes
+  // to routes and other consumers of the class after an insert/update/delete.
+
+  /**
+   * make a uniform response format for insertOne and insertMany
+   * @param {MongoInsertResultType} mongoRes
+   * @returns {Promise<InsertResponseType>}
+   */
+  async makeInsertResponse(mongoRes) {
+    // retrieve the "@id"s
+    const insertedIds = await this.getIiifIdsFromMongoIds(
+      // MongoInsertOneResultType and MongoInsertManyResultType have a different structureex
+      mongoRes.insertedId || Object.values(mongoRes.insertedIds)
+    );
+    return formatInsertResponse({ insertedIds });
+  }
+
+  /**
+   * @param {MongoUpdateResultType} mongoRes
+   * @returns {Promise<UpdateResponseType>}
+   */
+  async makeUpdateResponse(mongoRes) {
+    if (mongoRes.upsertedId) {
+      // only 1 entry can be upserted by a mongo query => extract the 1st upserted @id from the mongo @id.
+      const upsertedIds = await this.getIiifIdsFromMongoIds(
+        mongoRes.upsertedId
+      );
+      mongoRes.upsertedId = upsertedIds.length ? upsertedIds[0] : mongoRes.upsertedId;
+    }
+    return formatUpdateResponse(mongoRes);
+  }
+
+  /**
+   * throw an error with just the object describing the error data (and not the stack or anything else).
+   * used to propagate write errors to routes.
+   * @param {DataOperationsType} operation: describes the database operation
+   * @param {import("mongodb").MongoServerError} err: the mongo error
+   */
+  throwMongoError(operation, err) {
+    throw this.errorConstructor(operation)(err.message, err.errorResponse);
+  }
+
+  notImplementedError() {
+    throw this.errorNoAction("not implemented");
+  }
+
+  //////////////////////////////////////
+  // INSERT/UPDATE
+
+  /**
+   * insert a single document `doc` into `this.collection`.
+   * no validation or checking is done here. obviously, `doc` must fit the JsonSchema defined for `this.collection`.
+   * @private
+   * @param {object} doc
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertOne(doc) {
+    try {
+      const result = await this.collection.insertOne(doc);
+      return this.makeInsertResponse(result);
+    } catch (err) {
+      this.throwMongoError("insert", err);
+    }
+  }
+
+  /**
+   * insert documents from an array of documents.
+   * no validation or checking is done here. obviously, documents in `docArr` must fit the JsonSchema defined for `this.collection`.
+   * @param {object[]} docArr
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertMany(docArr) {
+    try {
+      // mongo insertMany throws an error if we try to insert an empty array of documetns
+      // => if docArr is empty, return an empty insert response.
+      if (docArr.length) {
+        const result = await this.collection.insertMany(docArr);
+        return this.makeInsertResponse(result);
+      } else {
+        return formatInsertResponse({
+          insertedIds: [],
+          rejectedIds: []
+        })
+      }
+    } catch (err) {
+      this.throwMongoError("insert", err);
+    }
+  }
+
+  /**
+   * update a single document, targeted by an unique identifier (should be "@id" for iiif 3, "id" otherwise).
+   * @param {object} query: query targeting a document
+   * @param {object} update: the updated document.
+   * @returns {Promise<UpdateResponseType>}
+   */
+  async updateOne(query, update){
+    try {
+      const result = await this.collection.updateOne(query, update);
+      return this.makeUpdateResponse(result);
+    } catch (err) {
+      this.throwMongoError("update", err)
+    }
+  }
+
+  //////////////////////////////////////
+  // DELETE
+
+  /**
+   * delete all objects that match `queryObj` from `this.collection`
+   * NOTE: if nothing is deleted, it's not an error, we return: { deletedCount: 0 }
+   * @param {object} queryObj
+   * @returns {Promise<DeleteResponseType>}
+   */
+  async delete(queryObj) {
+    try {
+      const deleteResult = await this.collection.deleteMany(queryObj);
+      return formatDeleteResponse(deleteResult);
+    } catch (err) {
+      this.throwMongoError("delete", err);
+    }
+  }
+
+  //////////////////////////////////////
+  // READ
+
+  /**
+   * true if `queryObj` matches at least 1 document, false otherwise.
+   * @param {object} queryObj
+   * @returns {Promise<boolean>}
+   */
+  async exists(queryObj) {
+    const r = await this.collection.countDocuments(queryObj, { limit: 1 });
+    return r === 1;
+  }
+
+  /**
+   * count the number of documents that match `queryObj`.
+   * @param {object} queryObj
+   * @returns {Promise<number>}
+   */
+  count(queryObj) {
+    return this.collection.countDocuments(queryObj);
+  }
+
+}
+
+export default CollectionAbstract;

package/src/data/index.js

@@ -0,0 +1,29 @@
+import fastifyPlugin from "fastify-plugin"
+
+import Annotations2 from "#annotations/annotations2.js";
+import Annotations3 from "#annotations/annotations3.js";
+import Manifests2 from "#manifests/manifests2.js";
+import Manifests3 from "#manifests/manifests3.js";
+import annotationsRoutes from "#annotations/routes.js";
+import manifestsRoutes from "#manifests/routes.js";
+import commonRoutes from "#data/routes.js";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+
+/**
+ * @param {FastifyInstanceType} fastify
+ * @param {object} options
+ */
+function data(fastify, options, done) {
+
+  fastify.register(Manifests2);
+  fastify.register(Manifests3);
+  fastify.register(Annotations2);
+  fastify.register(Annotations3);
+  fastify.register(annotationsRoutes);
+  fastify.register(manifestsRoutes);
+  fastify.register(commonRoutes);
+  done();
+}
+
+export default fastifyPlugin(data);

package/src/data/manifests/manifests2.js

@@ -0,0 +1,378 @@
+import fastifyPlugin from "fastify-plugin";
+
+import CollectionAbstract from "#data/collectionAbstract.js";
+import { getManifestShortId } from "#utils/iiif2Utils.js";
+import { formatInsertResponse } from "#utils/routeUtils.js";
+import { inspectObj, visibleLog, ajvCompile, memoize, objectHasKey } from "#utils/utils.js";
+import { IIIF_PRESENTATION_2_CONTEXT } from "#utils/iiifUtils.js";
+import { PUBLIC_URL } from "#constants";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").MongoObjectId} MongoObjectId */
+/** @typedef {import("#types").MongoInsertResultType} MongoInsertResultType */
+/** @typedef {import("#types").MongoUpdateResultType} MongoUpdateResultType */
+/** @typedef {import("#types").MongoDeleteResultType} MongoDeleteResultType */
+/** @typedef {import("#types").InsertResponseType} InsertResponseType */
+/** @typedef {import("#types").UpdateResponseType} UpdateResponseType */
+/** @typedef {import("#types").DeleteResponseType} DeleteResponseType */
+/** @typedef {import("#types").DataOperationsType } DataOperationsType */
+/** @typedef {import("#types").AnnotationsDeleteKeyType } AnnotationsDeleteKeyType */
+/** @typedef {import("#types").Manifest2InternalType } Manifest2InternalType */
+/** @typedef {import("#types").AjvValidateFunctionType} AjvValidateFunctionType */
+/** @typedef {import("#types").IiifCollection2Type} IiifCollection2Type */
+
+/** @typedef {Manifests2} Manifests2InstanceType */
+
+
+/**
+ * @class
+ * @constructor
+ * @public
+ * @extends {CollectionAbstract}
+ */
+class Manifests2 extends CollectionAbstract {
+  /**
+   * @param {FastifyInstanceType} fastify
+   */
+  constructor(fastify) {
+    super(fastify, "manifests2");
+
+    /** @type {AjvValidateFunctionType} */
+    this.validatorManifest = ajvCompile(fastify.schemasResolver(
+      fastify.schemasPresentation2.getSchema("manifestPublic")
+    ));
+  }
+
+  /////////////////////////////////////////////
+  // utils
+
+  /**
+   * fetch the array of canvasIds for a single manifest.
+   * since, in AIKON after a RegionExtraction, an annotation insert
+   * is done once per canvas, and for each annotation insert, we
+   * fetch the canvas index, we memoize the canvas list for each manifest URI
+   * to avoid multiplying database calls.
+   * @type {(string) => Promise<string[]>}
+   */
+  #memoizeGetManifestCanvasIds = memoize(async (manifestUri) => {
+    const doc = await this.collection
+      .findOne(
+        { "@id": manifestUri },
+        { projection: { canvasIds: 1, _id: 0 } }  // findOne is enough, there's only one manifest per URI
+      );
+    return doc?.canvasIds ?? [];
+  }, 60_000);
+
+  /**
+   * NOTE: PERFORMANCE: using AJV validation is MUCH FASTER than doing manual verifications (-25% execution time for the test suite)
+   * @param {object} manifest
+   * @returns {void}
+   */
+  #validateManifest(manifest) {
+    if (!this.validatorManifest(manifest)) {
+      let info = {};
+      if (objectHasKey(manifest, "@id")) {
+        info = { "@id": manifest["@id"] };
+      }
+      throw this.insertError("validateManifest: invalid manifest structure", info);
+    }
+  }
+
+  /**
+   * convert a manifest to internal data model
+   *
+   * NOTE: there is no need to reprocess "@id"s: the whole manifest is not stored in the database, so we need to keep all urls and references to external data intact.
+   * NOTE: only the 1st (default) sequence is processed. other optional sequences MUST be referenced from the manifest (not embedded). in practice, they are rare, so we don´t process them.
+   * see: https://iiif.io/api/presentation/2.1/#sequence
+   *
+   * @param {object} manifest
+   * @returns {Manifest2InternalType}
+   */
+  #cleanManifest(manifest) {
+    return {
+      "@id": manifest["@id"],
+      "@type": "sc:Manifest",
+      manifestShortId: getManifestShortId(manifest["@id"]),
+      canvasIds: manifest.sequences[0].canvases.map((canvas) => canvas["@id"])
+    };
+  }
+
+  /**
+   * validation + cleaning pipeline
+   * @param {object} manifest
+   * @returns {object}
+   */
+  #validateAndCleanManifest(manifest) {
+    this.#validateManifest(manifest);
+    return this.#cleanManifest(manifest);
+  }
+
+  /**
+   * fetch a manifest and return it as an object
+   * @param {string} manifestUri
+   * @returns
+   */
+  async #fetchManifestFromUri(manifestUri) {
+    console.log(">>>> MANIFEST URI", manifestUri);
+    try {
+      const r = await fetch(manifestUri);
+      return await r.json();
+    } catch (err) {
+      throw this.insertError(`error fetching manifest with URI '${manifestUri}'`);
+    }
+  }
+
+  /////////////////////////////////////////////
+  // write
+
+  /**
+   * save a single manifest to database.
+   * @param {object} manifest - a IIIF manifest
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertManifest(manifest) {
+    manifest = this.#validateAndCleanManifest(manifest);
+    const manifestExists = await this.exists({ "@id": manifest["@id"] });
+    if (!manifestExists) {
+      return this.insertOne(manifest);
+    } else {
+      return formatInsertResponse({ preExistingIds: [ manifest["@id"] ] });
+    }
+  }
+
+  /**
+   * insert several manifests to database
+   * if `throwOnError===false`, don't raise if there is an error: instead, insert as many documents as possible.
+   * see the docs of `insertManifestsFromUriArray` for more info.
+   *
+   * @param {object[]} manifestArray - array of manifests
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertManifestArray(manifestArray, throwOnError=true) {
+    // build 2 arrays, one of the manifests that pass validation, one of the @ids of the manifests with errors, mapped to an error message.
+    let
+      cleanManifestArray = [],
+      invalidManifestArray = [],
+      preExistingIds = [];
+    manifestArray.map((manifest) => {
+      try {
+        cleanManifestArray.push(this.#validateAndCleanManifest(manifest));
+      } catch (err) {
+        if (throwOnError) {
+          throw err;
+        }
+        // returns a mapping of `{manifestUri: errorMessage}`
+        invalidManifestArray.push({ [manifest["@id"]]: err.message });
+      }
+    });
+
+    // filter out the manifests that are aldready in our collection
+    // NOTE: i have attempted to move this to `insertManifestsFromUriArray` but it leads to what I suspect is a data race causing unique constaints fails.
+    //  TLDR: don't move or disable this check.
+    let cleanIds = cleanManifestArray.map((manifest) => manifest["@id"]);
+    [ cleanIds, preExistingIds ] = await this.#filterManifestIdsInCollection(cleanIds);
+
+    // remove pre-inserted IDs of manifests from cleanManifestArray
+    cleanManifestArray = cleanManifestArray.filter((manifest) => cleanIds.includes(manifest["@id"]));
+
+    // insert. if there has been an error but throwOnError === "false", complete the response object with description of the errors
+    // no need for try..except, no errors should happen here.
+    if (cleanManifestArray.length) {
+      const result = await this.insertMany(cleanManifestArray);
+      result.preExistingIds = preExistingIds;
+      result.rejectedIds = invalidManifestArray;
+      return result;
+
+    } else {
+      return formatInsertResponse({
+        preExistingIds: preExistingIds,
+        rejectedIds: invalidManifestArray
+      });
+    }
+  }
+
+  /**
+   * insert a manifest from an URI
+   * @param {string} manifestUri
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertManifestFromUri(manifestUri) {
+    try {
+      const manifest = await this.#fetchManifestFromUri(manifestUri);
+      return this.insertManifest(manifest);
+    } catch (err) {
+      throw this.insertError(`error inserting manifest with URI '${manifestUri}' because of error: ${err.message}`);
+    }
+  }
+
+  /**
+   * from an array of URIs, insert many manifests.
+   *
+   * if `throwOnError===false`, the function will not throw. instead, it will try to insert as much as possible, and the response will give info on the failure cases.
+   * the first use case for this behaviour is to index all manifests related to an array of annotations. given that we reconstruct
+   * manifest URIs from canvas URIs manually, there may always be an error. we want to insert a manifest when possible, and return an error othersise.
+   *
+   * @param {string[]} manifestUriArray
+   * @param {boolean} throwOnError
+   * @returns {Promise<InsertResponseType>}
+   */
+  async insertManifestsFromUriArray(manifestUriArray, throwOnError=true) {
+    // PERFORMANCE ~2850ms
+    const
+      fetchErrorIds = [],
+      manifestArray = [];
+
+    // fetch the manifests. if there's a fetch error, they won't be inserted.
+    await Promise.all(
+      manifestUriArray.map(async (manifestUri) => {
+        try {
+          const r = await this.#fetchManifestFromUri(manifestUri);
+          if (! r.error) {
+            manifestArray.push(r);
+          } else {
+            fetchErrorIds.push(manifestUri);
+          }
+        } catch (err) {
+          if (throwOnError) {
+            throw err;
+          }
+          fetchErrorIds.push(manifestUri);
+        }
+      })
+    );
+
+    if (fetchErrorIds.length){
+      const errMsg = `error inserting ${fetchErrorIds.length} manifests: ${fetchErrorIds}`
+      if (throwOnError) {
+        throw this.insertError(errMsg)
+      } else if (fetchErrorIds.length) {
+        this.fastify.log.error(errMsg, fetchErrorIds);
+      }
+    }
+
+    // insert and format response
+    const result = await this.insertManifestArray(manifestArray, throwOnError, true);
+    result.fetchErrorIds = fetchErrorIds;
+    return result;
+  }
+
+  /////////////////////////////////////////////
+  // delete
+
+  /**
+   * @param {"manifestShortId"|"uri"} deleteKey = what deleteId describes: a manifest URI or its short ID
+   * @param {string} deleteVal - data to delete
+   * @returns {Promise<DeleteResponseType>}
+   */
+  // NOTE: could be refactored with `annotations2.delete`: both functions are the same, only the filter changes
+  async deleteManifest(deleteKey, deleteVal) {
+    const allowedDeleteKey = [ "uri", "manifestShortId" ];
+    if (!allowedDeleteKey.includes(deleteKey)) {
+      throw this.deleteError(`${this.funcName(this.deleteManifest)}: expected one of ${allowedDeleteKey}, got '${deleteKey}'`);
+    }
+
+    const deleteFilter =
+      deleteKey==="uri"
+        ? { "@id": deleteVal }
+        : { manifestShortId: deleteVal };
+
+    return this.delete(deleteFilter);
+  }
+
+  /////////////////////////////////////////////
+  // read
+
+  /**
+   * find which manifests in an array of manifest IDs are aldready in the manifests collection
+   * @param {string[]} manifestUriArray - array of manifest IDs
+   * @returns {Promise<Array<Array<string?>>>} 2 arrays:
+   *  - array of manifest IDs that are not aldready in this collection
+   *  - array of manifest IDs that are not in this collection
+   */
+  async #filterManifestIdsInCollection(manifestUriArray) {
+    const
+      preExistingIds = [],
+      toInsertIds = [];
+    // all manifest IDs from manifestUriArray that are aldready in our manifest collection
+    const inCollectionArray = (
+      await this.collection.find(
+        { "@id": { $in: manifestUriArray } },
+        { projection: { "@id": 1 } }
+      ).toArray()
+    ).map((r) => r["@id"]);
+    // split manifestUriArray in 2 lists.
+    manifestUriArray.map((manifestUri) =>
+      inCollectionArray.includes(manifestUri)
+        ? preExistingIds.push(manifestUri)
+        : toInsertIds.push(manifestUri)
+    );
+    return [ toInsertIds, preExistingIds ];
+  }
+
+  /**
+   * return the position of `canvasUri` within the manifest with ID `manifestUri`,
+   * or return `undefined` if the canvas is not found in the manifest, or the manifest is not indexed.
+   * @param {string} manifestUri
+   * @param {string} canvasUri
+   * @returns {Promise<number?>}
+   */
+  async getCanvasIdx(manifestUri, canvasUri) {
+    // old method without memoization.
+    // - with `aggregate`, ~2800ms for the whole test suite to run.
+    // - with a native `coll.findOne()` and then getting the canvas ID manually (`arr.indexOf`), ~4000ms for the whole test suite to run.
+    // https://www.mongodb.com/docs/manual/aggregation/
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/indexOfArray/
+    // const r = await this.collection.aggregate([
+    //   { $match: { "@id": manifestUri } },
+    //   { $project: { index: { $indexOfArray: ["$canvasIds", canvasUri] } } }
+    // ]).next();
+    const r = await this.#memoizeGetManifestCanvasIds(manifestUri);
+    const index = r.indexOf(canvasUri);
+    return index !== -1 ? index : undefined
+  }
+
+  /**
+   * return a collection of all manifests in the database.
+   * @returns {Promise<IiifCollection2Type>}
+   */
+  async getManifests() {
+
+    const manifestIndex = await this.collection.find(
+      {},
+      { projection: { "@id": 1, "@type": 1, _id: 0 } }
+    ).toArray();
+    return {
+      ...IIIF_PRESENTATION_2_CONTEXT,
+      "@type": "sc:Collection",
+      "@id": `${PUBLIC_URL}/manifests/2`,
+      label: "Collection of all manifests indexed in the annotation server",
+      members: manifestIndex
+    }
+  }
+
+  /**
+   * @param {string} manifestShortId
+   * @returns {object}
+   */
+  async findByManifestShortId(manifestShortId) {
+    try {
+      const manifestIndexArray = await this.collection
+        .find(
+          { manifestShortId: manifestShortId },
+          { limit: 1, project: { _id: 0 } }
+        )
+        .limit(1);
+      return manifestIndexArray.length ? manifestIndexArray[1] : {}
+    } catch (err) {
+      throw this.readError(`${this.funcName(this.findByManifestShortId)}: error fetching manifest with manifestShortId: '${manifestShortId}'`)
+    }
+  }
+}
+
+export default fastifyPlugin((fastify, options, done) => {
+  fastify.decorate("manifests2", new Manifests2(fastify));
+  done();
+}, {
+  name: "manifests2",
+})
+