jskos-server 2.4.0

package/test/services.js

@@ -0,0 +1,557 @@
+import jskos from "jskos-tools"
+import _ from "lodash"
+import assert from "node:assert"
+
+import { teardownInMemoryMongo, setupInMemoryMongo, createCollectionsAndIndexes, assertIndexes, assertMongoDB, dropDatabaseBeforeAndAfter, arrayToStream } from "./test-utils.js"
+
+import { InvalidBodyError } from "../errors/index.js"
+
+import { createServices } from "../index.js"
+import config from "../config/config.test.json" with { type: "json" }
+const services = createServices(config)
+
+describe("Services Features", () => {
+  before(async () => {
+    const mongoUri = await setupInMemoryMongo({ replSet: false })
+    process.env.MONGO_URI = mongoUri
+    await createCollectionsAndIndexes()
+    await assertIndexes()
+  })
+
+  after(async () => {
+    // close server if you started one
+    await teardownInMemoryMongo()
+  })
+
+  // 🗑 Drop DB before *and* after every single `it()` in this file
+  dropDatabaseBeforeAndAfter()
+
+  // 🔌 Sanity‐check that mongoose really is connected
+  assertMongoDB()
+
+  Object.keys(services).forEach(type => {
+    it(`should return an empty array for ${type} queryItems`, async () => {
+      const entities = await services[type].queryItems({ limit: 1, offset: 0 })
+      assert.strictEqual(entities.length, 0)
+    })
+  })
+
+  describe("Concordance Service", () => {
+
+    const fromScheme = { uri: "test:fromScheme" }
+    const toScheme = { uri: "test:toScheme" }
+
+    it("should post schemes for testing concordances", async () => {
+      await services.scheme.createItem({ bodyStream: await arrayToStream([fromScheme, toScheme]) })
+    })
+
+    it("should post a concordance with a named contributor, then remove the contributor name, then remove the contributor", async () => {
+      const concordance = {
+        fromScheme,
+        toScheme,
+        contributor: [{
+          uri: "test:user",
+          prefLabel: { de: "test" },
+        }],
+      }
+      const [postedConcordance] = await services.concordance.createItem({ bodyStream: await arrayToStream([concordance]) })
+      const patch = {
+        contributor: [{
+          uri: "test:user",
+        }],
+      }
+      const patchedConcordance = await services.concordance.patchConcordance({ body: patch, existing: postedConcordance })
+      assert.ok(!patchedConcordance.contributor[0].prefLabel, "PATCH requests should merge objects only on the top level.")
+      const patch2 = {
+        contributor: null,
+      }
+      const patchedConcordance2 = await services.concordance.patchConcordance({ body: patch2, existing: patchedConcordance })
+      assert.ok(patchedConcordance2.contributor === undefined, "A field should be removed when set to `null`.")
+    })
+
+    for (const scheme of [fromScheme, toScheme]) {
+      it("should delete scheme after testing concordances", async () => {
+        scheme._id = scheme.uri
+        scheme.concepts = []
+        await services.scheme.deleteItem({ uri: scheme.uri, existing: scheme })
+      })
+    }
+
+  })
+
+  describe("Mapping Service", () => {
+
+    describe("filter mappings by annotations", () => {
+      const mappings = [
+        {
+          uri: "mapping:1",
+        },
+        {
+          uri: "mapping:2",
+        },
+        {
+          uri: "mapping:3",
+        },
+        {
+          to: { memberSet: [{ uri: "urn:test:concept" }] },
+          uri: "mapping:4",
+        },
+        {
+          uri: "mapping:5",
+        },
+      ].map(mapping => {
+        // Add fromScheme and toScheme
+        mapping.fromScheme = { uri: "urn:test:fromScheme" }
+        mapping.toScheme = { uri: "urn:test:toScheme" }
+        // Add from if necessary
+        if (!mapping.from) {
+          mapping.from = { memberSet: [{ uri: "urn:test:fromConcept" }] }
+        }
+        // Add empty to if necessary
+        if (!mapping.to) {
+          mapping.to = { memberSet: [] }
+        }
+        return mapping
+      })
+      const annotations = [
+        {
+          target: "mapping:1",
+          motivation: "assessing",
+          bodyValue: "+1",
+        },
+        {
+          target: "mapping:1",
+          motivation: "assessing",
+          bodyValue: "-1",
+        },
+        {
+          target: "mapping:2",
+          motivation: "moderating",
+          creator: {
+            id: "urn:test:creator",
+          },
+        },
+        {
+          target: "mapping:3",
+          motivation: "moderating",
+        },
+        {
+          target: "mapping:4",
+          motivation: "assessing",
+          bodyValue: "+1",
+        },
+      ]
+
+      it("should post mappings and annotations used for tests", async () => {
+        let result
+        // Mappings
+        result = await services.mapping.createItem({ bodyStream: await arrayToStream(mappings) })
+        assert.strictEqual(result.length, mappings.length)
+        mappings.forEach(mapping => {
+          // Find corresponding mapping and set identifier/uri
+          const corresponding = result.find(m => jskos.compare(m, mapping))
+          assert.ok(!!corresponding)
+          mapping.identifier = corresponding.identifier
+          mapping.uri = corresponding.uri
+        })
+        // Annotations
+        // First adjust targets with actual URIs
+        annotations.forEach(annotation => {
+          const mapping = mappings.find(m => jskos.compare(m, { uri: annotation.target }))
+          assert.ok(!!mapping)
+          annotation.target = mapping.uri
+        })
+        result = await services.annotation.createItem({ bodyStream: await arrayToStream(annotations), admin: true })
+        assert.strictEqual(result.length, annotations.length)
+      })
+
+      it("should get correct number of mappings when using annotatedWith param", async () => {
+        const annotatedWith = "-1"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedWith })
+        const expected = _.uniq(annotations.filter(a => a.bodyValue === annotatedWith).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get the correct mappings when using annotatedWith param with comparison operator", async () => {
+        for (let { from, to, annotatedWith } of [
+          { to: "urn:test:concept", annotatedWith: ">=1" },
+          { from: "urn:test:fromConcept", annotatedWith: "=0" },
+        ]) {
+          const result = await services.mapping.queryItems({ limit: 100, offset: 0, from, to, annotatedWith })
+          // Replace = with == for later evaluation
+          if (annotatedWith.startsWith("=")) {
+            annotatedWith = `=${annotatedWith}`
+          }
+          const expected = mappings.filter(m => {
+            if (from && from !== _.get(m, "from.memberSet[0].uri") || to && to !== _.get(m, "to.memberSet[0].uri")) {
+              return false
+            }
+            const annotationSum = annotations.filter(a => a.target === m.uri).reduce((prev, cur) => {
+              if (cur.motivation !== "assessing") {
+                return prev
+              }
+              return prev + parseInt(cur.bodyValue)
+            }, 0)
+            return Function(`"use strict";return (${annotationSum}${annotatedWith})`)()
+          })
+          assert.deepStrictEqual(result.map(r => r.uri).sort(), expected.map(e => e.uri).sort())
+        }
+      })
+
+      it("should get correct number of mappings when using annotatedFor param", async () => {
+        const annotatedFor = "assessing"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor })
+        const expected = _.uniq(annotations.filter(a => a.motivation === annotatedFor).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedFor param with value `any`", async () => {
+        const annotatedFor = "any"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor })
+        const expected = _.uniq(annotations.map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedFor param with value `none`", async () => {
+        const annotatedFor = "none"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor })
+        const expected = mappings.map(m => m.uri).filter(uri => !annotations.find(a => a.target === uri)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedFor param with negative value", async () => {
+        const annotatedFor = "!assessing"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor })
+        const expected = mappings.map(m => m.uri).filter(uri => !annotations.find(a => a.target === uri && a.motivation === annotatedFor.slice(1))).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedBy param", async () => {
+        const annotatedBy = "urn:test:creator|urn:other:uri"
+        const result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedBy })
+        const expected = _.uniq(annotations.filter(a => annotatedBy.split("|").includes(_.get(a, "creator.id"))).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedFor together with annotatedBy", async () => {
+        let result, expected
+        const annotatedFor = "moderating"
+        // First only annotatedFor
+        result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor })
+        expected = _.uniq(annotations.filter(a => a.motivation === annotatedFor).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+        // Then with annotatedBy
+        const annotatedBy = "urn:test:creator|urn:other:uri"
+        result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedFor, annotatedBy })
+        expected = _.uniq(annotations.filter(a => annotatedBy.split("|").includes(_.get(a, "creator.id")) && a.motivation === annotatedFor).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+      })
+
+      it("should get correct number of mappings when using annotatedWith together with to", async () => {
+        let result, expected
+        const annotatedWith = "+1"
+        // First only annotatedWith
+        result = await services.mapping.queryItems({ limit: 10, offset: 0, annotatedWith })
+        expected = _.uniq(annotations.filter(a => a.bodyValue === annotatedWith).map(a => a.target)).sort()
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected)
+        // Then with to
+        const to = "urn:test:concept"
+        result = await services.mapping.queryItems({ limit: 10, offset: 0, to, annotatedWith })
+        expected = mappings.filter(m => jskos.isContainedIn({ uri: to }, jskos.conceptsOfMapping(m, "to")) && annotations.find(a => a.target === m.uri && a.bodyValue === annotatedWith))
+        assert.deepStrictEqual(result.map(r => r.uri).sort(), expected.map(r => r.uri).sort())
+      })
+
+      it("should reject mappings without fromScheme/toScheme", async () => {
+        for (const mapping of [
+          {
+            from: {
+              memberSet: [{
+                uri: "urn:test:concept",
+              }],
+            },
+            to: {
+              memberSet: [{
+                uri: "urn:test:concept",
+              }],
+            },
+            toScheme: { uri: "urn:test:toScheme" },
+          },
+          {
+            from: {
+              memberSet: [{
+                uri: "urn:test:concept",
+              }],
+            },
+            fromScheme: { uri: "urn:test:fromScheme" },
+            to: {
+              memberSet: [{
+                uri: "urn:test:concept",
+              }],
+            },
+          },
+        ]) {
+          try {
+            await services.mapping.createItem({ bodyStream: await arrayToStream([mapping]) })
+            assert.fail("Expected createItem to fail")
+          } catch (error) {
+            assert.ok(error instanceof InvalidBodyError)
+          }
+        }
+      })
+
+      it("should add fromScheme and toScheme fields from concepts' inScheme property", async () => {
+        const mapping = {
+          from: {
+            memberSet: [{
+              uri: "urn:test:concept",
+              inScheme: [{ uri: "urn:test:fromScheme" }],
+            }],
+          },
+          to: {
+            memberSet: [{
+              uri: "urn:test:concept",
+              inScheme: [{ uri: "urn:test:toScheme" }],
+            }],
+          },
+        }
+        const postedMapping = (await services.mapping.createItem({ bodyStream: await arrayToStream([mapping]) }))?.[0]
+        assert.deepStrictEqual(postedMapping.fromScheme?.uri, mapping.from.memberSet[0].inScheme[0].uri)
+        assert.deepStrictEqual(postedMapping.toScheme?.uri, mapping.to.memberSet[0].inScheme[0].uri)
+      })
+    })
+
+  })
+
+  describe("Annotation Service", () => {
+
+    const mismatchTagScheme = {
+      uri: "https://uri.gbv.de/terminology/mismatch/",
+    }
+    const mismatchTagConcept = {
+      uri: "https://uri.gbv.de/terminology/mismatch/test",
+      inScheme: [{uri: "https://uri.gbv.de/terminology/mismatch/"}],
+    }
+
+    it("should post tag mismatch scheme and concepts", async () => {
+      await services.scheme.createItem({ bodyStream: await arrayToStream([mismatchTagScheme]) })
+      await services.concept.createItem({ bodyStream: await arrayToStream([mismatchTagConcept]) })
+      const concept = await services.concept.getItem(mismatchTagConcept.uri)
+      assert.strictEqual(concept?.uri, mismatchTagConcept.uri)
+    })
+
+    it("should post negative assessment annotation that is correctly tagged", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "-1",
+        body: [
+          {
+            type: "SpecificResource",
+            value: mismatchTagConcept.uri,
+            purpose: "tagging",
+          },
+        ],
+      }
+      const results = await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+      assert.ok(results?.[0]?.id)
+    })
+
+    it("should not post negative assessment annotation that is correctly tagged with a URI that is not explicitly allowed", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "-1",
+        body: [
+          {
+            type: "SpecificResource",
+            value: mismatchTagConcept.uri + "2",
+            purpose: "tagging",
+          },
+        ],
+      }
+      try {
+        await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+        assert.fail("No error was thrown even though it was expected.")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+    it("should not post positive assessment annotation that is tagged", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "+1",
+        body: [
+          {
+            type: "SpecificResource",
+            value: mismatchTagConcept.uri,
+            purpose: "tagging",
+          },
+        ],
+      }
+      try {
+        await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+        assert.fail("No error was thrown even though it was expected.")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+    it("should require `body` to be an array", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "-1",
+        body: {
+          type: "SpecificResource",
+          value: mismatchTagConcept.uri,
+          purpose: "tagging",
+        },
+      }
+      try {
+        await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+        assert.fail("No error was thrown even though it was expected.")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+    it("should not negative assessment annotation that is tagged incorrectly (1)", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "-1",
+        body: [
+          {
+            type: "SpecificResources",
+            value: mismatchTagConcept.uri,
+            purpose: "tagging",
+          },
+        ],
+      }
+      try {
+        await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+        assert.fail("No error was thrown even though it was expected.")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+    it("should not negative assessment annotation that is tagged incorrectly (2)", async () => {
+      const annotation = {
+        target: "abc:def",
+        bodyValue: "-1",
+        body: [
+          {
+            type: "SpecificResource",
+            value: mismatchTagConcept.uri,
+            purpose: "tag",
+          },
+        ],
+      }
+      try {
+        await services.annotation.createItem({ bodyStream: await arrayToStream([annotation]) })
+        assert.fail("No error was thrown even though it was expected.")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+  })
+
+  describe("Registry Service", () => {
+
+    const registryExample = {
+      uri: "urn:test:registry:1",
+      notation: ["ERMS"],
+      prefLabel: { en: "Example Registry" },
+      definition: { en: ["Example definition mentioning ERMS."] },
+      url: "https://example.org/registry/1",
+    }
+
+    it("should post a registry and return with uri", async () => {
+      const result = await services.registry.createItem({
+        bodyStream: await arrayToStream([registryExample]),
+      })
+      assert.ok(result.length === 1)
+      assert.ok(result[0].uri)
+    })
+
+    it("should get a registry by id/uri after posting", async () => {
+      const doc = await services.registry.getItem(registryExample.uri)
+      assert.strictEqual(doc?.uri, registryExample.uri)
+    })
+
+    it("should patch a registry and remove a field when set to null", async () => {
+      const existing = await services.registry.getItem(registryExample.uri)
+
+      // Add a field and verify it exists
+      const patched1 = await services.registry.patchRegistry({
+        existing,
+        body: { publisher: [{ uri: "urn:test:publisher", prefLabel: { en: "Pub" } }] },
+      })
+      assert.ok(patched1.publisher?.length)
+
+      // Now remove field and verify it is removed
+      const patched2 = await services.registry.patchRegistry({
+        existing: patched1,
+        body: { publisher: null },
+      })
+      assert.ok(patched2.publisher === undefined, "A field should be removed when set to `null`.")
+    })
+
+    it("should put a registry and preserve immutable fields while updating", async () => {
+      const existing = await services.registry.getItem(registryExample.uri)
+
+      const body = {
+        // intentionally omit _id/id/created; service should preserve/override them
+        uri: registryExample.uri,
+        prefLabel: { en: "Example Registry Updated" },
+        notation: ["ERMS"],
+      }
+
+      const updated = await services.registry.updateItem({ body, existing })
+      assert.strictEqual(updated.id, existing.id)
+      assert.strictEqual(updated.created, existing.created)
+      assert.ok(updated.modified, "modified should be set")
+      assert.strictEqual(updated.prefLabel?.en, "Example Registry Updated")
+    })
+
+    it("should delete a registry", async () => {
+      const existing = await services.registry.getItem(registryExample.uri)
+      await services.registry.deleteItem({ existing })
+      try {
+        await services.registry.getItem(registryExample.uri)
+        assert.fail("Expected getItem to fail after delete")
+      } catch (error) {
+        assert.ok(error)
+      }
+    })
+
+    it("should reject invalid registry bodies", async () => {
+      try {
+        await services.registry.createItem({
+          bodyStream: await arrayToStream([{uri:42}]),
+          bulk: false,
+        })
+        assert.fail("Expected createItem to fail")
+      } catch (error) {
+        assert.ok(error instanceof InvalidBodyError)
+      }
+    })
+
+    it("should filter out invalid registry bodies in bulk mode", async () => {
+      const items = [
+        { uri: "registry:1" },
+        { uri: 42 },
+      ]
+      try {
+        const res = await services.registry.createItem({
+          bodyStream: await arrayToStream(items),
+          bulk: true,
+        })
+        assert.deepStrictEqual(res, [ { uri: "registry:1" } ])
+      } catch (error) {
+        assert.fail("Should not fail")
+      }
+    })
+
+  })
+
+})

package/test/terminologies/terminologies.json

@@ -0,0 +1,94 @@
+[
+  {
+    "type": [
+      "http://www.w3.org/2004/02/skos/core#ConceptScheme",
+      "http://w3id.org/nkos/nkostype#thesaurus"
+    ],
+    "languages": [
+      "en",
+      "de"
+    ],
+    "uri": "http://bartoc.org/en/node/313",
+    "license": [
+      {
+        "uri": "http://opendatacommons.org/licenses/odbl/1.0/"
+      }
+    ],
+    "prefLabel": {
+      "de": "Standard Thesaurus Wirtschaft",
+      "en": "STW Thesaurus for Economics"
+    },
+    "subject": [
+      {
+        "uri": "http://dewey.info/class/3/e23/"
+      }
+    ]
+  },
+  {
+    "uri": "http://dewey.info/scheme/edition/e23/",
+    "prefLabel": {
+      "de": "Dewey-Dezimalklassifikation",
+      "en": "Dewey Decimal Classification"
+    },
+    "notation": [
+      "DDC"
+    ],
+    "identifier": [
+      "http://bartoc.org/en/node/241"
+    ],
+    "license": [
+      {
+        "uri": "http://creativecommons.org/licenses/by-nc-nd/3.0/"
+      }
+    ],
+    "publisher": [
+      {
+        "uri": "http://d-nb.info/gnd/1086052218",
+        "prefLabel": {
+          "de": "OCLC"
+        },
+        "altLabel": {
+          "de": [
+            "OCLC Online Computer Library Center"
+          ]
+        },
+        "url": "https://www.oclc.org/"
+      }
+    ],
+    "type": [
+      "http://www.w3.org/2004/02/skos/core#ConceptScheme",
+      "http://w3id.org/nkos/nkostype#classification_schema"
+    ],
+    "subject": [
+      {
+        "uri": "http://dewey.info/class/0/e23/"
+      }
+    ],
+    "languages": [
+      "en",
+      "fr",
+      "de"
+    ]
+  }
+  ,
+  {
+    "uri" : "http://bartoc.org/en/node/732",
+    "identifier": [
+      "http://www.wikidata.org/entity/Q1571087"
+    ],
+    "languages": [
+      "de"
+    ],
+    "notation": [
+      "ASB"
+    ],
+    "prefLabel":{
+      "de": "Allgemeine Systematik für Öffentliche Bibliotheken",
+      "en": "General Systematic for Public Libraries"
+    },
+    "type": [
+      "http://www.w3.org/2004/02/skos/core#ConceptScheme",
+      "http://w3id.org/nkos/nkostype#classification_schema"
+    ]
+  }
+]