aiiinotate 0.2.15 → 0.3.0

package/docker/docker.sh

@@ -45,7 +45,7 @@ env_to_docker() {
     # NOTE that the MongoDB host in Docker MUST BE the name of the Mongo docker service (defined in docker-compose)
     cp "$ENV_CONFIG" "$ENV_DOCKER";
     sed_repl s~^MONGODB_HOST=.*$~MONGODB_HOST=mongo~ "$ENV_DOCKER";
-    sed_repl s~^AIIINOTATE_HOST=.*~AIIINOTATE_HOST=0.0.0.0~ "$ENV_DOCKER";
+    sed_repl s~^AIIINOTATE_HOST=.*~AIIINOTATE_HOST=0.0.0.0~ "$ENV_DOCKER"
 }
 env_to_docker;
 

package/docs/architecture.md

@@ -6,19 +6,19 @@ This is a high-level overview of the Aiiinotate and a good place to start if you
 
 ## Top level plugins
 
-Fastify uses a [**plugin system**](https://fastify.dev/docs/latest/Guides/Plugins-Guide/). In short, it means that, 
+Fastify uses a [**plugin system**](https://fastify.dev/docs/latest/Guides/Plugins-Guide/). In short, it means that,
 - to access the global `fastify` instance, your code needs to be a plugin
 - all plugins must export a single function that registers the plugin on the global fastify instance
 
-This can be quite convoluted and conflict with a "normal" module architecture, so we do a mix of the two: 
+This can be quite convoluted and conflict with a "normal" module architecture, so we do a mix of the two:
 - **all modules at the root** of `src/` are plugins (except `config`)
-- **nested plugins** within each of the above are defined when they need to access the fastify instance. 
+- **nested plugins** within each of the above are defined when they need to access the fastify instance.
 
 ```
-./src/fileServer/ - module storing and serving data files for test fixtures
+./src/fixtures/ - module storing and serving data files for test fixtures
 ./src/schemas/    - JsonSchemas definition and validation
 ./src/db/         - connects the app to the mongojs database
-./src/data/       - routes and modules to read/write data 
+./src/data/       - routes and modules to read/write data
 
 ```
 
@@ -38,13 +38,13 @@ Each `route` and `class` is a fastify plugin. Since the `data` plugin is registe
 
 ```
 ├── index.js               // `data` plugin root
-├── routes.js              // generic routes 
+├── routes.js              // generic routes
 ├── annotations
 │   ├── annotations2.js    // plugin for IIIF presentation 2 annotations
-│   ├── annotations3.js    // plugin for IIIF presentation 3 annotations 
+│   ├── annotations3.js    // plugin for IIIF presentation 3 annotations
 │   ├── routes.js          // routes for both plugins
 ├── collectionAbstract.js  // abstract class with functionnalities for all plugins
-├── manifests              
+├── manifests
     ├── manifests2.js      // plugin for IIIF presentation 2 manifests
     ├── manifests3.js      // plugin for IIIF presentation 3 manifests
     ├── routes.js          // routes for both plugins
@@ -57,9 +57,9 @@ At a high level, `route` files receive data and relegate internal mongoJS intera
 
 Our 5 `collection classes` (`collectionAbstract`, `annotations2`, `annotations3`, `manifests2`, `manifests3`) use class inheritence: all classes inherit from `collectionAbstract`
 - `collectionAbstract` defines collection-agnostic processes that can be used by all other classes.
-- other classes implement functionnalities for a specific data type and collection. 
+- other classes implement functionnalities for a specific data type and collection.
 
---- 
+---
 
 ## Details: why plugins are complicated ?
 
@@ -69,13 +69,13 @@ If using a plugin-only architecture, **you should not do "local" imports** (impo
 // here, we define a root plugin with 2 subplugins (1st is a decorator, 2nd a normal plugin).
 fastify.register((instance, opts, done) => {
 
-  // decorator 
+  // decorator
   instance.decorate('util', (a, b) => a + b)
   console.log(instance.util('that is ', 'awesome'))
 
   // plugin
   fastify.register((instance, opts, done) => {
-    console.log(instance.util('that is ', 'awesome')) 
+    console.log(instance.util('that is ', 'awesome'))
     done()
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiiinotate",
-  "version": "0.2.15",
+  "version": "0.3.0",
   "description": "a fast IIIF-compliant annotation server",
   "main": "./cli/index.js",
   "type": "module",
@@ -47,8 +47,8 @@
     "#config/*.js": "./config/*.js",
     "#data/*.js": "./src/data/*.js",
     "#utils/*.js": "./src/data/utils/*.js",
-    "#fileServer/*.js": "./src/fileServer/*.js",
-    "#fileServer/*.json": "./src/fileServer/*.json",
+    "#fixtures/*.js": "./src/fixtures/*.js",
+    "#fixtures/*.json": "./src/fixtures/*.json",
     "#manifests/*.js": "./src/data/manifests/*.js",
     "#annotations/*.js": "./src/data/annotations/*.js"
   },

package/scripts/setup_mongodb.sh

@@ -1,11 +1,20 @@
 #!/bin/env bash
 
+set -e
+
 # mongo install guide: https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-ubuntu/#std-label-install-mdb-community-ubuntu
 
 #NOTE only the mongodb installation is done here. for database creation, see `setup_mongodb_populate.sh`
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$SCRIPT_DIR/utils.sh";
+source "$SCRIPT_DIR/utils.sh"
+
+# float arithmetic comparison is not supported by bash and we need to use `bc`
+# usage: if float_comparison "a >= b"; then... ; fi
+float_comparison () {
+    expr="$1"
+    (( $(echo "$expr" |bc -l) ));
+}
 
 install_mongodb_ubuntu () {
 

package/scripts/utils.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+
+color_echo() {
+    Color_Off="\033[0m"
+    Red="\033[1;91m"        # Red
+    Green="\033[1;92m"      # Green
+    Yellow="\033[1;93m"     # Yellow
+    Blue="\033[1;94m"       # Blue
+    Purple="\033[1;95m"     # Purple
+    Cyan="\033[1;96m"       # Cyan
+
+    case "$1" in
+        "green") echo -e "$Green$2$Color_Off";;
+        "red") echo -e "$Red$2$Color_Off";;
+        "blue") echo -e "$Blue$2$Color_Off";;
+        "yellow") echo -e "$Yellow$2$Color_Off";;
+        "purple") echo -e "$Purple$2$Color_Off";;
+        "cyan") echo -e "$Cyan$2$Color_Off";;
+        *) echo "$2";;
+    esac
+}
+
+echo_title(){
+    sep_line="========================================"
+    len_title=${#1}
+
+    if [ "$len_title" -gt 40 ]; then
+        sep_line=$(printf "%0.s=" $(seq 1 $len_title))
+        title="$1"
+    else
+        diff=$((38 - len_title))
+        half_diff=$((diff / 2))
+        sep=$(printf "%0.s=" $(seq 1 $half_diff))
+
+        if [ $((diff % 2)) -ne 0 ]; then
+            title="$sep $1 $sep="
+        else
+            title="$sep $1 $sep"
+        fi
+    fi
+
+    color_echo purple "\n\n$sep_line\n$title\n$sep_line"
+}
+
+get_os() {
+    uname_out="$(uname -s)"
+    case "${uname_out}" in
+        Linux*)     os=Linux;;
+        Darwin*)    os=Mac;;
+        CYGWIN*)    os=Cygwin;;
+        MINGW*)     os=MinGw;;
+        MSYS_NT*)   os=Git;;
+        *)          os="UNKNOWN:${unameOut}"
+    esac
+    echo "${os}"
+}
+export OS
+OS=$(get_os)
+
+# float arithmetic comparison is not supported by bash and we need to use `bc`
+# usage: if float_comparison "a >= b"; then... ; fi
+float_comparison () {
+    expr="$1"
+    (( $(echo "$expr" |bc -l) ));
+}

package/src/app.js

@@ -6,7 +6,7 @@ import Fastify from "fastify";
 import cors from "@fastify/cors";
 // import swagger from "@fastify/swagger";
 
-import fileServer from "#fileServer/index.js";
+import fixtures from "#fixtures/index.js";
 import schemas from "#schemas/index.js";
 import data from "#data/index.js";
 import db from "#db/index.js";
@@ -101,7 +101,7 @@ async function build(mode="default") {
   });
 
   await fastify.register(db, mongoConfig);
-  await fastify.register(fileServer);
+  await fastify.register(fixtures);
   fastify.register(schemas);
   fastify.register(data);
   await fastify.ready();

package/src/data/annotations/annotations2.js

@@ -106,18 +106,18 @@ class Annotations2 extends CollectionAbstract {
    * @returns {object}
    */
   #cleanAnnotation(annotation, update=false) {
-    // 1) extract ids and targets
+    // 1) extract ids and targets. convert the target to an array.
     const
-      annotationTarget = makeTarget(annotation),
-      manifestShortId = getManifestShortId(annotationTarget.full);
+      annotationTargetArray = makeTarget(annotation),
+      // we assume that all values of `annotationTargetArray` point to the same manifest => take the manifest of the 1st target
+      manifestShortId = annotationTargetArray[0].manifestShortId;
 
     // in updates, "@id" has aldready been extracted
     if ( !update ) {
       annotation["@id"] = makeAnnotationId(annotation, manifestShortId);
     }
     annotation["@context"] = IIIF_PRESENTATION_2_CONTEXT["@context"];
-    annotation.on = annotationTarget;
-    annotation.on.manifestShortId = manifestShortId;
+    annotation.on = annotationTargetArray;
 
     // 2) process motivations.
     // - motivations are an array of strings
@@ -170,26 +170,25 @@ class Annotations2 extends CollectionAbstract {
   /**
    * handle all side effects on the `manifests2` collection. this does 2 things:
    * - insert all manifests referenced by `annotationData`, and set a key `on.manifestId` on all annotations.
-   * - set a key `on.canvasIdx`, containing the position of the annotation's target canvas in the manifest,
+   * - set a key `canvasIdx` in all values of `annotation.on`, containing the position of the annotation's target canvas in the manifest,
    *    (or undefined if the manifest or canvas were not found).
    * @param {object|object[]} annotationData - an annotation, or array of annotations.
    */
   async #insertManifestsAndGetCanvasIdx(annotationData) {
     // TODO  : extract all canvas Ids, reconstruct manifest IDs from it. if they're valid, insert the manifests into the db.
     // convert objects to array to get a uniform interface.
-    let converted, manifestUris;
+    let converted
     [ annotationData, converted ] = maybeToArray(annotationData, true);
 
-    // extract all manifest URIs and add them to `annotationData`
-    annotationData = annotationData.map((ann) => {
-      ann.on.manifestUri = canvasUriToManifestUri(ann.on.full);
-      return ann;
-    })
+    // 1. get all distinct manifest URIs
+    const manifestUris = [];
+    annotationData.map((ann) => ann.on.map((target) => {
+      if ( target.manifestUri !== undefined && !manifestUris.includes(target.manifestUri) ) {
+        manifestUris.push(target.manifestUri);
+      }
+    }));
 
-    // get all distinct manifest URIs, and insert them.
-    manifestUris = [...new Set(
-      annotationData.map((ann) => ann.on.manifestUri)
-    )];
+    // 2. insert the manifests
     // NOTE: PERFORMANCE significantly drops because of this: test running for the entire app goes from ~1000ms to ~2600ms
     const
       insertResponse = await this.manifestsPlugin.insertManifestsFromUriArray(manifestUris, false),
@@ -197,19 +196,25 @@ class Annotations2 extends CollectionAbstract {
       insertedManifestsIds = insertResponse.insertedIds.concat(insertResponse.preExistingIds || []);
 
     // 3. update annotations with 2 things:
-    //  - where manifest insertion has failed, set `annotation.on.manifestUri` to undefined
+    //  - where manifest insertion has failed, set `manifestUri` to undefined on all values of `annotation.on`
     //  - set `annotation.on.canvasIdx`: the position of the target canvas within the manifest, or undefined if it cound not be found.
     annotationData = await Promise.all(
       annotationData.map(async (ann) => {
-        ann.on.manifestUri =
-          // has the insertion of `manifestUri` worked ? (has it returned a valid response, woth `insertedIds` key).
-          insertedManifestsIds.find((x) => x === ann.on.manifestUri)
-            ? ann.on.manifestUri
-            : undefined;
-        ann.on.canvasIdx =
-          ann.on.manifestUri
-            ? await this.manifestsPlugin.getCanvasIdx(ann.on.manifestUri, ann.on.full)
-            : undefined;
+        ann.on = await Promise.all(
+          ann.on.map(async (target) => {
+            target.manifestUri =
+              // has the insertion of `manifestUri` worked ? (has it returned a valid response, woth `insertedIds` key).
+              insertedManifestsIds.find((x) => x === target.manifestUri)
+                ? target.manifestUri
+                : undefined;
+            target.canvasIdx =
+              target.manifestUri
+                ? await this.manifestsPlugin.getCanvasIdx(target.manifestUri, target.full)
+                : undefined;
+            // console.log(">>> #insertManifestsAndGetCanvasIdx: target", target);
+            return target;
+          })
+        )
         return ann;
       })
     );
@@ -282,7 +287,6 @@ class Annotations2 extends CollectionAbstract {
         : deleteKey==="canvasUri"
           ? { "on.full": deleteVal }
           : { "on.manifestShortId": deleteVal };
-
     return this.delete(deleteFilter);
   }
 
@@ -391,9 +395,7 @@ class Annotations2 extends CollectionAbstract {
    * @returns
    */
   async findByCanvasUri(queryUrl, canvasUri, asAnnotationList=false) {
-    const annotations = await this.find({
-      "on.full": canvasUri
-    });
+    const annotations = await this.find({ "on.full": canvasUri });
     return asAnnotationList
       ? toAnnotationList(annotations, queryUrl, `annotations targeting canvas ${canvasUri}`)
       : annotations;

package/src/data/annotations/routes.js

@@ -65,6 +65,7 @@ function annotationsRoutes(fastify, options, done) {
     /** @type {Annotations3InstanceType} */
     annotations3 = fastify.annotations3,
     iiifPresentationVersionSchema = fastify.schemasBase.getSchema("presentation"),
+    routeAnnotation2Or3Schema = fastify.schemasRoutes.getSchema("routeAnnotation2Or3"),
     routeAnnotationCreateManySchema = fastify.schemasRoutes.getSchema("routeAnnotationCreateMany"),
     iiifAnnotationListSchema = fastify.schemasPresentation2.getSchema("annotationList"),
     iiifAnnotation2ArraySchema = fastify.schemasPresentation2.getSchema("annotationArray"),
@@ -169,7 +170,7 @@ function annotationsRoutes(fastify, options, done) {
             action: { type: "string", enum: [ "create", "update" ] }
           }
         },
-        body: { type: "object" } /* routeAnnotations2Or3Schema */,
+        body: routeAnnotation2Or3Schema,
         response: responsePostSchema
       },
     },

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

@@ -31,7 +31,7 @@ test("test annotation Routes", async (t) => {
       annotationListArray,
       annotationListUriInvalid,
       annotationListUriArrayInvalid
-    } = fastify.fileServer;
+    } = fastify.fixtures;
 
   await fastify.ready();
   // close the app after running the tests
@@ -71,8 +71,8 @@ test("test annotation Routes", async (t) => {
   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')
     const data = [
-      [fastify.fileServer.annotations2Valid, testPostRouteCreateSuccess],
-      [fastify.fileServer.annotations2Invalid, testPostRouteCreateFailure],
+      [fastify.fixtures.annotations2Valid, testPostRouteCreateSuccess],
+      [fastify.fixtures.annotations2Invalid, testPostRouteCreateFailure],
     ]
     for ( let i=0; i<data.length; i++ ) {
       let [ testData, func ] = data.at(i);
@@ -126,7 +126,7 @@ test("test annotation Routes", async (t) => {
           annotation = await getRandomItem(
             await fastify.mongo.db.collection("annotations2").find().toArray()
           ),
-          canvasId = annotation.on.full,
+          canvasId = getRandomItem(annotation.on).full,
           r = await fastify.inject({
             method: "GET",
             url: `/annotations/2/search?uri=${canvasId}&asAnnotationList=${asAnnotationList}`

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

@@ -17,7 +17,7 @@ test("test Manifests2 module", async (t) => {
       manifest2ValidUri,
       manifest2Invalid,
       manifest2InvalidUri
-    } = fastify.fileServer;
+    } = fastify.fixtures;
 
   await fastify.ready();
   // close the app after running the tests

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

@@ -20,7 +20,7 @@ test("test manifests Routes", async (t) => {
       manifest2Invalid,
       manifest2ValidUri,
       manifest2InvalidUri,
-    } = fastify.fileServer;
+    } = fastify.fixtures;
 
   await fastify.ready();
   // close the app after running the tests

package/src/data/routes.test.js

@@ -16,7 +16,7 @@ test("test common routes", async (t) => {
     fastify = await build("test"),
     testPostRoute = testPostRouteCurry(fastify),
     testDeleteRoute = testDeleteRouteCurry(fastify),
-    { manifest2Valid, annotationList } = fastify.fileServer;
+    { manifest2Valid, annotationList } = fastify.fixtures;
 
   await fastify.ready();
   // close the app after running the tests
@@ -88,16 +88,16 @@ test("test common routes", async (t) => {
                       ? deleteBy==="uri"
                         ? getRandomItem(annotations.map((a) => a["@id"]))
                         : deleteBy==="canvasUri"
-                          ? getRandomItem(annotations.map((a) => a.on.full))
-                          : getRandomItem(annotations.map((a) => a.on.manifestShortId))
+                          ? getRandomItem(annotations.map((a) => getRandomItem(a.on).full))
+                          : getRandomItem(annotations.map((a) => getRandomItem(a.on).manifestShortId))
                       : `invalid-filter-${uuid4()}`,
                   expectedDeletedCount =
                     validFilter
                       ? deleteBy==="uri"
                         ? annotations.filter((a) => a["@id"]===deleteKey).length
                         : deleteBy==="canvasUri"
-                          ? annotations.filter((a) => a.on.full===deleteKey).length
-                          : annotations.filter((a) => a.on.manifestShortId===deleteKey).length
+                          ? annotations.filter((a) => a.on.some((x) => x.full===deleteKey)).length
+                          : annotations.filter((a) => a.on.some((x) => x.manifestShortId===deleteKey)).length
                       : 0;
 
                 await testDeleteRoute(t, `/annotations/2/delete?${deleteBy}=${deleteKey}`, expectedDeletedCount);

package/src/data/utils/iiif2Utils.js

@@ -1,6 +1,6 @@
 import { v4 as uuid4 } from "uuid";
 
-import { maybeToArray, getHash, isNullish, isObject } from "#utils/utils.js";
+import { maybeToArray, getHash, isNullish, isObject, objectHasKey, visibleLog } from "#utils/utils.js";
 import { IIIF_PRESENTATION_2, IIIF_PRESENTATION_2_CONTEXT } from "#utils/iiifUtils.js";
 
 /** @typedef {import("#types").MongoCollectionType} MongoCollectionType */
@@ -84,44 +84,52 @@ const getAnnotationTarget = (annotation) => {
 /**
  * convert the annotation's `on` to a SpecificResource
  * reimplemented from SAS: https://github.com/glenrobson/SimpleAnnotationServer/blob/dc7c8c6de9f4693c678643db2a996a49eebfcbb0/src/main/java/uk/org/llgc/annotation/store/AnnotationUtils.java#L123-L135
+ * @param {object} annotation
+ * @returns {object[]} - the array of targets extracted from 'annotation.on'
  */
 const makeTarget = (annotation) => {
-  const
-    // must be either string or SpecificResource
-    target = annotation.on,
-    // error that will raise is `target` can't be processed
-    err = new Error(`${makeTarget.name}: could not make target for annotation: 'annotation.on' must be an URI or an object with 'annotation.on.@type==="oa:SpecificResource"' and 'annotation.on.@id' must be a string URI`, { info: annotation });
-
-  let specificResource;
-
-  // convert to SpecificResource if it's not aldready the case
-  if ( typeof(target) === "string" && !isNullish(target) ) {
-    let [full, fragment] = target.split("#");
-    specificResource = {
-      "@type": "oa:SpecificResource",
-      full: full,
-      selector: {
-        "@type": "oa:FragmentSelector",
-        value: fragment
+  const err = new Error(`${makeTarget.name}: could not make target for annotation: 'annotation.on' must be an URI, an object or an array of objects containing { on: {@id: "<string URI>", @type: "oa:SpecificResource"} }`, { info: annotation });
+
+  /** annotation.on is converted to an array => this function creates a target from a single item of that array */
+  const makeSingleTarget = (_target) => {
+    let specificResource;
+
+    // convert to SpecificResource if it's not aldready the case
+    if ( typeof(_target) === "string" && !isNullish(_target) ) {
+      let [full, fragment] = _target.split("#");
+      specificResource = {
+        "@id": _target,
+        "@type": "oa:SpecificResource",
+        full: full,
+        selector: {
+          "@type": "oa:FragmentSelector",
+          value: fragment
+        }
       }
-    }
-  } else if ( isObject(target) ) {
-    // if 'target' is an object but not a specificresource, raise.
-    if ( target["@type"] === "oa:SpecificResource" && !isNullish(target["full"]) ) {
-      specificResource = target;
-      // the received specificResource `selector` may have its type specified using the key `type`. correct it to `@type`.
-      if ( isObject(target.selector) && Object.keys(target.selector).includes("type") ) {
-        target.selector["@type"] = target.selector.type;
-        delete target.selector.type;
+    } else if ( isObject(_target) ) {
+      if ( _target["@type"] === "oa:SpecificResource" && !isNullish(_target["full"]) ) {
+        specificResource = _target;
+        // the received specificResource `selector` may have its type specified using the key `type`. correct it to `@type`.
+        if ( specificResource.selector !== undefined && isObject(specificResource.selector) && Object.keys(specificResource.selector).includes("type") ) {
+          specificResource.selector["@type"] = specificResource.selector.type;
+          delete specificResource.selector.type;
+        }
+      // if '_target' is an object but not a specificresource, raise.
+      } else {
+        throw err
       }
+    // if _target is neither a string nor an object, raise
     } else {
       throw err
     }
-  } else {
-    throw err
+    if ( objectHasKey(specificResource, "full") ) {
+      specificResource.manifestShortId = getManifestShortId(specificResource.full);
+      specificResource.manifestUri = manifestUri(specificResource.manifestShortId);
+    }
+    return specificResource
   }
 
-  return specificResource
+  return maybeToArray(annotation.on).map(makeSingleTarget);
 }
 
 /**

package/src/data/utils/iiif2Utils.test.js

@@ -12,7 +12,7 @@ const
 test("test 'iiif2Utils' functions", async (t) => {
   const
     fastify = await build("test"),
-    { annotations2Valid, annotations2Invalid } = fastify.fileServer;
+    { annotations2Valid, annotations2Invalid } = fastify.fixtures;
 
   await fastify.ready();
 

package/src/{fileServer → fixtures}/annotations.js

@@ -1,5 +1,5 @@
 // test data for the annotations create and createMany functions.
-import { readFileToObject, toUrl } from "#fileServer/utils.js";
+import { readFileToObject, toUrl } from "#fixtures/utils.js";
 
 const annotations2Invalid = readFileToObject("annotations2Invalid.jsonld");
 const annotations2Valid = readFileToObject("annotations2Valid.jsonld");
@@ -14,10 +14,10 @@ const annotationListUriArray = [
 ];
 
 // will trigger an error because the path doesn't exist
-const annotationListUriInvalid = { uri: "/fileServer/annotationList_that_does_not_exist.jsonld" };
+const annotationListUriInvalid = { uri: "/fixtures/annotationList_that_does_not_exist.jsonld" };
 
 const annotationListUriArrayInvalid = [
-  { uri: "/fileServer/annotationList_that_does_not_exist.jsonld" }
+  { uri: "/fixtures/annotationList_that_does_not_exist.jsonld" }
 ];
 
 const annotationList = readFileToObject("annotationList_aikon_wit9_man11_anno165_all.jsonld");

package/src/{fileServer → fixtures}/index.js

@@ -1,11 +1,11 @@
 /**
- * the `fileServer` plugin makes test files available to the entire fastify app, mostly for testing purposes.
+ * the `fixtures` plugin makes test files available to the entire fastify app, mostly for testing purposes.
  */
 import fastifyPlugin from "fastify-plugin";
 
-import { annotations2Invalid, annotations2Valid, annotationListUri, annotationListUriArray, annotationList, annotationListArray, annotationListUriInvalid, annotationListUriArrayInvalid } from "#src/fileServer/annotations.js";
-import { manifest2Valid, manifest2ValidUri, manifest2Invalid, manifest2InvalidUri } from "#fileServer/manifests.js";
-import { readFileToObject } from "#fileServer/utils.js";
+import { annotations2Invalid, annotations2Valid, annotationListUri, annotationListUriArray, annotationList, annotationListArray, annotationListUriInvalid, annotationListUriArrayInvalid } from "#src/fixtures/annotations.js";
+import { manifest2Valid, manifest2ValidUri, manifest2Invalid, manifest2InvalidUri } from "#fixtures/manifests.js";
+import { readFileToObject } from "#fixtures/utils.js";
 
 /** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
 
@@ -15,11 +15,11 @@ import { readFileToObject } from "#fileServer/utils.js";
  * @param {FastifyInstanceType} fastify  Encapsulated Fastify Instance
  * @param {object} options
  */
-async function fileServer(fastify, options) {
+async function fixtures(fastify, options) {
 
   /** route to return a file in `dataDir` */
   fastify.get(
-    "/fileServer/:fileName",
+    "/fixtures/:fileName",
     {
       schema: {
         params: {
@@ -45,7 +45,7 @@ async function fileServer(fastify, options) {
     }
   )
 
-  fastify.decorate("fileServer", {
+  fastify.decorate("fixtures", {
     annotationListUri: annotationListUri,
     annotationListUriArray: annotationListUriArray,
     annotationList: annotationList,
@@ -61,4 +61,4 @@ async function fileServer(fastify, options) {
   });
 }
 
-export default fastifyPlugin(fileServer);
+export default fastifyPlugin(fixtures);

package/src/{fileServer → fixtures}/manifests.js

@@ -1,4 +1,4 @@
-import { readFileToObject, toUrl } from "#fileServer/utils.js";
+import { readFileToObject, toUrl } from "#fixtures/utils.js";
 
 const manifest2ValidUri = { uri: toUrl("bnf_valid_manifest.json") };
 const manifest2Valid = readFileToObject("bnf_valid_manifest.json");

package/src/{fileServer → fixtures}/utils.js

@@ -4,13 +4,13 @@ import fs from "node:fs";
 
 // path to dirctory of curent file
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-// path to fileServer/data
+// path to fixtures/data
 const dataDir = path.join(__dirname, "data");
 
 const availableFiles = fs.readdirSync(dataDir);
 
 /**
- * for simplicity, `readFileToObject` is synchronous. given that `fileServer` should only be used in tests, there is no performance downgrade for the prod server.
+ * for simplicity, `readFileToObject` is synchronous. given that `fixtures` should only be used in tests, there is no performance downgrade for the prod server.
  * @param {string} fn: the filename
  * @returns {object}
  */
@@ -25,7 +25,7 @@ const readFileToObject = (fn) => {
  * @param {string} fn
  * @returns {string}
  */
-const toUrl = (fn) => `${process.env.AIIINOTATE_BASE_URL}/fileServer/${fn}`;
+const toUrl = (fn) => `${process.env.AIIINOTATE_BASE_URL}/fixtures/${fn}`;
 
 
 export {

package/src/schemas/schemasPresentation2.js

@@ -201,12 +201,15 @@ function addSchemas(fastify, options, done) {
 
   fastify.addSchema({
     $id: makeSchemaUri("annotationTarget"),
-    anyOf: [
-      // URI
-      { type: "string" },
-      // SpecificResource
-      { $ref: makeSchemaUri("specificResource") }
-    ]
+    type: "array",
+    items: {
+      anyOf: [
+        // URI
+        { type: "string" },
+        // SpecificResource
+        { $ref: makeSchemaUri("specificResource") }
+      ]
+    }
   })
 
   fastify.addSchema({

package/src/schemas/schemasRoutes.js

@@ -41,7 +41,20 @@ function addSchemas(fastify, options, done) {
         { type: "string", enum: [ "oa:Annotation" ] },
         { type: "array", items: { type: "string" }}
       ]},
-      on: { anyOf: [{ type: "string" }, { type: "object" }]}
+      on: {
+        anyOf: [
+          { type: "string" },
+          { type: "object" },
+          {
+            type: "array",
+            items: [
+              { type: "string" },
+              { type: "object" }
+            ],
+            minItems: 1
+          }
+        ]
+      }
     }
   });
 
@@ -56,7 +69,20 @@ function addSchemas(fastify, options, done) {
         { type: "string" },
         { type: "array", items: { type: "string" } },
       ]},
-      target: { anyOf: [{ type: "string" }, { type: "object" }]}
+      target: {
+        anyOf: [
+          { type: "string" },
+          { type: "object" },
+          {
+            type: "array",
+            items: [
+              { type: "string" },
+              { type: "object" }
+            ],
+            minItems: 1
+          }
+        ]
+      }
     }
   })