@jbrowse/plugin-rdf 4.2.1 → 5.0.0-beta.1

package/esm/SPARQLAdapter/SPARQLAdapter.d.ts

@@ -1,11 +1,10 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type MyConfigSchema from './configSchema.ts';
+import type { SPARQLAdapterConfig } from './configSchema.ts';
 import type PluginManager from '@jbrowse/core/PluginManager';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import type { Feature } from '@jbrowse/core/util/simpleFeature';
 import type { NoAssemblyRegion } from '@jbrowse/core/util/types';
-import type { Instance } from '@jbrowse/mobx-state-tree';
 export default class SPARQLAdapter extends BaseFeatureDataAdapter {
     private endpoint;
     private queryTemplate;
@@ -13,7 +12,7 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
     private additionalQueryParams;
     private configRefNames;
     private refNames;
-    constructor(config: Instance<typeof MyConfigSchema>, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    constructor(config: SPARQLAdapterConfig, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     getFeatures(query: NoAssemblyRegion, opts?: BaseOptions): import("rxjs").Observable<Feature>;
     private querySparql;

package/esm/SPARQLAdapter/SPARQLAdapter.js

@@ -2,7 +2,15 @@ import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
-import format from 'string-template';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+// fill `{name}` placeholders from data; `{{name}}` is an escaped literal.
+// replaces the `string-template` dependency
+const templateRegex = /\{([0-9a-zA-Z_]+)\}/g;
+function fillTemplate(template, data) {
+    return template.replaceAll(templateRegex, (match, key, index) => template[index - 1] === '{' && template[index + match.length] === '}'
+        ? key
+        : `${data[key] ?? ''}`);
+}
 export default class SPARQLAdapter extends BaseFeatureDataAdapter {
     endpoint;
     queryTemplate;
@@ -12,7 +20,8 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
     refNames;
     constructor(config, getSubAdapter, pluginManager) {
         super(config, getSubAdapter, pluginManager);
-        this.endpoint = readConfObject(config, 'endpoint').uri;
+        const endpoint = readConfObject(config, 'endpoint');
+        this.endpoint = 'uri' in endpoint ? endpoint.uri : '';
         this.queryTemplate = readConfObject(config, 'queryTemplate');
         this.additionalQueryParams = readConfObject(config, 'additionalQueryParams');
         this.refNamesQueryTemplate = readConfObject(config, 'refNamesQueryTemplate');
@@ -34,8 +43,8 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
     }
     getFeatures(query, opts = {}) {
         return ObservableCreate(async (observer) => {
-            const filledTemplate = encodeURIComponent(format(this.queryTemplate, query));
-            const { refName } = query;
+            const { refName, start, end } = query;
+            const filledTemplate = encodeURIComponent(fillTemplate(this.queryTemplate, { refName, start, end }));
             const results = await this.querySparql(filledTemplate, opts);
             const features = this.resultsToFeatures(results, refName);
             for (const feature of features) {
@@ -44,21 +53,26 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
             observer.complete();
         }, opts.stopToken);
     }
-    async querySparql(query, _opts) {
+    async querySparql(query, opts) {
         let additionalQueryParams = '';
         if (this.additionalQueryParams.length) {
             additionalQueryParams = `&${this.additionalQueryParams.join('&')}`;
         }
+        checkStopToken(opts?.stopToken);
         const url = `${this.endpoint}?query=${query}${additionalQueryParams}`;
         const response = await fetch(url, {
             headers: {
                 accept: 'application/json,application/sparql-results+json',
             },
         });
+        if (!response.ok) {
+            throw new Error(`SPARQL query failed: ${response.status} ${response.statusText}`);
+        }
+        checkStopToken(opts?.stopToken);
         return response.json();
     }
     resultsToRefNames(response) {
-        const rows = response.results.bindings || [];
+        const rows = response.results.bindings ?? [];
         const fields = response.head.vars;
         if (!fields.includes('refName')) {
             throw new Error('"refName" not found in refNamesQueryTemplate response');
@@ -66,7 +80,7 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
         return rows.map(row => row.refName.value);
     }
     resultsToFeatures(results, refName) {
-        const rows = results.results.bindings || [];
+        const rows = results.results.bindings ?? [];
         const fields = results.head.vars;
         const requiredFields = ['start', 'end', 'uniqueId'];
         for (const requiredField of requiredFields) {
@@ -74,91 +88,59 @@ export default class SPARQLAdapter extends BaseFeatureDataAdapter {
                 console.error(`Required field ${requiredField} missing from feature data`);
             }
         }
-        const seenFeatures = {};
+        // Each row encodes a feature plus its sub_/sub_sub_ ancestors. Flatten
+        // every level into a single uniqueId->feature map and record each level's
+        // parent, then attach children to parents in a second pass. Building the
+        // full map first makes attachment independent of row/level ordering.
+        const featuresById = new Map();
+        const parentById = new Map();
         for (const row of rows) {
-            const rawData = [{}];
-            for (let field of fields) {
+            const levels = [{}];
+            for (const field of fields) {
                 if (field in row) {
-                    const { value } = row[field];
-                    let idx = 0;
-                    while (field.startsWith('sub_')) {
-                        field = field.slice(4);
-                        idx += 1;
+                    let name = field;
+                    let depth = 0;
+                    while (name.startsWith('sub_')) {
+                        name = name.slice(4);
+                        depth += 1;
                     }
-                    while (idx > rawData.length - 1) {
-                        rawData.push({});
+                    while (depth > levels.length - 1) {
+                        levels.push({});
                     }
-                    rawData[idx][field] = value;
+                    levels[depth][name] = row[field].value;
                 }
             }
-            for (const [idx, rd] of rawData.entries()) {
-                const { uniqueId, start, end, strand } = rd;
-                if (idx < rawData.length - 1) {
-                    rawData[idx + 1].parentUniqueId = uniqueId;
+            for (const [depth, level] of levels.entries()) {
+                const { uniqueId, start, end, strand } = level;
+                featuresById.set(uniqueId, {
+                    ...level,
+                    uniqueId: uniqueId,
+                    refName,
+                    start: Number.parseInt(start, 10),
+                    end: Number.parseInt(end, 10),
+                    strand: Number.parseInt(strand, 10) || 0,
+                });
+                if (depth > 0) {
+                    parentById.set(uniqueId, levels[depth - 1].uniqueId);
                 }
-                seenFeatures[uniqueId] = {
-                    data: {
-                        ...rd,
-                        uniqueId: uniqueId,
-                        refName,
-                        start: Number.parseInt(start, 10),
-                        end: Number.parseInt(end, 10),
-                        strand: Number.parseInt(strand, 10) || 0,
-                    },
-                };
             }
         }
-        for (const [uniqueId, f] of Object.entries(seenFeatures)) {
-            const pid = f.data.parentUniqueId;
-            f.data.parentUniqueId = undefined;
-            if (pid) {
-                const p = seenFeatures[pid];
-                if (p) {
-                    if (!p.data.subfeatures) {
-                        p.data.subfeatures = [];
-                    }
-                    p.data.subfeatures.push({
-                        ...f.data,
-                        uniqueId,
-                    });
-                    delete seenFeatures[uniqueId];
-                }
-                else {
-                    const subfeatures = Object.values(seenFeatures)
-                        .map(sf => sf.data.subfeatures)
-                        .filter(sf => !!sf)
-                        .flat();
-                    let found = false;
-                    for (const subfeature of subfeatures) {
-                        if (subfeature.uniqueId === pid) {
-                            if (!subfeature.subfeatures) {
-                                subfeature.subfeatures = [];
-                            }
-                            subfeature.subfeatures.push({
-                                ...f.data,
-                                uniqueId,
-                            });
-                            delete seenFeatures[uniqueId];
-                            found = true;
-                            break;
-                        }
-                        if (subfeature.subfeatures) {
-                            for (const sf of subfeature.subfeatures) {
-                                subfeatures.push(sf);
-                            }
-                        }
-                    }
-                    if (!found) {
-                        console.error(`Could not find parentID ${pid}`);
-                    }
+        const roots = [];
+        for (const [uniqueId, feature] of featuresById) {
+            const pid = parentById.get(uniqueId);
+            const parent = pid ? featuresById.get(pid) : undefined;
+            if (parent) {
+                parent.subfeatures ??= [];
+                parent.subfeatures.push(feature);
+            }
+            else {
+                if (pid) {
+                    console.error(`Could not find parentID ${pid}`);
                 }
+                roots.push(feature);
             }
         }
-        return Object.keys(seenFeatures).map(seenFeature => new SimpleFeature({
-            ...seenFeatures[seenFeature].data,
-            uniqueId: seenFeature,
-            subfeatures: seenFeatures[seenFeature].data.subfeatures,
-        }));
+        return roots.map(data => new SimpleFeature(data));
     }
     async hasDataForRefName(refName, opts = {}) {
         const refNames = await this.getRefNames(opts);

package/esm/SPARQLAdapter/configSchema.d.ts

@@ -1,31 +1,72 @@
-declare const _default: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    endpoint: {
-        type: string;
-        defaultValue: {
-            uri: string;
-            locationType: string;
+import type { Instance } from '@jbrowse/mobx-state-tree';
+/**
+ * #config SPARQLAdapter
+ * #trackType FeatureTrack
+ * #category adapter
+ * fetches features from a SPARQL endpoint, substituting the queried region into
+ * a query template
+ *
+ * #example
+ * `{refName}`, `{start}` and `{end}` are substituted per request, so the
+ * endpoint is queried for the visible window rather than the whole genome. The
+ * result columns become feature fields, so the query has to select at least
+ * `?start`, `?end` and a `?uniqueID`:
+ * ```js
+ * {
+ *   type: 'SPARQLAdapter',
+ *   endpoint: { uri: 'https://example.com/sparql' },
+ *   queryTemplate: `SELECT ?uniqueID ?start ?end ?strand ?name WHERE {
+ *     ?f a :Feature ; :ref "{refName}" ; :start ?start ; :end ?end .
+ *     FILTER(?start < {end} && ?end > {start})
+ *   }`,
+ *   refNamesQueryTemplate: 'SELECT DISTINCT ?refName WHERE { ?f :ref ?refName }',
+ * }
+ * ```
+ */
+declare const SPARQLAdapterConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    /**
+     * #slot
+     */
+    readonly endpoint: {
+        readonly type: "fileLocation";
+        readonly defaultValue: {
+            readonly uri: "https://somesite.com/sparql";
+            readonly locationType: "UriLocation";
         };
-        description: string;
+        readonly description: "URL of the SPARQL endpoint";
     };
-    queryTemplate: {
-        type: string;
-        defaultValue: string;
-        description: string;
+    /**
+     * #slot
+     */
+    readonly queryTemplate: {
+        readonly type: "text";
+        readonly defaultValue: "";
+        readonly description: "SPARQL query where {start} {end} and {refName} will get replaced for each call";
     };
-    refNamesQueryTemplate: {
-        type: string;
-        defaultValue: string;
-        description: string;
+    /**
+     * #slot
+     */
+    readonly refNamesQueryTemplate: {
+        readonly type: "text";
+        readonly defaultValue: "";
+        readonly description: "SPARQL query that returns the possible refNames in a ?refName column";
     };
-    refNames: {
-        type: string;
-        defaultValue: never[];
-        description: string;
+    /**
+     * #slot
+     */
+    readonly refNames: {
+        readonly type: "stringArray";
+        readonly defaultValue: readonly [];
+        readonly description: "Possible refNames used by the SPARQL endpoint (ignored if \"refNamesQueryTemplate\" is provided)";
     };
-    additionalQueryParams: {
-        type: string;
-        defaultValue: never[];
-        description: string;
+    /**
+     * #slot
+     */
+    readonly additionalQueryParams: {
+        readonly type: "stringArray";
+        readonly defaultValue: readonly [];
+        readonly description: "Additional parameters to add to the query, e.g. \"format=JSON\"";
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-export default _default;
+export default SPARQLAdapterConfigSchema;
+export type SPARQLAdapterConfig = Instance<typeof SPARQLAdapterConfigSchema>;

package/esm/SPARQLAdapter/configSchema.js

@@ -1,5 +1,32 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-export default ConfigurationSchema('SPARQLAdapter', {
+/**
+ * #config SPARQLAdapter
+ * #trackType FeatureTrack
+ * #category adapter
+ * fetches features from a SPARQL endpoint, substituting the queried region into
+ * a query template
+ *
+ * #example
+ * `{refName}`, `{start}` and `{end}` are substituted per request, so the
+ * endpoint is queried for the visible window rather than the whole genome. The
+ * result columns become feature fields, so the query has to select at least
+ * `?start`, `?end` and a `?uniqueID`:
+ * ```js
+ * {
+ *   type: 'SPARQLAdapter',
+ *   endpoint: { uri: 'https://example.com/sparql' },
+ *   queryTemplate: `SELECT ?uniqueID ?start ?end ?strand ?name WHERE {
+ *     ?f a :Feature ; :ref "{refName}" ; :start ?start ; :end ?end .
+ *     FILTER(?start < {end} && ?end > {start})
+ *   }`,
+ *   refNamesQueryTemplate: 'SELECT DISTINCT ?refName WHERE { ?f :ref ?refName }',
+ * }
+ * ```
+ */
+const SPARQLAdapterConfigSchema = ConfigurationSchema('SPARQLAdapter', {
+    /**
+     * #slot
+     */
     endpoint: {
         type: 'fileLocation',
         defaultValue: {
@@ -8,24 +35,37 @@ export default ConfigurationSchema('SPARQLAdapter', {
         },
         description: 'URL of the SPARQL endpoint',
     },
+    /**
+     * #slot
+     */
     queryTemplate: {
         type: 'text',
         defaultValue: '',
         description: 'SPARQL query where {start} {end} and {refName} will get replaced for each call',
     },
+    /**
+     * #slot
+     */
     refNamesQueryTemplate: {
         type: 'text',
         defaultValue: '',
         description: 'SPARQL query that returns the possible refNames in a ?refName column',
     },
+    /**
+     * #slot
+     */
     refNames: {
         type: 'stringArray',
         defaultValue: [],
         description: 'Possible refNames used by the SPARQL endpoint (ignored if "refNamesQueryTemplate" is provided)',
     },
+    /**
+     * #slot
+     */
     additionalQueryParams: {
         type: 'stringArray',
         defaultValue: [],
         description: 'Additional parameters to add to the query, e.g. "format=JSON"',
     },
 }, { explicitlyTyped: true });
+export default SPARQLAdapterConfigSchema;

package/esm/SPARQLAdapter/index.js

@@ -1,5 +1,5 @@
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes';
-import configSchema from "./configSchema.js";
+import configSchema from './configSchema.js';
 export default function SPARQLAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'SPARQLAdapter',
@@ -8,6 +8,6 @@ export default function SPARQLAdapterF(pluginManager) {
         adapterMetadata: {
             category: 'Uncommon',
         },
-        getAdapterClass: () => import("./SPARQLAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./SPARQLAdapter.js').then(r => r.default),
     }));
 }

package/esm/index.js

@@ -1,23 +1,8 @@
 import Plugin from '@jbrowse/core/Plugin';
-import { getFileName } from '@jbrowse/core/util/tracks';
-import SPARQLAdapterF from "./SPARQLAdapter/index.js";
+import SPARQLAdapterF from './SPARQLAdapter/index.js';
 export default class RdfPlugin extends Plugin {
     name = 'RdfPlugin';
     install(pluginManager) {
         SPARQLAdapterF(pluginManager);
-        pluginManager.addToExtensionPoint('Core-guessAdapterForLocation', (adapterGuesser) => {
-            return (file, index, adapterHint) => {
-                const regexGuess = /\/sparql$/i;
-                const adapterName = 'SPARQLAdapter';
-                const fileName = getFileName(file);
-                if (regexGuess.test(fileName) || adapterHint === adapterName) {
-                    return {
-                        type: adapterName,
-                        endpoint: file,
-                    };
-                }
-                return adapterGuesser(file, index, adapterHint);
-            };
-        });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-rdf",
-  "version": "4.2.1",
+  "version": "5.0.0-beta.1",
   "type": "module",
   "description": "JBrowse 2 RDF resources",
   "keywords": [
@@ -21,11 +21,10 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^5.6.0",
-    "mobx": "^6.15.0",
+    "@jbrowse/mobx-state-tree": "^6.5.1",
+    "mobx": "^7.0.3",
     "rxjs": "^7.8.2",
-    "string-template": "^1.0.0",
-    "@jbrowse/core": "^4.2.1"
+    "@jbrowse/core": "^5.0.0-beta.1"
   },
   "publishConfig": {
     "access": "public"
@@ -35,14 +34,11 @@
     "build": "pnpm run /^build:/",
     "test": "cd ../..; jest --passWithNoTests plugins/rdf",
     "prebuild": "pnpm clean",
-    "build:esm": "tsc -p tsconfig.build.esm.json",
+    "build:esm": "node ../../node_modules/typescript7/bin/tsc --build tsconfig.build.esm.json",
     "clean": "rimraf esm *.tsbuildinfo"
   },
   "types": "esm/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./esm/index.d.ts",
-      "import": "./esm/index.js"
-    }
+    ".": "./esm/index.js"
   }
 }