cocoda-sdk 3.2.2 → 3.3.0

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 import CocodaSDK from "./lib/CocodaSDK.js";
 import * as errors from "./errors/index.js";
+import * as utils from "./utils/index.js";
 export * from "./providers/index.js";
 const cdk = new CocodaSDK();
 import * as providers from "./providers/index.js";
@@ -10,5 +11,6 @@ export {
   CocodaSDK,
   addAllProviders,
   cdk,
-  errors
+  errors,
+  utils
 };

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

@@ -257,9 +257,9 @@ class BaseProvider {
     if (options.auth && this._auth.key != _.get(this._config, "auth.key")) {
       return false;
     }
+    const userUris = [user.uri].concat(Object.values(user.identities || {}).map((id) => id.uri)).filter((uri) => uri != null);
     if (options.auth && options.identities) {
-      const uris = [user.uri].concat(Object.values(user.identities || {}).map((id) => id.uri)).filter((uri) => uri != null);
-      if (_.intersection(uris, options.identities).length == 0) {
+      if (_.intersection(userUris, options.identities).length == 0) {
         return false;
       }
     }
@@ -270,7 +270,7 @@ class BaseProvider {
       }
     }
     if (crossUser) {
-      return !!options.crossUser;
+      return options.crossUser === true || _.intersection(options.crossUser || [], userUris).length > 0;
     }
     return !!this.has[type][action];
   }
