cocoda-sdk 3.0.2 → 3.2.0

package/dist/esm/lib/CocodaSDK.js

@@ -114,7 +114,8 @@ class CocodaSDK {
       timer: null,
       result: null,
       error: null,
-      isPaused: false
+      isPaused: false,
+      interval
     };
     const handleResult = (result) => {
       const previousResult = repeat.result;
@@ -134,7 +135,7 @@ class CocodaSDK {
       }
       repeat.timer = setTimeout(() => {
         toCall();
-      }, interval);
+      }, repeat.interval);
     };
     const call = () => asyncFunc().then(handleResult).catch(handleError).then(() => repeatIfNecessary(call));
     const setup = (_callImmediately = callImmediately) => {
@@ -157,7 +158,7 @@ class CocodaSDK {
         } else {
           setTimeout(() => {
             repeat.timer && clearTimeout(repeat.timer);
-          }, interval);
+          }, repeat.interval);
         }
       },
       get isPaused() {
@@ -168,6 +169,12 @@ class CocodaSDK {
       },
       get hasErrored() {
         return !!repeat.error;
+      },
+      get interval() {
+        return repeat.interval;
+      },
+      set interval(value) {
+        repeat.interval = value;
       }
     };
   }
@@ -177,7 +184,7 @@ class CocodaSDK {
       if (registry.has.schemes !== false) {
         let promise = registry.getSchemes(config).then((results) => {
           for (let scheme of results) {
-            const currentSchemeRegistry = scheme._registry;
+            scheme._registry = registry;
             scheme.__DETAILSLOADED__ = 1;
             scheme.type = scheme.type || ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
             let otherScheme = schemes.find((s) => jskos.compare(s, scheme)), prio, otherPrio, override = false;
@@ -208,7 +215,7 @@ class CocodaSDK {
                 }
                 scheme = jskos.merge(scheme, _.omit(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
               }
-              scheme._registry = currentSchemeRegistry;
+              scheme._registry = registry;
               schemes.push(scheme);
             } else {
               const index = schemes.findIndex((s) => jskos.compare(s, scheme));
@@ -226,6 +233,16 @@ class CocodaSDK {
       }
     }
     await Promise.all(promises);
+    schemes.forEach((scheme) => {
+      const previousRegistry = scheme._registry;
+      delete scheme._registry;
+      const newRegistry = this.registryForScheme(scheme);
+      if (!newRegistry || newRegistry._api.api === previousRegistry._api.api) {
+        scheme._registry = previousRegistry;
+      } else {
+        scheme._registry = newRegistry;
+      }
+    });
     return jskos.sortSchemes(schemes.filter(Boolean));
   }
   registryForScheme(scheme) {

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.");
@@ -315,7 +317,7 @@ class BaseProvider {
     }
     const previousRegistry = scheme._registry;
     scheme._registry = this.cdk && this.cdk.registryForScheme(scheme);
-    if (!scheme._registry || previousRegistry === scheme._registry) {
+    if (!scheme._registry || previousRegistry === scheme._registry || scheme._registry._api.api === this._api.api) {
       scheme._registry = previousRegistry || this;
     } else {
       ["concepts", "topConcepts"].forEach((key) => {

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

@@ -36,7 +36,13 @@ class MappingsApiProvider extends BaseProvider {
       this.has.mappings.delete = !!_.get(this._config, "mappings.delete");
       this.has.mappings.anonymous = !!_.get(this._config, "mappings.anonymous");
     }
-    this.has.concordances = !!this._api.concordances;
+    this.has.concordances = this._api.concordances ? {} : false;
+    if (this.has.concordances) {
+      this.has.concordances.read = !!_.get(this._config, "concordances.read");
+      this.has.concordances.create = !!_.get(this._config, "concordances.create");
+      this.has.concordances.update = !!_.get(this._config, "concordances.update");
+      this.has.concordances.delete = !!_.get(this._config, "concordances.delete");
+    }
     this.has.annotations = this._api.annotations ? {} : false;
     if (this.has.annotations) {
       this.has.annotations.read = !!_.get(this._config, "annotations.read");
@@ -72,7 +78,7 @@ class MappingsApiProvider extends BaseProvider {
       throw error;
     }
   }
-  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, 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;
@@ -104,6 +110,18 @@ class MappingsApiProvider extends BaseProvider {
     if (direction) {
       params.direction = direction;
     }
+    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;
     }
@@ -169,8 +187,6 @@ class MappingsApiProvider extends BaseProvider {
     if (!mapping) {
       throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
     }
-    mapping = jskos.minifyMapping(mapping);
-    mapping = jskos.addMappingIdentifiers(mapping);
     const uri = mapping.uri;
     if (!uri || !uri.startsWith(this._api.mappings)) {
       throw new errors.InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
@@ -179,7 +195,7 @@ class MappingsApiProvider extends BaseProvider {
       ...config,
       method: "patch",
       url: uri,
-      data: mapping,
+      data: _.omit(mapping, "uri"),
       params: {
         ...this._defaultParams,
         ...config.params || {}
@@ -262,6 +278,74 @@ class MappingsApiProvider extends BaseProvider {
       url: this._api.concordances
     });
   }
+  async postConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.concordances,
+      data: concordance,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async putConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: concordance,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async patchConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: _.omit(concordance, "uri"),
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async deleteConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
 }
 MappingsApiProvider.providerName = "MappingsApi";
 MappingsApiProvider.stored = true;

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

@@ -0,0 +1,227 @@
+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 }) {
+    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.0.2",
+  "version": "3.2.0",
   "description": "SDK for Cocoda",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
@@ -26,7 +26,8 @@
     "release": "npm run build && npm test && git checkout dev && git pull && npm version $SEMVER && git push && git checkout master && git merge dev && git push --follow-tags && git checkout dev",
     "release:patch": "SEMVER=patch npm run release",
     "release:minor": "SEMVER=minor npm run release",
-    "release:major": "SEMVER=major npm run release"
+    "release:major": "SEMVER=major npm run release",
+    "postinstall": "[ -d './dist' ] || npm run build"
   },
   "lint-staged": {
     "**/*.js": [
@@ -51,23 +52,24 @@
   },
   "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.23",
+    "esbuild": "~0.14.43",
     "esbuild-plugin-ifdef": "^1.0.1",
-    "eslint": "^8.9.0",
+    "eslint": "^8.17.0",
     "eslint-config-gbv": "^1.0.3",
-    "glob": "^7.2.0",
+    "glob": "^8.0.3",
     "jsdoc": "^3.6.10",
     "license-checker": "^25.0.1",
-    "lint-staged": "^12.3.4",
-    "mocha": "^9.2.1",
+    "lint-staged": "^12.5.0",
+    "mocha": "^9.2.2",
     "mocha-eslint": "^7.0.0",
     "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "axios": "^0.26.0",
-    "jskos-tools": "^1.0.25",
+    "axios": "~0.26.1",
+    "flexsearch": "~0.6.32",
+    "jskos-tools": "^1.0.26",
     "localforage": "^1.10.0",
     "lodash": "^4.17.21",
     "uuid": "^8.3.2"