cocoda-sdk 1.0.13 → 2.0.0

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

@@ -0,0 +1,278 @@
+import BaseProvider from "./base-provider.js";
+import * as _ from "../utils/lodash.js";
+import * as errors from "../errors/index.js";
+import * as utils from "../utils/index.js";
+import jskos from "jskos-tools";
+class ConceptApiProvider extends BaseProvider {
+  _prepare() {
+    if (this._api.api && this._api.status === void 0) {
+      this._api.status = utils.concatUrl(this._api.api, "/status");
+    }
+  }
+  _setup() {
+    if (this._api.api) {
+      const endpoints = {
+        schemes: "/voc",
+        top: "/voc/top",
+        concepts: "/voc/concepts",
+        data: "/data",
+        narrower: "/narrower",
+        ancestors: "/ancestors",
+        types: "/types",
+        suggest: "/suggest",
+        search: "/search"
+      };
+      for (let key of Object.keys(endpoints)) {
+        if (this._api[key] === void 0) {
+          this._api[key] = utils.concatUrl(this._api.api, endpoints[key]);
+        }
+      }
+    }
+    this.has.schemes = !!this._api.schemes;
+    this.has.top = !!this._api.top;
+    this.has.data = !!this._api.data;
+    this.has.concepts = !!this._api.concepts || this.has.data;
+    this.has.narrower = !!this._api.narrower;
+    this.has.ancestors = !!this._api.ancestors;
+    this.has.types = !!this._api.types;
+    this.has.suggest = !!this._api.suggest;
+    this.has.search = !!this._api.search;
+    this.has.auth = _.get(this._config, "auth.key") != null;
+    this._defaultParams = {
+      properties: "uri,prefLabel,notation,inScheme"
+    };
+  }
+  static _registryConfigForBartocApiConfig({ url } = {}) {
+    if (!url) {
+      return null;
+    }
+    return {
+      api: url
+    };
+  }
+  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 schemes = await this.getSchemes({ uri: jskos.getAllUris(scheme) });
+    const resultScheme = schemes.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;
+    }
+  }
+  async getSchemes(config) {
+    if (!this._api.schemes) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (Array.isArray(this._api.schemes)) {
+      return this._api.schemes;
+    }
+    const schemes = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.schemes,
+      params: {
+        ...this._defaultParams,
+        limit: 500,
+        ...config.params || {}
+      }
+    });
+    if (Array.isArray(this._jskos.schemes)) {
+      return utils.withCustomProps(schemes.filter((s) => jskos.isContainedIn(s, this._jskos.schemes)), schemes);
+    } else {
+      return schemes;
+    }
+  }
+  async getTop({ scheme, ...config }) {
+    if (!this._api.top) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!scheme) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    const schemeUri = await this._getSchemeUri(scheme);
+    if (!schemeUri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    if (Array.isArray(this._api.top)) {
+      return this._api.top;
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.top,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: schemeUri
+      }
+    });
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!this.has.data) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!concepts) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concepts" });
+    }
+    if (!Array.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    let uris = concepts.map((concept) => concept.uri).filter((uri) => uri != null);
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.data,
+      params: {
+        ...this._defaultParams,
+        limit: 500,
+        ...config.params || {},
+        uri: uris.join("|")
+      }
+    });
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!this._api.narrower) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.narrower,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: concept.uri
+      }
+    });
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!this._api.ancestors) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.ancestors,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: concept.uri
+      }
+    });
+  }
+  async suggest({ scheme, use = "notation,label", types = [], sort = "score", ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "suggest",
+      params: {
+        ...config.params,
+        voc: _.get(scheme, "uri", ""),
+        type: types.join("|"),
+        use,
+        sort
+      }
+    });
+  }
+  async search({ scheme, types = [], ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "search",
+      params: {
+        ...config.params,
+        voc: _.get(scheme, "uri", ""),
+        type: types.join("|")
+      }
+    });
+  }
+  async vocSuggest({ use = "notation,label", sort = "score", ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "voc-suggest",
+      params: {
+        ...config.params,
+        use,
+        sort
+      }
+    });
+  }
+  async vocSearch(config) {
+    return this._search({
+      ...config,
+      endpoint: "voc-search"
+    });
+  }
+  async _search({ endpoint, search, limit, offset, params, ...config }) {
+    let url = this._api[endpoint];
+    if (!url) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!search) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    limit = limit || this._jskos.suggestResultLimit || 100;
+    offset = offset || 0;
+    url = url.replace("{searchTerms}", search);
+    return this.axios({
+      ...config,
+      params: {
+        ...this._defaultParams,
+        ...params,
+        limit,
+        count: limit,
+        offset,
+        search,
+        query: search
+      },
+      method: "get",
+      url
+    });
+  }
+  async getTypes({ scheme, ...config }) {
+    if (!this._api.types) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (Array.isArray(this._api.types)) {
+      return this._api.types;
+    }
+    const schemeUri = scheme && await this._getSchemeUri(scheme);
+    if (schemeUri) {
+      _.set(config, "params.uri", schemeUri);
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.types
+    });
+  }
+}
+ConceptApiProvider.providerName = "ConceptApi";
+ConceptApiProvider.providerType = "http://bartoc.org/api-type/jskos";
+export {
+  ConceptApiProvider as default
+};

