@rdfx/sparql-client 0.0.1

package/dist/HttpSparqlBaseClient.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Abstract base class for HTTP-based SPARQL clients.
+ */
+export declare abstract class HttpSparqlBaseClient<RequestOptionsT extends HttpSparqlBaseClient.RequestOptions> {
+    protected defaultRequestOptions?: RequestOptionsT;
+    protected readonly endpointUrl: string;
+    constructor({ defaultRequestOptions, endpointUrl, }: HttpSparqlBaseClient.Parameters<RequestOptionsT>);
+    protected ensureOkResponse(response: Response): Promise<Response>;
+    protected fetch({ body, hardCodedHeaders, method, options, url, }: {
+        body: RequestInit["body"] | null;
+        hardCodedHeaders: {
+            accept: string | null;
+            contentType: string | null;
+        } | null;
+        method: RequestInit["method"];
+        options: RequestOptionsT | null;
+        url: URL;
+    }): Promise<Response>;
+    protected responseToError(response: Response): Promise<Error>;
+}
+export declare namespace HttpSparqlBaseClient {
+    interface Parameters<RequestOptionsT extends RequestOptions> {
+        defaultRequestOptions?: RequestOptionsT;
+        endpointUrl: string;
+    }
+    interface RequestOptions {
+        cache?: Request["cache"];
+        headers?: Headers;
+    }
+}
+//# sourceMappingURL=HttpSparqlBaseClient.d.ts.map

package/dist/HttpSparqlBaseClient.js

@@ -0,0 +1,70 @@
+/**
+ * Abstract base class for HTTP-based SPARQL clients.
+ */
+export class HttpSparqlBaseClient {
+    constructor({ defaultRequestOptions, endpointUrl, }) {
+        this.defaultRequestOptions = defaultRequestOptions;
+        this.endpointUrl = endpointUrl;
+    }
+    async ensureOkResponse(response) {
+        if (response.ok) {
+            return response;
+        }
+        throw await this.responseToError(response);
+    }
+    async fetch({ body, hardCodedHeaders, method, options, url, }) {
+        const mergedHeaders = new Headers();
+        // Keep track of which headers should be set vs. appended
+        // This is used to enforce the semantics that:
+        // - requestOptions headers overwrite (set) defaultRequestOptions headers
+        // - requestOptions headers don't overwrite (set) each other, but append
+        const setHeaderNames = new Set();
+        if (this.defaultRequestOptions?.headers) {
+            for (const [name, value,] of this.defaultRequestOptions.headers.entries()) {
+                mergedHeaders.append(name, value);
+                setHeaderNames.add(name);
+            }
+        }
+        if (options?.headers) {
+            for (const [name, value] of options.headers.entries()) {
+                if (setHeaderNames.has(name)) {
+                    mergedHeaders.set(name, value);
+                    setHeaderNames.delete(name); // Append if we see another header with that name.
+                }
+                else {
+                    mergedHeaders.append(name, value);
+                }
+            }
+        }
+        if (hardCodedHeaders?.accept) {
+            // Enforce our preference on accept
+            mergedHeaders.set("accept", hardCodedHeaders.accept);
+        }
+        if (hardCodedHeaders?.contentType) {
+            mergedHeaders.append("content-type", hardCodedHeaders.contentType);
+        }
+        else {
+            mergedHeaders.delete("content-type");
+        }
+        // if (this.logger.isLevelEnabled("trace")) {
+        //   this.logger.trace("request URL: %s", url);
+        //   this.logger.trace("request method: %s", method);
+        //   for (const [name, value] of mergedHeaders.entries()) {
+        //     this.logger.trace("request header: %s: %s", name, value);
+        //   }
+        //   if (body && typeof body === "string") {
+        //     this.logger.trace("request body (length=%s):\n%s", body.length, body);
+        //   }
+        // }
+        return await fetch(url, {
+            body,
+            // cache: options?.cache ?? this.defaultRequestOptions?.cache,
+            headers: mergedHeaders,
+            method,
+        });
+    }
+    async responseToError(response) {
+        return new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+    }
+}
+//# sourceMappingURL=HttpSparqlBaseClient.js.map

package/dist/HttpSparqlGraphStoreClient.d.ts

