@paulhectork/aiiinotate 0.12.0

package/src/data/annotations/annotations3.js

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

package/src/data/annotations/routes.js

@@ -0,0 +1,335 @@
+import fastifyPlugin from "fastify-plugin"
+
+import { STRICT_MODE } from "#constants";
+import { pathToAiiinotatePublicUrl, objectHasKey, maybeToArray, throwIfKeyUndefined, throwIfValueError, getFirstNonEmptyPair, visibleLog } from "#utils/utils.js";
+import { makeResponseSchema, makeResponsePostSchema, returnError, addPagination } from "#utils/routeUtils.js";
+
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").Annotations2InstanceType} Annotations2InstanceType */
+/** @typedef {import("#types").Annotations3InstanceType} Annotations3InstanceType */
+
+/**
+ * validate an annotation, annotationPage or annotationList: that is, ensure it fits the IIIF presentation API
+ * @param {2|3} iiifPresentationVersion
+ * @param {object} annotationData
+ * @param {boolean} isListOrPage: it's an annotationList or annotationPage instead of a regular annotation.
+ */
+const validateAnnotationVersion = (iiifPresentationVersion, annotationData, isListOrPage=false) => {
+  // object keys are always strings, so we need to convert to string (https://stackoverflow.com/questions/3633362)
+  iiifPresentationVersion = iiifPresentationVersion.toString();
+  const expectedTypeKeys = {
+    "2": "@type",
+    "3": "type"
+  };
+  throwIfKeyUndefined(expectedTypeKeys, iiifPresentationVersion);
+  const expectedTypeKey = expectedTypeKeys[iiifPresentationVersion];
+  throwIfKeyUndefined(annotationData, expectedTypeKey);
+  const expectedTypeVal = (
+    isListOrPage
+      ? { "2": "sc:AnnotationList", "3":"AnnotationPage" }
+      : { "2": "oa:Annotation", "3": "Annotation" }
+  )[iiifPresentationVersion];
+  throwIfValueError(annotationData, expectedTypeKey, expectedTypeVal);
+}
+
+/**
+ * `annotationArray` is an array of AnnotationLists or AnnotationPages, depending on the IIIF Presentaion API version.
+ * assert that it indeed the case, raise otherwise
+ * @param {2|3} iiifPresentationVersion
+ * @param {object[]} annotationArray
+ * @returns {void}
+ */
+const validateAnnotationArrayVersion = (iiifPresentationVersion, annotationArray) =>
+  annotationArray.map(annotationData => validateAnnotationVersion(iiifPresentationVersion, annotationData, true));
+
+/**
+ * @param {import("#types").InsertResponseArrayType} insertResponseArray
+ * @returns {import("#types").InsertResponseType}
+ */
+const reduceInsertResponseArray = (insertResponseArray) => ({
+  insertedCount: insertResponseArray.reduce((acc, r) => acc+r.insertedCount, 0),
+  insertedIds: insertResponseArray.reduce((acc, r) => acc.concat(r.insertedIds), [])
+})
+
+
+/**
+ * Encapsulates the routes
+ * @param {FastifyInstanceType} fastify  Encapsulated Fastify Instance
+ * @param {object} options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ * @param {Function} done
+ */
+function annotationsRoutes(fastify, options, done) {
+  const
+    /** @type {Annotations2InstanceType} */
+    annotations2 = fastify.annotations2,
+    /** @type {Annotations3InstanceType} */
+    annotations3 = fastify.annotations3,
+    routeAnnotation2Or3Schema = fastify.schemasRoutes.getSchema("routeAnnotation2Or3"),
+    routeAnnotationCreateManySchema = fastify.schemasRoutes.getSchema("routeAnnotationCreateMany"),
+    routeAnnotationFilterSchema = fastify.schemasRoutes.getSchema("routeAnnotationFilter"),
+    routeResponseCountSchema = fastify.schemasRoutes.getSchema("routeResponseCount"),
+    iiifPresentationVersionSchema = fastify.schemasBase.getSchema("presentation"),
+    iiifAnnotationListSchema = fastify.schemasPresentation2.getSchema("annotationList"),
+    iiifAnnotation2ArraySchema = fastify.schemasPresentation2.getSchema("annotationArray"),
+    iiifAnnotation2Schema = fastify.schemasPresentation2.getSchema("annotation"),
+    responsePostSchema = makeResponsePostSchema(fastify);
+
+  /////////////////////////////////////////////////////////
+  // get routes
+
+  /** get all annotations by a canvas URI */
+  fastify.get(
+    "/annotations/:iiifPresentationVersion/search",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        querystring: addPagination({
+          type: "object",
+          properties: {
+            canvasUri: { type: "string" },
+          }
+        }),
+        response: makeResponseSchema(
+          fastify,
+          {
+            oneOf: [
+              fastify.schemasResolver(iiifAnnotationListSchema),
+              fastify.schemasResolver(iiifAnnotation2ArraySchema)
+            ]
+          },
+        )
+      },
+    },
+    async (request, reply) => {
+      const
+        queryUrl = pathToAiiinotatePublicUrl(request.url),
+        { iiifPresentationVersion } = request.params,
+        { canvasUri, page, pageSize } = request.query;
+
+      try {
+        if (iiifPresentationVersion === 2) {
+          return await annotations2.findByCanvasUri({
+            queryUrl,
+            canvasUri,
+            page,
+            pageSize
+          });
+        } else {
+          annotations3.notImplementedError();
+        }
+      } catch (err) {
+        returnError(request, reply, err);
+      }
+    }
+  );
+
+  fastify.get(
+    "/annotations/:iiifPresentationVersion/count",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        querystring: routeAnnotationFilterSchema,
+        response: makeResponseSchema(
+          fastify, routeResponseCountSchema
+        )
+      }
+    },
+    async (request, reply) => {
+      const
+        { iiifPresentationVersion } = request.params,
+        [ filterKey, filterVal ] = getFirstNonEmptyPair(request.query);
+      try {
+        return iiifPresentationVersion === 2
+          ? await annotations2.count(filterKey, filterVal)
+          : annotations3.notImplementedError();
+      } catch (err) {
+        returnError(request, reply, err);
+      }
+    }
+  )
+
+  /** retrieve a single annotation by its "@id"|"id". this route defers an annotation */
+  fastify.get(
+    "/data/:iiifPresentationVersion/:manifestShortId/annotation/:annotationShortId",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema,
+            manifestShortId: { type: "string" },
+            annotationShortId: { type: "string" },
+          }
+        },
+        response: makeResponseSchema(
+          fastify,
+          fastify.schemasResolver(iiifAnnotation2Schema)
+        )
+      }
+    },
+    async (request, reply) => {
+      const
+        annotationUri = pathToAiiinotatePublicUrl(request.url),
+        { iiifPresentationVersion } = request.params;
+      try {
+        return iiifPresentationVersion === 2
+          ? annotations2.findById(annotationUri)
+          : annotations3.notImplementedError();
+      } catch (err) {
+        returnError(request, reply, err);
+      }
+    }
+  )
+
+  /////////////////////////////////////////////////////////
+  // create/update routes
+
+  /** create or update a single annotation from an annotation object */
+  fastify.post(
+    "/annotations/:iiifPresentationVersion/:action",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema,
+            action: { type: "string", enum: [ "create", "update" ] }
+          }
+        },
+        // NOTE: `throwOnCanvasIndexError` is only implemented if `action==="create"` (see preValidation)
+        querystring: {
+          type: "object",
+          properties: {
+            throwOnCanvasIndexError: { type: "boolean", default: STRICT_MODE },
+            throwOnXywhError: { type: "boolean", default: STRICT_MODE },
+          }
+        },
+        preValidation: async (request, reply) => {
+          const
+            { action } = request.params,
+            { throwOnCanvasIndexError } = request.querystring;
+          if (action==="update" && throwOnCanvasIndexError) {
+            returnError(request, reply, "'throwOnCanvasIndexError' is only allowed when ':action' is 'create'.");
+          }
+          return;
+        },
+        body: routeAnnotation2Or3Schema,
+        response: responsePostSchema
+      },
+    },
+    async (request, reply) => {
+      const
+        { iiifPresentationVersion, action } = request.params,
+        { throwOnCanvasIndexError, throwOnXywhError } = request.query,
+        annotation = request.body;
+
+      try {
+        validateAnnotationVersion(iiifPresentationVersion, annotation);
+        // insert or update
+        if (iiifPresentationVersion === 2) {
+          return action==="create"
+            ? await annotations2.insertAnnotation(annotation, throwOnCanvasIndexError, throwOnXywhError)
+            : await annotations2.updateAnnotation(annotation, throwOnCanvasIndexError, throwOnXywhError);
+        } else {
+          annotations3.notImplementedError();
+        }
+
+      } catch (err) {
+        returnError(request, reply, err, request.body);
+      }
+    }
+  )
+
+  /**
+   * create several annotations from:
+   * - an annotationList (if iiifPresentationVersion === 2)
+   * - an annotationPage (if iiifPresentationVersion === 3)
+   * - an URI to an annotationList or annotationPage
+   * - or an Array of any of the previous
+   *
+   * NOTE that POST body size is limited to 1MB, so your query might be rejected. body size is limited by:
+   * - fastify's `bodyLimit` (https://fastify.dev/docs/latest/Reference/Server/#bodylimit)
+   * - nginx's `client_max_body_size` (https://nginx.org/en/docs/http/ngx_http_core_module.html#client_max_body_size)
+   * - any other server's max body size.
+   * both fastify and nginx limit body size defaults to to 1MB.
+   */
+  fastify.post(
+    "/annotations/:iiifPresentationVersion/createMany",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        querystring: {
+          type: "object",
+          properties: {
+            throwOnCanvasIndexError: { type: "boolean", default: STRICT_MODE },
+            throwOnXywhError: { type: "boolean", default: STRICT_MODE },
+          }
+        },
+        body: routeAnnotationCreateManySchema,
+        response: responsePostSchema
+      }
+    },
+    async (request, reply) => {
+      const
+        { iiifPresentationVersion } = request.params,
+        { throwOnCanvasIndexError, throwOnXywhError } = request.query,
+        body = maybeToArray(request.body),  // convert to an array to have a homogeneous data structure
+        insertResponseArray = [];
+
+      // data to actually insert (body with resolved URIs, if the body is  `annotationListOrPageUri` or `annotationListOrPageUriArray`)
+      let annotationsArray = [];
+
+      try {
+        // if we received `annotationListOrPageUri` or `annotationListOrPageUriArray`, fetch objects
+        const asUri = body.find(item => objectHasKey(item, "uri")) !== undefined;
+        if (asUri) {
+          annotationsArray = await Promise.all(
+            body.map(async (item) =>
+              fetch(item.uri).then(r => r.json()))
+          );
+        } else {
+          annotationsArray = body;
+        }
+
+        validateAnnotationArrayVersion(iiifPresentationVersion, annotationsArray);
+
+        // insert
+        if (iiifPresentationVersion === 2) {
+          await Promise.all(annotationsArray.map(
+            async (annotationList) => {
+              const r = await annotations2.insertAnnotationList(annotationList, throwOnCanvasIndexError, throwOnXywhError);
+              insertResponseArray.push(r);
+            }
+          ));
+          return reduceInsertResponseArray(insertResponseArray);
+        } else {
+          annotations3.notImplementedError();
+        }
+
+      } catch (err) {
+        returnError(request, reply, err, request.body);
+      }
+    }
+  )
+
+  done();
+
+}
+
+export default fastifyPlugin(annotationsRoutes);

