cocoda-sdk 1.0.13 → 2.0.0

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

@@ -0,0 +1,337 @@
+import BaseProvider from "./base-provider.js";
+import jskos from "jskos-tools";
+import * as _ from "../utils/lodash.js";
+import localforage from "localforage";
+import { v4 as uuid } from "uuid";
+import * as errors from "../errors/index.js";
+const uriPrefix = "urn:uuid:";
+class LocalMappingsProvider extends BaseProvider {
+  _setup() {
+    this.has.mappings = {
+      read: true,
+      create: true,
+      update: true,
+      delete: true
+    };
+    this.queue = [];
+    this.localStorageKey = "cocoda-mappings--" + this._path;
+    let oldLocalStorageKey = "mappings";
+    let addUris = () => {
+      return localforage.getItem(this.localStorageKey).then((mappings) => {
+        mappings = mappings || [];
+        let adjusted = 0;
+        for (let mapping of mappings.filter((m) => !m.uri || !m.uri.startsWith(uriPrefix))) {
+          if (mapping.uri) {
+            if (!mapping.identifier) {
+              mapping.identifier = [];
+            }
+            mapping.identifier.push(mapping.uri);
+          }
+          mapping.uri = `${uriPrefix}${uuid()}`;
+          adjusted += 1;
+        }
+        if (adjusted) {
+          console.warn(`URIs added to ${adjusted} local mappings.`);
+        }
+        return localforage.setItem(this.localStorageKey, mappings);
+      });
+    };
+    localforage.getItem(oldLocalStorageKey).then((results) => {
+      if (results) {
+        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);
+    }));
+  }
+  isAuthorizedFor({ type, action }) {
+    if (type == "mappings" && action != "anonymous") {
+      return true;
+    }
+    return false;
+  }
+  _getMappingsQueue() {
+    let last = _.last(this.queue) || Promise.resolve();
+    return new Promise((resolve) => {
+      function defer() {
+        var res, rej;
+        var promise2 = new Promise((resolve2, reject) => {
+          res = resolve2;
+          rej = reject;
+        });
+        promise2.resolve = res;
+        promise2.reject = rej;
+        return promise2;
+      }
+      let promise = defer();
+      let done = () => {
+        promise.resolve();
+      };
+      this.queue.push(promise);
+      last.then(() => {
+        return localforage.getItem(this.localStorageKey);
+      }).then((mappings) => {
+        resolve({ mappings, done });
+      });
+    });
+  }
+  async getMapping({ mapping, ...config }) {
+    config._raw = true;
+    if (!mapping || !mapping.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    return (await this.getMappings({ ...config, uri: mapping.uri }))[0];
+  }
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, uri } = {}) {
+    let params = {};
+    if (from) {
+      params.from = _.isString(from) ? from : from.uri;
+    }
+    if (fromScheme) {
+      params.fromScheme = _.isString(fromScheme) ? { uri: fromScheme } : fromScheme;
+    }
+    if (to) {
+      params.to = _.isString(to) ? to : to.uri;
+    }
+    if (toScheme) {
+      params.toScheme = _.isString(toScheme) ? { uri: toScheme } : toScheme;
+    }
+    if (creator) {
+      params.creator = _.isString(creator) ? creator : jskos.prefLabel(creator);
+    }
+    if (type) {
+      params.type = _.isString(type) ? type : type.uri;
+    }
+    if (partOf) {
+      params.partOf = _.isString(partOf) ? partOf : partOf.uri;
+    }
+    if (offset) {
+      params.offset = offset;
+    }
+    if (limit) {
+      params.limit = limit;
+    }
+    if (direction) {
+      params.direction = direction;
+    }
+    if (mode) {
+      params.mode = mode;
+    }
+    if (identifier) {
+      params.identifier = identifier;
+    }
+    if (uri) {
+      params.uri = uri;
+    }
+    return this._getMappingsQueue().catch((relatedError) => {
+      throw new errors.CDKError({ message: "Could not get mappings from local storage", relatedError });
+    }).then(({ mappings, done }) => {
+      done();
+      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;
+          if (params.direction == "backward") {
+            if (params.mode == "or") {
+              return params.from && fromInTo || params.to && toInFrom;
+            } else {
+              return (!params.from || fromInTo) && (!params.to || toInFrom);
+            }
+          } else if (params.direction == "both") {
+            if (params.mode == "or") {
+              return params.from && (fromInFrom || fromInTo) || params.to && (toInFrom || toInTo);
+            } else {
+              return (!params.from || fromInFrom) && (!params.to || toInTo) || (!params.from || fromInTo) && (!params.to || toInFrom);
+            }
+          } else {
+            if (params.mode == "or") {
+              return params.from && fromInFrom || params.to && toInTo;
+            } else {
+              return (!params.from || fromInFrom) && (!params.to || toInTo);
+            }
+          }
+        });
+      }
+      if (params.fromScheme || params.toScheme) {
+        mappings = mappings.filter((mapping) => {
+          let fromInFrom = jskos.compare(mapping.fromScheme, params.fromScheme);
+          let fromInTo = jskos.compare(mapping.toScheme, params.fromScheme);
+          let toInFrom = jskos.compare(mapping.fromScheme, params.toScheme);
+          let toInTo = jskos.compare(mapping.toScheme, params.toScheme);
+          if (params.direction == "backward") {
+            if (params.mode == "or") {
+              return params.fromScheme && fromInTo || params.toScheme && toInFrom;
+            } else {
+              return (!params.fromScheme || fromInTo) && (!params.toScheme || toInFrom);
+            }
+          } else if (params.direction == "both") {
+            if (params.mode == "or") {
+              return params.fromScheme && (fromInFrom || fromInTo) || params.toScheme && (toInFrom || toInTo);
+            } else {
+              return (!params.fromScheme || fromInFrom) && (!params.toScheme || toInTo) || (!params.fromScheme || fromInTo) && (!params.toScheme || toInFrom);
+            }
+          } else {
+            if (params.mode == "or") {
+              return params.fromScheme && fromInFrom || params.toScheme && toInTo;
+            } else {
+              return (!params.fromScheme || fromInFrom) && (!params.toScheme || toInTo);
+            }
+          }
+        });
+      }
+      if (params.creator) {
+        let creators = params.creator.split("|");
+        mappings = mappings.filter((mapping) => {
+          return (mapping.creator && mapping.creator.find((creator2) => creators.includes(jskos.prefLabel(creator2)) || creators.includes(creator2.uri))) != null;
+        });
+      }
+      if (params.type) {
+        mappings = mappings.filter((mapping) => (mapping.type || [jskos.defaultMappingType.uri]).includes(params.type));
+      }
+      if (params.partOf) {
+        mappings = mappings.filter((mapping) => {
+          return mapping.partOf != null && mapping.partOf.find((partOf2) => jskos.compare(partOf2, { uri: params.partOf })) != null;
+        });
+      }
+      if (params.identifier) {
+        mappings = mappings.filter((mapping) => {
+          return params.identifier.split("|").map((identifier2) => {
+            return (mapping.identifier || []).includes(identifier2) || mapping.uri == identifier2;
+          }).reduce((current, total) => current || total);
+        });
+      }
+      if (params.uri) {
+        mappings = mappings.filter((mapping) => mapping.uri == params.uri);
+      }
+      let totalCount = mappings.length;
+      mappings = mappings.sort((a, b) => {
+        let aDate = a.modified || a.created;
+        let bDate = b.modified || b.created;
+        if (bDate == null) {
+          return -1;
+        }
+        if (aDate == null) {
+          return 1;
+        }
+        if (aDate > bDate) {
+          return -1;
+        }
+        return 1;
+      });
+      mappings = mappings.slice(params.offset || 0);
+      mappings = mappings.slice(0, params.limit);
+      mappings._totalCount = totalCount;
+      return mappings;
+    });
+  }
+  async postMapping({ mapping }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    if (!mapping.uri || !mapping.uri.startsWith(uriPrefix)) {
+      if (mapping.uri) {
+        if (!mapping.identifier) {
+          mapping.identifier = [];
+        }
+        mapping.identifier.push(mapping.uri);
+      }
+      mapping.uri = `${uriPrefix}${uuid()}`;
+    }
+    if (localMappings.find((m) => m.uri == mapping.uri)) {
+      done();
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping", message: "Duplicate URI" });
+    }
+    if (!mapping.created) {
+      mapping.created = new Date().toISOString();
+    }
+    if (!mapping.modified) {
+      mapping.modified = mapping.created;
+    }
+    localMappings.push(mapping);
+    localMappings = localMappings.map((mapping2) => jskos.minifyMapping(mapping2));
+    try {
+      await localforage.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async putMapping({ mapping }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    const index = localMappings.findIndex((m) => m.uri == mapping.uri);
+    if (index == -1) {
+      done();
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping", message: "Mapping not found" });
+    }
+    if (!mapping.created) {
+      mapping.created = localMappings[index].created;
+    }
+    mapping.modified = new Date().toISOString();
+    localMappings[index] = mapping;
+    localMappings = localMappings.map((mapping2) => jskos.minifyMapping(mapping2));
+    try {
+      await localforage.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async patchMapping({ mapping }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    const index = localMappings.findIndex((m) => m.uri == mapping.uri);
+    if (index == -1) {
+      done();
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping", message: "Mapping not found" });
+    }
+    if (!mapping.created) {
+      mapping.created = localMappings[index].created;
+    }
+    mapping.modified = new Date().toISOString();
+    localMappings[index] = Object.assign(localMappings[index], mapping);
+    localMappings = localMappings.map((mapping2) => jskos.minifyMapping(mapping2));
+    try {
+      await localforage.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async deleteMapping({ mapping }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    try {
+      localMappings = localMappings.filter((m) => m.uri != mapping.uri);
+      localMappings = localMappings.map((mapping2) => jskos.minifyMapping(mapping2));
+      await localforage.setItem(this.localStorageKey, localMappings);
+      done();
+      return true;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+}
+LocalMappingsProvider.providerName = "LocalMappings";
+LocalMappingsProvider.stored = true;
+export {
+  LocalMappingsProvider as default
+};

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

@@ -0,0 +1,264 @@
+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 MappingsApiProvider 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 = {
+        mappings: "/mappings",
+        concordances: "/concordances",
+        annotations: "/annotations"
+      };
+      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.mappings = this._api.mappings ? {} : false;
+    if (this.has.mappings) {
+      this.has.mappings.read = !!_.get(this._config, "mappings.read", true);
+      this.has.mappings.create = !!_.get(this._config, "mappings.create");
+      this.has.mappings.update = !!_.get(this._config, "mappings.update");
+      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.annotations = this._api.annotations ? {} : false;
+    if (this.has.annotations) {
+      this.has.annotations.read = !!_.get(this._config, "annotations.read");
+      this.has.annotations.create = !!_.get(this._config, "annotations.create");
+      this.has.annotations.update = !!_.get(this._config, "annotations.update");
+      this.has.annotations.delete = !!_.get(this._config, "annotations.delete");
+    }
+    this.has.auth = _.get(this._config, "auth.key") != null;
+    this._defaultParams = {
+      properties: "annotations"
+    };
+  }
+  async getMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    if (!mapping.uri || !mapping.uri.startsWith(this._api.mappings)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
+    }
+    try {
+      return await this.axios({
+        ...config,
+        url: mapping.uri,
+        params: {
+          ...this._defaultParams,
+          ...config.params || {}
+        }
+      });
+    } catch (error) {
+      if (_.get(error, "response.status") == 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, sort, order, ...config }) {
+    let params = {}, url = this._api.mappings;
+    if (from) {
+      params.from = _.isString(from) ? from : from.uri;
+    }
+    if (fromScheme) {
+      params.fromScheme = _.isString(fromScheme) ? fromScheme : fromScheme.uri;
+    }
+    if (to) {
+      params.to = _.isString(to) ? to : to.uri;
+    }
+    if (toScheme) {
+      params.toScheme = _.isString(toScheme) ? toScheme : toScheme.uri;
+    }
+    if (creator) {
+      params.creator = _.isString(creator) ? creator : jskos.prefLabel(creator);
+    }
+    if (type) {
+      params.type = _.isString(type) ? type : type.uri;
+    }
+    if (partOf) {
+      params.partOf = _.isString(partOf) ? partOf : partOf.uri;
+    }
+    if (offset) {
+      params.offset = offset;
+    }
+    if (limit) {
+      params.limit = limit;
+    }
+    if (direction) {
+      params.direction = direction;
+    }
+    if (mode) {
+      params.mode = mode;
+    }
+    if (identifier) {
+      params.identifier = identifier;
+    }
+    if (sort) {
+      params.sort = sort;
+    }
+    if (order) {
+      params.order = order;
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {},
+        ...params
+      }
+    });
+  }
+  async postMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    mapping = jskos.minifyMapping(mapping);
+    mapping = jskos.addMappingIdentifiers(mapping);
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.mappings,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async putMapping({ mapping, ...config }) {
+    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." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async patchMapping({ mapping, ...config }) {
+    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." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async deleteMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "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." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
+  async getAnnotations({ target, ...config }) {
+    if (target) {
+      _.set(config, "params.target", target);
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.annotations
+    });
+  }
+  async postAnnotation({ annotation, ...config }) {
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.annotations,
+      data: annotation
+    });
+  }
+  async putAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: annotation
+    });
+  }
+  async patchAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: annotation
+    });
+  }
+  async deleteAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
+  async getConcordances(config) {
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.concordances
+    });
+  }
+}
+MappingsApiProvider.providerName = "MappingsApi";
+MappingsApiProvider.stored = true;
+export {
+  MappingsApiProvider as default
+};