@@ -298,7 +298,7 @@ class BaseProvider {
       return (await this.getConcepts({ ...config, concepts: [concept] }))[0];
     };
     for (let type of ["broader", "narrower", "ancestors"]) {
-      if (Array.isArray(concept[type]) && !concept[type].includes(null)) {
+      if (Array.isArray(concept[type]) && concept[type].length && !concept[type].includes(null)) {
         concept[type] = this.adjustConcepts(concept[type]);
       }
     }

package/dist/esm/providers/index.js

@@ -8,6 +8,7 @@ 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";
+import MyCoReProvider from "./mycore-provider.js";
 export {
   BaseProvider,
   ConceptApiProvider,
@@ -15,6 +16,7 @@ export {
   LocApiProvider,
   LocalMappingsProvider,
   MappingsApiProvider,
+  MyCoReProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
   SkohubProvider,

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

@@ -94,20 +94,22 @@ class LocApiProvider extends BaseProvider {
   }
   async getSchemes() {
     const schemes = [];
-    for (let scheme of await Promise.all(supportedSchemes.filter((s) => !this.schemes || !this.schemes.length || this.schemes.find((s2) => jskos.compare(s, s2))).map((s) => axios({
-      method: "get",
-      url: `${s.uri.replace("http:", "https:")}.json`
-    }).then(({ status, data }) => {
-      if (status === 200) {
-        let scheme2 = data.find((d) => s.uri === d["@id"]);
-        if (scheme2) {
-          scheme2 = jskos.merge(madsToJskosScheme(scheme2), s);
-          scheme2.topConcepts = (scheme2.topConcepts || []).filter((c) => c);
-          return scheme2;
+    for (let scheme of await Promise.all(
+      supportedSchemes.filter((s) => !this.schemes || !this.schemes.length || this.schemes.find((s2) => jskos.compare(s, s2))).map((s) => axios({
+        method: "get",
+        url: `${s.uri.replace("http:", "https:")}.json`
+      }).then(({ status, data }) => {
+        if (status === 200) {
+          let scheme2 = data.find((d) => s.uri === d["@id"]);
+          if (scheme2) {
+            scheme2 = jskos.merge(madsToJskosScheme(scheme2), s);
+            scheme2.topConcepts = (scheme2.topConcepts || []).filter((c) => c);
+            return scheme2;
+          }
         }
-      }
-      return null;
-    })))) {
+        return null;
+      }))
+    )) {
       if (scheme) {
         schemes.push(scheme);
       }

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

@@ -47,9 +47,11 @@ class LocalMappingsProvider extends BaseProvider {
         console.warn(`Warning: There is old data in local storage (or IndexedDB, depending on the ) with the key "${oldLocalStorageKey}". This data will not be used anymore. A manual export is necessary to get this data back.`);
       }
     });
-    this.queue.push(addUris().catch((error) => {
-      console.warn("Error when adding URIs to local mappings:", error);
-    }));
+    this.queue.push(
+      addUris().catch((error) => {
+        console.warn("Error when adding URIs to local mappings:", error);
+      })
+    );
   }
   isAuthorizedFor({ type, action }) {
     if (type == "mappings" && action != "anonymous") {
@@ -137,10 +139,10 @@ class LocalMappingsProvider extends BaseProvider {
       let checkConcept = (concept, param) => concept.uri == param || param && concept.notation && concept.notation[0].toLowerCase() == param.toLowerCase();
       if (params.from || params.to) {
         mappings = mappings.filter((mapping) => {
-          let fromInFrom = jskos.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.from)) != null;
-          let fromInTo = jskos.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.from)) != null;
-          let toInFrom = jskos.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.to)) != null;
-          let toInTo = jskos.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.to)) != null;
+          let fromInFrom = null != jskos.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.from));
+          let fromInTo = null != jskos.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.from));
+          let toInFrom = null != jskos.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.to));
+          let toInTo = null != jskos.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.to));
           if (params.direction == "backward") {
             if (params.mode == "or") {
               return params.from && fromInTo || params.to && toInFrom;

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

@@ -0,0 +1,216 @@
+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";
+const data = {};
+class MyCoReProvider 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._scheme = null;
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    return {
+      api: url
+    };
+  }
+  _schemeInfoToJSKOS(schemeInfo) {
+    const uri = schemeInfo.labels.find((l) => l.lang === "x-uri").text;
+    const prefLabel = {};
+    schemeInfo.labels.filter((l) => !l.lang.startsWith("x-")).forEach((l) => {
+      prefLabel[l.lang] = l.text;
+    });
+    const scheme = {
+      uri,
+      prefLabel
+    };
+    if (schemeInfo.categories && schemeInfo.categories.length) {
+      scheme.topConcepts = [null];
+    }
+    if (schemeInfo.category && schemeInfo.category.length) {
+      scheme.concepts = [null];
+    }
+    return scheme;
+  }
+  _categoryToJSKOS(category, { scheme, broader = [] }) {
+    if (!category || !scheme) {
+      return null;
+    }
+    const id = category.ID;
+    const uri = `${scheme.uri}/${id}`;
+    if (data[scheme.uri].concepts[uri]) {
+      return data[scheme.uri].concepts[uri];
+    }
+    const prefLabel = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.text).forEach((l) => {
+      prefLabel[l.lang] = l.text.replace(`${id} `, "");
+      data[scheme.uri].searchIndex.add(uri, prefLabel[l.lang]);
+    });
+    const scopeNote = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.description).forEach((l) => {
+      if (!scopeNote[l.lang]) {
+        scopeNote[l.lang] = [];
+      }
+      scopeNote[l.lang].push(l.description);
+    });
+    data[scheme.uri].concepts[uri] = {
+      uri,
+      notation: [id],
+      prefLabel,
+      scopeNote,
+      inScheme: [{ uri: scheme.uri }],
+      narrower: (category.categories || []).map((c) => ({ uri: `${scheme.uri}/${c.ID}` })),
+      broader
+    };
+    return data[scheme.uri].concepts[uri];
+  }
+  _removeNarrower(concept) {
+    if (!concept)
+      return concept;
+    return Object.assign({}, concept, { narrower: concept.narrower && concept.narrower.length ? [null] : [] });
+  }
+  async _loadSchemeData(config) {
+    const schemeInfo = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.api,
+      _skipAdditionalParameters: true
+    });
+    this._scheme = this._schemeInfoToJSKOS(schemeInfo);
+    const uri = this._scheme.uri;
+    data[uri] = {
+      schemeInfo,
+      searchIndex: FlexSearch.create({
+        tokenize: "full"
+      }),
+      concepts: {}
+    };
+    const dealWithCategory = (category, { broader = [] } = {}) => {
+      const concept = this._categoryToJSKOS(category, { scheme: this._scheme, broader });
+      (category.categories || []).forEach((c) => dealWithCategory(c, { broader: [{ uri: concept.uri }] }));
+    };
+    schemeInfo.categories.forEach((category) => dealWithCategory(category));
+    data[uri].topConcepts = schemeInfo.categories.map((category) => this._categoryToJSKOS(category, { scheme: this._scheme }));
+  }
+  async getSchemes(config = {}) {
+    if (!this._api.api) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!this._scheme) {
+      if (!this._loadSchemeDataPromise) {
+        this._loadSchemeDataPromise = this._loadSchemeData(config);
+      }
+      await this._loadSchemeDataPromise;
+    }
+    return [this._scheme];
+  }
+  async getTop({ scheme, ...config }) {
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    if (!jskos.compare(scheme, this._scheme)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    return data[this._scheme.uri].topConcepts.map(this._removeNarrower);
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!_.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    return concepts.map((c) => data[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.ancestors && concept.ancestors[0] !== null) {
+      return concept.ancestors;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data[this._scheme.uri].concepts[concept.uri];
+    const broader = concept && concept.broader && concept.broader[0];
+    if (!broader) {
+      return [];
+    }
+    return [broader].concat(await this.getAncestors({ concept: broader, ...config }));
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.narrower && concept.narrower[0] !== null) {
+      return concept.narrower;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data[this._scheme.uri].concepts[concept.uri];
+    return (concept && concept.narrower || []).map((c) => data[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async search({ search, scheme, limit = 100 }) {
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes();
+    }
+    if (!jskos.compare(scheme, this._scheme)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    const result = await data[this._scheme.uri].searchIndex.search(search);
+    return result.map((uri) => data[this._scheme.uri].concepts[uri]).map(this._removeNarrower).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;
+  }
+}
+MyCoReProvider.providerName = "MyCoRe";
+MyCoReProvider.providerType = "http://bartoc.org/api-type/mycore";
+export {
+  MyCoReProvider as default
+};

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

@@ -3,9 +3,13 @@ import jskos from "jskos-tools";
 import * as _ from "../utils/lodash.js";
 import * as errors from "../errors/index.js";
 import * as utils from "../utils/index.js";
+const cache = {};
 class OccurrencesApiProvider extends BaseProvider {
+  get _cache() {
+    return cache[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache[this.uri] = [];
     this._occurrencesSupportedSchemes = [];
     this.has.occurrences = true;
     this.has.mappings = true;
@@ -146,7 +150,7 @@ class OccurrencesApiProvider extends BaseProvider {
       data
     });
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache[this.uri] = this._cache.slice(this._cache.length - 20);
     }
     return data;
   }

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

@@ -3,9 +3,13 @@ import jskos from "jskos-tools";
 import * as _ from "../utils/lodash.js";
 import * as errors from "../errors/index.js";
 import { listOfCapabilities } from "../utils/index.js";
+const cache = {};
 class ReconciliationApiProvider extends BaseProvider {
+  get _cache() {
+    return cache[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache[this.uri] = [];
     this.has.mappings = true;
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
@@ -132,7 +136,7 @@ class ReconciliationApiProvider extends BaseProvider {
     };
     this._cache.push(newCacheEntry);
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache[this.uri] = this._cache.slice(this._cache.length - 20);
     }
     return newCacheEntry;
   }

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

@@ -5,10 +5,14 @@ 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));
-  });
+  return text.replace(
+    /\\u[\dA-F]{4}/gi,
+    function(match) {
+      return String.fromCharCode(parseInt(match.replace(/\\u/g, ""), 16));
+    }
+  );
 }
+const data = {};
 class SkohubProvider extends BaseProvider {
   _prepare() {
     this.has.schemes = true;
@@ -22,11 +26,20 @@ class SkohubProvider extends BaseProvider {
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
     });
+    data[this.uri] = {
+      index: {},
+      conceptCache: {},
+      schemeCache: {}
+    };
+  }
+  get _index() {
+    return data[this.uri] && data[this.uri].index;
+  }
+  get _conceptCache() {
+    return data[this.uri] && data[this.uri].conceptCache;
   }
-  _setup() {
-    this._index = {};
-    this._conceptCache = {};
-    this._schemeCache = {};
+  get _schemeCache() {
+    return data[this.uri] && data[this.uri].schemeCache;
   }
   static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
     if (!url || !scheme) {
@@ -52,11 +65,11 @@ class SkohubProvider extends BaseProvider {
     if (uri.endsWith("/")) {
       postfix = "index.json";
     }
-    const data = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
-    if (data.id !== uri) {
+    const data2 = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
+    if (data2.id !== uri) {
       throw new errors.InvalidRequestError({ message: "Skohub URL did not return expected concept scheme" });
     }
-    const { title, preferredNamespaceUri, hasTopConcept, description } = data;
+    const { title, preferredNamespaceUri, hasTopConcept, description } = data2;
     scheme = { uri, identifier: uris.filter((u) => u !== uri) };
     scheme.prefLabel = title;
     Object.keys(scheme.prefLabel || {}).forEach((key) => {
@@ -84,33 +97,33 @@ class SkohubProvider extends BaseProvider {
       return this._conceptCache[uri];
     }
     try {
-      const data = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
-      if (data.id !== uri) {
+      const data2 = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
+      if (data2.id !== uri) {
         throw new errors.InvalidRequestError({ message: "Skohub URL did not return expected concept URI" });
       }
-      const concept = this._toJskosConcept(data);
+      const concept = this._toJskosConcept(data2);
       this._conceptCache[uri] = concept;
       return concept;
     } catch (error) {
       return null;
     }
   }
-  _toJskosConcept(data) {
-    const concept = { uri: data.id };
-    concept.prefLabel = data.prefLabel;
+  _toJskosConcept(data2) {
+    const concept = { uri: data2.id };
+    concept.prefLabel = data2.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 }];
+    concept.narrower = (data2.narrower || []).map((c) => this._toJskosConcept(c));
+    concept.notation = data2.notation || [];
+    if (data2.broader && data2.broader.id) {
+      concept.broader = [{ uri: data2.broader.id }];
     }
-    if (data.inScheme && data.inScheme.id) {
-      concept.inScheme = [{ uri: data.inScheme.id }];
+    if (data2.inScheme && data2.inScheme.id) {
+      concept.inScheme = [{ uri: data2.inScheme.id }];
     }
-    if (data.scopeNote) {
-      concept.scopeNote = data.scopeNote;
+    if (data2.scopeNote) {
+      concept.scopeNote = data2.scopeNote;
       Object.keys(concept.scopeNote).forEach((key) => {
         concept.scopeNote[key] = [decodeUnicode(concept.scopeNote[key])];
       });
@@ -182,13 +195,13 @@ class SkohubProvider extends BaseProvider {
         if (scheme.uri.endsWith("/")) {
           postfix = `index${postfix}`;
         }
-        const data = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
-        if (data.length < 100) {
+        const data2 = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
+        if (data2.length < 100) {
           this._index[scheme.uri][lang] = null;
           continue;
         }
         index = FlexSearch.create();
-        index.import(data);
+        index.import(data2);
         this._index[scheme.uri][lang] = index;
         break;
       } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocoda-sdk",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "SDK for Cocoda",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
@@ -27,7 +27,7 @@
     "release:patch": "SEMVER=patch npm run release",
     "release:minor": "SEMVER=minor npm run release",
     "release:major": "SEMVER=major npm run release",
-    "postinstall": "[ -d './dist' ] || npm run build"
+    "prepare": "[ -d './dist' ] || npm run build"
   },
   "lint-staged": {
     "**/*.js": [
@@ -52,14 +52,14 @@
   },
   "homepage": "https://github.com/gbv/cocoda-sdk#readme",
   "devDependencies": {
-    "axios-mock-adapter": "^1.21.1",
+    "axios-mock-adapter": "^1.21.2",
     "better-docs": "^2.7.2",
-    "esbuild": "~0.14.43",
+    "esbuild": "~0.14.54",
     "esbuild-plugin-ifdef": "^1.0.1",
-    "eslint": "^8.17.0",
+    "eslint": "^8.23.1",
     "eslint-config-gbv": "^1.0.3",
     "glob": "^8.0.3",
-    "jsdoc": "^3.6.10",
+    "jsdoc": "^3.6.11",
     "license-checker": "^25.0.1",
     "lint-staged": "^12.5.0",
     "mocha": "^9.2.2",
@@ -72,6 +72,6 @@
     "jskos-tools": "^1.0.26",
     "localforage": "^1.10.0",
     "lodash": "^4.17.21",
-    "uuid": "^8.3.2"
+    "uuid": "^9.0.0"
   }
 }