package/src/data/annotations/routes.test.js

@@ -0,0 +1,271 @@
+import test from "node:test";
+
+import build from "#src/app.js";
+
+import { v4 as uuid4 } from "uuid";
+
+import { inspectObj, isObject, getRandomItem, visibleLog } from "#utils/utils.js"
+import { testPostRouteCurry, testDeleteRouteCurry, injectTestAnnotations, injectPost, injectGet } from "#utils/testUtils.js";
+import { PUBLIC_URL, PORT, HOST } from "#constants";
+
+
+/** @typedef {import("#types").NodeTestType} NodeTestType */
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").FastifyReplyType} FastifyReplyType */
+/** @typedef {import("#types").DataOperationsType} DataOperationsType */
+
+test("test annotation Routes", async (t) => {
+
+  const
+    fastify = await build("test"),
+    testPostRoute = testPostRouteCurry(fastify),
+    testPostRouteCreate = testPostRoute("insert"),
+    testPostRouteUpdate = testPostRoute("update"),
+    testDeleteRoute = testDeleteRouteCurry(fastify),
+    testPostRouteCreateSuccess = testPostRouteCreate(true),
+    testPostRouteCreateFailure = testPostRouteCreate(false),
+    testPostRouteUpdateSuccess = testPostRouteUpdate(true),
+    testPostRouteUpdateFailure = testPostRouteUpdate(false),
+    {
+      annotationListUri,
+      annotationListUriArray,
+      annotationList,
+      annotationListArray,
+      annotationListUriInvalid,
+      annotationListUriArrayInvalid
+    } = fastify.fixtures;
+
+  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: PORT, host: HOST });
+  } catch (err) {
+    console.log("FASTIFY ERROR", err);
+    throw err;
+  }
+
+  await t.test("test route /annotations/:iiifPresentationVersion/createMany", async (t) => {
+    // truncate the contents of `annotationListArray` to avoid an `fst_err_ctp_body_too_large` error
+    // `https://fastify.dev/docs/latest/Reference/Errors/#fst_err_ctp_body_too_large`
+    const annotationListArrayLimit = annotationListArray.map(a => {
+      a.resources = a.resources.length > 500 ? a.resources.slice(0,500) : a.resources
+      return a;
+    });
+
+    // test basic inserts
+    //NOTE: we can't do Promise.all because it causes a data race that can cause a failure of unique constraints (i.e., on manifests '@id')
+    let data = [
+      [[ annotationListUri, annotationListUriArray, annotationList, annotationListArrayLimit ], testPostRouteCreateSuccess ],
+      [[ annotationListUriInvalid, annotationListUriArrayInvalid ], testPostRouteCreateFailure ]
+    ];
+    for (let i=0; i<data.length; i++) {
+      let [ testData, func ] = data.at(i);
+      for (let i=0; i<testData.length; i++) {
+        await func(t, "/annotations/2/createMany?throwOnXywhError=true", testData.at(i));
+      }
+    }
+
+    // test that `throwOnCanvasIndexError` throws errors when it's supposed to
+    const annotationListWithTargetErrors = structuredClone(annotationList);
+    // replace the annotation.on with an uuid => should trigger an error.https://www.cinefil.com/film/mulholland-drive
+    annotationListWithTargetErrors.resources =
+      annotationListWithTargetErrors
+        .resources
+        .map((annotation) => {
+          // if annotation.on is a string, the annotation should have a fragment
+          annotation.on = `https://test/${uuid4()}#xywh=100,100,300,300`;
+          return annotation
+        });
+
+    data = [[ testPostRouteCreateFailure, true ], [ testPostRouteCreateSuccess, false ]];
+    for (let i=0; i<data.length; i++) {
+      const [ func, v ] = data.at(i);
+      func(t, `/annotations/2/createMany?throwOnCanvasIndexError=${v}`, annotationListWithTargetErrors)
+    }
+  })
+
+  await t.test("test route /annotations/:iiifPresentationVersion/create", async (t) => {
+    //NOTE: we can't do Promise.all because it causes a data race that can cause a failure of unique constraints (i.e., on manifests '@id')
+    let data = [
+      [ fastify.fixtures.annotations2Valid, testPostRouteCreateSuccess ],
+      [ fastify.fixtures.annotations2Invalid, testPostRouteCreateFailure ],
+    ]
+    for (const [ testData, func ] of data) {
+      for (let i=0; i<testData.length; i++) {
+        await func(t, "/annotations/2/create?throwOnXywhError=true", testData.at(i));
+      }
+    };
+
+    // test SVG to XYWH conversion
+    // 1. insert and assert there was no mistake
+    // 2. retrieve the inserted annotation and check its xywh coordinates.
+    for (const ann of  fastify.fixtures.annotations2SvgValid) {
+      let r, rBody;
+      r = await injectPost(fastify, "/annotations/2/create", ann);
+      rBody = await JSON.parse(r.body);
+      t.assert.deepStrictEqual(r.statusCode, 200);
+      t.assert.deepStrictEqual(rBody.insertedIds.length, 1);
+      const annId = JSON.parse(r.body).insertedIds[0];
+      r = await injectGet(fastify, annId);
+      rBody = await JSON.parse(r.body);  // the annotation we just inserted
+      rBody.on.map(target => {
+        t.assert.deepStrictEqual(Array.isArray(target.xywh), true);
+        t.assert.deepStrictEqual(target.xywh.every((i) => !isNaN(i)), true);
+      })
+    }
+
+    // test throwOnCanvasIndexError
+    let annotationError;
+    annotationError = structuredClone(fastify.fixtures.annotations2Valid.at(0));
+    annotationError.on = `https://test/${uuid4()}#xywh=100,100,300,300`;
+    data = [[ testPostRouteCreateFailure, true ], [ testPostRouteCreateSuccess, false ]];
+    for (let i=0; i<data.length; i++) {
+      const [ func, v ] = data.at(i);
+      await func(t, `/annotations/2/create?throwOnCanvasIndexError=${v}`, annotationError)
+    }
+
+    // test throwOnXywhError. SvgSelectors are not supported, so this should fail
+    annotationError = structuredClone(fastify.fixtures.annotations2Valid.at(0));
+    // NOTE : this is an SVG selector and not a CSS selector !!!!
+    annotationError.on = {
+      "@type": "oa:SpecificResource",
+      "full": "https://aikon.enpc.fr/aikon/iiif/v2/wit9_man11_anno165/canvas/c11.json",
+      selector: {
+        "@context": "http://iiif.io/api/annex/openannotation/context.json",
+        "@type": "iiif:ImageApiSelector",
+        "region": "50,50,1250,1850"      }
+    }
+    data = [[ testPostRouteCreateFailure, true ], [ testPostRouteCreateSuccess, false ]];
+    for (let i=0; i<data.length; i++) {
+      const [ func, v ] = data.at(i);
+      await func(t, `/annotations/2/create?throwOnXywhError=${v}`, annotationError);
+    }
+
+  })
+
+  await t.test("test route /annotations/:iiifPresentationVersion/update", async (t) => {
+    const updatePipeline = async (annotation, success) => {
+      // update the annotation
+      const
+        newLabel = `label-${uuid4()}`,
+        newBody = {
+          "@type": "cnt:ContentAsText",
+          format: "text/html",
+          value: "<p>What a grand pleasure it is to have updated this annotation !</p>"
+        };
+      annotation.label = newLabel;
+      annotation.resource = newBody;
+      if (!success) {
+        annotation["@type"] = "invalidType";
+      }
+      success
+        ? await testPostRouteUpdateSuccess(t, "/annotations/2/update", annotation)
+        : await testPostRouteUpdateFailure(t, "/annotations/2/update", annotation);
+    }
+
+    // insert valid documents and retrieve an annotation to update.
+    const
+      [ insertedCount, insertedIds ] = await injectTestAnnotations(fastify, t, annotationList),
+      idToUpdate = getRandomItem(insertedIds),  // get a random item
+      annotation = await fastify.mongo.db.collection("annotations2").findOne(
+        { "@id": idToUpdate },
+        { projection: { _id: 0 } }
+      );
+
+    await updatePipeline(annotation, true);
+    await updatePipeline(annotation, false);
+    return;
+  });
+
+  // NOTE: this route handles pagination, but we don't test it here. the pagination module is aldready tested in `search-api`
+  await t.test("test route /annotations/:iiifPresentationVersion/search", async (t) => {
+    await injectTestAnnotations(fastify, t, annotationList);
+    const
+      annotationCollection = await fastify.mongo.db.collection("annotations2").find().toArray(),
+      annotation = getRandomItem(annotationCollection),
+      canvasId = getRandomItem(annotation.on).full,
+      expectedCount = annotationCollection
+        .filter((annotation) => annotation.on.map(target => target.full).includes(canvasId))
+        .length,
+      pageSize = expectedCount + 1,  // all results will always be in 1 page
+      r = await fastify.inject({
+        method: "GET",
+        url: `/annotations/2/search?canvasUri=${canvasId}&page=1&pageSize=${pageSize}`
+      }),
+      body = await r.json();
+
+    t.assert.deepStrictEqual(r.statusCode, 200);
+    t.assert.deepStrictEqual(Array.isArray(body?.resources), true);
+    t.assert.deepStrictEqual(body.resources.length, expectedCount);
+  })
+
+  await t.test("test route /data/:iiifPresentationVersion/:manifestShortId/annotation/:annotationShortId", async (t) => {
+    await injectTestAnnotations(fastify, t, annotationList);
+    const annotationId = await getRandomItem(
+      await fastify.mongo.db.collection("annotations2").find().toArray()
+    )["@id"];
+    await Promise.all(
+      // if shouldExist, search an annotation that exists, otherwise, search an annotation that does not exist. test accordingly.
+      [ true, false ].map(async (shouldExist) => {
+        const
+          annotationIdQuery =
+            shouldExist
+              ? annotationId.replace(PUBLIC_URL, "")
+              : annotationId.replace(PUBLIC_URL, "") + "string_that_does_not_exist_in_the_db",
+          r = await fastify.inject({
+            method: "GET",
+            url: annotationIdQuery
+          }),
+          body = await r.json();
+
+        t.assert.deepStrictEqual(r.statusCode, 200);
+        if (shouldExist) {
+          t.assert.deepStrictEqual(body["@id"]===annotationId, true);
+        } else {
+          t.assert.deepStrictEqual(Object.keys(body).length === 0, true);
+        }
+      })
+    )
+  })
+
+  await t.test("test route /annotations/:iiifPresentationVersion/count", async (t) => {
+    const expectedOnCount = (annotationArray, onKey, expectedOnVal) =>
+      annotationArray.filter((anno) => anno.on.some(x => x[onKey] === expectedOnVal)).length
+
+    await injectTestAnnotations(fastify, t, annotationList);
+    const
+      annotationArray = await fastify.mongo.db.collection("annotations2").find().toArray(),
+      annotationId = getRandomItem(annotationArray)["@id"],
+      canvasUri = getRandomItem(annotationArray).on[0].full,
+      manifestShortId = getRandomItem(annotationArray).on[0].manifestShortId,
+      expectedAnnotationIdCount = 1,
+      expectedCanvasUriCount = expectedOnCount(annotationArray, "full", canvasUri),
+      expectedManifestShortIdCount = expectedOnCount(annotationArray, "manifestShortId", manifestShortId),
+      mapper = [
+        [ "uri", annotationId, expectedAnnotationIdCount ],
+        [ "canvasUri", canvasUri, expectedCanvasUriCount ],
+        [ "manifestShortId", manifestShortId, expectedManifestShortIdCount ]
+      ];
+
+    await Promise.all(
+      mapper.map(async ([ filterKey, filterVal, expectedCount ]) => {
+        const
+          r = await fastify.inject({
+            method: "GET",
+            url: `/annotations/2/count?${filterKey}=${filterVal}`
+          }),
+          body = await r.json();
+        t.assert.deepStrictEqual(r.statusCode, 200);
+        t.assert.deepStrictEqual(body.count, expectedCount);
+      })
+    )
+
+  })
+
+  return
+})