@@ -0,0 +1,20 @@
+import type { DataFactory, DefaultGraph, NamedNode, Quad } from "@rdfjs/types";
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+import type { SparqlGraphStoreClient } from "./SparqlGraphStoreClient.js";
+export declare class HttpSparqlGraphStoreClient extends HttpSparqlBaseClient<HttpSparqlGraphStoreClient.RequestOptions> implements SparqlGraphStoreClient {
+    private readonly dataFactory;
+    constructor({ dataFactory, ...superParameters }: HttpSparqlGraphStoreClient.Parameters);
+    deleteGraph(graph: DefaultGraph | NamedNode, options?: HttpSparqlGraphStoreClient.RequestOptions): Promise<boolean>;
+    getGraph(graph: DefaultGraph | NamedNode, options?: HttpSparqlGraphStoreClient.RequestOptions): Promise<readonly Quad[]>;
+    postGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Quad>, options?: HttpSparqlGraphStoreClient.RequestOptions): Promise<void>;
+    putGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Quad>, options?: HttpSparqlGraphStoreClient.RequestOptions): Promise<void>;
+    private graphUrl;
+    private postOrPutGraph;
+}
+export declare namespace HttpSparqlGraphStoreClient {
+    interface Parameters extends HttpSparqlBaseClient.Parameters<RequestOptions> {
+        dataFactory: DataFactory;
+    }
+    type RequestOptions = HttpSparqlBaseClient.RequestOptions;
+}
+//# sourceMappingURL=HttpSparqlGraphStoreClient.d.ts.map

package/dist/HttpSparqlGraphStoreClient.js

@@ -0,0 +1,91 @@
+import N3 from "n3";
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+export class HttpSparqlGraphStoreClient extends HttpSparqlBaseClient {
+    constructor({ dataFactory, ...superParameters }) {
+        super(superParameters);
+        this.dataFactory = dataFactory;
+    }
+    async deleteGraph(graph, options) {
+        const response = await this.fetch({
+            body: null,
+            hardCodedHeaders: null,
+            method: "DELETE",
+            options: options ?? null,
+            url: this.graphUrl(graph),
+        });
+        if (response.ok) {
+            return true;
+        }
+        if (response.status === 404) {
+            return false;
+        }
+        throw await this.responseToError(response);
+    }
+    async getGraph(graph, options) {
+        const response = await this.fetch({
+            body: null,
+            hardCodedHeaders: {
+                accept: "application/n-triples; charset=utf-8",
+                contentType: null,
+            },
+            method: "GET",
+            options: options ?? null,
+            url: this.graphUrl(graph),
+        });
+        if (response.ok) {
+            return new N3.Parser({
+                factory: this.dataFactory,
+                format: "application/n-triples",
+            }).parse(await response.text());
+        }
+        if (response.status === 404) {
+            return [];
+        }
+        throw await this.responseToError(response);
+    }
+    async postGraph(graph, payload, options) {
+        return this.postOrPutGraph(graph, "POST", payload, options);
+    }
+    async putGraph(graph, payload, options) {
+        return this.postOrPutGraph(graph, "PUT", payload, options);
+    }
+    graphUrl(graph) {
+        const url = new URL(this.endpointUrl);
+        switch (graph.termType) {
+            case "DefaultGraph":
+                url.searchParams.append("default", "");
+                break;
+            case "NamedNode":
+                url.searchParams.append("graph", graph.value);
+                break;
+        }
+        return url;
+    }
+    async postOrPutGraph(graph, method, payload, options) {
+        // Strip named graphs out of the payload quads, since everything should go to the same graph.
+        const quads = [];
+        for (const quad of payload) {
+            if (quad.graph.termType === "DefaultGraph") {
+                quads.push(quad);
+            }
+            else {
+                quads.push(this.dataFactory.quad(quad.subject, quad.predicate, quad.object));
+            }
+        }
+        await this.ensureOkResponse(await this.fetch({
+            body: new N3.Writer({
+                format: "application/n-triples",
+            })
+                .quadsToString(quads)
+                .trimEnd(),
+            hardCodedHeaders: {
+                accept: null,
+                contentType: "application/n-triples; charset=utf-8",
+            },
+            method,
+            options: options ?? null,
+            url: this.graphUrl(graph),
+        }));
+    }
+}
+//# sourceMappingURL=HttpSparqlGraphStoreClient.js.map

package/dist/HttpSparqlQueryClient.d.ts

