@paulhectork/aiiinotate 0.12.0

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

@@ -0,0 +1,53 @@
+import test from "node:test";
+
+import build from "#src/app.js";
+import { PORT, HOST } from "#constants";
+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.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 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",
+})

package/src/data/manifests/routes.js

@@ -0,0 +1,122 @@
+import fastifyPlugin from "fastify-plugin";
+
+import { makeResponsePostSchema, returnError, makeResponseSchema } from "#utils/routeUtils.js";
+import { objectHasKey, getFirstNonEmptyPair, visibleLog } from "#utils/utils.js";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").Manifests2InstanceType} Manifests2InstanceType */
+/** @typedef {import("#types").Manifests3InstanceType} Manifests3InstanceType */
+
+/**
+ * @param {FastifyInstanceType} fastify
+ * @param {object} options
+ * @param {Function} done
+ */
+function manifestsRoutes(fastify, options, done) {
+  const
+    /** @type {Manifests2InstanceType} */
+    manifests2 = fastify.manifests2,
+    /** @type {Manifests3InstanceType} */
+    manifests3 = fastify.manifests3,
+    iiifPresentationVersionSchema = fastify.schemasBase.getSchema("presentation"),
+    responsePostSchema = makeResponsePostSchema(fastify),
+    collectionSchema = makeResponseSchema(fastify, fastify.schemasPresentation2.getSchema("collection"));
+
+  ///////////////////////////////////////////////
+  // read routes
+
+  fastify.get(
+    "/manifests/:iiifPresentationVersion",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        response: collectionSchema,
+      }
+    },
+    async (request, reply) => {
+      const { iiifPresentationVersion } = request.params;
+      try {
+        return iiifPresentationVersion === 2
+          ? await manifests2.getManifests()
+          : manifests3.notImplementedError();
+      } catch (err) {
+        returnError(request, reply, err);
+      }
+    }
+  )
+
+  fastify.get(
+    "/data/:iiifPresentationVersion/:manifestShortId/index",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema,
+            manifestShortId: { type: "string" }
+          }
+        },
+        response: {
+          200: { type: "object" }
+        }
+      }
+    },
+    async (request, reply) => {
+      const { iiifPresentationVersion, manifestShortId } = request.params;
+      try {
+        return iiifPresentationVersion === 2
+          ? await manifests2.findByManifestShortId(manifestShortId)
+          : manifests3.notImplementedError();
+      } catch (err) {
+        returnError(request, reply, err);
+      }
+    }
+  )
+
+  ///////////////////////////////////////////////
+  // insert routes
+
+  fastify.post(
+    "/manifests/:iiifPresentationVersion/create",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        body: { $ref: fastify.schemasRoutes.getSchema("manifest2Or3") },
+        response: responsePostSchema
+      }
+    },
+    async (request, reply) => {
+      const
+        { iiifPresentationVersion } = request.params,
+        manifestData = request.body;
+      try {
+        if (objectHasKey(manifestData, "uri")) {
+          return iiifPresentationVersion === 2
+            ? await manifests2.insertManifestFromUri(manifestData.uri)
+            : manifests3.notImplementedError();
+        } else {
+          return iiifPresentationVersion === 2
+            ? await manifests2.insertManifest(manifestData)
+            : manifests3.notImplementedError();
+        }
+      } catch (err) {
+        returnError(request, reply, err, request.body);
+      }
+    }
+  );
+
+  done();
+}
+
+export default fastifyPlugin(manifestsRoutes);
+

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

