aiiinotate 0.2.0

package/src/data/collectionAbstract.js

@@ -0,0 +1,270 @@
+import { maybeToArray, inspectObj } from "#utils/utils.js"
+import { formatInsertResponse, formatDeleteResponse, formatUpdateResponse } from "#src/data/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.error(Read|Insert|Update|Delete), 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);
+  }
+
+  //////////////////////////////////////
+  // 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 {
+      const result = await this.collection.insertMany(docArr);
+      return this.makeInsertResponse(result);
+    } 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,305 @@
+import fastifyPlugin from "fastify-plugin";
+
+import CollectionAbstract from "#data/collectionAbstract.js";
+import { getManifestShortId, manifestUri } from "#utils/iiif2Utils.js";
+import { formatInsertResponse } from "#src/data/utils/routeUtils.js";
+import { inspectObj, visibleLog, ajvCompile } from "#utils/utils.js";
+import { IIIF_PRESENTATION_2_CONTEXT } from "#utils/iiifUtils.js";
+
+/** @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
+
+  /**
+   * 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) ) {
+      throw this.insertError("validateManifest: invalid manifest structure", manifest);
+    }
+  }
+
+  /**
+   * 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) {
+    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([],[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 = [];
+    manifestArray.map((manifest) => {
+      try {
+        cleanManifestArray.push(this.#validateAndCleanManifest(manifest));
+      } catch (err) {
+        if ( throwOnError ) {
+          throw err;
+        }
+        // returns a mapping of `{manifestId: errorMessage}`
+        invalidManifestArray.push({ [manifest["@id"]]: err.message });
+      }
+    });
+
+    // find which manifests are not aldready in the DB, to avoid a unique constraint error.
+    // `preExistingIds` = all @ids that are in `cleanManifestArray` that are aldready in the database
+    const
+      mongoResponse =
+        await this.collection.find(
+          { "@id": {
+            $in: cleanManifestArray.map((manifest) => manifest["@id"])
+          }},
+          { projection: { "@id": 1 } }
+        )
+          .toArray(),
+      preExistingIds = mongoResponse.map((r) => r["@id"]);
+
+    // insert. if there has been an error but error-throwing was disabled, complete the response object with description of the errors
+    cleanManifestArray = cleanManifestArray.filter((manifest) => !preExistingIds.includes(manifest["@id"]))
+    if ( cleanManifestArray.length ) {
+      const result = await this.insertMany(cleanManifestArray);
+      result.preExistingIds = preExistingIds;
+      result.rejectedIds = invalidManifestArray;
+      return result;
+
+    } else {
+      return formatInsertResponse(
+        [],
+        preExistingIds,
+        [],
+        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 = [];
+    await Promise.all(
+      manifestUriArray.map(async (manifestUri) => {
+        try {
+          manifestArray.push(await this.#fetchManifestFromUri(manifestUri));
+        } catch (err) {
+          if ( throwOnError ) {
+            throw err;
+          }
+          fetchErrorIds.push(manifestUri);
+        }
+      })
+    );
+    const result = await this.insertManifestArray(manifestArray, throwOnError);
+    // if there has been an error but error-throwing was disabled, complete the response object with description of the errors
+    if ( !throwOnError ) {
+      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
+
+  /**
+   * 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) {
+    // NOTE: PERFORMANCE increases using `aggregate` with `$indexOfArray` to find the index of `canvasUri`: up to 30% faster execution of the app's test suite:
+    // - 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/
+    /**
+     * @type { { _id: MongoObjectId, index: number } | null }
+     * if `cursor.next() => null`, no document was found.
+     * otherwise the index is returned (-1 if `canvasIdx` was not found in the document)
+     */
+    const r = await this.collection.aggregate([
+      { $match: { "@id": manifestUri } },
+      { $project: { index: { $indexOfArray: ["$canvasIds", canvasUri] } } }
+    ]).next();
+    return r === null
+      ? undefined
+      : r.index !== -1 ? r.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": `${process.env.APP_BASE_URL}/manifests/2`,
+      label: "Collection of all manifests indexed in the annotation server",
+      members: manifestIndex
+    }
+  }
+}
+
+export default fastifyPlugin((fastify, options, done) => {
+  fastify.decorate("manifests2", new Manifests2(fastify));
+  done();
+}, {
+  name: "manifests2",
+})
+

package/src/data/manifests/manifests2.test.js

@@ -0,0 +1,53 @@
+import test from "node:test";
+
+import build from "#src/app.js";
+
+import { assertObjectKeysInsert } from "#utils/testUtils.js";
+
+/** @typedef {import("#types").NodeTestType} NodeTestType */
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").FastifyReplyType} FastifyReplyType */
+/** @typedef {import("#types").DataOperationsType} DataOperationsType */
+
+test("test Manifests2 module", async (t) => {
+  const
+    fastify = await build("test"),
+    {
+      manifest2Valid,
+      manifest2ValidUri,
+      manifest2Invalid,
+      manifest2InvalidUri
+    } = fastify.fileServer;
+
+  await fastify.ready();
+  // close the app after running the tests
+  t.after(async () => await fastify.close());
+  // after each subtest has run, delete all database records
+  t.afterEach(async() => fastify.emptyCollections());
+
+  // NOTE: it is necessary to run the app because internally there are fetches to external data.
+  try {
+    await fastify.listen({ port: process.env.APP_PORT });
+  } catch (err) {
+    console.log("FASTIFY ERROR", err);
+    throw err;
+  }
+
+  await t.test("test Manifests2.insertManifest", async (t) => {
+    const r = await fastify.manifests2.insertManifest(manifest2Valid);
+    assertObjectKeysInsert(t, r);
+
+    // insertion should fail. since we are not inserting through HTTPs, we can't test error response keys
+    await t.assert.rejects(fastify.manifests2.insertManifest(manifest2Invalid));
+  })
+
+  await t.test("test Manifests2.insertManifestFromUri", async (t) => {
+    const r = await fastify.manifests2.insertManifestFromUri(manifest2ValidUri.uri);
+    assertObjectKeysInsert(t, r);
+
+    // insertion should fail. since we are not inserting through HTTPs, we can't test error response keys
+    await t.assert.rejects(fastify.manifests2.insertManifest(manifest2InvalidUri.uri));
+  })
+
+  return
+})

package/src/data/manifests/manifests3.js

@@ -0,0 +1,23 @@
+import fastifyPlugin from "fastify-plugin";
+
+import CollectionAbstract from "#data/collectionAbstract.js";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+
+/** @typedef {Manifests3} Manifests3InstanceType */
+
+class Manifests3 extends CollectionAbstract {
+  /**
+   * @param {FastifyInstanceType} fastify
+   */
+  constructor(fastify) {
+    super(fastify, "manifests3");
+  }
+}
+
+export default fastifyPlugin((fastify, options, done) => {
+  fastify.decorate("manifests3", new Manifests3(fastify));
+  done();
+}, {
+  name: "manifests3",
+})