@@ -0,0 +1,24 @@
+import type { BlankNode, DataFactory, Literal, NamedNode, Quad } from "@rdfjs/types";
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+import type { SparqlQueryClient } from "./SparqlQueryClient.js";
+export declare class HttpSparqlQueryClient extends HttpSparqlBaseClient<HttpSparqlQueryClient.RequestOptions> implements SparqlQueryClient {
+    private readonly dataFactory;
+    constructor({ dataFactory, ...superParameters }: HttpSparqlQueryClient.Parameters);
+    queryBindings(query: string, options?: HttpSparqlQueryClient.RequestOptions): Promise<readonly Record<string, BlankNode | Literal | NamedNode>[]>;
+    queryBoolean(query: string, options?: HttpSparqlQueryClient.RequestOptions): Promise<boolean>;
+    queryQuads(query: string, options?: HttpSparqlQueryClient.RequestOptions): Promise<readonly Quad[]>;
+    private request;
+    private requestOptionsToUrlSearchParams;
+}
+export declare namespace HttpSparqlQueryClient {
+    interface Parameters extends HttpSparqlBaseClient.Parameters<RequestOptions> {
+        dataFactory: DataFactory;
+    }
+    interface RequestOptions extends HttpSparqlBaseClient.RequestOptions {
+        defaultGraphUris?: readonly NamedNode[];
+        method?: "GET" | "POSTDirectly" | "POSTWithUrlEncodedParameters";
+        namedGraphUris?: readonly NamedNode[];
+        unionDefaultGraph?: boolean;
+    }
+}
+//# sourceMappingURL=HttpSparqlQueryClient.d.ts.map

package/dist/HttpSparqlQueryClient.js

@@ -0,0 +1,115 @@
+import N3 from "n3";
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+export class HttpSparqlQueryClient extends HttpSparqlBaseClient {
+    constructor({ dataFactory, ...superParameters }) {
+        super(superParameters);
+        this.dataFactory = dataFactory;
+    }
+    async queryBindings(query, options) {
+        const response = await this.request(query, {
+            accept: "application/sparql-results+json",
+        }, options);
+        // https://www.w3.org/TR/sparql11-results-json/
+        const json = (await response.json());
+        return json.results.bindings.map((jsonResultsBindings) => {
+            const rdfjsBinding = {};
+            for (const [key, value] of Object.entries(jsonResultsBindings)) {
+                switch (value.type) {
+                    case "bnode":
+                        rdfjsBinding[key] = this.dataFactory.blankNode(value.value);
+                        break;
+                    case "literal":
+                        if (value.datatype) {
+                            rdfjsBinding[key] = this.dataFactory.literal(value.value, this.dataFactory.namedNode(value.datatype));
+                        }
+                        else {
+                            rdfjsBinding[key] = this.dataFactory.literal(value.value, value["xml:lang"]);
+                        }
+                        break;
+                    case "uri":
+                        rdfjsBinding[key] = this.dataFactory.namedNode(value.value);
+                        break;
+                }
+            }
+            return rdfjsBinding;
+        });
+    }
+    async queryBoolean(query, options) {
+        const response = await this.request(query, {
+            accept: "application/sparql-results+json",
+        }, options);
+        return (await response.json()).boolean;
+    }
+    async queryQuads(query, options) {
+        const response = await this.request(query, {
+            accept: "application/n-triples",
+        }, options);
+        return new N3.Parser({
+            factory: this.dataFactory,
+            format: "application/n-triples",
+        }).parse(await response.text());
+    }
+    async request(query, { accept }, options) {
+        const method = options?.method ?? this.defaultRequestOptions?.method ?? "GET";
+        const url = new URL(this.endpointUrl);
+        switch (method) {
+            case "GET": {
+                url.searchParams.set("query", query);
+                this.requestOptionsToUrlSearchParams(url.searchParams, options);
+                return await this.ensureOkResponse(await this.fetch({
+                    body: null,
+                    hardCodedHeaders: { accept, contentType: null },
+                    method: "GET",
+                    options: options ?? null,
+                    url,
+                }));
+            }
+            case "POSTDirectly": {
+                this.requestOptionsToUrlSearchParams(url.searchParams, options);
+                return await this.ensureOkResponse(await this.fetch({
+                    body: query,
+                    hardCodedHeaders: {
+                        accept,
+                        contentType: "application/sparql-query; charset=utf-8",
+                    },
+                    method: "POST",
+                    options: options ?? null,
+                    url,
+                }));
+            }
+            case "POSTWithUrlEncodedParameters": {
+                const urlEncodedParameters = new URLSearchParams();
+                this.requestOptionsToUrlSearchParams(urlEncodedParameters, options);
+                urlEncodedParameters.set("query", query);
+                return await this.ensureOkResponse(await this.fetch({
+                    body: urlEncodedParameters,
+                    hardCodedHeaders: {
+                        accept,
+                        contentType: "application/x-www-form-urlencoded",
+                    },
+                    method: "POST",
+                    options: options ?? null,
+                    url,
+                }));
+            }
+        }
+    }
+    requestOptionsToUrlSearchParams(urlSearchParams, requestOptions) {
+        for (const defaultGraphUri of requestOptions?.defaultGraphUris ??
+            this.defaultRequestOptions?.defaultGraphUris ??
+            []) {
+            urlSearchParams.append("default-graph-uri", defaultGraphUri.value);
+        }
+        for (const namedGraphUri of requestOptions?.namedGraphUris ??
+            this.defaultRequestOptions?.namedGraphUris ??
+            []) {
+            urlSearchParams.append("named-graph-uri", namedGraphUri.value);
+        }
+        if (requestOptions?.unionDefaultGraph ??
+            this.defaultRequestOptions?.unionDefaultGraph ??
+            false) {
+            urlSearchParams.append("union-default-graph", "");
+        }
+    }
+}
+//# sourceMappingURL=HttpSparqlQueryClient.js.map