package/dist/esm/providers/index.js

@@ -0,0 +1,20 @@
+import BaseProvider from "./base-provider.js";
+import LocalMappingsProvider from "./local-mappings-provider.js";
+import MappingsApiProvider from "./mappings-api-provider.js";
+import OccurrencesApiProvider from "./occurrences-api-provider.js";
+import ConceptApiProvider from "./concept-api-provider.js";
+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";
+export {
+  BaseProvider,
+  ConceptApiProvider,
+  LabelSearchSuggestionProvider,
+  LocApiProvider,
+  LocalMappingsProvider,
+  MappingsApiProvider,
+  OccurrencesApiProvider,
+  ReconciliationApiProvider,
+  SkosmosApiProvider
+};

package/dist/esm/providers/label-search-suggestion-provider.js

@@ -0,0 +1,101 @@
+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 LabelSearchSuggestionProvider extends BaseProvider {
+  _setup() {
+    this._cache = [];
+    this.has.mappings = true;
+  }
+  supportsScheme(scheme) {
+    return _.get(scheme, "_registry.has.search", false);
+  }
+  async getMappings({ from, to, mode, selected, limit = 10, ...config }) {
+    if (mode != "or") {
+      return [];
+    }
+    if (!selected) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "selected" });
+    }
+    let promises = [];
+    if (from && this.supportsScheme(selected.scheme[false])) {
+      promises.push(this._getMappings({ ...config, concept: from, sourceScheme: selected.scheme[true], targetScheme: selected.scheme[false], limit }));
+    } else {
+      promises.push(Promise.resolve([]));
+    }
+    if (to && this.supportsScheme(selected.scheme[true])) {
+      promises.push(this._getMappings({ ...config, concept: to, sourceScheme: selected.scheme[false], targetScheme: selected.scheme[true], limit, swap: true }));
+    } else {
+      promises.push(Promise.resolve([]));
+    }
+    let [fromResult, toResult] = await Promise.all(promises);
+    toResult = toResult.filter((m) => !fromResult.find((n) => jskos.compareMappingMembers(m, n)));
+    while (fromResult.length + toResult.length > limit) {
+      if (toResult.length >= fromResult.length) {
+        toResult = toResult.slice(0, -1);
+      } else {
+        fromResult = fromResult.slice(0, -1);
+      }
+    }
+    return _.union(fromResult, toResult);
+  }
+  async _getMappings({ concept, sourceScheme, targetScheme, limit, swap = false, ...config }) {
+    if (!concept || !sourceScheme || !targetScheme) {
+      return [];
+    }
+    if (jskos.compare(sourceScheme, targetScheme)) {
+      return [];
+    }
+    let label = jskos.prefLabel(concept, {
+      fallbackToUri: false,
+      language: this.languages[0] || this._defaultLanguages[0]
+    });
+    if (!label) {
+      return [];
+    }
+    const results = await this._getResults({ ...config, label, targetScheme, limit });
+    let mappings = results.map((result) => ({
+      fromScheme: sourceScheme,
+      from: { memberSet: [concept] },
+      toScheme: targetScheme,
+      to: { memberSet: [result] },
+      type: ["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
+      }));
+    }
+    return mappings;
+  }
+  async _getResults({ label, targetScheme, limit, ...config }) {
+    let resultsFromCache = (this._cache[targetScheme.uri] || {})[label];
+    if (resultsFromCache && resultsFromCache._limit >= limit) {
+      return resultsFromCache;
+    }
+    const registry = _.get(targetScheme, "_registry");
+    if (!registry || !registry.has.search) {
+      return [];
+    }
+    const data = await registry.search({
+      ...config,
+      search: label,
+      scheme: targetScheme,
+      limit
+    });
+    if (!this._cache[targetScheme.uri]) {
+      this._cache[targetScheme.uri] = {};
+    }
+    this._cache[targetScheme.uri][label] = data;
+    this._cache[targetScheme.uri][label]._limit = limit;
+    return data;
+  }
+}
+LabelSearchSuggestionProvider.providerName = "LabelSearchSuggestion";
+LabelSearchSuggestionProvider.stored = false;
+export {
+  LabelSearchSuggestionProvider as default
+};

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

