cocoda-sdk 3.1.0 → 3.2.2

package/README.md

@@ -165,6 +165,8 @@ The following providers are also exported, but have to be added via `cdk.addProv
 - `SkosmosApi` - access to concept schemes and concepts via a [Skosmos](https://github.com/NatLibFi/Skosmos) API
 - `LocApi` - access to concept schemes and concepts via the [Library of Congress Linked Data Service](https://id.loc.gov/)
   - **This integration is currently experimental and only supports LCSH and LCNAF.**
+- `Skohub` - access to concept schemes and concepts via a [SkoHub Vocabs](https://blog.lobid.org/2019/09/27/presenting-skohub-vocabs.html)
+  - **This integration is currently experimental. Only vocabularies that use a [slash namespace pattern]([hash](https://www.w3.org/2001/sw/BestPractices/VM/http-examples/2006-01-18/#slash)) with dereferenceable URIs are supported.**
 - `ReconciliationApi` - access to mapping suggestions via a [OpenRefine Reconciliation API](https://github.com/OpenRefine/OpenRefine/wiki/Reconciliation-Service-API)
 - `OccurrencesApi` - access to concept occurrences via [occurrences-api](https://github.com/gbv/occurrences-api) (will be changed to [occurrences-server](https://github.com/gbv/occurrences-server) in the future)
 - `LabelSearchSuggestion` - access to mapping suggestions using other registries' search endpoints (using [jskos-server])

package/dist/cjs/index.cjs

@@ -31,6 +31,7 @@ __export(src_exports, {
   MappingsApiProvider: () => MappingsApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
+  SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider,
   addAllProviders: () => addAllProviders,
   cdk: () => cdk,
@@ -108,7 +109,7 @@ var import_omit = __toESM(require("lodash/omit.js"), 1);
 var import_concat = __toESM(require("lodash/concat.js"), 1);
 
 // src/lib/CocodaSDK.js
-var import_jskos_tools10 = __toESM(require("jskos-tools"), 1);
+var import_jskos_tools11 = __toESM(require("jskos-tools"), 1);
 
 // src/providers/index.js
 var providers_exports = {};
@@ -121,6 +122,7 @@ __export(providers_exports, {
   MappingsApiProvider: () => MappingsApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
+  SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider
 });
 
@@ -330,10 +332,12 @@ var BaseProvider = class {
     this._config = {};
     this.setRetryConfig();
     this.axios.interceptors.request.use((config) => {
-      const language = import_uniq.default([].concat(import_get.default(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
-      import_set.default(config, "params.language", language);
-      if (this.has.auth && this._auth.bearerToken && !import_get.default(config, "headers.Authorization")) {
-        import_set.default(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+      if (!config._skipAdditionalParameters) {
+        const language = import_uniq.default([].concat(import_get.default(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
+        import_set.default(config, "params.language", language);
+        if (this.has.auth && this._auth.bearerToken && !import_get.default(config, "headers.Authorization")) {
+          import_set.default(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+        }
       }
       if (config.url.startsWith("http:") && typeof window !== "undefined" && window.location.protocol == "https:") {
         throw new import_axios.default.Cancel("Can't call http API from https.");
@@ -1108,7 +1112,7 @@ var MappingsApiProvider = class extends BaseProvider {
       throw error;
     }
   }
-  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, cardinality, sort, order, ...config }) {
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, cardinality, annotatedBy, annotatedFor, annotatedWith, sort, order, ...config }) {
     let params = {}, url = this._api.mappings;
     if (from) {
       params.from = import_isString.default(from) ? from : from.uri;
@@ -1143,6 +1147,15 @@ var MappingsApiProvider = class extends BaseProvider {
     if (cardinality) {
       params.cardinality = cardinality;
     }
+    if (annotatedBy) {
+      params.annotatedBy = annotatedBy;
+    }
+    if (annotatedFor) {
+      params.annotatedFor = annotatedFor;
+    }
+    if (annotatedWith) {
+      params.annotatedWith = annotatedWith;
+    }
     if (mode) {
       params.mode = mode;
     }
@@ -1406,8 +1419,10 @@ var OccurrencesApiProvider = class extends BaseProvider {
   }
   async getMappings(config) {
     const occurrences = await this.getOccurrences(config);
-    const fromScheme = import_get.default(config, "from.inScheme[0]") || config.fromScheme;
-    const toScheme = import_get.default(config, "to.inScheme[0]") || config.toScheme;
+    const from = config.from;
+    const fromScheme = import_get.default(from, "inScheme[0]") || config.fromScheme;
+    const to = config.to;
+    const toScheme = import_get.default(to, "inScheme[0]") || config.toScheme;
     const mappings = [];
     for (let occurrence of occurrences) {
       if (!occurrence) {
@@ -1428,7 +1443,7 @@ var OccurrencesApiProvider = class extends BaseProvider {
         mapping.to = { memberSet: [] };
       }
       mapping.toScheme = import_get.default(occurrence, "memberSet[1].inScheme[0]");
-      if (fromScheme && mapping.fromScheme && !import_jskos_tools4.default.compare(mapping.fromScheme, fromScheme) || toScheme && mapping.toScheme && !import_jskos_tools4.default.compare(mapping.toScheme, toScheme)) {
+      if (from && import_jskos_tools4.default.compare(from, import_get.default(mapping, "to.memberSet[0]")) || to && import_jskos_tools4.default.compare(to, import_get.default(mapping, "from.memberSet[0]"))) {
         [mapping.from, mapping.fromScheme, mapping.to, mapping.toScheme] = [mapping.to, mapping.toScheme, mapping.from, mapping.fromScheme];
       }
       if (!mapping.fromScheme && fromScheme) {
@@ -1440,14 +1455,12 @@ var OccurrencesApiProvider = class extends BaseProvider {
       mapping.type = [import_jskos_tools4.default.defaultMappingType.uri];
       mapping._occurrence = occurrence;
       mapping = import_jskos_tools4.default.addMappingIdentifiers(mapping);
-      if (occurrence.database) {
-        mapping.creator = [occurrence.database];
-      }
       mappings.push(mapping);
     }
+    mappings._url = occurrences._url;
     return mappings;
   }
-  async getOccurrences({ from, to, concepts, ...config }) {
+  async getOccurrences({ from, to, concepts, threshold = 0, ...config }) {
     let promises = [];
     concepts = (concepts || []).concat([from, to]).filter((c) => !!c);
     for (let concept of concepts) {
@@ -1471,17 +1484,7 @@ var OccurrencesApiProvider = class extends BaseProvider {
         params: {
           member: uri,
           scheme: "*",
-          threshold: 5
-        }
-      }));
-    }
-    if (uris.length > 1) {
-      let urisString = uris.join(" ");
-      promises.push(this._getOccurrences({
-        ...config,
-        params: {
-          member: urisString,
-          threshold: 5
+          threshold
         }
       }));
     }
@@ -1505,7 +1508,9 @@ var OccurrencesApiProvider = class extends BaseProvider {
       delete occurrences[value];
     });
     occurrences = occurrences.filter((o) => o != null);
-    return occurrences.sort((a, b) => parseInt(b.count || 0) - parseInt(a.count || 0));
+    occurrences = occurrences.sort((a, b) => parseInt(b.count || 0) - parseInt(a.count || 0));
+    occurrences._url = results.map((result) => result._url);
+    return occurrences;
   }
   async _getOccurrences(config) {
     let resultsFromCache = this._cache.find((item) => {
@@ -2586,6 +2591,229 @@ var LocApiProvider = class extends BaseProvider {
 LocApiProvider.providerName = "LocApi";
 LocApiProvider.providerType = "http://bartoc.org/api-type/loc";
 
+// src/providers/skohub-provider.js
+var import_jskos_tools10 = __toESM(require("jskos-tools"), 1);
+var import_flexsearch = __toESM(require("flexsearch"), 1);
+function decodeUnicode(text) {
+  return text.replace(/\\u[\dA-F]{4}/gi, function(match) {
+    return String.fromCharCode(parseInt(match.replace(/\\u/g, ""), 16));
+  });
+}
+var SkohubProvider = class extends BaseProvider {
+  _prepare() {
+    this.has.schemes = true;
+    this.has.top = true;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = true;
+    this.has.suggest = true;
+    this.has.search = true;
+    listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
+      this.has[c] = false;
+    });
+  }
+  _setup() {
+    this._index = {};
+    this._conceptCache = {};
+    this._schemeCache = {};
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    const newScheme = { uri: url, identifier: import_jskos_tools10.default.getAllUris(scheme).filter((uri) => uri !== url) };
+    return { schemes: [newScheme] };
+  }
+  async _loadScheme({ scheme, ...config }) {
+    let uris = import_jskos_tools10.default.getAllUris(scheme);
+    for (let uri2 of uris) {
+      if (this._schemeCache[uri2]) {
+        return this._schemeCache[uri2];
+      }
+    }
+    const schemeFromList = this.schemes.find((s) => import_jskos_tools10.default.compare(s, scheme));
+    if (!schemeFromList || !schemeFromList.uri) {
+      throw new InvalidRequestError({ message: `Tried to load unsupported scheme (${scheme && scheme.uri})` });
+    }
+    const uri = schemeFromList.uri;
+    uris = import_uniq.default(uris.concat(import_jskos_tools10.default.getAllUris(schemeFromList)));
+    let postfix = ".json";
+    if (uri.endsWith("/")) {
+      postfix = "index.json";
+    }
+    const data = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
+    if (data.id !== uri) {
+      throw new InvalidRequestError({ message: "Skohub URL did not return expected concept scheme" });
+    }
+    const { title, preferredNamespaceUri, hasTopConcept, description } = data;
+    scheme = { uri, identifier: uris.filter((u) => u !== uri) };
+    scheme.prefLabel = title;
+    Object.keys(scheme.prefLabel || {}).forEach((key) => {
+      scheme.prefLabel[key] = decodeUnicode(scheme.prefLabel[key]);
+    });
+    scheme.namespace = preferredNamespaceUri;
+    scheme.topConcepts = (hasTopConcept || []).map((c) => this._toJskosConcept(c));
+    scheme.concepts = [null];
+    if (description) {
+      scheme.definition = description;
+      Object.keys(scheme.definition).forEach((key) => {
+        scheme.definition[key] = [decodeUnicode(scheme.definition[key])];
+      });
+    }
+    for (let key of Object.keys(scheme).filter((key2) => !scheme[key2])) {
+      delete scheme[key];
+    }
+    for (let uri2 of uris) {
+      this._schemeCache[uri2] = scheme;
+    }
+    return scheme;
+  }
+  async _loadConcept({ uri, ...config }) {
+    if (this._conceptCache[uri]) {
+      return this._conceptCache[uri];
+    }
+    try {
+      const data = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
+      if (data.id !== uri) {
+        throw new InvalidRequestError({ message: "Skohub URL did not return expected concept URI" });
+      }
+      const concept = this._toJskosConcept(data);
+      this._conceptCache[uri] = concept;
+      return concept;
+    } catch (error) {
+      return null;
+    }
+  }
+  _toJskosConcept(data) {
+    const concept = { uri: data.id };
+    concept.prefLabel = data.prefLabel;
+    Object.keys(concept.prefLabel || {}).forEach((key) => {
+      concept.prefLabel[key] = decodeUnicode(concept.prefLabel[key]);
+    });
+    concept.narrower = (data.narrower || []).map((c) => this._toJskosConcept(c));
+    concept.notation = data.notation || [];
+    if (data.broader && data.broader.id) {
+      concept.broader = [{ uri: data.broader.id }];
+    }
+    if (data.inScheme && data.inScheme.id) {
+      concept.inScheme = [{ uri: data.inScheme.id }];
+    }
+    if (data.scopeNote) {
+      concept.scopeNote = data.scopeNote;
+      Object.keys(concept.scopeNote).forEach((key) => {
+        concept.scopeNote[key] = [decodeUnicode(concept.scopeNote[key])];
+      });
+    }
+    return concept;
+  }
+  async getSchemes({ ...config }) {
+    return Promise.all(this.schemes.map((scheme) => this._loadScheme({ ...config, scheme })));
+  }
+  async getTop({ scheme, ...config }) {
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    scheme = await this._loadScheme({ scheme, ...config });
+    return scheme.topConcepts || [];
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!import_isArray.default(concepts)) {
+      concepts = [concepts];
+    }
+    return (await Promise.all(concepts.map(({ uri }) => this._loadConcept({ ...config, uri })))).filter(Boolean);
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.ancestors && concept.ancestors[0] !== null) {
+      return concept.ancestors;
+    }
+    concept = await this._loadConcept({ ...config, uri: concept.uri });
+    if (!concept || !concept.broader || !concept.broader.length) {
+      return [];
+    }
+    const broader = concept.broader[0];
+    return [broader].concat(await this.getAncestors({ concept: broader, ...config })).map((c) => ({ uri: c.uri }));
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.narrower && concept.narrower[0] !== null) {
+      return concept.narrower;
+    }
+    concept = await this._loadConcept({ ...config, uri: concept.uri });
+    return concept.narrower;
+  }
+  async search({ search, scheme, limit = 100 }) {
+    scheme = await this._loadScheme({ scheme });
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    let index;
+    if (!this._index[scheme.uri]) {
+      this._index[scheme.uri] = {};
+    }
+    for (const lang of [""].concat(this.languages)) {
+      if (this._index[scheme.uri][lang]) {
+        index = this._index[scheme.uri][lang];
+        break;
+      }
+      if (this._index[scheme.uri][lang] === null) {
+        continue;
+      }
+      try {
+        let postfix = lang ? `.${lang}.index` : ".index";
+        if (scheme.uri.endsWith("/")) {
+          postfix = `index${postfix}`;
+        }
+        const data = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
+        if (data.length < 100) {
+          this._index[scheme.uri][lang] = null;
+          continue;
+        }
+        index = import_flexsearch.default.create();
+        index.import(data);
+        this._index[scheme.uri][lang] = index;
+        break;
+      } catch (error) {
+        this._index[scheme.uri][lang] = null;
+      }
+    }
+    if (!index) {
+      throw new InvalidRequestError({ message: "Could not find search index for any of the available languages " + this.languages.join(",") });
+    }
+    const result = index.search(search);
+    const concepts = await this.getConcepts({ concepts: result.map((uri) => ({ uri })) });
+    return concepts.slice(0, limit);
+  }
+  async suggest(config) {
+    config._raw = true;
+    const concepts = await this.search(config);
+    const result = [config.search, [], [], []];
+    for (let concept of concepts) {
+      const notation = import_jskos_tools10.default.notation(concept);
+      const label = import_jskos_tools10.default.prefLabel(concept);
+      result[1].push((notation ? notation + " " : "") + label);
+      result[2].push("");
+      result[3].push(concept.uri);
+    }
+    if (concepts._totalCount != void 0) {
+      result._totalCount = concepts._totalCount;
+    } else {
+      result._totalCount = concepts.length;
+    }
+    return result;
+  }
+};
+SkohubProvider.providerName = "Skohub";
+SkohubProvider.providerType = "http://bartoc.org/api-type/skohub";
+
 // src/lib/CocodaSDK.js
 var providers = {
   [BaseProvider.providerName]: BaseProvider,
@@ -2771,7 +2999,7 @@ var CocodaSDK = class {
             scheme._registry = registry;
             scheme.__DETAILSLOADED__ = 1;
             scheme.type = scheme.type || ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
-            let otherScheme = schemes.find((s) => import_jskos_tools10.default.compare(s, scheme)), prio, otherPrio, override = false;
+            let otherScheme = schemes.find((s) => import_jskos_tools11.default.compare(s, scheme)), prio, otherPrio, override = false;
             if (otherScheme) {
               prio = this.config.registries.indexOf(registry);
               if (prio != -1) {
@@ -2793,19 +3021,19 @@ var CocodaSDK = class {
             }
             if (!otherScheme || override) {
               if (override) {
-                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, otherScheme));
+                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, otherScheme));
                 if (otherSchemeIndex != -1) {
                   schemes.splice(otherSchemeIndex, 1);
                 }
-                scheme = import_jskos_tools10.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                scheme = import_jskos_tools11.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
               }
               scheme._registry = registry;
               schemes.push(scheme);
             } else {
-              const index = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, scheme));
+              const index = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, scheme));
               if (index != -1) {
                 const otherSchemeRegistry = schemes[index]._registry;
-                schemes[index] = import_jskos_tools10.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                schemes[index] = import_jskos_tools11.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
                 schemes[index]._registry = otherSchemeRegistry;
               }
             }
@@ -2827,7 +3055,7 @@ var CocodaSDK = class {
         scheme._registry = newRegistry;
       }
     });
-    return import_jskos_tools10.default.sortSchemes(schemes.filter(Boolean));
+    return import_jskos_tools11.default.sortSchemes(schemes.filter(Boolean));
   }
   registryForScheme(scheme) {
     let registry = scheme._registry;
@@ -2838,7 +3066,7 @@ var CocodaSDK = class {
       const url = config.url;
       if (registryCache[url]) {
         const registry2 = registryCache[url];
-        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools10.default.isContainedIn(scheme, registry2._jskos.schemes)) {
+        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools11.default.isContainedIn(scheme, registry2._jskos.schemes)) {
           registry2._jskos.schemes.push(scheme);
         }
         return registry2;
@@ -2885,6 +3113,7 @@ function addAllProviders(_cdk) {
   MappingsApiProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
+  SkohubProvider,
   SkosmosApiProvider,
   addAllProviders,
   cdk,