cocoda-sdk 1.0.13 → 2.0.0

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

@@ -0,0 +1,163 @@
+import BaseProvider from "./base-provider.js";
+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";
+class OccurrencesApiProvider extends BaseProvider {
+  _setup() {
+    this._cache = [];
+    this._occurrencesSupportedSchemes = [];
+    this.has.occurrences = true;
+    this.has.mappings = true;
+  }
+  async _occurrencesIsSupported(scheme) {
+    if (this._occurrencesSupportedSchemes && this._occurrencesSupportedSchemes.length) {
+    } else {
+      try {
+        const url = utils.concatUrl(this._api.api, "voc");
+        const data = await this.axios({
+          method: "get",
+          url
+        });
+        this._occurrencesSupportedSchemes = data || [];
+      } catch (error) {
+      }
+    }
+    let supported = false;
+    for (let supportedScheme of this._occurrencesSupportedSchemes) {
+      if (jskos.compare(scheme, supportedScheme)) {
+        supported = true;
+      }
+    }
+    return supported;
+  }
+  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 mappings = [];
+    for (let occurrence of occurrences) {
+      if (!occurrence) {
+        continue;
+      }
+      let mapping = {};
+      mapping.from = _.get(occurrence, "memberSet[0]");
+      if (mapping.from) {
+        mapping.from = { memberSet: [mapping.from] };
+      } else {
+        mapping.from = null;
+      }
+      mapping.fromScheme = _.get(occurrence, "memberSet[0].inScheme[0]");
+      mapping.to = _.get(occurrence, "memberSet[1]");
+      if (mapping.to) {
+        mapping.to = { memberSet: [mapping.to] };
+      } else {
+        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)) {
+        [mapping.from, mapping.fromScheme, mapping.to, mapping.toScheme] = [mapping.to, mapping.toScheme, mapping.from, mapping.fromScheme];
+      }
+      if (!mapping.fromScheme && fromScheme) {
+        mapping.fromScheme = fromScheme;
+      }
+      if (!mapping.toScheme && toScheme) {
+        mapping.toScheme = toScheme;
+      }
+      mapping.type = [jskos.defaultMappingType.uri];
+      mapping._occurrence = occurrence;
+      mapping = jskos.addMappingIdentifiers(mapping);
+      if (occurrence.database) {
+        mapping.creator = [occurrence.database];
+      }
+      mappings.push(mapping);
+    }
+    return mappings;
+  }
+  async getOccurrences({ from, to, concepts, ...config }) {
+    let promises = [];
+    concepts = (concepts || []).concat([from, to]).filter((c) => !!c);
+    for (let concept of concepts) {
+      promises.push(this._occurrencesIsSupported(_.get(concept, "inScheme[0]")).then((supported) => {
+        if (supported && concept.uri) {
+          return concept.uri;
+        } else {
+          return null;
+        }
+      }));
+    }
+    let uris = await Promise.all(promises);
+    uris = uris.filter((uri) => uri != null);
+    if (uris.length == 0) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concepts" });
+    }
+    promises = [];
+    for (let uri of uris) {
+      promises.push(this._getOccurrences({
+        ...config,
+        params: {
+          member: uri,
+          scheme: "*",
+          threshold: 5
+        }
+      }));
+    }
+    if (uris.length > 1) {
+      let urisString = uris.join(" ");
+      promises.push(this._getOccurrences({
+        ...config,
+        params: {
+          member: urisString,
+          threshold: 5
+        }
+      }));
+    }
+    const results = await Promise.all(promises);
+    let occurrences = _.concat([], ...results);
+    let existingUris = [];
+    let indexesToDelete = [];
+    for (let i = 0; i < occurrences.length; i += 1) {
+      let occurrence = occurrences[i];
+      if (!occurrence) {
+        continue;
+      }
+      let uris2 = occurrence.memberSet.reduce((total, current) => total.concat(current.uri), []).sort().join(" ");
+      if (existingUris.includes(uris2)) {
+        indexesToDelete.push(i);
+      } else {
+        existingUris.push(uris2);
+      }
+    }
+    indexesToDelete.forEach((value) => {
+      delete occurrences[value];
+    });
+    occurrences = occurrences.filter((o) => o != null);
+    return occurrences.sort((a, b) => parseInt(b.count || 0) - parseInt(a.count || 0));
+  }
+  async _getOccurrences(config) {
+    let resultsFromCache = this._cache.find((item) => {
+      return _.isEqual(item.config.params, config.params);
+    });
+    if (resultsFromCache) {
+      return resultsFromCache.data;
+    }
+    const data = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.api
+    });
+    this._cache.push({
+      config,
+      data
+    });
+    if (this._cache.length > 20) {
+      this._cache = this._cache.slice(this._cache.length - 20);
+    }
+    return data;
+  }
+}
+OccurrencesApiProvider.providerName = "OccurrencesApi";
+OccurrencesApiProvider.stored = false;
+export {
+  OccurrencesApiProvider as default
+};

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

