@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/rdf/RdfQuerySparqlEngine.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdfQuerySparqlEngine = void 0;
+const asynciterator_1 = require("asynciterator");
+const n3_1 = require("n3");
+const RdfAccessScope_1 = require("./RdfAccessScope");
+const RdfEngineRdfJsSource_1 = require("./RdfEngineRdfJsSource");
+const RdfSparqlBoundary_1 = require("./RdfSparqlBoundary");
+const RdfSparqlSerialization_1 = require("./RdfSparqlSerialization");
+const XpodComunicaQueryEngine_1 = require("./XpodComunicaQueryEngine");
+const { namedNode, quad } = n3_1.DataFactory;
+/**
+ * Public Cloud SPARQL authority.
+ *
+ * Comunica is the sole SPARQL algebra evaluator. Every RDF/JS source match is
+ * translated into an access-scoped query against the PostgreSQL RDF facts
+ * authority; there is no second evaluator or alternate per-query route.
+ */
+class RdfQuerySparqlEngine {
+    constructor(rdfEngine) {
+        this.rdfEngine = rdfEngine;
+        this.comunica = (0, XpodComunicaQueryEngine_1.createXpodComunicaQueryEngine)();
+    }
+    async queryBindings(query, basePath, accessScope, options) {
+        this.assertCloudQuery(query, basePath);
+        const abort = createQueryAbort(options);
+        try {
+            assertQueryNotAborted(abort.signal);
+            const result = await this.comunica.query(query, this.context(basePath, accessScope, abort.signal));
+            if (result.resultType !== 'bindings') {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError(`${result.resultType} query cannot produce bindings`);
+            }
+            const bindingsResult = result;
+            const bindings = await bindingsResult.execute();
+            bindings.metadata = bindingsResult.metadata.bind(bindingsResult);
+            return abort.watchStream(bindings);
+        }
+        catch (error) {
+            abort.dispose();
+            throw abort.normalize(error);
+        }
+    }
+    async queryBoolean(query, basePath, accessScope, options) {
+        this.assertCloudQuery(query, basePath);
+        const abort = createQueryAbort(options);
+        try {
+            assertQueryNotAborted(abort.signal);
+            const result = await this.comunica.query(query, this.context(basePath, accessScope, abort.signal));
+            if (result.resultType !== 'boolean') {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError(`${result.resultType} query cannot produce a boolean`);
+            }
+            return await result.execute();
+        }
+        catch (error) {
+            throw abort.normalize(error);
+        }
+        finally {
+            abort.dispose();
+        }
+    }
+    async queryQuads(query, basePath, accessScope, options) {
+        this.assertCloudQuery(query, basePath);
+        const abort = createQueryAbort(options);
+        try {
+            assertQueryNotAborted(abort.signal);
+            const result = await this.comunica.query(query, this.context(basePath, accessScope, abort.signal));
+            if (result.resultType !== 'quads') {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError(`${result.resultType} query cannot produce quads`);
+            }
+            return abort.watchStream(await result.execute());
+        }
+        catch (error) {
+            abort.dispose();
+            throw abort.normalize(error);
+        }
+    }
+    async queryVoid(_query, _basePath, _accessScope, _options) {
+        throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Direct SPARQL UPDATE execution is disabled; use the Pod update authority prepared-delta path', {
+            code: 'rdf.sparql.update_authority_required',
+            capability: 'sparql.update.authority',
+            hint: 'Send the update through the Pod SPARQL HTTP endpoint so the authority can prepare and atomically commit source-file changes.',
+        });
+    }
+    async constructGraph(graph, basePath, accessScope) {
+        if (!graph.startsWith(basePath) || (accessScope && !(0, RdfAccessScope_1.rdfAccessGraphAllowed)(graph, accessScope))) {
+            return new asynciterator_1.ArrayIterator([]);
+        }
+        const stream = await this.queryBindings(`SELECT ?s ?p ?o WHERE { GRAPH ${(0, RdfSparqlSerialization_1.serializeSparqlIri)(graph)} { ?s ?p ?o } }`, basePath, accessScope);
+        const graphNode = namedNode(graph);
+        const quads = [];
+        for await (const binding of stream) {
+            const subject = binding.get('s');
+            const predicate = binding.get('p');
+            const object = binding.get('o');
+            if (isQuadSubjectTerm(subject) && predicate?.termType === 'NamedNode' && isQuadObjectTerm(object)) {
+                quads.push(quad(subject, predicate, object, graphNode));
+            }
+        }
+        return new asynciterator_1.ArrayIterator(quads);
+    }
+    async listGraphs(basePath, accessScope) {
+        const stream = await this.queryBindings('SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }', basePath, accessScope);
+        const graphs = new Set();
+        for await (const binding of stream) {
+            const graph = binding.get('g');
+            if (graph?.termType === 'NamedNode') {
+                graphs.add(graph.value);
+            }
+        }
+        return (0, RdfAccessScope_1.filterRdfAccessGraphs)(graphs, {
+            ...accessScope,
+            basePath,
+            mode: RdfAccessScope_1.RdfAccessMode.READ,
+        });
+    }
+    async close() {
+        await this.rdfEngine.close();
+    }
+    context(basePath, accessScope, signal) {
+        const scope = {
+            ...accessScope,
+            basePath,
+            mode: RdfAccessScope_1.RdfAccessMode.READ,
+        };
+        return {
+            sources: [new RdfEngineRdfJsSource_1.RdfEngineRdfJsSource(this.rdfEngine, { accessScope: scope, signal })],
+            baseIRI: basePath,
+            readOnly: true,
+        };
+    }
+    assertCloudQuery(query, basePath) {
+        if ((0, RdfSparqlBoundary_1.assertServerOwnedNativeSparqlQuery)(query, basePath)) {
+            throw new RdfSparqlBoundary_1.DisabledSparqlFeatureError('QLever extension SERVICE clauses are disabled in public Cloud queries');
+        }
+    }
+}
+exports.RdfQuerySparqlEngine = RdfQuerySparqlEngine;
+function createQueryAbort(options) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const abortFromCaller = () => controller.abort(options?.signal?.reason);
+    if (options?.signal?.aborted) {
+        abortFromCaller();
+    }
+    else {
+        options?.signal?.addEventListener('abort', abortFromCaller, { once: true });
+    }
+    const timer = options?.timeoutMs === undefined
+        ? undefined
+        : setTimeout(() => {
+            timedOut = true;
+            controller.abort(new RdfSparqlBoundary_1.NativeSparqlTimeoutError(options.timeoutMs));
+        }, options.timeoutMs);
+    const dispose = () => {
+        if (timer)
+            clearTimeout(timer);
+        options?.signal?.removeEventListener('abort', abortFromCaller);
+    };
+    return {
+        signal: controller.signal,
+        dispose,
+        normalize(error) {
+            if (timedOut && options?.timeoutMs !== undefined) {
+                return new RdfSparqlBoundary_1.NativeSparqlTimeoutError(options.timeoutMs, errorMessage(error));
+            }
+            return error instanceof Error ? error : new Error(String(error));
+        },
+        watchStream(stream) {
+            stream.once('end', dispose);
+            stream.once('error', dispose);
+            const close = stream.close.bind(stream);
+            stream.close = () => {
+                dispose();
+                close();
+            };
+            const destroy = stream.destroy.bind(stream);
+            stream.destroy = (cause) => {
+                dispose();
+                destroy(cause);
+            };
+            const iterate = stream[Symbol.asyncIterator].bind(stream);
+            stream[Symbol.asyncIterator] = () => {
+                const iterator = iterate();
+                return {
+                    next: iterator.next.bind(iterator),
+                    return: async () => {
+                        stream.destroy();
+                        return { done: true, value: undefined };
+                    },
+                };
+            };
+            return stream;
+        },
+    };
+}
+function isQuadObjectTerm(term) {
+    return Boolean(term
+        && term.termType !== 'Variable'
+        && term.termType !== 'DefaultGraph'
+        && term.termType !== 'Quad');
+}
+function assertQueryNotAborted(signal) {
+    if (signal.aborted) {
+        throw signal.reason instanceof Error
+            ? signal.reason
+            : new DOMException('SPARQL query aborted', 'AbortError');
+    }
+}
+function isQuadSubjectTerm(term) {
+    return term?.termType === 'NamedNode' || term?.termType === 'BlankNode';
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=RdfQuerySparqlEngine.js.map

package/dist/storage/rdf/RdfQuerySparqlEngine.jsonld

@@ -0,0 +1,78 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine",
+      "@type": "Class",
+      "requireElement": "RdfQuerySparqlEngine",
+      "extends": [
+        "undefineds:dist/storage/sparql/SubgraphQueryEngine.jsonld#SparqlEngine"
+      ],
+      "comment": "Public Cloud SPARQL authority.  Comunica is the sole SPARQL algebra evaluator. Every RDF/JS source match is translated into an access-scoped query against the PostgreSQL RDF facts authority; there is no second evaluator or alternate per-query route.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine_rdfEngine",
+          "range": "undefineds:dist/storage/rdf/types.jsonld#RdfEngineLike"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_rdfEngine",
+          "memberFieldName": "rdfEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_comunica",
+          "memberFieldName": "comunica"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_queryBindings",
+          "memberFieldName": "queryBindings"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_queryBoolean",
+          "memberFieldName": "queryBoolean"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_queryQuads",
+          "memberFieldName": "queryQuads"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_queryVoid",
+          "memberFieldName": "queryVoid"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_constructGraph",
+          "memberFieldName": "constructGraph"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_listGraphs",
+          "memberFieldName": "listGraphs"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_close",
+          "memberFieldName": "close"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_context",
+          "memberFieldName": "context"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine__member_assertCloudQuery",
+          "memberFieldName": "assertCloudQuery"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuerySparqlEngine.jsonld#RdfQuerySparqlEngine_rdfEngine"
+        }
+      ]
+    }
+  ]
+}

package/dist/storage/rdf/RdfSparqlAdapter.d.ts

@@ -73,10 +73,6 @@ export declare class UnsupportedSparqlQueryError extends Error {
 export declare class DisabledSparqlFeatureError extends Error {
     constructor(message: string);
 }
-export declare class NativeSparqlExecutionError extends Error {
-    readonly code = "rdf.sparql.native_execution_error";
-    constructor(message: string);
-}
 export declare function sparqlCorrectionForCapability(capability: string): SparqlCorrection;
 export declare class RdfSparqlAdapter {
     assertServerOwnedNativeQuery(query: string, basePath: string): void;