cocoda-sdk 3.4.13 → 3.6.0

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

@@ -0,0 +1,325 @@
+import BaseProvider from "./base-provider.js";
+class OlsApiProvider extends BaseProvider {
+  static providerName = "OlsApi";
+  static providerType = "http://bartoc.org/api-type/ols";
+  static supports = {
+    schemes: true,
+    top: true,
+    data: false,
+    // TODO
+    concepts: true,
+    narrower: true,
+    ancestors: true,
+    types: true,
+    suggest: true,
+    search: true
+  };
+  constructor(config) {
+    super(config);
+    this.endpoint = config.endpoint;
+  }
+  /**
+   * Used by `registryForScheme` (see src/lib/CocodaSDK.js) to determine a provider config for a concept schceme.
+   * TODO: make this obsolete
+   */
+  static _registryConfigForBartocApiConfig({ url } = {}) {
+    if (url) {
+      return { endpoint: url };
+    }
+  }
+  /**
+   * Constructs the full API URL for a given endpoint.
+   */
+  _getApiUrl(parts, params = {}) {
+    const url = this.endpoint + parts.join("/");
+    params = Object.fromEntries(Object.entries(params).filter(([_, v]) => v != null));
+    params = new URLSearchParams(params);
+    return params.size ? `${url}?${params}` : url;
+  }
+  _ontologyToJSKOS(ontology) {
+    const lan = ontology.lang || this._language || "en";
+    const scheme = {};
+    if (ontology.iri) {
+      scheme.uri = ontology.iri;
+    }
+    scheme.type = [
+      "http://www.w3.org/2004/02/skos/core#ConceptScheme"
+    ];
+    if (ontology["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]) {
+      scheme.type = scheme.type.concat(ontology["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]);
+    }
+    if (ontology.title) {
+      scheme.prefLabel = {};
+      scheme.prefLabel[lan] = ontology.title;
+    }
+    if (ontology.description) {
+      scheme.definition = {};
+      scheme.definition[lan] = [ontology.description];
+    }
+    if (ontology.homepage) {
+      scheme.url = ontology.homepage;
+    }
+    if (ontology.tracker) {
+      scheme.issueTracker = [{ url: ontology.tracker }];
+    }
+    if (ontology.language) {
+      scheme.languages = ontology.language;
+    }
+    if (ontology.ontologyId) {
+      scheme.VOCID = ontology.ontologyId;
+      scheme.notation = [ontology.ontologyId];
+    }
+    if (ontology.license?.url) {
+      scheme.license = [{ uri: ontology.license.url }];
+    }
+    return scheme;
+  }
+  _termToJSKOS(term) {
+    const lan = term.language || this._language || "en";
+    const concept = {};
+    if (term.curie) {
+      concept.notation = [term.curie];
+    }
+    if (term.hasDirectChildren) {
+      concept.narrower = [null];
+    } else {
+      concept.narrower = [];
+    }
+    if (term.hasDirectParents) {
+      concept.broader = [null];
+    } else {
+      concept.broader = [];
+    }
+    if (term.iri) {
+      concept.uri = term.iri;
+    }
+    if (term["http://www.w3.org/2000/01/rdf-schema#label"]) {
+      concept.prefLabel = {};
+      concept.prefLabel[lan] = term["http://www.w3.org/2000/01/rdf-schema#label"];
+    }
+    concept.type = [
+      "http://www.w3.org/2004/02/skos/core#Concept",
+      // FIXME: properties are no classes
+      "http://www.w3.org/2002/07/owl#Class"
+    ];
+    if (term.ontologyIri) {
+      concept.inScheme = [{ uri: term.ontologyIri }];
+    }
+    return concept;
+  }
+  // #### API REQUESTS ####
+  // TODO: rename _skipAdditionalParameters
+  async _request(url, config = { _skipAdditionalParameters: true }) {
+    if (url) {
+      url = new URL(url);
+      const given = Object.fromEntries(url.searchParams.entries());
+      return this.axios({
+        method: "get",
+        url: url.origin + url.pathname,
+        params: {
+          ...given,
+          ...config.params
+          // explicit params win
+        },
+        ...config
+      });
+    }
+  }
+  // API REQUESTS SCHEMES
+  async _paginate(base, query, limit) {
+    const size = limit > 0 ? limit : null;
+    let url = this._getApiUrl(base, { ...query, size });
+    let page = await this._request(url);
+    let items = page?.elements || [];
+    if (!size) {
+      const totalPages = page?.totalPages || 0;
+      for (let n = 1; n < totalPages; n++) {
+        url = this._getApiUrl(base, { ...query, page: n });
+        page = await this._request(url);
+        items = items.concat(page?.elements || []);
+      }
+    }
+    return items;
+  }
+  // API REQUESTS CONCEPTS
+  async _getConceptOls(concept) {
+    const VOCID = await this._getSchemeVOCID(concept?.inScheme?.[0]);
+    if (VOCID) {
+      let url = null;
+      if (concept.notation) {
+        url = this._getApiUrl(["ontologies", VOCID, "classes"], { curie: concept.notation });
+      } else if (concept.uri) {
+        url = this._getApiUrl(["ontologies", VOCID, "classes"], { iri: concept.uri });
+      }
+      let response = await this._request(url);
+      return response?.elements?.[0] || null;
+    }
+  }
+  async _searchOls(search, scheme, limit, types) {
+    let items = [];
+    const knownTypes = {
+      "http://www.w3.org/2002/07/owl#Class": "classes",
+      "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property": "properties"
+    };
+    if (!types?.length) {
+      types = Object.keys(knownTypes);
+    }
+    for (const type of types) {
+      if (type in knownTypes) {
+        const VOCID = scheme ? await this._getSchemeVOCID(scheme) : null;
+        const query = { search, ontology: VOCID };
+        if (!scheme || VOCID) {
+          const found = await this._paginate([knownTypes[type]], query, limit);
+          items.push(...found);
+        }
+      }
+    }
+    return items;
+  }
+  // UTILITIES
+  async _conceptIriFromObj(VOCID, conceptNotation) {
+    let url = this._getApiUrl(["ontologies", VOCID, "classes"], { curie: conceptNotation });
+    let response = await this._request(url);
+    if (response && response.elements && response.elements.length > 0) {
+      return response.elements[0].iri;
+    }
+  }
+  get _language() {
+    return this._jskos.language || this.languages[0] || this._defaultLanguages[0] || "en";
+  }
+  async _getSchemeVOCID(scheme) {
+    return scheme?.VOCID ? scheme.VOCID : this._getScheme(scheme).then((s) => s?.ontologyId);
+  }
+  async _getScheme(scheme) {
+    if (scheme) {
+      const { VOCID, uri, notation, identifier } = scheme;
+      if (VOCID) {
+        return this._request(this._getApiUrl(["ontologies", VOCID]));
+      }
+      if (uri) {
+        scheme = await this._getSchemeFromUri(uri);
+        if (scheme) {
+          return scheme;
+        }
+      }
+      if (notation?.[0] && (uri || identifier?.length)) {
+        scheme = await this._request(this._getApiUrl(["ontologies", notation[0]]));
+        if (scheme.iri === uri || identifier?.includes(scheme.iri)) {
+          return scheme;
+        }
+      }
+      for (let id of identifier || []) {
+        const found = await this._getSchemeFromUri(id);
+        if (found) {
+          return found;
+        }
+      }
+    }
+  }
+  async _getSchemeFromUri(uri) {
+    if (uri) {
+      const url = this._getApiUrl(["ontologies"], { searchFields: "iri", search: uri });
+      const response = await this._request(url);
+      const schemes = response?.elements || [];
+      return schemes.reduce((short, cur) => cur.ontologyId.length < short.ontologyId.length ? cur : short, schemes[0]);
+    }
+    return null;
+  }
+  // MAIN FUNCTIONS
+  // TODO: query parameter are different: schemes are in "params.uri"?
+  async getSchemes({ schemes, limit }) {
+    let ontologies = [];
+    if (schemes) {
+      ontologies = (await Promise.all(schemes.map((s) => this._getScheme(s)))).filter(Boolean);
+    } else if (limit > 0) {
+      const url = this._getApiUrl(["ontologies"], { size: limit });
+      const response = await this._request(url);
+      ontologies = response.elements || [];
+    } else {
+      ontologies = await this._paginate(["ontologies"], {});
+    }
+    return Promise.all(ontologies.map((scheme) => this._ontologyToJSKOS(scheme)));
+  }
+  async getConcepts({ concepts, scheme, limit }) {
+    let result = [];
+    if (concepts) {
+      for (const concept of concepts) {
+        let item = await this._getConceptOls(concept);
+        if (item) {
+          result.push(await this._termToJSKOS(item));
+        }
+      }
+    } else if (scheme) {
+      const VOCID = await this._getSchemeVOCID(scheme);
+      if (VOCID) {
+        const items = await this._paginate(["ontologies", VOCID, "classes"], {}, limit);
+        result = Promise.all(items.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return result;
+  }
+  async getTop({ scheme }) {
+    const VOCID = await this._getSchemeVOCID(scheme);
+    if (VOCID) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes"], { hasDirectParents: "false" });
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async _splitConcept(concept) {
+    const obj = {};
+    if (concept) {
+      obj.VOCID = await this._getSchemeVOCID(concept?.inScheme?.[0]);
+      obj.iri = concept.uri || await this._conceptIriFromObj(obj.VOCID, concept.notation);
+      obj.iri = encodeURIComponent(encodeURIComponent(obj.iri));
+    }
+    return obj;
+  }
+  async getNarrower({ concept }) {
+    const { VOCID, iri } = await this._splitConcept(concept);
+    if (VOCID && iri) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes", iri, "children"]);
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async getAncestors({ concept }) {
+    const { VOCID, iri } = await this._splitConcept(concept);
+    if (VOCID && iri) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes", iri, "ancestors"]);
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async getTypes() {
+    return [{
+      uri: "http://www.w3.org/2002/07/owl#Class",
+      prefLabel: {
+        en: "Class",
+        de: "Klasse"
+      }
+    }, {
+      uri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property",
+      prefLabel: {
+        en: "Property",
+        de: "Eigenschaft"
+      }
+    }];
+  }
+  async search({ search, scheme = null, limit = 0, types = ["http://www.w3.org/2002/07/owl#Class"] }) {
+    let items = await this._searchOls(search, scheme, limit, types);
+    return Promise.all(items.map((item) => this._termToJSKOS(item)));
+  }
+}
+export {
+  OlsApiProvider as default
+};

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

@@ -338,34 +338,6 @@ class SkosmosApiProvider extends BaseProvider {
     const concepts = ancestors.map((c) => this._toJskosConcept(c, { scheme })).filter((c) => c.uri != concept.uri);
     return concepts;
   }
-  /**
-   * Returns suggestion result in OpenSearch Suggest Format.
-   *
-   * @param {Object} config
-   * @param {string} config.search search string
-   * @param {Object} [config.scheme] concept scheme to search in
-   * @param {number} [config.limit=100] maximum number of search results (default might be overridden by registry)
-   * @param {string[]} [config.types=[]] list of type URIs
-   * @returns {Array} result in OpenSearch Suggest Format
-   */
-  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;
-  }
   /**
    * Returns concept search results.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocoda-sdk",
-  "version": "3.4.13",
+  "version": "3.6.0",
   "description": "SDK for Cocoda",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
@@ -18,13 +18,15 @@
   ],
   "scripts": {
     "test": "mocha --recursive",
+    "coverage": "c8 --reporter=text --skip-full mocha --exit",
+    "validate": "jskos-validate",
     "lint": "eslint",
     "fix": "eslint --fix",
     "lint-staged": "lint-staged",
     "build": "node build.js",
     "docs": "jsdoc -c jsdoc.json",
     "yesno": "node -e \"const yesno = require('yesno'); yesno({ question: 'Are you sure you want to continue?' }).then(ok => process.exit(ok ? 0 : 1));\"",
-    "release": "test $(git rev-parse --abbrev-ref HEAD) = dev && git pull && npm test && npm run build && npm version $SEMVER && npm run --silent yesno && (git push && git checkout master && git merge dev && git push --follow-tags && git checkout dev) || (git tag -d $(git describe --tags) && git reset --hard HEAD~1)",
+    "release": "test $(git rev-parse --abbrev-ref HEAD) = dev && git pull && npm test && npm run build && npm version $SEMVER && npm run --silent yesno && (git push && git checkout main && git merge dev && git push --follow-tags && git checkout dev) || (git tag -d $(git describe --tags) && git reset --hard HEAD~1)",
     "release:patch": "SEMVER=patch npm run release",
     "release:minor": "SEMVER=minor npm run release",
     "release:major": "SEMVER=major npm run release",
@@ -50,25 +52,27 @@
   "homepage": "https://github.com/gbv/cocoda-sdk#readme",
   "devDependencies": {
     "axios-mock-adapter": "^2.1.0",
+    "c8": "^10.1.3",
     "clean-jsdoc-theme": "^4.3.0",
-    "esbuild": "~0.24.0",
+    "esbuild": "~0.27.0",
     "esbuild-plugin-ifdef": "^1.0.1",
-    "eslint": "~9.16",
-    "eslint-config-gbv": "~2.6",
-    "glob": "^10.4.5",
+    "eslint": "~9.39",
+    "eslint-config-gbv": "~2.7",
+    "glob": "^13.0.0",
     "husky": "^9.1.7",
     "jsdoc": "^4.0.4",
+    "jskos-cli": "^0.8.4",
     "license-checker": "^25.0.1",
-    "lint-staged": "^15.2.11",
+    "lint-staged": "^16.2.7",
     "mocha": "^11.0.1",
     "yesno": "^0.4.0"
   },
   "dependencies": {
     "axios": "^1.7.9",
-    "flexsearch": "~0.6.32",
+    "flexsearch": "~0.8.0",
     "jskos-tools": "^1.0.43",
     "localforage": "^1.10.0",
     "lodash": "^4.17.21",
-    "uuid": "^11.0.3"
+    "uuid": "^13.0.0"
   }
 }