cocoda-sdk 3.1.0 → 3.2.2

package/dist/esm/providers/base-provider.js

@@ -41,10 +41,12 @@ class BaseProvider {
     this._config = {};
     this.setRetryConfig();
     this.axios.interceptors.request.use((config) => {
-      const language = _.uniq([].concat(_.get(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
-      _.set(config, "params.language", language);
-      if (this.has.auth && this._auth.bearerToken && !_.get(config, "headers.Authorization")) {
-        _.set(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+      if (!config._skipAdditionalParameters) {
+        const language = _.uniq([].concat(_.get(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
+        _.set(config, "params.language", language);
+        if (this.has.auth && this._auth.bearerToken && !_.get(config, "headers.Authorization")) {
+          _.set(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+        }
       }
       if (config.url.startsWith("http:") && typeof window !== "undefined" && window.location.protocol == "https:") {
         throw new axios.Cancel("Can't call http API from https.");

package/dist/esm/providers/index.js

@@ -7,6 +7,7 @@ import ReconciliationApiProvider from "./reconciliation-api-provider.js";
 import LabelSearchSuggestionProvider from "./label-search-suggestion-provider.js";
 import SkosmosApiProvider from "./skosmos-api-provider.js";
 import LocApiProvider from "./loc-api-provider.js";
+import SkohubProvider from "./skohub-provider.js";
 export {
   BaseProvider,
   ConceptApiProvider,
@@ -16,5 +17,6 @@ export {
   MappingsApiProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
+  SkohubProvider,
   SkosmosApiProvider
 };

package/dist/esm/providers/mappings-api-provider.js

@@ -78,7 +78,7 @@ class MappingsApiProvider 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 = _.isString(from) ? from : from.uri;
@@ -113,6 +113,15 @@ class MappingsApiProvider 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;
     }

package/dist/esm/providers/occurrences-api-provider.js

@@ -36,8 +36,10 @@ class OccurrencesApiProvider extends BaseProvider {
   }
   async getMappings(config) {
     const occurrences = await this.getOccurrences(config);
-    const fromScheme = _.get(config, "from.inScheme[0]") || config.fromScheme;
-    const toScheme = _.get(config, "to.inScheme[0]") || config.toScheme;
+    const from = config.from;
+    const fromScheme = _.get(from, "inScheme[0]") || config.fromScheme;
+    const to = config.to;
+    const toScheme = _.get(to, "inScheme[0]") || config.toScheme;
     const mappings = [];
     for (let occurrence of occurrences) {
       if (!occurrence) {
@@ -58,7 +60,7 @@ class OccurrencesApiProvider extends BaseProvider {
         mapping.to = { memberSet: [] };
       }
       mapping.toScheme = _.get(occurrence, "memberSet[1].inScheme[0]");
-      if (fromScheme && mapping.fromScheme && !jskos.compare(mapping.fromScheme, fromScheme) || toScheme && mapping.toScheme && !jskos.compare(mapping.toScheme, toScheme)) {
+      if (from && jskos.compare(from, _.get(mapping, "to.memberSet[0]")) || to && jskos.compare(to, _.get(mapping, "from.memberSet[0]"))) {
         [mapping.from, mapping.fromScheme, mapping.to, mapping.toScheme] = [mapping.to, mapping.toScheme, mapping.from, mapping.fromScheme];
       }
       if (!mapping.fromScheme && fromScheme) {
@@ -70,14 +72,12 @@ class OccurrencesApiProvider extends BaseProvider {
       mapping.type = [jskos.defaultMappingType.uri];
       mapping._occurrence = occurrence;
       mapping = jskos.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) {
@@ -101,17 +101,7 @@ class OccurrencesApiProvider 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
         }
       }));
     }
@@ -135,7 +125,9 @@ class OccurrencesApiProvider 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) => {

package/dist/esm/providers/skohub-provider.js

@@ -0,0 +1,228 @@
+import BaseProvider from "./base-provider.js";
+import * as _ from "../utils/lodash.js";
+import * as errors from "../errors/index.js";
+import { listOfCapabilities } from "../utils/index.js";
+import jskos from "jskos-tools";
+import FlexSearch from "flexsearch";
+function decodeUnicode(text) {
+  return text.replace(/\\u[\dA-F]{4}/gi, function(match) {
+    return String.fromCharCode(parseInt(match.replace(/\\u/g, ""), 16));
+  });
+}
+class SkohubProvider 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: jskos.getAllUris(scheme).filter((uri) => uri !== url) };
+    return { schemes: [newScheme] };
+  }
+  async _loadScheme({ scheme, ...config }) {
+    let uris = jskos.getAllUris(scheme);
+    for (let uri2 of uris) {
+      if (this._schemeCache[uri2]) {
+        return this._schemeCache[uri2];
+      }
+    }
+    const schemeFromList = this.schemes.find((s) => jskos.compare(s, scheme));
+    if (!schemeFromList || !schemeFromList.uri) {
+      throw new errors.InvalidRequestError({ message: `Tried to load unsupported scheme (${scheme && scheme.uri})` });
+    }
+    const uri = schemeFromList.uri;
+    uris = _.uniq(uris.concat(jskos.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 errors.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 errors.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 errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    scheme = await this._loadScheme({ scheme, ...config });
+    return scheme.topConcepts || [];
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!_.isArray(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 errors.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 errors.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 errors.InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new errors.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 = FlexSearch.create();
+        index.import(data);
+        this._index[scheme.uri][lang] = index;
+        break;
+      } catch (error) {
+        this._index[scheme.uri][lang] = null;
+      }
+    }
+    if (!index) {
+      throw new errors.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 = jskos.notation(concept);
+      const label = jskos.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";
+export {
+  SkohubProvider as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocoda-sdk",
-  "version": "3.1.0",
+  "version": "3.2.2",
   "description": "SDK for Cocoda",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
@@ -52,22 +52,23 @@
   },
   "homepage": "https://github.com/gbv/cocoda-sdk#readme",
   "devDependencies": {
-    "axios-mock-adapter": "^1.20.0",
+    "axios-mock-adapter": "^1.21.1",
     "better-docs": "^2.7.2",
-    "esbuild": "~0.14.36",
+    "esbuild": "~0.14.43",
     "esbuild-plugin-ifdef": "^1.0.1",
-    "eslint": "^8.13.0",
+    "eslint": "^8.17.0",
     "eslint-config-gbv": "^1.0.3",
-    "glob": "^8.0.1",
+    "glob": "^8.0.3",
     "jsdoc": "^3.6.10",
     "license-checker": "^25.0.1",
-    "lint-staged": "^12.3.8",
+    "lint-staged": "^12.5.0",
     "mocha": "^9.2.2",
     "mocha-eslint": "^7.0.0",
     "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "axios": "^0.26.1",
+    "axios": "~0.26.1",
+    "flexsearch": "~0.6.32",
     "jskos-tools": "^1.0.26",
     "localforage": "^1.10.0",
     "lodash": "^4.17.21",