@@ -0,0 +1,70 @@
+import test from "node:test";
+
+import build from "#src/app.js";
+import { visibleLog } from "#utils/utils.js";
+import { getManifestShortId } from "#utils/iiif2Utils.js";
+import { testPostRouteCurry, injectPost, injectTestManifest, assertStatusCode, assertObjectKeys } from "#utils/testUtils.js";
+import { PORT, HOST } from "#constants";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").NodeTestType} NodeTestType */
+
+test("test manifests Routes", async (t) => {
+  const
+    fastify = await build("test"),
+    testPostRoute = testPostRouteCurry(fastify),
+    testPostRouteCreate = testPostRoute("insert"),
+    testPostRouteCreateSuccess = testPostRouteCreate(true),
+    testPostRouteCreateFailure = testPostRouteCreate(false),
+    {
+      manifest2Valid,
+      manifest2Invalid,
+      manifest2ValidUri,
+      manifest2InvalidUri,
+    } = 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 /manifests/:iiifPresentationVersion/create", async (t) => {
+    const data = [
+      [[ manifest2Valid, manifest2ValidUri ], testPostRouteCreateSuccess ],
+      [[ manifest2Invalid, manifest2InvalidUri ], testPostRouteCreateFailure ]
+    ];
+    for (let i=0; i<data.length; i++) {
+      const [ testData, func ] = data.at(i);
+      for (let j=0; j<testData.length; j++) {
+        const payload = testData.at(j);
+        await func(t, "/manifests/2/create", payload);
+        // for some reason, it is necessary to call `emptyCollections` explicitly here to avoid a JSONSchema validation error.
+        await fastify.emptyCollections();
+      }
+    }
+  })
+
+  await t.test("test route /manifests/:iiifPresentationVersion/collection", async (t) => {
+    await injectTestManifest(fastify, t, manifest2Valid);
+    const r = await fastify.inject({
+      method: "GET",
+      url: "/manifests/2"
+    });
+    assertStatusCode(t, r, 200);
+    assertObjectKeys(
+      t,
+      JSON.parse(r.body),
+      [ "@context", "@id", "@type", "members", "label" ]
+    );
+  })
+
+})

package/src/data/routes.js