@@ -0,0 +1,185 @@
+import BaseProvider from "./base-provider.js";
+import * as errors from "../errors/index.js";
+import jskos from "jskos-tools";
+import axios from "axios";
+const locUriPrefix = "http://id.loc.gov/authorities/";
+const supportedSchemes = [
+  {
+    uri: `${locUriPrefix}subjects`,
+    identifier: [
+      "http://bartoc.org/en/node/454"
+    ],
+    notation: ["LCSH"],
+    concepts: [null],
+    topConcepts: []
+  },
+  {
+    uri: `${locUriPrefix}names`,
+    identifier: [
+      "http://bartoc.org/en/node/18536"
+    ],
+    notation: ["LCNAF"],
+    concepts: [null],
+    topConcepts: []
+  }
+];
+const lccUri = `${locUriPrefix}classification`;
+function madsToJskosItem(data) {
+  const item = {};
+  item.uri = data["@id"];
+  item.notation = (data["http://www.loc.gov/mads/rdf/v1#code"] || []).map((n) => n["@value"]);
+  const prefLabelArray = data["http://www.loc.gov/mads/rdf/v1#authoritativeLabel"] || data["http://www.w3.org/2000/01/rdf-schema#label"] || [];
+  if (prefLabelArray.length) {
+    item.prefLabel = {};
+    item.prefLabel[prefLabelArray[0]["@language"] || "en"] = prefLabelArray[0]["@value"];
+  }
+  const altLabelArray = data["http://www.w3.org/2004/02/skos/core#altLabel"] || [];
+  if (altLabelArray.length) {
+    item.altLabel = { en: altLabelArray.map((l) => l["@value"]) };
+  }
+  for (let definition of data["http://www.w3.org/2000/01/rdf-schema#comment"] || []) {
+    item.definition = item.definition || {};
+    item.definition.en = item.definition.en || [];
+    item.definition.en.push(definition["@value"]);
+  }
+  return item;
+}
+function madsToJskosScheme(data) {
+  const scheme = madsToJskosItem(data);
+  scheme.namespace = scheme.uri + "/";
+  scheme.type = ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
+  return scheme;
+}
+const schemeNamespaceFilter = (scheme) => (c) => {
+  if (!c || !scheme || !scheme.namespace) {
+    return true;
+  }
+  return c.uri.startsWith(scheme.namespace);
+};
+function madsToJskosConcept(data, { scheme }) {
+  const concept = madsToJskosItem(data);
+  concept.type = ["http://www.w3.org/2004/02/skos/core#Concept"];
+  concept.inScheme = scheme ? [scheme] : (data["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSScheme"] || []).map((s) => supportedSchemes.find((s2) => s2.uri === s["@id"]));
+  if (!concept.inScheme.length || !concept.inScheme[0]) {
+    delete concept.inScheme;
+  }
+  const narrower = data["http://www.loc.gov/mads/rdf/v1#hasNarrowerAuthority"] || jskos.compare(concept.inScheme[0], { uri: lccUri }) && data["http://www.loc.gov/mads/rdf/v1#hasMADSCollectionMember"] || [];
+  concept.narrower = narrower.map((n) => ({ uri: n["@id"] })).filter(schemeNamespaceFilter(concept.inScheme && concept.inScheme[0]));
+  const broader = data["http://www.loc.gov/mads/rdf/v1#hasBroaderAuthority"] || jskos.compare(concept.inScheme[0], { uri: lccUri }) && data["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSCollection"] || [];
+  concept.broader = broader.map((n) => ({ uri: n["@id"] })).filter(schemeNamespaceFilter(concept.inScheme && concept.inScheme[0]));
+  return concept;
+}
+class LocApiProvider 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 = false;
+    this.has.suggest = true;
+    this.has.search = true;
+  }
+  static _registryConfigForBartocApiConfig({ scheme } = {}) {
+    if (!scheme || !supportedSchemes.find((s) => jskos.compare(s, scheme))) {
+      return null;
+    }
+    return {
+      schemes: [scheme]
+    };
+  }
+  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;
+        }
+      }
+      return null;
+    })))) {
+      if (scheme) {
+        schemes.push(scheme);
+      }
+    }
+    return schemes;
+  }
+  async getConcepts({ concepts }) {
+    if (!Array.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    const resultConcepts = [];
+    for (let concept of await Promise.all(concepts.map((c) => axios({
+      method: "get",
+      url: `${c.uri.replace("http:", "https:")}.json`
+    }).then(({ status, data }) => {
+      if (status === 200) {
+        let concept2 = data.find((d) => c.uri === d["@id"]);
+        if (concept2) {
+          return madsToJskosConcept(concept2, { scheme: c.inScheme && c.inScheme[0] });
+        }
+        return null;
+      }
+    })))) {
+      if (concept) {
+        resultConcepts.push(concept);
+      }
+    }
+    return resultConcepts;
+  }
+  async suggest(config) {
+    const results = await this.search(config);
+    return [
+      config.search,
+      results.map((c) => {
+        let string = "";
+        const notation = jskos.notation(c);
+        if (notation) {
+          string += notation + " ";
+        }
+        string += jskos.prefLabel(c, { fallbackToUri: string === "" });
+        return string;
+      }),
+      [],
+      results.map((c) => c.uri)
+    ];
+  }
+  async search({ search, scheme, limit, offset }) {
+    const schemeUri = jskos.getAllUris(scheme).find((uri) => uri.startsWith(locUriPrefix));
+    if (!schemeUri || !supportedSchemes.find((s) => jskos.compare(s, { uri: schemeUri }))) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "provided scheme is not supported (yet)" });
+    }
+    if (!search) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "search", message: "parameter is empty or missing" });
+    }
+    limit = limit || this._jskos.suggestResultLimit || 100;
+    offset = offset || 0;
+    const { data } = await axios({
+      method: "get",
+      url: `${schemeUri}/suggest2`.replace("http:", "https:"),
+      params: {
+        q: search,
+        count: limit || 100,
+        offset,
+        searchtype: "keyword"
+      }
+    });
+    return (data.hits || []).map((d) => ({
+      uri: d.uri,
+      notation: [d.token],
+      prefLabel: { en: d.aLabel },
+      inScheme: [scheme]
+    })).filter(schemeNamespaceFilter(scheme));
+  }
+}
+LocApiProvider.providerName = "LocApi";
+LocApiProvider.providerType = "http://bartoc.org/api-type/loc";
+export {
+  LocApiProvider as default
+};