package/dist/HttpSparqlUpdateClient.d.ts

@@ -0,0 +1,17 @@
+import type { NamedNode } from "@rdfjs/types";
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+import type { SparqlUpdateClient } from "./SparqlUpdateClient.js";
+export declare class HttpSparqlUpdateClient extends HttpSparqlBaseClient<HttpSparqlUpdateClient.RequestOptions> implements SparqlUpdateClient {
+    update(update: string, options?: HttpSparqlUpdateClient.RequestOptions): Promise<void>;
+    private requestOptionsToUrlSearchParams;
+}
+export declare namespace HttpSparqlUpdateClient {
+    type Parameters = HttpSparqlBaseClient.Parameters<RequestOptions>;
+    interface RequestOptions extends HttpSparqlBaseClient.RequestOptions {
+        method?: "POSTDirectly" | "POSTWithUrlEncodedParameters";
+        usingGraphUris?: readonly NamedNode[];
+        usingNamedGraphUris?: readonly NamedNode[];
+        usingUnionGraph?: boolean;
+    }
+}
+//# sourceMappingURL=HttpSparqlUpdateClient.d.ts.map

package/dist/HttpSparqlUpdateClient.js

@@ -0,0 +1,56 @@
+import { HttpSparqlBaseClient } from "./HttpSparqlBaseClient.js";
+export class HttpSparqlUpdateClient extends HttpSparqlBaseClient {
+    async update(update, options) {
+        const method = options?.method ?? this.defaultRequestOptions?.method ?? "POSTDirectly";
+        const url = new URL(this.endpointUrl);
+        switch (method) {
+            case "POSTDirectly": {
+                this.requestOptionsToUrlSearchParams(url.searchParams, options);
+                await this.ensureOkResponse(await this.fetch({
+                    body: update,
+                    hardCodedHeaders: {
+                        accept: null,
+                        contentType: "application/sparql-update; charset=utf-8",
+                    },
+                    method: "POST",
+                    options: options ?? null,
+                    url,
+                }));
+                return;
+            }
+            case "POSTWithUrlEncodedParameters": {
+                const urlEncodedParameters = new URLSearchParams();
+                this.requestOptionsToUrlSearchParams(urlEncodedParameters, options);
+                urlEncodedParameters.set("update", update);
+                await this.ensureOkResponse(await this.fetch({
+                    body: urlEncodedParameters,
+                    hardCodedHeaders: {
+                        accept: null,
+                        contentType: "application/x-www-form-urlencoded",
+                    },
+                    method: "POST",
+                    options: options ?? null,
+                    url,
+                }));
+            }
+        }
+    }
+    requestOptionsToUrlSearchParams(urlSearchParams, requestOptions) {
+        for (const usingGraphUri of requestOptions?.usingGraphUris ??
+            this.defaultRequestOptions?.usingGraphUris ??
+            []) {
+            urlSearchParams.append("using-graph-uri", usingGraphUri.value);
+        }
+        for (const usingNamedGraphUri of requestOptions?.usingNamedGraphUris ??
+            this.defaultRequestOptions?.usingNamedGraphUris ??
+            []) {
+            urlSearchParams.append("using-named-graph-uri", usingNamedGraphUri.value);
+        }
+        if (requestOptions?.usingUnionGraph ??
+            this.defaultRequestOptions?.usingUnionGraph ??
+            false) {
+            urlSearchParams.append("using-union-graph", "");
+        }
+    }
+}
+//# sourceMappingURL=HttpSparqlUpdateClient.js.map