@@ -0,0 +1,140 @@
+import BaseProvider from "./base-provider.js";
+import jskos from "jskos-tools";
+import * as _ from "../utils/lodash.js";
+import * as errors from "../errors/index.js";
+class ReconciliationApiProvider extends BaseProvider {
+  _setup() {
+    this.has.mappings = true;
+    this._cache = [];
+  }
+  async getMappings({ from, to, mode, ...config }) {
+    let schemes = [];
+    if (_.isArray(this.schemes)) {
+      schemes = this.schemes;
+    }
+    let swap;
+    let concept;
+    let fromConceptScheme = _.get(from, "inScheme[0]");
+    let toConceptScheme = _.get(to, "inScheme[0]");
+    let fromScheme;
+    let toScheme;
+    if (!from || jskos.isContainedIn(fromConceptScheme, schemes)) {
+      swap = true;
+      concept = to;
+      fromScheme = toConceptScheme;
+      toScheme = schemes.find((scheme) => jskos.compare(scheme, fromConceptScheme)) || schemes[0];
+    } else {
+      swap = false;
+      concept = from;
+      fromScheme = fromConceptScheme;
+      toScheme = schemes.find((scheme) => jskos.compare(scheme, toConceptScheme)) || schemes[0];
+    }
+    if (mode != "or") {
+      return [];
+    }
+    if (!this._api.api) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!concept) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: swap ? "to" : "from" });
+    }
+    let language = jskos.languagePreference.selectLanguage(concept.prefLabel);
+    if (!language) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: swap ? "to" : "from", message: "Missing language" });
+    }
+    let altLabels = _.get(concept, `altLabel.${language}`, []);
+    if (_.isString(altLabels)) {
+      altLabels = [altLabels];
+    }
+    let prefLabel = _.get(concept, `prefLabel.${language}`);
+    let labels = altLabels.concat([prefLabel]);
+    labels = [prefLabel];
+    let { url, data: results } = await this._getReconciliationResults({ ...config, labels, language });
+    results = [].concat(...Object.values(results).map((value) => value.result)).filter((r) => r);
+    results = results.sort((a, b) => {
+      if (a.score != b.score) {
+        return b.score - a.score;
+      }
+      if (a.match != b.match) {
+        if (a.match) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+      return a.id.length - b.id.length;
+    });
+    let namespace = _.get(toScheme, "namespace", "");
+    let mappings = results.map((result) => ({
+      fromScheme,
+      from: { memberSet: [concept] },
+      toScheme,
+      to: {
+        memberSet: [
+          {
+            uri: namespace + result.id
+          }
+        ]
+      },
+      type: [
+        result.match ? "http://www.w3.org/2004/02/skos/core#exactMatch" : result.score >= 80 ? "http://www.w3.org/2004/02/skos/core#closeMatch" : "http://www.w3.org/2004/02/skos/core#mappingRelation"
+      ]
+    }));
+    if (swap) {
+      mappings = mappings.map((mapping) => Object.assign(mapping, {
+        fromScheme: mapping.toScheme,
+        from: mapping.to,
+        toScheme: mapping.fromScheme,
+        to: mapping.from
+      }));
+    }
+    mappings._url = url;
+    return mappings;
+  }
+  async _getReconciliationResults({ labels, language, ...config }) {
+    labels = labels.sort();
+    let resultsFromCache = this._cache.find((item) => {
+      return _.isEqual(item.labels, labels) && item.language == language;
+    });
+    if (resultsFromCache) {
+      return resultsFromCache;
+    }
+    let queries = {};
+    let index = 0;
+    for (let label of labels) {
+      queries[`q${index}`] = {
+        query: label
+      };
+      index += 1;
+    }
+    let url = this._api.api;
+    if (language) {
+      url = url.replace("{language}", language);
+    }
+    const encodedData = `queries=${encodeURIComponent(JSON.stringify(queries))}`;
+    _.set(config, ["headers", "Content-Type"], "application/x-www-form-urlencoded");
+    let data = await this.axios({
+      ...config,
+      method: "post",
+      url,
+      data: encodedData
+    });
+    data = data || {};
+    let newCacheEntry = {
+      labels,
+      language,
+      data,
+      url: `${url}${url.includes("?") ? "&" : "?"}${encodedData}`
+    };
+    this._cache.push(newCacheEntry);
+    if (this._cache.length > 20) {
+      this._cache = this._cache.slice(this._cache.length - 20);
+    }
+    return newCacheEntry;
+  }
+}
+ReconciliationApiProvider.providerName = "ReconciliationApi";
+ReconciliationApiProvider.stored = false;
+export {
+  ReconciliationApiProvider as default
+};

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

