cocoda-sdk 1.0.13 → 2.0.0

package/dist/esm/errors/index.js

@@ -0,0 +1,46 @@
+class CDKError extends Error {
+  constructor({ message = "", relatedError = null, code = null } = {}) {
+    if (!message && relatedError && relatedError.message) {
+      message = relatedError.message;
+    }
+    super(message);
+    this.name = this.constructor.name;
+    this.relatedError = relatedError;
+    this.code = code;
+  }
+}
+class MethodNotImplementedError extends CDKError {
+  constructor({ method, message = "", ...options }) {
+    options.message = `Method not implemented: ${method} (${message})`;
+    super(options);
+  }
+}
+class InvalidOrMissingParameterError extends CDKError {
+  constructor({ parameter, message = "", ...options }) {
+    options.message = `Invalid or missing parameter: ${parameter} (${message})`;
+    super(options);
+  }
+}
+class InvalidRequestError extends CDKError {
+}
+class BackendError extends CDKError {
+}
+class BackendUnavailableError extends CDKError {
+}
+class NetworkError extends CDKError {
+}
+class MissingApiUrlError extends CDKError {
+}
+class InvalidProviderError extends CDKError {
+}
+export {
+  BackendError,
+  BackendUnavailableError,
+  CDKError,
+  InvalidOrMissingParameterError,
+  InvalidProviderError,
+  InvalidRequestError,
+  MethodNotImplementedError,
+  MissingApiUrlError,
+  NetworkError
+};

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+import CocodaSDK from "./lib/CocodaSDK.js";
+import * as errors from "./errors/index.js";
+export * from "./providers/index.js";
+const cdk = new CocodaSDK();
+export {
+  CocodaSDK,
+  cdk,
+  errors
+};

package/dist/esm/lib/CocodaSDK.js