package/dist/LoggingSparqlBaseClient.d.ts

@@ -0,0 +1,15 @@
+import type { SparqlGraphStoreClient } from "./SparqlGraphStoreClient.js";
+import type { SparqlQueryClient } from "./SparqlQueryClient.js";
+import type { SparqlUpdateClient } from "./SparqlUpdateClient.js";
+type Logger = (message: string, ...parameters: (boolean | number | string)[]) => void;
+export declare class LoggingSparqlBaseClient<DelegateT extends SparqlGraphStoreClient | SparqlQueryClient | SparqlUpdateClient> {
+    protected delegate: DelegateT;
+    protected logger: Logger;
+    constructor({ delegate, logger }: {
+        delegate: DelegateT;
+        logger: Logger;
+    });
+    protected loggableQuery(query: string): string;
+}
+export {};
+//# sourceMappingURL=LoggingSparqlBaseClient.d.ts.map

package/dist/LoggingSparqlBaseClient.js

@@ -0,0 +1,10 @@
+export class LoggingSparqlBaseClient {
+    constructor({ delegate, logger }) {
+        this.delegate = delegate;
+        this.logger = logger;
+    }
+    loggableQuery(query) {
+        return query.replace(/\s+/g, " ").trim();
+    }
+}
+//# sourceMappingURL=LoggingSparqlBaseClient.js.map

package/dist/LoggingSparqlGraphStoreClient.d.ts

@@ -0,0 +1,11 @@
+import type { DatasetCore, DefaultGraph, NamedNode, Quad } from "@rdfjs/types";
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+import type { SparqlGraphStoreClient } from "./SparqlGraphStoreClient.js";
+export declare class LoggingSparqlGraphStoreClient extends LoggingSparqlBaseClient<SparqlGraphStoreClient> implements SparqlGraphStoreClient {
+    deleteGraph(graph: DefaultGraph | NamedNode): Promise<boolean>;
+    getGraph(graph: DefaultGraph | NamedNode): Promise<readonly Quad[]>;
+    postGraph(graph: DefaultGraph | NamedNode, payload: DatasetCore): Promise<void>;
+    putGraph(graph: DefaultGraph | NamedNode, payload: DatasetCore): Promise<void>;
+    private loggableGraph;
+}
+//# sourceMappingURL=LoggingSparqlGraphStoreClient.d.ts.map

package/dist/LoggingSparqlGraphStoreClient.js

@@ -0,0 +1,34 @@
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+export class LoggingSparqlGraphStoreClient extends LoggingSparqlBaseClient {
+    async deleteGraph(graph) {
+        this.logger("deleting graph %s", this.loggableGraph(graph));
+        const result = await this.delegate.deleteGraph(graph);
+        this.logger("deleted graph %s: %s", this.loggableGraph(graph), result);
+        return result;
+    }
+    async getGraph(graph) {
+        this.logger("getting dataset from %s", this.loggableGraph(graph));
+        const result = await this.delegate.getGraph(graph);
+        this.logger("got %d quads from %s", result.length, this.loggableGraph(graph));
+        return result;
+    }
+    async postGraph(graph, payload) {
+        this.logger("posting %d-quad dataset to %s", payload.size, this.loggableGraph(graph));
+        await this.delegate.postGraph(graph, payload);
+        this.logger("posted %d-quad dataset to %s", payload.size, this.loggableGraph(graph));
+    }
+    async putGraph(graph, payload) {
+        this.logger("putting %d-quad dataset to %s", payload.size, this.loggableGraph(graph));
+        await this.delegate.putGraph(graph, payload);
+        this.logger("put %d-quad dataset to %s", payload.size, this.loggableGraph(graph));
+    }
+    loggableGraph(graph) {
+        switch (graph.termType) {
+            case "DefaultGraph":
+                return "default graph";
+            case "NamedNode":
+                return `graph <${graph.value}>`;
+        }
+    }
+}
+//# sourceMappingURL=LoggingSparqlGraphStoreClient.js.map