@@ -0,0 +1,181 @@
+import fastifyPlugin from "fastify-plugin"
+
+import { pathToAiiinotatePublicUrl, ajvCompile, inspectObj, getFirstNonEmptyPair, visibleLog } from "#utils/utils.js";
+import { returnError, makeResponseSchema, makeResponsePostSchema, addPagination } from "#utils/routeUtils.js";
+
+/** @typedef {import("#types").Manifests2InstanceType} Manifests2InstanceType */
+/** @typedef {import("#types").Manifests3InstanceType} Manifests3InstanceType */
+/** @typedef {import("#types").Annotations2InstanceType} Annotations2InstanceType */
+/** @typedef {import("#types").Annotations3InstanceType} Annotations3InstanceType */
+
+/**
+ * @param {FastifyInstanceType} fastify
+ * @param {object} options
+ * @param {Function} done
+ */
+function commonRoutes(fastify, options, done) {
+  const
+    /** @type {Annotations2InstanceType} */
+    annotations2 = fastify.annotations2,
+    /** @type {Annotations3InstanceType} */
+    annotations3 = fastify.annotations3,
+    /** @type {Manifests2InstanceType} */
+    manifests2 = fastify.manifests2,
+    /** @type {Manifests3InstanceType} */
+    manifests3 = fastify.manifests3,
+    iiifPresentationVersionSchema = fastify.schemasBase.getSchema("presentation"),
+    iiifSearchApiVersionSchema = fastify.schemasBase.getSchema("search"),
+    iiifAnnotationListSchema = fastify.schemasPresentation2.getSchema("annotationList"),
+    routeDeleteSchema = fastify.schemasRoutes.getSchema("routeDelete"),
+    responsePostSchema = makeResponsePostSchema(fastify),
+    validatorRouteAnnotationDeleteSchema = ajvCompile(fastify.schemasResolver(
+      fastify.schemasRoutes.getSchema("routeAnnotationDeleteFilter")
+    )),
+    validatorRouteManifestDeleteSchema = ajvCompile(fastify.schemasResolver(
+      fastify.schemasRoutes.getSchema("routeManifestFilter")
+    ));
+
+  fastify.get(
+    "/search-api/:iiifSearchVersion/manifests/:manifestShortId/search",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            iiifSearchVersion: iiifSearchApiVersionSchema,
+            manifestShortId: { type: "string" },
+          },
+        },
+        querystring: addPagination({
+          type: "object",
+          properties: {
+            q: { type: "string" },
+            motivation: {
+              type: "string",
+              enum: [ "painting", "non-painting", "commenting", "describing", "tagging", "linking" ]
+            },
+            canvasMin: {
+              type: "integer",
+              minimum: 0
+            },
+            canvasMax: {
+              type: [ "integer","null" ],
+              minimum: 0
+            },
+            onlyIds: {
+              type: "boolean",
+              default: "false"
+            },
+          }
+        }),
+        // return either an AnnotationList, or if `onlyIds=true`, an array of strings
+        response: makeResponseSchema(fastify, {
+          anyOf: [
+            { type: "array", items: { type: "string" } },
+            // anyOf does not handle well $refs => resolve all references in the schema.
+            fastify.schemasResolver(iiifAnnotationListSchema)
+          ]
+        })
+        // { 200: iiifAnnotationListSchema }
+      },
+      preValidation: async (request, reply) => {
+        const
+          { canvasMin, canvasMax } = request.query,
+          error = new Error(`Error validating GET search-api route: 'canvasMin' must be smaller than 'canvasMax'. If 'canvasMax' is defined, 'canvasMin' must be defined as well. Got canvasMin=${canvasMin}, canvasMax=${canvasMax}`),
+          throwError = () => returnError(request, reply, error, {}, 400);
+        if (
+          (canvasMin == null && canvasMax != null)
+          || (Number(canvasMax) < Number(canvasMin))
+        ) {
+          throwError();
+        }
+        return;
+      }
+    },
+    async (request, reply) => {
+      const
+        queryUrl = pathToAiiinotatePublicUrl(request.url),
+        { iiifSearchVersion, manifestShortId } = request.params,
+        { q, motivation, canvasMin, canvasMax, onlyIds, page, pageSize } = request.query;
+
+      if (iiifSearchVersion===1) {
+        return await annotations2.search({
+          queryUrl,
+          manifestShortId,
+          q,
+          motivation,
+          canvasMin,
+          canvasMax,
+          onlyIds,
+          page,
+          pageSize
+        });
+      } else {
+        annotations3.notImplementedError();
+      }
+    }
+  );
+
+  /////////////////////////////////////////////
+  // DELETE routes
+
+  /**
+   * manifest and annotations work in the same manner, so we group them here.
+   * we add a custom `preHandler` to ensure that `queryString` follows the proper schema.
+   */
+  fastify.delete(
+    "/:collectionName/:iiifPresentationVersion/delete",
+    {
+      schema: {
+        params: {
+          type: "object",
+          properties: {
+            collectionName: { type: "string", enum: [ "annotations", "manifests" ] },
+            iiifPresentationVersion: iiifPresentationVersionSchema
+          }
+        },
+        queryString: routeDeleteSchema,
+        response: responsePostSchema,
+      },
+      preValidation: async (request, reply) => {
+        // implement a custom validation hook: depending on the value of `collectionName`, run different schema validations.
+        const
+          { collectionName } = request.params,
+          query = request.query,
+          validator =
+            collectionName==="annotations"
+              ? validatorRouteAnnotationDeleteSchema
+              : validatorRouteManifestDeleteSchema,
+          error = new Error(`Error validating DELETE route on collection '${collectionName}' with queryString '${inspectObj(query)}'`);
+        if (!validator(query)) {
+          returnError(request, reply, error, {}, 400);
+        }
+        return;
+      }
+    },
+    async (request, reply) => {
+      const { collectionName, iiifPresentationVersion } = request.params;
+
+      try {
+        if (collectionName==="annotations") {
+          const deleteFilter = request.query;
+          return iiifPresentationVersion === 2
+            ? await annotations2.deleteAnnotations(deleteFilter)
+            : annotations3.notImplementedError();
+        } else {
+          const [ deleteKey, deleteVal ] = getFirstNonEmptyPair(request.query);
+          return iiifPresentationVersion === 2
+            ? await manifests2.deleteManifest(deleteKey, deleteVal)
+            : manifests3.notImplementedError();
+        }
+      } catch (err) {
+        returnError(request, reply, err, request.body);
+      }
+
+    }
+  )
+
+  done();
+}
+
+export default fastifyPlugin(commonRoutes);