@@ -0,0 +1,269 @@
+import * as errors from "../errors/index.js";
+import axios from "axios";
+import * as _ from "../utils/lodash.js";
+import jskos from "jskos-tools";
+import { BaseProvider, ConceptApiProvider, MappingsApiProvider } from "../providers/index.js";
+const providers = {
+  [BaseProvider.providerName]: BaseProvider,
+  init(registry) {
+    if (this[registry.provider]) {
+      return new this[registry.provider](registry);
+    }
+    throw new errors.InvalidProviderError();
+  },
+  addProvider(provider) {
+    if (provider.prototype instanceof BaseProvider || provider === BaseProvider) {
+      this[provider.providerName] = provider;
+    } else {
+      throw new errors.InvalidProviderError();
+    }
+  }
+};
+providers.addProvider(ConceptApiProvider);
+providers.addProvider(MappingsApiProvider);
+class CocodaSDK {
+  constructor(config) {
+    this.config = config;
+    this.axios = axios.create();
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  get config() {
+    return this._config;
+  }
+  set config(config) {
+    config = config || {};
+    config.registries = config.registries || [];
+    config.registries = config.registries.map((registry) => providers.init(registry)).filter((r) => r);
+    config.registries.forEach((registry) => {
+      registry.cdk = this;
+    });
+    this._config = config;
+  }
+  get providers() {
+    return providers;
+  }
+  createInstance(config) {
+    return new CocodaSDK(config);
+  }
+  async loadConfig(url) {
+    const response = await this.axios.get(url);
+    this.config = response.data;
+  }
+  loadBuildInfo({ url, buildInfo = null, interval = 6e4, callback, ...config }) {
+    if (!url && !this.config.cocodaBaseUrl) {
+      throw new errors.CDKError({ message: "Could not determine URL to load build config." });
+    }
+    if (!url) {
+      url = `${this.config.cocodaBaseUrl}build-info.json`;
+    }
+    return this.repeat({
+      ...config,
+      function: async () => {
+        return (await this.axios.get(url, {
+          headers: {
+            "Cache-Control": "no-cache"
+          }
+        })).data;
+      },
+      interval,
+      callback: (error, result, previousResult) => {
+        if (error) {
+          callback(error);
+        } else if (previousResult || !previousResult && buildInfo && !_.isEqual(result, buildInfo)) {
+          callback(null, result, previousResult || buildInfo);
+        }
+      }
+    });
+  }
+  getRegistryForUri(uri) {
+    return this.config.registries.find((r) => r.uri == uri);
+  }
+  initializeRegistry(registry) {
+    registry = providers.init(registry);
+    registry.cdk = this;
+    return registry;
+  }
+  addProvider(provider) {
+    providers.addProvider(provider);
+  }
+  static addProvider(provider) {
+    providers.addProvider(provider);
+  }
+  repeat({ function: func, interval = 15e3, callback, callImmediately = true } = {}) {
+    if (!func) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "function" });
+    }
+    if (typeof func != "function") {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "function", message: "function needs to be a function" });
+    }
+    const asyncFunc = async () => func();
+    interval = parseInt(interval);
+    if (isNaN(interval)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "interval" });
+    }
+    if (!callback) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "callback" });
+    }
+    if (typeof callback != "function") {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "callback", message: "callback needs to be a function" });
+    }
+    let repeat = {
+      timer: null,
+      result: null,
+      error: null,
+      isPaused: false
+    };
+    const handleResult = (result) => {
+      const previousResult = repeat.result;
+      if (!_.isEqual(previousResult, result)) {
+        repeat.result = result;
+        repeat.error = null;
+        callback(null, result, previousResult);
+      }
+    };
+    const handleError = (error) => {
+      repeat.error = error;
+      callback(error);
+    };
+    const repeatIfNecessary = (toCall) => {
+      if (repeat.isPaused) {
+        return;
+      }
+      repeat.timer = setTimeout(() => {
+        toCall();
+      }, interval);
+    };
+    const call = () => asyncFunc().then(handleResult).catch(handleError).then(() => repeatIfNecessary(call));
+    const setup = (_callImmediately = callImmediately) => {
+      if (_callImmediately) {
+        call();
+      } else {
+        repeatIfNecessary(call);
+      }
+    };
+    setup();
+    return {
+      start: (...params) => {
+        repeat.isPaused = false;
+        setup(...params);
+      },
+      stop: () => {
+        repeat.isPaused = true;
+        if (repeat.timer) {
+          clearTimeout(repeat.timer);
+        } else {
+          setTimeout(() => {
+            repeat.timer && clearTimeout(repeat.timer);
+          }, interval);
+        }
+      },
+      get isPaused() {
+        return repeat.isPaused;
+      },
+      get lastResult() {
+        return repeat.result;
+      },
+      get hasErrored() {
+        return !!repeat.error;
+      }
+    };
+  }
+  async getSchemes(config = {}) {
+    let schemes = [], promises = [];
+    for (let registry of this.config.registries) {
+      if (registry.has.schemes) {
+        let promise = registry.getSchemes(config).then((results) => {
+          for (let scheme of results) {
+            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;
+            if (otherScheme) {
+              prio = this.config.registries.indexOf(registry);
+              if (prio != -1) {
+                prio = this.config.registries.length - prio;
+              }
+              otherPrio = this.config.registries.indexOf(_.get(otherScheme, "_registry"));
+              if (otherPrio != -1) {
+                otherPrio = this.config.registries.length - otherPrio;
+              }
+              let currentHasConcepts = !scheme.concepts ? 0 : scheme.concepts.length == 0 ? -1 : 1;
+              let otherHasConcepts = !otherScheme.concepts ? 0 : otherScheme.concepts.length == 0 ? -1 : 1;
+              if (currentHasConcepts > otherHasConcepts) {
+                override = true;
+              } else if (currentHasConcepts < otherHasConcepts) {
+                override = false;
+              } else {
+                override = otherPrio < prio;
+              }
+            }
+            if (!otherScheme || override) {
+              if (override) {
+                let otherSchemeIndex = schemes.findIndex((s) => jskos.compare(s, otherScheme));
+                if (otherSchemeIndex != -1) {
+                  schemes.splice(otherSchemeIndex, 1);
+                }
+                scheme = jskos.merge(scheme, otherScheme, { mergeUris: true, skipPaths: ["_registry"] });
+              }
+              scheme._registry = registry;
+              schemes.push(scheme);
+            } else {
+              let index = schemes.findIndex((s) => jskos.compare(s, scheme));
+              if (index != -1) {
+                let registry2 = schemes[index]._registry;
+                schemes[index] = jskos.merge(schemes[index], _.omit(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                schemes[index]._registry = registry2;
+              }
+            }
+          }
+        }).catch((error) => {
+          console.warn("Couldn't load schemes for registry", registry.uri, error);
+        });
+        promises.push(promise);
+      }
+    }
+    return Promise.all(promises).then(() => {
+      for (let scheme of schemes) {
+        if (scheme.concepts && scheme.concepts.length == 0) {
+          delete scheme.concepts;
+        }
+        if (scheme.topConcepts && scheme.topConcepts.length == 0) {
+          delete scheme.topConcepts;
+        }
+      }
+      schemes = schemes.filter((scheme) => scheme != null);
+      schemes = jskos.sortSchemes(schemes);
+      return schemes;
+    });
+  }
+  registryForScheme(scheme) {
+    let registry = scheme._registry;
+    if (registry) {
+      return registry;
+    }
+    for (let { type, ...config } of scheme.API || []) {
+      const provider = Object.values(providers).find((p) => p.providerType === type);
+      if (!provider || !provider._registryConfigForBartocApiConfig) {
+        continue;
+      }
+      const providerName = provider.providerName;
+      config.scheme = scheme;
+      config = providers[providerName]._registryConfigForBartocApiConfig(config);
+      if (!config) {
+        continue;
+      }
+      config.provider = providerName;
+      try {
+        registry = this.initializeRegistry(config);
+        return registry;
+      } catch (error) {
+        continue;
+      }
+    }
+    return null;
+  }
+}
+export {
+  CocodaSDK as default
+};

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

@@ -0,0 +1,368 @@
+import jskos from "jskos-tools";
+import * as _ from "../utils/lodash.js";
+import axios from "axios";
+import * as utils from "../utils/index.js";
+import * as errors from "../errors/index.js";
+class BaseProvider {
+  constructor(registry = {}) {
+    this._jskos = registry;
+    this.axios = axios.create({
+      timeout: 2e4
+    });
+    this._path = typeof window !== "undefined" && window.location.pathname;
+    this.has = {};
+    this._defaultLanguages = "en,de,fr,es,nl,it,fi,pl,ru,cs,jp".split(",");
+    this.languages = [];
+    this._auth = {
+      key: null,
+      bearerToken: null
+    };
+    this._repeating = [];
+    this._api = {
+      status: registry.status,
+      schemes: registry.schemes,
+      top: registry.top,
+      data: registry.data,
+      concepts: registry.concepts,
+      narrower: registry.narrower,
+      ancestors: registry.ancestors,
+      types: registry.types,
+      suggest: registry.suggest,
+      search: registry.search,
+      "voc-suggest": registry["voc-suggest"],
+      "voc-search": registry["voc-search"],
+      mappings: registry.mappings,
+      concordances: registry.concordances,
+      annotations: registry.annotations,
+      occurrences: registry.occurrences,
+      reconcile: registry.reconcile,
+      api: registry.api
+    };
+    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.url.startsWith("http:") && typeof window !== "undefined" && window.location.protocol == "https:") {
+        throw new axios.Cancel("Can't call http API from https.");
+      }
+      return config;
+    });
+    this.axios.interceptors.response.use(({ data, headers = {}, config = {} }) => {
+      data = jskos.normalize(data);
+      let url = config.url;
+      if (!url.endsWith("?")) {
+        url += "?";
+      }
+      _.forOwn(config.params || {}, (value, key) => {
+        url += `${key}=${encodeURIComponent(value)}&`;
+      });
+      if (_.isArray(data) || _.isObject(data)) {
+        let totalCount = parseInt(headers["x-total-count"]);
+        if (!isNaN(totalCount)) {
+          data._totalCount = totalCount;
+        }
+        data._url = url;
+      }
+      return data;
+    }, (error) => {
+      const count = _.get(error, "config._retryCount", 0);
+      const method = _.get(error, "config.method");
+      const statusCode = _.get(error, "response.status");
+      if (this._retryConfig.methods.includes(method) && this._retryConfig.statusCodes.includes(statusCode) && count < this._retryConfig.count) {
+        error.config._retryCount = count + 1;
+        if (error.config.data)
+          error.config.data = JSON.parse(error.config.data);
+        return new Promise((resolve, reject) => {
+          setTimeout(() => {
+            this.axios(error.config).then(resolve).catch(reject);
+          }, (() => {
+            const delay = this._retryConfig.delay;
+            if (typeof delay === "function") {
+              return delay(count);
+            }
+            return delay;
+          })());
+        });
+      } else {
+        return Promise.reject(error);
+      }
+    });
+    const currentRequests = [];
+    for (let { method, type } of utils.requestMethods) {
+      const existingMethod = this[method] && this[method].bind(this);
+      if (!existingMethod) {
+        this[method] = () => {
+          throw new errors.MethodNotImplementedError({ method });
+        };
+        continue;
+      }
+      this[method] = (options = {}) => {
+        if (options._raw) {
+          delete options._raw;
+          return existingMethod(options);
+        }
+        const existingRequest = currentRequests.find((r) => r.method == method && _.isEqual(r.options, options));
+        if (existingRequest) {
+          return existingRequest.promise;
+        }
+        let source;
+        if (!options.cancelToken) {
+          source = this.getCancelTokenSource();
+          options.cancelToken = source.token;
+        }
+        const promise = this.init().then(() => existingMethod(options)).then((result) => {
+          if (_.isArray(result) && result._totalCount === void 0) {
+            result._totalCount = result.length;
+          } else if (_.isObject(result) && result._totalCount === void 0) {
+            result._totalCount = 1;
+          }
+          if (result && type && this[`adjust${type}`]) {
+            result = this[`adjust${type}`](result);
+          }
+          return result;
+        }).catch((error) => {
+          if (error instanceof errors.CDKError) {
+            throw error;
+          } else {
+            if (error.response) {
+              if (error.response.status.toString().startsWith(4)) {
+                throw new errors.InvalidRequestError({ relatedError: error, code: error.response.status });
+              } else {
+                throw new errors.BackendError({ relatedError: error, code: error.response.status });
+              }
+            } else if (error.request) {
+              if (typeof navigator !== "undefined") {
+                if (navigator.connection || navigator.mozConnection || navigator.webkitConnection) {
+                  throw new errors.BackendUnavailableError({ relatedError: error });
+                }
+              }
+              throw new errors.NetworkError({ relatedError: error });
+            } else {
+              throw new errors.CDKError({ relatedError: error });
+            }
+          }
+        });
+        if (source) {
+          promise.cancel = (...args) => {
+            return source.cancel(...args);
+          };
+        }
+        const request = {
+          method,
+          options: _.omit(options, ["cancelToken"]),
+          promise
+        };
+        currentRequests.push(request);
+        promise.catch(() => {
+        }).then(() => currentRequests.splice(currentRequests.indexOf(request), 1));
+        return promise;
+      };
+    }
+  }
+  get uri() {
+    return this._jskos.uri;
+  }
+  get notation() {
+    return this._jskos.notation;
+  }
+  get prefLabel() {
+    return this._jskos.prefLabel;
+  }
+  get definition() {
+    return this._jskos.definition;
+  }
+  get schemes() {
+    return this._jskos.schemes;
+  }
+  get excludedSchemes() {
+    return this._jskos.excludedSchemes;
+  }
+  get stored() {
+    return this._jskos.stored !== void 0 ? this._jskos.stored : this.constructor.stored;
+  }
+  async init() {
+    if (this._init) {
+      return this._init;
+    }
+    this._init = (async () => {
+      this._prepare();
+      let status;
+      if (_.isString(this._api.status)) {
+        try {
+          status = await this.axios({
+            method: "get",
+            url: this._api.status
+          });
+        } catch (error) {
+          if (_.get(error, "response.status") === 404) {
+            this._api.status = null;
+          }
+        }
+      } else {
+        status = this._api.status;
+      }
+      if (_.isObject(status) && !_.isEmpty(status)) {
+        this._config = status.config || {};
+        for (let key of Object.keys(this._api)) {
+          if (this._api[key] === void 0) {
+            this._api[key] = status[key] || null;
+          }
+        }
+      }
+      this._setup();
+    })();
+    return this._init;
+  }
+  _prepare() {
+  }
+  _setup() {
+  }
+  getCancelTokenSource() {
+    return axios.CancelToken.source();
+  }
+  setAuth({ key = this._auth.key, bearerToken = this._auth.bearerToken }) {
+    this._auth.key = key;
+    this._auth.bearerToken = bearerToken;
+  }
+  setRetryConfig(config = {}) {
+    this._retryConfig = Object.assign({
+      methods: ["get", "head", "options"],
+      statusCodes: [401, 403],
+      count: 3,
+      delay: (count) => {
+        return 300 * count;
+      }
+    }, config);
+  }
+  isAuthorizedFor({ type, action, user, crossUser }) {
+    if (action == "read" && this.has[type] === true) {
+      return true;
+    }
+    if (!this.has[type]) {
+      return false;
+    }
+    const options = _.get(this._config, `${type}.${action}`);
+    if (!options) {
+      return !!this.has[type][action];
+    }
+    if (options.auth && (!user || !this._auth.key)) {
+      return false;
+    }
+    if (options.auth && this._auth.key != _.get(this._config, "auth.key")) {
+      return false;
+    }
+    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) {
+        return false;
+      }
+    }
+    if (options.auth && options.identityProviders) {
+      const providers = Object.keys(user && user.identities || {});
+      if (_.intersection(providers, options.identityProviders).length == 0) {
+        return false;
+      }
+    }
+    if (crossUser) {
+      return !!options.crossUser;
+    }
+    return !!this.has[type][action];
+  }
+  supportsScheme(scheme) {
+    if (!scheme) {
+      return false;
+    }
+    let schemes = _.isArray(this.schemes) ? this.schemes : null;
+    if (schemes == null && !jskos.isContainedIn(scheme, this.excludedSchemes || [])) {
+      return true;
+    }
+    return jskos.isContainedIn(scheme, schemes);
+  }
+  adjustConcept(concept) {
+    concept._getNarrower = (config) => {
+      return this.getNarrower({ ...config, concept });
+    };
+    concept._getAncestors = (config) => {
+      return this.getAncestors({ ...config, concept });
+    };
+    concept._getDetails = async (config) => {
+      return (await this.getConcepts({ ...config, concepts: [concept] }))[0];
+    };
+    for (let type of ["broader", "narrower", "ancestors"]) {
+      if (Array.isArray(concept[type]) && !concept[type].includes(null)) {
+        concept[type] = this.adjustConcepts(concept[type]);
+      }
+    }
+    concept._registry = this;
+    return concept;
+  }
+  adjustConcepts(concepts) {
+    return utils.withCustomProps(concepts.map((concept) => this.adjustConcept(concept)), concepts);
+  }
+  adjustRegistries(registries) {
+    return registries;
+  }
+  adjustScheme(scheme) {
+    scheme._registry = this.cdk && this.cdk.registryForScheme(scheme) || this;
+    if (scheme._registry) {
+      scheme._getTop = (config) => {
+        return scheme._registry.getTop({ ...config, scheme });
+      };
+      scheme._getTypes = (config) => {
+        return scheme._registry.getTypes({ ...config, scheme });
+      };
+      scheme._suggest = ({ search, ...config }) => {
+        return scheme._registry.suggest({ ...config, search, scheme });
+      };
+    }
+    return scheme;
+  }
+  adjustSchemes(schemes) {
+    return utils.withCustomProps(schemes.map((scheme) => this.adjustScheme(scheme)), schemes);
+  }
+  adjustConcordances(concordances) {
+    for (let concordance of concordances) {
+      concordance._registry = this;
+    }
+    return concordances;
+  }
+  adjustMapping(mapping) {
+    for (let side of ["from", "to"]) {
+      let sideScheme = `${side}Scheme`;
+      if (!mapping[sideScheme]) {
+        mapping[sideScheme] = _.get(jskos.conceptsOfMapping(mapping, side), "[0].inScheme[0]", null);
+      }
+    }
+    mapping._registry = this;
+    if (!mapping.identifier) {
+      let identifier = _.get(jskos.addMappingIdentifiers(mapping), "identifier");
+      if (identifier) {
+        mapping.identifier = identifier;
+      }
+    }
+    return mapping;
+  }
+  adjustMappings(mappings) {
+    return utils.withCustomProps(mappings.map((mapping) => this.adjustMapping(mapping)), mappings);
+  }
+  async postMappings({ mappings, ...config } = {}) {
+    if (!mappings || !mappings.length) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mappings" });
+    }
+    return Promise.all(mappings.map((mapping) => this.postMapping({ mapping, ...config, _raw: true })));
+  }
+  async deleteMappings({ mappings, ...config } = {}) {
+    if (!mappings || !mappings.length) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mappings" });
+    }
+    return Promise.all(mappings.map((mapping) => this.deleteMapping({ mapping, ...config, _raw: true })));
+  }
+}
+BaseProvider.providerName = "Base";
+export {
+  BaseProvider as default
+};