package/dist/LoggingSparqlQueryClient.d.ts

@@ -0,0 +1,12 @@
+import type { BlankNode, Literal, NamedNode, Quad } from "@rdfjs/types";
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+import type { SparqlQueryClient } from "./SparqlQueryClient.js";
+/**
+ * SparqlClient implementation that logs queries and delegates actual work to another SparqlClient implementation.
+ */
+export declare class LoggingSparqlQueryClient extends LoggingSparqlBaseClient<SparqlQueryClient> implements SparqlQueryClient {
+    queryBindings(query: string): Promise<readonly Record<string, BlankNode | Literal | NamedNode>[]>;
+    queryBoolean(query: string): Promise<boolean>;
+    queryQuads(query: string): Promise<readonly Quad[]>;
+}
+//# sourceMappingURL=LoggingSparqlQueryClient.d.ts.map

package/dist/LoggingSparqlQueryClient.js

@@ -0,0 +1,34 @@
+import N3 from "n3";
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+/**
+ * SparqlClient implementation that logs queries and delegates actual work to another SparqlClient implementation.
+ */
+export class LoggingSparqlQueryClient extends LoggingSparqlBaseClient {
+    async queryBindings(query) {
+        this.logger(this.loggableQuery(query));
+        const result = await this.delegate.queryBindings(query);
+        this.logger("queryBindings results:\n%s", JSON.stringify(result, undefined, 2));
+        return result;
+    }
+    async queryBoolean(query) {
+        this.logger(this.loggableQuery(query));
+        const result = await this.delegate.queryBoolean(query);
+        this.logger("queryBoolean result: %s", result);
+        return result;
+    }
+    async queryQuads(query) {
+        this.logger(this.loggableQuery(query));
+        const result = await this.delegate.queryQuads(query);
+        this.logger("queryQuads result: %d quads", result.length);
+        // if (this.logger.isLevelEnabled("trace")) {
+        const writer = new N3.Writer({ format: "application/N-Quads" });
+        for (const quad of result) {
+            this.logger(writer
+                .quadToString(quad.subject, quad.predicate, quad.object, quad.graph)
+                .trimEnd());
+        }
+        // }
+        return result;
+    }
+}
+//# sourceMappingURL=LoggingSparqlQueryClient.js.map

package/dist/LoggingSparqlUpdateClient.d.ts

@@ -0,0 +1,9 @@
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+import type { SparqlUpdateClient } from "./SparqlUpdateClient.js";
+/**
+ * SparqlClient implementation that logs queries and delegates actual work to another SparqlClient implementation.
+ */
+export declare class LoggingSparqlUpdateClient extends LoggingSparqlBaseClient<SparqlUpdateClient> implements SparqlUpdateClient {
+    update(update: string): Promise<void>;
+}
+//# sourceMappingURL=LoggingSparqlUpdateClient.d.ts.map

package/dist/LoggingSparqlUpdateClient.js

@@ -0,0 +1,12 @@
+import { LoggingSparqlBaseClient } from "./LoggingSparqlBaseClient.js";
+/**
+ * SparqlClient implementation that logs queries and delegates actual work to another SparqlClient implementation.
+ */
+export class LoggingSparqlUpdateClient extends LoggingSparqlBaseClient {
+    async update(update) {
+        this.logger(this.loggableQuery(update));
+        await this.delegate.update(update);
+        this.logger("SPARQL update executed successfully");
+    }
+}
+//# sourceMappingURL=LoggingSparqlUpdateClient.js.map

package/dist/OxigraphSparqlClient.d.ts

