@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/SparqlClient-UPc88SHy.d.mts

@@ -0,0 +1,290 @@
+import { _ as Quad, d as NamedNode, s as GroundTerm } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { nt as Update, q as Query } from "./Ast-vcw2W-lf.mjs";
+import { t as Bindings } from "./Bindings-DiKpBd7f.mjs";
+import { a as SparqlClientError } from "./ClientErrors-D4IZHUM-.mjs";
+import { f as ResultSet, n as BooleanResult } from "./Results-BVNEC-Wt.mjs";
+import { r as Builder, u as Row$1 } from "./QueryBuilder-DUqh4ECe.mjs";
+import { n as ResultEvent } from "./ResultsStream-toYMXrOe.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/http/HttpClient";
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+declare namespace SparqlClient_d_exports {
+  export { Config, DEFAULT_RESULTS_ACCEPT, GraphIri, GraphTarget, Method, QueryInput, QueryOptions, QueryResult, RequestOptions, Row, SelectAccessor, SparqlClient, SparqlClientShape, UpdateInput, UpdateOptions, UploadOptions, ask, construct, decode, layer, make, select, toSparql, update };
+}
+/**
+ * How queries are sent: `get` (URL query string), `post`
+ * (`application/sparql-query` body) or `auto` (`GET` unless the URL would
+ * exceed `maxGetLength`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Method = 'auto' | 'get' | 'post';
+/**
+ * Client configuration.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Config {
+  /** The SPARQL query endpoint URL. */
+  readonly endpoint: string;
+  /** The SPARQL update endpoint URL (default: `endpoint`). */
+  readonly updateEndpoint?: string | undefined;
+  /** The Graph Store Protocol endpoint URL (required for graph operations). */
+  readonly graphStoreEndpoint?: string | undefined;
+  /** Headers sent with every request (e.g. `authorization`). */
+  readonly headers?: Readonly<Record<string, string>> | undefined;
+  /** How queries are sent (default `auto`). */
+  readonly method?: Method | undefined;
+  /** The longest URL sent with `GET` in `auto` mode (default 2048). */
+  readonly maxGetLength?: number | undefined;
+  /** Time limit for receiving a response (headers). */
+  readonly timeout?: Duration.Input | undefined;
+  /**
+   * Retry policy for transient failures (transport errors, timeouts and the
+   * statuses 408, 429, 502, 503 and 504; see `retryWhile`).
+   */
+  readonly retry?: Schedule.Schedule<unknown, SparqlClientError> | undefined;
+  /** Which errors are retried (default `ClientErrors.isTransient`). */
+  readonly retryWhile?: ((error: SparqlClientError) => boolean) | undefined;
+  /** The `Accept` header of `SELECT` / `ASK` requests. */
+  readonly resultsAccept?: string | undefined;
+  /** The media type used to upload graphs (default `application/n-triples`). */
+  readonly graphMediaType?: string | undefined;
+}
+/**
+ * A query: SPARQL text, a parsed query or a `QueryBuilder` builder.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type QueryInput = string | Query | Builder<'Select', any, any> | Builder<'Ask', any, any> | Builder<'Construct', any, any> | Builder<'Describe', any, any>;
+/**
+ * An update: SPARQL text or a parsed update.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type UpdateInput = string | Update;
+/**
+ * A graph IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GraphIri = string | NamedNode;
+/**
+ * The graph of a Graph Store operation: `'default'` or a named graph.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GraphTarget = 'default' | NamedNode;
+/**
+ * Per-request options.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface RequestOptions {
+  /** Extra headers. */
+  readonly headers?: Readonly<Record<string, string>> | undefined;
+  /** Overrides the configured timeout. */
+  readonly timeout?: Duration.Input | undefined;
+}
+/**
+ * Options of query requests.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface QueryOptions extends RequestOptions {
+  /** `default-graph-uri` parameters. */
+  readonly defaultGraphs?: ReadonlyArray<GraphIri> | undefined;
+  /** `named-graph-uri` parameters. */
+  readonly namedGraphs?: ReadonlyArray<GraphIri> | undefined;
+  /** Overrides the configured method. */
+  readonly method?: Method | undefined;
+}
+/**
+ * Options of update requests.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface UpdateOptions extends RequestOptions {
+  /** `using-graph-uri` parameters. */
+  readonly usingGraphs?: ReadonlyArray<GraphIri> | undefined;
+  /** `using-named-graph-uri` parameters. */
+  readonly usingNamedGraphs?: ReadonlyArray<GraphIri> | undefined;
+}
+/**
+ * Options of Graph Store uploads.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface UploadOptions extends RequestOptions {
+  /** The media type to upload with (default: the configured one). */
+  readonly mediaType?: string | undefined;
+}
+/**
+ * An untyped `SELECT` row.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Row = Readonly<Record<string, GroundTerm>>;
+/**
+ * The materialised result of any query.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type QueryResult = ResultSet | BooleanResult | {
+  readonly _tag: 'Graph';
+  readonly dataset: Dataset;
+};
+/**
+ * The client service.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SparqlClientShape {
+  readonly config: Config;
+  /** Streams the rows of a `SELECT` query (typed for builders). */
+  readonly select: {
+    <R extends string, O extends string>(query: Builder<'Select', R, O>, options?: QueryOptions): Stream.Stream<Row$1<R, O>, SparqlClientError>;
+    (query: string | Query, options?: QueryOptions): Stream.Stream<Row, SparqlClientError>;
+  };
+  /** Streams the solutions of a `SELECT` query. */
+  readonly selectBindings: (query: QueryInput, options?: QueryOptions) => Stream.Stream<Bindings, SparqlClientError>;
+  /** Streams the raw events (variables, solutions, boolean) of a results document. */
+  readonly results: (query: QueryInput, options?: QueryOptions) => Stream.Stream<ResultEvent, SparqlClientError>;
+  /** Collects a `SELECT` result, with its variables. */
+  readonly selectAll: (query: QueryInput, options?: QueryOptions) => Effect.Effect<ResultSet, SparqlClientError>;
+  /** Evaluates an `ASK` query. */
+  readonly ask: (query: QueryInput, options?: QueryOptions) => Effect.Effect<boolean, SparqlClientError>;
+  /** Streams the triples of a `CONSTRUCT` (or `DESCRIBE`) query. */
+  readonly construct: (query: QueryInput, options?: QueryOptions) => Stream.Stream<Quad, SparqlClientError>;
+  /** Streams the triples of a `DESCRIBE` query. */
+  readonly describe: (query: QueryInput, options?: QueryOptions) => Stream.Stream<Quad, SparqlClientError>;
+  /** Collects the triples of a `CONSTRUCT` / `DESCRIBE` query. */
+  readonly constructDataset: (query: QueryInput, options?: QueryOptions) => Effect.Effect<Dataset, SparqlClientError>;
+  /** Evaluates a query of any form, dispatching on the response media type. */
+  readonly query: (query: QueryInput, options?: QueryOptions) => Effect.Effect<QueryResult, SparqlClientError>;
+  /** Executes an update request. */
+  readonly update: (update: UpdateInput, options?: UpdateOptions) => Effect.Effect<void, SparqlClientError>;
+  /** Streams the triples of a graph (Graph Store `GET`). */
+  readonly getGraph: (graph: GraphTarget, options?: RequestOptions) => Stream.Stream<Quad, SparqlClientError>;
+  /** Fetches a graph as a `Dataset` (triples in the default graph). */
+  readonly getGraphDataset: (graph: GraphTarget, options?: RequestOptions) => Effect.Effect<Dataset, SparqlClientError>;
+  /** Whether a graph exists (Graph Store `HEAD`). */
+  readonly hasGraph: (graph: GraphTarget, options?: RequestOptions) => Effect.Effect<boolean, SparqlClientError>;
+  /** Replaces a graph (Graph Store `PUT`). */
+  readonly putGraph: (graph: GraphTarget, triples: Iterable<Quad>, options?: UploadOptions) => Effect.Effect<void, SparqlClientError>;
+  /** Adds triples to a graph (Graph Store `POST`). */
+  readonly postGraph: (graph: GraphTarget, triples: Iterable<Quad>, options?: UploadOptions) => Effect.Effect<void, SparqlClientError>;
+  /** Creates a new graph in the graph store and returns its IRI. */
+  readonly createGraph: (triples: Iterable<Quad>, options?: UploadOptions) => Effect.Effect<NamedNode, SparqlClientError>;
+  /** Deletes a graph (Graph Store `DELETE`). */
+  readonly deleteGraph: (graph: GraphTarget, options?: RequestOptions) => Effect.Effect<void, SparqlClientError>;
+}
+declare const SparqlClient_base: Context.ServiceClass<SparqlClient, "@thomasfosterau/effect-rdf/sparql/SparqlClient", SparqlClientShape>;
+/**
+ * The SPARQL client service.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+declare class SparqlClient extends SparqlClient_base {}
+/**
+ * The default `Accept` header of `SELECT` / `ASK` requests.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+declare const DEFAULT_RESULTS_ACCEPT = "application/sparql-results+json, application/sparql-results+xml;q=0.9, text/tab-separated-values;q=0.8, text/csv;q=0.5";
+/**
+ * The SPARQL text of a query or update input.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const toSparql: (input: QueryInput | UpdateInput) => string;
+/**
+ * Builds a client from configuration, using the `HttpClient` from the context
+ * and the `Serialization.Formats` service when provided (the default formats
+ * otherwise).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (config: Config) => Effect.Effect<SparqlClientShape, never, HttpClient.HttpClient>;
+/**
+ * A layer providing the client (requires an `HttpClient`, e.g.
+ * `FetchHttpClient.layer`).
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: (config: Config) => Layer.Layer<SparqlClient, never, HttpClient.HttpClient>;
+/**
+ * The type of the {@link select} accessor: `SparqlClientShape['select']`
+ * with the `SparqlClient` taken from the context.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+interface SelectAccessor {
+  <R extends string, O extends string>(query: Builder<'Select', R, O>, options?: QueryOptions): Stream.Stream<Row$1<R, O>, SparqlClientError, SparqlClient>;
+  (query: string | Query, options?: QueryOptions): Stream.Stream<Row, SparqlClientError, SparqlClient>;
+}
+/**
+ * Streams the rows of a `SELECT` query with the `SparqlClient` from the
+ * context. Builder queries produce typed rows.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+declare const select: SelectAccessor;
+/**
+ * Streams the rows of a `SELECT` query decoded with a schema (whose fields
+ * are typically `TermSchema` codecs).
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+declare const decode: <A, RD>(query: QueryInput, schema: Schema.Decoder<A, RD>, options?: QueryOptions) => Stream.Stream<A, SparqlClientError | Schema.SchemaError, SparqlClient | RD>;
+/**
+ * Evaluates an `ASK` query with the `SparqlClient` from the context.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+declare const ask: (query: QueryInput, options?: QueryOptions) => Effect.Effect<boolean, SparqlClientError, SparqlClient>;
+/**
+ * Streams the triples of a `CONSTRUCT` / `DESCRIBE` query with the
+ * `SparqlClient` from the context.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+declare const construct: (query: QueryInput, options?: QueryOptions) => Stream.Stream<Quad, SparqlClientError, SparqlClient>;
+/**
+ * Executes an update with the `SparqlClient` from the context.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+declare const update: (input: UpdateInput, options?: UpdateOptions) => Effect.Effect<void, SparqlClientError, SparqlClient>;
+export { select as C, make as S, update as T, UploadOptions as _, Method as a, decode as b, QueryResult as c, SelectAccessor as d, SparqlClient as f, UpdateOptions as g, UpdateInput as h, GraphTarget as i, RequestOptions as l, SparqlClient_d_exports as m, DEFAULT_RESULTS_ACCEPT as n, QueryInput as o, SparqlClientShape as p, GraphIri as r, QueryOptions as s, Config as t, Row as u, ask as v, toSparql as w, layer as x, construct as y };
+//# sourceMappingURL=SparqlClient-UPc88SHy.d.mts.map

package/dist/SparqlServer-CbUW-pVj.d.mts

@@ -0,0 +1,71 @@
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { a as Formats } from "./Serialization-Df8iVauT.mjs";
+import { a as QuadStore } from "./Store-D0jmVfb3.mjs";
+import { o as SparqlEngine, t as EngineOptions } from "./Engine-CYPB3g4h.mjs";
+import { n as Options } from "./Options-BommQwP9.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as HttpServer from "effect/http/HttpServer";
+declare namespace SparqlServer_d_exports {
+  export { Requirements, graphStoreHandler, handler, layerMemoryServices, layerRoutes, layerServe, sparqlHandler };
+}
+/**
+ * The services a server needs.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Requirements = SparqlEngine | QuadStore | Formats;
+/**
+ * The SPARQL endpoint (query, update and service description) as an HTTP
+ * app.
+ *
+ * @since 0.1.0
+ * @category handlers
+ */
+declare const sparqlHandler: (options?: Options) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | Requirements>;
+/**
+ * The Graph Store Protocol endpoint as an HTTP app.
+ *
+ * @since 0.1.0
+ * @category handlers
+ */
+declare const graphStoreHandler: (options?: Options) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | QuadStore | Formats>;
+/**
+ * The whole server as one HTTP app: routes requests to the SPARQL endpoint(s)
+ * and the graph store by path, and answers `404` otherwise.
+ *
+ * @since 0.1.0
+ * @category handlers
+ */
+declare const handler: (options?: Options) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | Requirements>;
+/**
+ * Registers the server's routes on the `HttpRouter`: the SPARQL endpoint(s),
+ * the graph store root and everything below it (direct graph
+ * identification).
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerRoutes: (options?: Options) => Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", Requirements>>;
+/**
+ * Serves the routes with `HttpRouter.serve` on an `HttpServer` from the
+ * context (logging requests unless `logging: false`).
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerServe: (options?: Options) => Layer.Layer<never, never, HttpServer.HttpServer | Requirements>;
+/**
+ * The services of an in-memory server: the engine over an in-memory store
+ * (optionally pre-loaded) and the default formats.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerMemoryServices: (data?: Dataset, engineOptions?: EngineOptions) => Layer.Layer<Requirements>;
+export { layerMemoryServices as a, sparqlHandler as c, handler as i, SparqlServer_d_exports as n, layerRoutes as o, graphStoreHandler as r, layerServe as s, Requirements as t };
+//# sourceMappingURL=SparqlServer-CbUW-pVj.d.mts.map

package/dist/SparqlServer-Db7w7Cll.mjs

@@ -0,0 +1,308 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { s as make } from "./PrefixMap-BHFPDLO-.mjs";
+import { t as Formats } from "./Serialization-DP9H5bYQ.mjs";
+import { n as SparqlEngine, r as layer } from "./Engine-DF8PN7g-.mjs";
+import { i as parseQuery, s as parseUpdate } from "./Parser-xARsOWXk.mjs";
+import { i as layerMemory, t as QuadStore } from "./Store-DH3Ow1GO.mjs";
+import { d as codecs, m as negotiate } from "./Results-peJjGA2V.mjs";
+import { a as internal, c as notFound, i as forbidden, l as timeout, r as badRequest, s as notAcceptable, u as toResponse } from "./ProtocolErrors-czDPVcX5.mjs";
+import { a as serializerMediaTypes, i as negotiateSerializer, r as layer$1 } from "./ServerFormats-CrRnjjf6.mjs";
+import { i as resolve, n as requestPath, r as requestUrl } from "./Options-BLBGL4HE.mjs";
+import { o as decode } from "./Protocol-BA7OkNgp.mjs";
+import { n as handle } from "./GraphStore-DvbqwKy1.mjs";
+import { r as describe, t as SD } from "./ServiceDescription-Dq5hxeGy.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Headers from "effect/http/Headers";
+import * as Cause from "effect/Cause";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import * as HttpMiddleware from "effect/http/HttpMiddleware";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as Fiber from "effect/Fiber";
+import * as Queue from "effect/Queue";
+// src/sparql/internal/prefetch.ts
+/** Raised when a query exceeds its time limit. */
+var QueryTimeout = class extends Schema.TaggedError()("QueryTimeout", {}) {};
+/**
+* Starts evaluating a stream in the background and waits for its first
+* element (or its end or failure), so that errors raised before the first
+* result — and a timeout — can still be answered with a proper HTTP status.
+* The returned stream yields every element; the whole evaluation is limited
+* by `timeout` when given.
+*/
+const prefetch = (stream, timeout) => Effect.gen(function* () {
+	const queue = yield* Queue.bounded(256);
+	const run = Stream.runIntoQueue(stream, queue);
+	const limited = timeout === void 0 ? run : Effect.timeoutOrElse(run, {
+		duration: timeout,
+		orElse: () => Queue.fail(queue, new QueryTimeout())
+	});
+	const fiber = yield* Effect.forkDetach(limited);
+	const first = yield* Queue.take(queue).pipe(Effect.map(Option.some), Effect.catchIf(Cause.isDone, () => Effect.succeed(Option.none())), Effect.onError(() => Fiber.interrupt(fiber)));
+	if (Option.isNone(first)) return Stream.empty;
+	return Stream.concat(Stream.succeed(first.value), Stream.fromQueue(queue)).pipe(Stream.ensuring(Fiber.interrupt(fiber)));
+});
+// src/sparql/SparqlServer.ts
+/**
+* A SPARQL 1.1 Protocol and Graph Store HTTP Protocol server built on
+* `effect/http`.
+*
+* The server needs the `SparqlEngine` and `QuadStore` services (`Engine`,
+* `Store`) and the core `Serialization.Formats`
+* service (see `ServerFormats.layer` for the defaults). It is available as
+*
+* - `handler(options)`: a plain HTTP app (`Effect` of a response, given the
+*   `HttpServerRequest`) that routes the endpoint paths itself;
+* - `layerRoutes(options)`: routes registered on an `HttpRouter`, to mount
+*   into your own server;
+* - `layerServe(options)`: the routes served on the `HttpServer` from the
+*   context, whatever platform provides it.
+*
+* Everything here is platform-neutral. A complete Node HTTP server (and the
+* `effect-sparql-server` command) is `NodeSparqlServer` in
+* `@thomasfosterau/effect-sparql-node`.
+*
+* @since 0.1.0
+*/
+var SparqlServer_exports = /* @__PURE__ */ __exportAll({
+	graphStoreHandler: () => graphStoreHandler,
+	handler: () => handler,
+	layerMemoryServices: () => layerMemoryServices,
+	layerRoutes: () => layerRoutes,
+	layerServe: () => layerServe,
+	sparqlHandler: () => sparqlHandler
+});
+const formatParseError = (e) => `Syntax error at line ${e.line}, column ${e.column}: ${e.message}`;
+const fromEngineError = (failure) => {
+	return Match.value(failure).pipe(Match.tag("SparqlParseError", (e) => badRequest(formatParseError(e))), Match.tag("UpdateError", (e) => badRequest(e.message)), Match.tag("EvaluationError", (e) => internal(e.message)), Match.tag("StoreError", (e) => internal(e.message)), Match.tag("QueryTimeout", () => timeout("The request exceeded the time limit")), Match.exhaustive);
+};
+const withTimeout = (effect, timeout) => timeout === void 0 ? effect : Effect.timeoutOrElse(effect, {
+	duration: timeout,
+	orElse: () => Effect.fail(new QueryTimeout())
+});
+const charsetUtf8 = (mediaType) => `${mediaType}; charset=utf-8`;
+const isGraphForm = (q) => Predicate.isTagged(q, "Construct") || Predicate.isTagged(q, "Describe");
+const runQuery = (options, operation, baseIri) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const engine = yield* SparqlEngine;
+	const formats = yield* Formats;
+	const accept = request.headers["accept"];
+	yield* Effect.annotateCurrentSpan({ "sparql.query": operation.query });
+	yield* Effect.logDebug("SPARQL query").pipe(Effect.annotateLogs({ query: operation.query }));
+	const parsed = yield* parseQuery(operation.query, { baseIri }).pipe(Effect.mapError((e) => badRequest(formatParseError(e))));
+	const query = operation.dataset !== void 0 ? {
+		...parsed,
+		dataset: void 0
+	} : parsed;
+	const requestOptions = {
+		baseIri,
+		dataset: operation.dataset
+	};
+	if (isGraphForm(query)) {
+		const serializer = negotiateSerializer(formats, accept);
+		if (serializer === void 0) return yield* notAcceptable(accept ?? "", serializerMediaTypes(formats));
+		const constructed = Effect.flatMap(engine.construct(query, requestOptions), (s) => prefetch(options.maxResults === void 0 ? s : Stream.take(s, options.maxResults), options.queryTimeout));
+		const quads = yield* Effect.mapError(withTimeout(constructed, options.queryTimeout), fromEngineError);
+		const body = serializer.serializeStream(quads, { prefixes: make(options.prefixes) });
+		return HttpServerResponse.stream(Stream.encodeText(body), { contentType: charsetUtf8(serializer.format.mediaType) });
+	}
+	const codec = negotiate(accept);
+	if (Option.isNone(codec)) return yield* notAcceptable(accept ?? "", codecs.flatMap((c) => c.format.mediaTypes));
+	const evaluated = Effect.flatMap(engine.query(query, requestOptions), (r) => {
+		if (Predicate.isTagged(r, "Ask")) return Effect.succeedSome(r);
+		if (!Predicate.isTagged(r, "Select")) return Effect.succeedNone;
+		const bindings = options.maxResults === void 0 ? r.bindings : Stream.take(r.bindings, options.maxResults);
+		return Effect.map(prefetch(bindings, options.queryTimeout), (b) => Option.some({
+			...r,
+			bindings: b
+		}));
+	});
+	const result = yield* Effect.mapError(withTimeout(evaluated, options.queryTimeout), fromEngineError);
+	if (Option.isNone(result)) return yield* internal("Unexpected graph result");
+	const body = codec.value.serialize(result.value);
+	return HttpServerResponse.stream(Stream.encodeText(body), { contentType: charsetUtf8(codec.value.format.mediaType) });
+}).pipe(Effect.withSpan("SparqlServer.query"));
+const declaresDataset = (op) => Predicate.isTagged(op, "Modify") && (op.using !== void 0 || op.with !== void 0);
+const runUpdate = (options, operation, baseIri) => Effect.gen(function* () {
+	const engine = yield* SparqlEngine;
+	yield* Effect.annotateCurrentSpan({ "sparql.update": operation.update });
+	yield* Effect.logDebug("SPARQL update").pipe(Effect.annotateLogs({ update: operation.update }));
+	if (options.readOnly) return yield* forbidden("This endpoint is read-only");
+	const update = yield* parseUpdate(operation.update, { baseIri }).pipe(Effect.mapError((e) => badRequest(formatParseError(e))));
+	if (operation.using !== void 0 && update.operations.some(declaresDataset)) return yield* badRequest("using-graph-uri / using-named-graph-uri cannot be combined with USING, USING NAMED or WITH");
+	yield* Effect.mapError(withTimeout(engine.update(update, {
+		baseIri,
+		dataset: operation.using
+	}), options.updateTimeout), fromEngineError);
+	return HttpServerResponse.empty({ status: 204 });
+}).pipe(Effect.withSpan("SparqlServer.update"));
+const serviceDescription = (options, url) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const store = yield* QuadStore;
+	const formats = yield* Formats;
+	const accept = request.headers["accept"];
+	const serializer = negotiateSerializer(formats, accept);
+	if (serializer === void 0) return yield* notAcceptable(accept ?? "", serializerMediaTypes(formats));
+	const graphs = yield* Stream.runCollect(Stream.take(store.graphs, 1e3)).pipe(Effect.mapError((e) => internal(e.message)));
+	const endpoint = new URL(options.path, url).href;
+	const quads = describe({
+		endpoint,
+		updateEndpoint: options.readOnly ? void 0 : new URL(options.updatePath, url).href,
+		formats,
+		unionDefaultGraph: options.unionDefaultGraph,
+		federation: options.federation,
+		namedGraphs: graphs.filter((g) => Predicate.isTagged(g, "NamedNode"))
+	});
+	const text = yield* serializer.serialize(quads, { prefixes: make({
+		sd: SD,
+		...options.prefixes
+	}) }).pipe(Effect.mapError((e) => internal(e.message)));
+	const contentType = charsetUtf8(serializer.format.mediaType);
+	return request.method === "HEAD" ? HttpServerResponse.empty({
+		status: 200,
+		headers: { "content-type": contentType }
+	}) : HttpServerResponse.text(text, { contentType });
+}).pipe(Effect.withSpan("SparqlServer.serviceDescription"));
+const endpoint = (options, kind) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const url = requestUrl(request, options);
+	const base = new URL(url.href);
+	base.search = "";
+	const baseIri = options.baseIri ?? base.href;
+	const decoded = yield* decode(request, kind, baseIri);
+	return yield* Match.value(decoded).pipe(Match.tag("Query", (operation) => Effect.gen(function* () {
+		return yield* runQuery(options, operation, baseIri);
+	})), Match.tag("Update", (operation) => Effect.gen(function* () {
+		return yield* runUpdate(options, operation, baseIri);
+	})), Match.tag("ServiceDescription", () => Effect.gen(function* () {
+		if (!options.serviceDescription) return yield* badRequest("Missing 'query' parameter");
+		return yield* serviceDescription(options, url);
+	})), Match.exhaustive);
+});
+const corsHeaders = (cors, request, preflight) => {
+	const headers = {};
+	const origin = request.headers["origin"];
+	const allowed = cors.allowedOrigins;
+	if (allowed === void 0 || Arr.isReadonlyArrayEmpty(allowed)) headers["access-control-allow-origin"] = "*";
+	else if (origin !== void 0 && allowed.includes(origin)) {
+		headers["access-control-allow-origin"] = origin;
+		headers["vary"] = "Origin";
+	} else headers["vary"] = "Origin";
+	if (cors.credentials === true) headers["access-control-allow-credentials"] = "true";
+	if (cors.exposedHeaders !== void 0 && Arr.isReadonlyArrayNonEmpty(cors.exposedHeaders)) headers["access-control-expose-headers"] = cors.exposedHeaders.join(", ");
+	if (preflight) {
+		headers["access-control-allow-methods"] = "GET, HEAD, POST, PUT, DELETE, OPTIONS";
+		const requested = request.headers["access-control-request-headers"];
+		if (cors.allowedHeaders !== void 0 && Arr.isReadonlyArrayNonEmpty(cors.allowedHeaders)) headers["access-control-allow-headers"] = cors.allowedHeaders.join(", ");
+		else if (requested !== void 0) headers["access-control-allow-headers"] = requested;
+		if (cors.maxAge !== void 0) headers["access-control-max-age"] = String(cors.maxAge);
+	}
+	return headers;
+};
+const withCors = (options) => (app) => {
+	const cors = options.cors;
+	if (cors === void 0) return app;
+	return Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => request.method === "OPTIONS" ? Effect.succeed(HttpServerResponse.empty({
+		status: 204,
+		headers: corsHeaders(cors, request, true)
+	})) : Effect.map(app, (response) => HttpServerResponse.setHeaders(response, Headers.fromInput(corsHeaders(cors, request, false)))));
+};
+const recover = (app) => Effect.catchTag(app, "ProtocolError", (e) => Effect.as(e.status >= 500 ? Effect.logError("SPARQL request failed", e.message) : Effect.logDebug("SPARQL request rejected", e.status, e.message), toResponse(e)));
+const finish = (options) => (app) => {
+	const handled = withCors(options)(recover(app));
+	return options.logging ? HttpMiddleware.logger(handled) : handled;
+};
+/**
+* The SPARQL endpoint (query, update and service description) as an HTTP
+* app.
+*
+* @since 0.1.0
+* @category handlers
+*/
+const sparqlHandler = (options) => {
+	const resolved = resolve(options);
+	return endpointFor(resolved, resolved.path);
+};
+const endpointFor = (resolved, path) => finish(resolved)(endpoint(resolved, {
+	query: path === resolved.path,
+	update: path === resolved.updatePath
+}));
+/**
+* The Graph Store Protocol endpoint as an HTTP app.
+*
+* @since 0.1.0
+* @category handlers
+*/
+const graphStoreHandler = (options) => {
+	const resolved = resolve(options);
+	return finish(resolved)(handle(resolved, resolved.graphStorePath ?? "/"));
+};
+/**
+* The whole server as one HTTP app: routes requests to the SPARQL endpoint(s)
+* and the graph store by path, and answers `404` otherwise.
+*
+* @since 0.1.0
+* @category handlers
+*/
+const handler = (options) => {
+	const resolved = resolve(options);
+	const query = endpointFor(resolved, resolved.path);
+	const update = resolved.updatePath === resolved.path ? query : endpointFor(resolved, resolved.updatePath);
+	const gsp = resolved.graphStorePath === void 0 ? void 0 : finish(resolved)(handle(resolved, resolved.graphStorePath));
+	const notFound$1 = finish(resolved)(Effect.fail(notFound("Not found")));
+	return Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => {
+		const path = requestPath(request.url);
+		if (path === resolved.path) return query;
+		if (path === resolved.updatePath) return update;
+		if (gsp !== void 0 && resolved.graphStorePath !== void 0 && (path === resolved.graphStorePath || path.startsWith(`${resolved.graphStorePath}/`))) return gsp;
+		return notFound$1;
+	});
+};
+/**
+* Registers the server's routes on the `HttpRouter`: the SPARQL endpoint(s),
+* the graph store root and everything below it (direct graph
+* identification).
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerRoutes = (options) => {
+	const resolved = resolve(options);
+	return HttpRouter.use((router) => Effect.gen(function* () {
+		yield* router.add("*", resolved.path, endpointFor(resolved, resolved.path));
+		if (resolved.updatePath !== resolved.path) yield* router.add("*", resolved.updatePath, endpointFor(resolved, resolved.updatePath));
+		if (resolved.graphStorePath !== void 0) {
+			const gsp = finish(resolved)(handle(resolved, resolved.graphStorePath));
+			yield* router.add("*", `${resolved.graphStorePath}/*`, gsp);
+		}
+	}));
+};
+/**
+* Serves the routes with `HttpRouter.serve` on an `HttpServer` from the
+* context (logging requests unless `logging: false`).
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerServe = (options) => HttpRouter.serve(layerRoutes({
+	...options,
+	logging: false
+}), { disableLogger: options?.logging === false });
+/**
+* The services of an in-memory server: the engine over an in-memory store
+* (optionally pre-loaded) and the default formats.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerMemoryServices = (data, engineOptions) => Layer.mergeAll(layer(engineOptions).pipe(Layer.provideMerge(layerMemory(data))), layer$1);
+export { layerRoutes as a, layerMemoryServices as i, graphStoreHandler as n, layerServe as o, handler as r, sparqlHandler as s, SparqlServer_exports as t };
+
+//# sourceMappingURL=SparqlServer-Db7w7Cll.mjs.map