@@ -0,0 +1,345 @@
+import BaseProvider from "./base-provider.js";
+import jskos from "jskos-tools";
+import * as _ from "../utils/lodash.js";
+import * as errors from "../errors/index.js";
+class SkosmosApiProvider extends BaseProvider {
+  _setup() {
+    this.has.schemes = true;
+    this.has.top = false;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = true;
+    this.has.types = true;
+    this.has.suggest = true;
+    this.has.search = true;
+    for (let scheme of this.schemes) {
+      scheme.concepts = [null];
+      scheme.topConcepts = [];
+    }
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    const config = {};
+    const match = url.match(/(.+\/)([^/]+)\/$/);
+    if (!match) {
+      return null;
+    }
+    config.api = match[1] + "rest/v1/";
+    scheme.VOCID = match[2];
+    config.schemes = [scheme];
+    return config;
+  }
+  get _language() {
+    return this.languages[0] || this._defaultLanguages[0] || "en";
+  }
+  _getApiUrl(scheme, endpoint, params) {
+    if (!scheme || !scheme.VOCID) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme or VOCID property on scheme" });
+    }
+    endpoint = endpoint || "";
+    params = params || {};
+    if (!params.lang) {
+      params.lang = this._language;
+    }
+    const paramString = Object.keys(params).map((k) => `${k}=${encodeURIComponent(params[k])}`).join("&");
+    return `${this._api.api}${scheme.VOCID}${endpoint}${paramString ? "?" + paramString : ""}`;
+  }
+  _getDataUrl(concept, { addFormatParameter = true } = {}) {
+    const scheme = _.get(concept, "inScheme[0]");
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept", message: "Missing concept URI" });
+    }
+    return this._getApiUrl(scheme, "/data", addFormatParameter ? { format: "application/json" } : {});
+  }
+  async _getSchemeUri(scheme) {
+    this._approvedSchemes = this._approvedSchemes || [];
+    this._rejectedSchemes = this._rejectedSchemes || [];
+    let _scheme = this._approvedSchemes.find((s) => jskos.compare(scheme, s));
+    if (_scheme) {
+      return _scheme.uri;
+    }
+    if (this._rejectedSchemes.find((s) => jskos.compare(scheme, s))) {
+      return null;
+    }
+    const url = this._getApiUrl(scheme, "/");
+    const data = await this.axios({
+      method: "get",
+      url
+    });
+    const resultScheme = data.conceptschemes.find((s) => jskos.compare(s, scheme));
+    if (resultScheme) {
+      this._approvedSchemes.push({
+        uri: resultScheme.uri,
+        identifier: jskos.getAllUris(scheme)
+      });
+      return resultScheme.uri;
+    } else {
+      this._rejectedSchemes.push({
+        uri: scheme.uri,
+        identifier: scheme.identifier
+      });
+      return null;
+    }
+  }
+  _toJskosConcept(skosmosConcept, { concept, scheme, result, language } = {}) {
+    if (!skosmosConcept) {
+      return null;
+    }
+    concept = jskos.deepCopy(concept || {});
+    language = language || skosmosConcept.lang || "en";
+    concept.uri = skosmosConcept.uri;
+    if (scheme) {
+      concept.inScheme = [scheme];
+    }
+    let prefLabel = skosmosConcept.matchedPrefLabel || skosmosConcept.prefLabel || skosmosConcept.label;
+    if (_.isString(prefLabel)) {
+      _.set(concept, `prefLabel.${language}`, prefLabel);
+    } else {
+      if (prefLabel && !_.isArray(prefLabel)) {
+        prefLabel = [prefLabel];
+      }
+      for (let label of prefLabel || []) {
+        _.set(concept, `prefLabel.${label.lang}`, label.value);
+      }
+    }
+    let altLabel = skosmosConcept.altLabel;
+    if (_.isString(altLabel)) {
+      _.set(concept, `altLabel.${language}`, [altLabel]);
+    } else {
+      if (altLabel && !_.isArray(altLabel)) {
+        altLabel = [altLabel];
+      }
+      for (let label of altLabel || []) {
+        if (_.get(concept, `altLabel.${label.lang}`)) {
+          concept.altLabel[label.lang].push(label.value);
+          concept.altLabel[label.lang] = _.uniq(concept.altLabel[label.lang]);
+        } else {
+          _.set(concept, `altLabel.${label.lang}`, [label.value]);
+        }
+      }
+    }
+    const notation = skosmosConcept.notation || skosmosConcept["skos:notation"] || jskos.notation(concept);
+    if (notation) {
+      concept.notation = [notation.value || notation];
+    }
+    if (skosmosConcept.broader) {
+      if (!_.isArray(skosmosConcept.broader)) {
+        skosmosConcept.broader = [skosmosConcept.broader];
+      }
+      concept.broader = skosmosConcept.broader.map((concept2) => _.isString(concept2) ? { uri: concept2 } : concept2);
+    }
+    if (skosmosConcept.hasChildren === true) {
+      concept.narrower = [null];
+    } else if (skosmosConcept.hasChildren === false) {
+      concept.narrower = [];
+    }
+    if (skosmosConcept.type && !_.isArray(skosmosConcept.type)) {
+      skosmosConcept.type = [skosmosConcept.type];
+    }
+    concept.type = concept.type || [];
+    for (let type of skosmosConcept.type || []) {
+      if (!jskos.isValidUri(type)) {
+        continue;
+      }
+      const uriScheme = type.slice(0, type.indexOf(":"));
+      if (result && result["@context"] && result["@context"][uriScheme]) {
+        type = type.replace(uriScheme + ":", result["@context"][uriScheme]);
+      }
+      concept.type.push(type);
+    }
+    concept.type = _.uniq(concept.type);
+    if (!concept.type.length) {
+      concept.type = ["http://www.w3.org/2004/02/skos/core#Concept"];
+    }
+    return concept;
+  }
+  async getSchemes({ ...config }) {
+    const schemes = [];
+    for (let scheme of this.schemes || []) {
+      const url = this._getApiUrl(scheme, "/");
+      const data = await this.axios({
+        ...config,
+        method: "get",
+        url
+      });
+      const resultScheme = data.conceptschemes.find((s) => jskos.compare(s, scheme));
+      const label = resultScheme && (resultScheme.prefLabel || resultScheme.label || resultScheme.title);
+      if (label) {
+        _.set(scheme, `prefLabel.${this._language}`, label);
+      }
+      schemes.push(scheme);
+      this._approvedSchemes = this._approvedSchemes || [];
+      if (!this._approvedSchemes.find((s) => jskos.compare(scheme, s))) {
+        this._approvedSchemes.push({
+          uri: resultScheme.uri,
+          identifier: jskos.getAllUris(scheme)
+        });
+      }
+    }
+    return schemes;
+  }
+  async getTop({ scheme, ...config }) {
+    const url = this._getApiUrl(scheme, "/topConcepts");
+    const schemeUri = await this._getSchemeUri(scheme);
+    if (!schemeUri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing or unsupported scheme or VOCID property on scheme" });
+    }
+    _.set(config, "params.scheme", schemeUri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = [];
+    for (let concept of response.topconcepts || []) {
+      const newConcept = this._toJskosConcept(concept, {
+        scheme,
+        language: this._language
+      });
+      newConcept.topConceptOf = [scheme];
+      concepts.push(newConcept);
+    }
+    return concepts;
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!_.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    concepts = concepts.map((c) => ({ uri: c.uri, inScheme: c.inScheme }));
+    const newConcepts = [];
+    for (let concept of concepts) {
+      const url = this._getDataUrl(concept, { addFormatParameter: false });
+      if (!url) {
+        continue;
+      }
+      const result = await this.axios({
+        ...config,
+        method: "get",
+        url,
+        params: {
+          uri: concept.uri,
+          format: "application/json"
+        }
+      });
+      const resultConcept = result && result.graph && result.graph.find((c) => jskos.compare(c, concept));
+      if (resultConcept) {
+        const newConcept = this._toJskosConcept(resultConcept, { concept, result });
+        for (let type of ["broader", "narrower"]) {
+          let relatives = resultConcept[type] || newConcept[type];
+          if (relatives && !_.isArray(relatives)) {
+            relatives = [relatives];
+          }
+          if (!relatives) {
+            relatives = [];
+          }
+          newConcept[type] = relatives.map((r) => this._toJskosConcept(result.graph.find((c) => jskos.compare(c, r)), { scheme: concept.inScheme[0], result }));
+        }
+        newConcept.ancestors = [];
+        newConcepts.push(newConcept);
+      }
+    }
+    return newConcepts;
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    const scheme = concept.inScheme[0];
+    const url = this._getApiUrl(scheme, "/children");
+    _.set(config, "params.uri", concept.uri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = (response.narrower || []).map((c) => this._toJskosConcept(c, { scheme }));
+    return concepts;
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    const scheme = concept.inScheme[0];
+    const url = this._getApiUrl(scheme, "/broaderTransitive");
+    _.set(config, "params.uri", concept.uri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    let ancestors = [];
+    let uri = concept.uri;
+    while (uri) {
+      if (uri != concept.uri) {
+        const ancestor = _.get(response, `broaderTransitive["${uri}"]`);
+        ancestors = [ancestor].concat(ancestors);
+      }
+      uri = _.get(response, `broaderTransitive["${uri}"].broader[0]`);
+    }
+    const concepts = ancestors.map((c) => this._toJskosConcept(c, { scheme })).filter((c) => c.uri != concept.uri);
+    return concepts;
+  }
+  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;
+  }
+  async search({ search, scheme, limit, types = [], ...config }) {
+    const url = this._getApiUrl(scheme, "/search");
+    _.set(config, "params.query", `${search}*`);
+    _.set(config, "params.unique", 1);
+    _.set(config, "params.maxhits", limit || 100);
+    _.set(config, "params.type", types.join(" "));
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = (response.results || []).map((c) => this._toJskosConcept(c, { scheme }));
+    return concepts;
+  }
+  async getTypes({ scheme, ...config }) {
+    const url = this._getApiUrl(scheme, "/types");
+    const types = [];
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    for (let type of response && response.types || []) {
+      if (type.uri == "http://www.w3.org/2004/02/skos/core#Concept") {
+        continue;
+      }
+      if (type.label) {
+        type.prefLabel = {
+          [response["@context"]["@language"]]: type.label
+        };
+        delete type.label;
+      }
+      types.push(type);
+    }
+    types._url = url;
+    return types;
+  }
+}
+SkosmosApiProvider.providerName = "SkosmosApi";
+SkosmosApiProvider.providerType = "http://bartoc.org/api-type/skosmos";
+export {
+  SkosmosApiProvider as default
+};