@@ -0,0 +1,36 @@
+import type { BlankNode, DataFactory, DefaultGraph, Literal, NamedNode, Quad, Term } from "@rdfjs/types";
+import type { SparqlGraphStoreClient } from "./SparqlGraphStoreClient.js";
+import type { SparqlQueryClient } from "./SparqlQueryClient.js";
+import type { SparqlUpdateClient } from "./SparqlUpdateClient.js";
+interface Store {
+    add(quad: Quad): void;
+    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Quad[];
+    query(query: string, options?: {
+        base_iri?: NamedNode | string;
+        results_format?: string;
+        use_default_graph_as_union?: boolean;
+    }): boolean | Map<string, Term>[] | Quad[] | string;
+    update(update: string, options?: {
+        base_iri?: NamedNode | string;
+    }): void;
+}
+export declare class OxigraphSparqlClient implements SparqlGraphStoreClient, SparqlQueryClient, SparqlUpdateClient {
+    private readonly dataFactory;
+    private readonly store;
+    private readonly useDefaultGraphAsUnion;
+    constructor({ dataFactory, store, useDefaultGraphAsUnion, }: {
+        dataFactory: Pick<DataFactory, "quad">;
+        store: Store;
+        useDefaultGraphAsUnion?: boolean;
+    });
+    deleteGraph(graph: DefaultGraph | NamedNode): Promise<boolean>;
+    getGraph(graph: DefaultGraph | NamedNode): Promise<readonly Quad[]>;
+    postGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Quad>): Promise<void>;
+    putGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Quad>): Promise<void>;
+    queryBindings(query: string): Promise<readonly Record<string, BlankNode | Literal | NamedNode>[]>;
+    queryBoolean(query: string): Promise<boolean>;
+    queryQuads(query: string): Promise<readonly Quad[]>;
+    update(update: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=OxigraphSparqlClient.d.ts.map

package/dist/OxigraphSparqlClient.js

@@ -0,0 +1,71 @@
+export class OxigraphSparqlClient {
+    constructor({ dataFactory, store, useDefaultGraphAsUnion, }) {
+        this.dataFactory = dataFactory;
+        this.store = store;
+        this.useDefaultGraphAsUnion = !!useDefaultGraphAsUnion;
+    }
+    async deleteGraph(graph) {
+        // https://www.w3.org/TR/2013/REC-sparql11-http-rdf-update-20130321/#http-put
+        if (graph.termType === "DefaultGraph") {
+            this.store.update("DROP SILENT DEFAULT");
+            return true;
+        }
+        try {
+            this.store.update(`DROP GRAPH <${graph.value}>`);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.endsWith("does not exist")) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    async getGraph(graph) {
+        return [...this.store.match(null, null, null, graph)];
+    }
+    async postGraph(graph, payload) {
+        for (const quad of payload) {
+            this.store.add(this.dataFactory.quad(quad.subject, quad.predicate, quad.object, graph));
+        }
+    }
+    async putGraph(graph, payload) {
+        await this.deleteGraph(graph);
+        await this.postGraph(graph, payload);
+    }
+    async queryBindings(query) {
+        const bindings = [];
+        for (const map of this.store.query(query, {
+            use_default_graph_as_union: this.useDefaultGraphAsUnion,
+        })) {
+            const mapBindings = {};
+            for (const entry of map.entries()) {
+                switch (entry[1].termType) {
+                    case "BlankNode":
+                    case "Literal":
+                    case "NamedNode":
+                        mapBindings[entry[0]] = entry[1];
+                        break;
+                    default:
+                        throw new RangeError(entry[1].termType);
+                }
+            }
+            bindings.push(mapBindings);
+        }
+        return bindings;
+    }
+    async queryBoolean(query) {
+        return this.store.query(query, {
+            use_default_graph_as_union: this.useDefaultGraphAsUnion,
+        });
+    }
+    async queryQuads(query) {
+        return this.store.query(query, {
+            use_default_graph_as_union: this.useDefaultGraphAsUnion,
+        });
+    }
+    async update(update) {
+        this.store.update(update, {});
+    }
+}
+//# sourceMappingURL=OxigraphSparqlClient.js.map

package/dist/SparqlGraphStoreClient.d.ts

@@ -0,0 +1,44 @@
+import type { DefaultGraph, NamedNode, Quad } from "@rdfjs/types";
+export interface SparqlGraphStoreClient {
+    /**
+     * Delete a graph.
+     *
+     * https://www.w3.org/TR/sparql11-http-rdf-update/#http-delete
+     *
+     * @param graph name of the graph or the default graph
+     * @return true on a 20x response, false on a 404 response
+     * @throw on any other response status
+     */
+    deleteGraph(graph: DefaultGraph | NamedNode): Promise<boolean>;
+    /**
+     * Get the triples in a graph.
+     *
+     * https://www.w3.org/TR/sparql11-http-rdf-update/#http-get
+     *
+     * @param graph name of the graph or the default graph
+     */
+    getGraph(graph: DefaultGraph | NamedNode): Promise<readonly Quad[]>;
+    /**
+     * Post triples to a graph.
+     *
+     * https://www.w3.org/TR/sparql11-http-rdf-update/#http-post
+     *
+     * Ignores the graph part of every quad in the payload.
+     *
+     * @param graph name of the graph or the default graph
+     * @param payload iterable of triples
+     */
+    postGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Omit<Quad, "graph">>): Promise<void>;
+    /**
+     * Replace the contents of a graph with the given triples.
+     *
+     * https://www.w3.org/TR/sparql11-http-rdf-update/#http-put
+     *
+     * Ignores the graph part of every quad in the payload.
+     *
+     * @param graph name of the
+     * @param payload
+     */
+    putGraph(graph: DefaultGraph | NamedNode, payload: Iterable<Quad>): Promise<void>;
+}
+//# sourceMappingURL=SparqlGraphStoreClient.d.ts.map

package/dist/SparqlGraphStoreClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SparqlGraphStoreClient.js.map

package/dist/SparqlQueryClient.d.ts

@@ -0,0 +1,22 @@
+import type { BlankNode, Literal, NamedNode, Quad } from "@rdfjs/types";
+/**
+ * SPARQL 1.1 Protocol query operations (https://www.w3.org/TR/2013/REC-sparql11-protocol-20130321/#query-operation).
+ *
+ * Loosely modeled on the RDF/JS: Query specification (https://rdf.js.org/query-spec/#queryquads-interface),
+ * returning arrays rather than streams.
+ */
+export interface SparqlQueryClient {
+    /**
+     * SELECT queries.
+     */
+    queryBindings(query: string): Promise<readonly Record<string, BlankNode | Literal | NamedNode>[]>;
+    /**
+     * ASK queries.
+     */
+    queryBoolean(query: string): Promise<boolean>;
+    /**
+     * CONSTRUCT or DESCRIBE queries
+     */
+    queryQuads(query: string): Promise<readonly Quad[]>;
+}
+//# sourceMappingURL=SparqlQueryClient.d.ts.map

package/dist/SparqlQueryClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SparqlQueryClient.js.map

package/dist/SparqlUpdateClient.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SPARQL 1.1 Protocol update operation (https://www.w3.org/TR/2013/REC-sparql11-protocol-20130321/#update-operation).
+ */
+export interface SparqlUpdateClient {
+    update(update: string): Promise<void>;
+}
+//# sourceMappingURL=SparqlUpdateClient.d.ts.map

package/dist/SparqlUpdateClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SparqlUpdateClient.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./HttpSparqlGraphStoreClient.js";
+export * from "./HttpSparqlQueryClient.js";
+export * from "./HttpSparqlUpdateClient.js";
+export * from "./LoggingSparqlGraphStoreClient.js";
+export * from "./LoggingSparqlQueryClient.js";
+export * from "./LoggingSparqlUpdateClient.js";
+export * from "./OxigraphSparqlClient.js";
+export * from "./SparqlGraphStoreClient.js";
+export * from "./SparqlQueryClient.js";
+export * from "./SparqlUpdateClient.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./HttpSparqlGraphStoreClient.js";
+export * from "./HttpSparqlQueryClient.js";
+export * from "./HttpSparqlUpdateClient.js";
+export * from "./LoggingSparqlGraphStoreClient.js";
+export * from "./LoggingSparqlQueryClient.js";
+export * from "./LoggingSparqlUpdateClient.js";
+export * from "./OxigraphSparqlClient.js";
+export * from "./SparqlGraphStoreClient.js";
+export * from "./SparqlQueryClient.js";
+export * from "./SparqlUpdateClient.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "dependencies": {
+    "@rdfjs/types": "~2.0.1",
+    "@types/n3": "~1.26.0",
+    "n3": "~1.26.0"
+  },
+  "devDependencies": {
+    "oxigraph": "0.4.7"
+  },
+  "files": [
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/sparql-client",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run --project @rdfx/sparql-client"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.1"
+}