package/src/data/routes.test.js

@@ -0,0 +1,166 @@
+import test from "node:test";
+
+import { v4 as uuid4 } from "uuid";
+
+import build from "#src/app.js";
+import { getRandomItem, visibleLog } from "#utils/utils.js";
+import { getManifestShortId } from "#utils/iiif2Utils.js";
+import { testPostRouteCurry, testDeleteRouteCurry, injectTestManifest, injectTestAnnotations, assertErrorValidResponse, assertDeleteValidResponse, testGetPaginated } from "#utils/testUtils.js";
+import { PORT, HOST } from "#constants";
+
+/** @typedef {import("#types").FastifyInstanceType} FastifyInstanceType */
+/** @typedef {import("#types").NodeTestType} NodeTestType */
+
+test("test common routes", async (t) => {
+  const
+    /** @type {FastifyInstanceType} */
+    fastify = await build("test"),
+    testPostRoute = testPostRouteCurry(fastify),
+    testDeleteRoute = testDeleteRouteCurry(fastify),
+    { manifest2Valid, annotationList } = 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;
+  }
+
+  ////////////////////////////////////////////////
+  // GET routes
+
+  await t.test("test route /search-api/:iiifPresentationVersion/manifests/:manifestShortId/search", async (t) => {
+    await injectTestAnnotations(fastify, t, annotationList);
+
+    const manifestShortIdArray = [ ...new Set(
+      annotationList.resources.map(annotation => getManifestShortId(annotation.on))
+    ) ];
+    let route, expectedCount, pageSize;
+    for (const manifestShortId of manifestShortIdArray) {
+      expectedCount = annotationList.resources.filter(annotation => annotation.on.includes(manifestShortId)).length;
+      pageSize = Math.max(Math.floor(expectedCount / 10), 1);
+      route = `/search-api/1/manifests/${manifestShortId}/search?pageSize=${pageSize}`;
+      await testGetPaginated(fastify, t, 2, route, expectedCount);
+    }
+  })
+
+  ////////////////////////////////////////////////
+  // DELETE routes
+
+  await t.test("test route /:collectionName/:iiifPresentationVersion/delete", async (t) => {
+
+    await t.test("test preValidation hook for queryString validation", async (t) => {
+      const data = [
+        [ "/manifests/2/delete?canvasUri=xxx", false ],    // canvasUri is only allowed if `collectionName==="annotations"` => will fail.
+        [ "/annotations/2/delete?tag=xxx", false ],  // if using tag, manifestShortId must also be defined
+        [ "/manifests/2/delete?tag=xxx&manifestShortId=xxx", false ],  // tag is not allowed with `manifests`
+        [ "/annotations/2/delete?tag=xxx&manifestShortId=xxx", true ],
+        [ "/manifests/2/delete?manifestShortId=xxx", true ],
+      ];
+      for (let i=0; i<data.length; i++) {
+        const [ url, expectSuccess ] = data.at(i);
+        const r = await fastify.inject({
+          method: "DELETE",
+          url: url
+        })
+        expectSuccess
+          ? assertDeleteValidResponse(t, r)
+          : assertErrorValidResponse(t, r, 400);
+      }
+    });
+
+    await t.test("test route /manifests/:iiifPresentationVersion/delete", async (t) => {
+      const
+        manifest = manifest2Valid,
+        deleteQuery = [
+          [ "uri", manifest["@id"] ],
+          [ "manifestShortId", getManifestShortId(manifest["@id"]) ]
+        ];
+
+      for (let i=0; i<deleteQuery.length; i++) {
+        const [ deleteBy, deleteKey ] = deleteQuery.at(i);
+        await injectTestManifest(fastify, t, manifest);
+        await testDeleteRoute(t, `/manifests/2/delete?${deleteBy}=${deleteKey}`, 1);
+        await fastify.emptyCollections();
+      }
+    });
+
+    await t.test("test route /annotations/:iiifPresentationVersion/delete", async (t) => {
+      const deletePipeline = async (validFilter) =>
+        // validFilter is true => delete data that exists in the db (test that deletions are done correctly),
+        // validFilter is false => delete data that doesn't exist (test that nothing is deleted by accident)
+        await Promise.all(
+          // all 3 possible ways to delete data
+          [ "manifestShortId", "canvasUri", "uri" ].map(
+            async (deleteBy) =>
+              await t.test(`validFilter: ${validFilter}, deleteBy: ${deleteBy}`, async (t) => {
+
+                await injectTestAnnotations(fastify, t, annotationList);
+                const
+                  annotations = await fastify.mongo.db.collection("annotations2").find({}).toArray(),
+                  deleteKey =
+                    validFilter
+                      ? deleteBy==="uri"
+                        ? getRandomItem(annotations.map((a) => a["@id"]))
+                        : deleteBy==="canvasUri"
+                          ? 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.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);
+              })
+          )
+        );
+
+      await deletePipeline(true);
+      await deletePipeline(false);
+      await fastify.emptyCollections();
+
+      await t.test("test route /annotations/:iiifPresentationVersion/delete with param 'tag'", async (t) => {
+        const
+          tags = [ "tag1", "tag2", "tag3" ],
+          // outputs one of the tags at random
+          selectTag = () => tags[Math.floor(Math.random() * 3)],
+          testTag = selectTag(),
+          // avoid changes to the global annotationList by cloning it.
+          annotationListCopy = structuredClone(annotationList),
+          // all annotations in the anno list are on the same manifest
+          manifestShortId = getManifestShortId(annotationList.resources[0].on);
+
+        annotationListCopy.resources = annotationList.resources.map((anno) => {
+          anno.resource = {
+            "@type": "oa:Tag",
+            "chars": selectTag()
+          }
+          return anno;
+        })
+        const expectedDeletedCount = annotationListCopy.resources.filter((anno) =>
+          anno.resource["@type"]==="oa:Tag"
+          && anno.resource["chars"]===testTag
+        ).length;
+        await injectTestAnnotations(fastify, t, annotationList);
+        await testDeleteRoute(t, `/annotations/2/delete?manifestShortId=${manifestShortId}&tag=${testTag}`, expectedDeletedCount);
+      })
+    });
+
+  })
+
+
+  return;
+})
+

package/src/db/index.js

@@ -0,0 +1,50 @@
+import fastifyPlugin from "fastify-plugin"
+import fastifyMongo from "@fastify/mongodb"
+
+import { MONGODB_DB, MONGODB_DB_TEST, MONGODB_CONNSTRING, MONGODB_CONNSTRING_TEST } from "#constants";
+
+/** @typedef {import('fastify').FastifyInstance} FastifyInstance */
+/** @typedef {import('mongodb').Db} MongoDB */
+
+/**
+ * empty all collections. can only be used on the test database for obvious reasons.
+ * @param {MongoDB} db
+ */
+const emptyCollections = async (db) => {
+  if (db.databaseName !== MONGODB_DB_TEST) {
+    throw new Error(`'emptyCollections' may only be used on test database defined by .env variable 'MONGODB_DB_TEST'. expected test database '${MONGODB_DB_TEST}' but working on database '${db.databaseName}'`);
+  }
+  await Promise.all(
+    [
+      "annotations3",
+      "annotations2",
+      "manifests3",
+      "manifests2"
+    ].map(async (collectionName) =>
+      await db.collection(collectionName).deleteMany({})
+    )
+  )
+};
+
+/**
+ * @param {FastifyInstance} fastify
+ * @param {Object} options
+ */
+async function dbConnector(fastify, options) {
+  const connString =
+    options.test
+      ? MONGODB_CONNSTRING_TEST
+      : MONGODB_CONNSTRING;
+
+  await fastify.register(fastifyMongo, {
+    forceClose: true,
+    url: connString
+  });
+
+  if (options.test) {
+    fastify.decorate("emptyCollections", () => emptyCollections(fastify.mongo.db));
+  }
+}
+
+// wrapping a plugin function with fastify-plugin exposes what is declared inside the plugin to the parent scope.
+export default fastifyPlugin(dbConnector)