@thomasfosterau/effect-sparql-node 0.0.0-stage → 0.1.0

package/dist/SparqlApi-BuycDkWu.mjs

@@ -0,0 +1,371 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Schema from "effect/Schema";
+import * as ServerFormats from "@thomasfosterau/effect-rdf/sparql/ServerFormats";
+import * as Arr from "effect/Array";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as HttpApi from "effect/http-api/HttpApi";
+import * as HttpApiEndpoint from "effect/http-api/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/http-api/HttpApiGroup";
+import * as HttpApiMiddleware from "effect/http-api/HttpApiMiddleware";
+import * as HttpApiSchema from "effect/http-api/HttpApiSchema";
+import * as OpenApi from "effect/http-api/OpenApi";
+import * as Results from "@thomasfosterau/effect-rdf/sparql/Results";
+import * as ProtocolErrors from "@thomasfosterau/effect-rdf/sparql/ProtocolErrors";
+import * as Protocol from "@thomasfosterau/effect-rdf/sparql/Protocol";
+// src/SparqlApi.ts
+/**
+* The SPARQL 1.1 Protocol and Graph Store HTTP Protocol as an Effect
+* `HttpApi` definition: the endpoints, their parameters, request media types,
+* response media types and error statuses, shared by the server
+* (`SparqlApiBuilder`), the derived client
+* (`SparqlApiClient`) and the OpenAPI document
+* (`openApi`).
+*
+* The API has two groups:
+*
+* - `sparql`: `query` (`GET` with `?query=`, or without it for the service
+*   description) and `post` (`POST` with an
+*   `application/x-www-form-urlencoded`, `application/sparql-query` or
+*   `application/sparql-update` body);
+* - `graphStore`: `get`, `head`, `put`, `post` and `delete` on the graph store
+*   with `?graph=<iri>` or `?default`, with RDF bodies under every media type
+*   of the default `Formats`.
+*
+* Content negotiation (`Accept`) and `405 Method Not Allowed` are not part of
+* the definition: the server's handlers negotiate with the same code as
+* `SparqlServer`, and `SparqlApiBuilder` answers the methods the API does not
+* declare. A request whose parameters the API's schemas reject (a repeated
+* `query` or `graph`, say) is handed to the protocol handler too, by the
+* `SchemaFallback` middleware, so it gets the protocol's own `400` and
+* message. Error bodies are `text/plain` messages decoded into
+* `ProtocolErrors.ProtocolError`.
+*
+* This module only describes the API, so a client can import it without the
+* server. `effect/http-api` is `@stability unstable` in Effect 4, and this
+* definition follows it.
+*
+* @since 0.1.0
+*/
+var SparqlApi_exports = /* @__PURE__ */ __exportAll({
+	AcceptHeader: () => AcceptHeader,
+	DatasetParams: () => DatasetParams,
+	DirectQueryBody: () => DirectQueryBody,
+	DirectUpdateBody: () => DirectUpdateBody,
+	FormBody: () => FormBody,
+	GraphParams: () => GraphParams,
+	ProtocolErrorResponse: () => ProtocolErrorResponse,
+	QueryParams: () => QueryParams,
+	QueryResponse: () => QueryResponse,
+	RdfDocumentBody: () => RdfDocumentBody,
+	RdfResponse: () => RdfResponse,
+	SchemaFallback: () => SchemaFallback,
+	SparqlApi: () => SparqlApi,
+	make: () => make,
+	openApi: () => openApi,
+	queryMediaTypes: () => queryMediaTypes,
+	rdfMediaTypes: () => rdfMediaTypes,
+	resultsMediaTypes: () => resultsMediaTypes
+});
+/**
+* The media types of the default RDF formats (`ServerFormats.codecs`), in order of
+* preference: Graph Store bodies and `CONSTRUCT` / `DESCRIBE` / service
+* description responses.
+*
+* @since 0.1.0
+* @category media types
+*/
+const rdfMediaTypes = Arr.dedupe(Arr.flatMap(ServerFormats.codecs, (codec) => codec.format.mediaTypes));
+/**
+* The media types of SPARQL results (`Results.codecs`): JSON, XML, CSV and
+* TSV, in order of preference.
+*
+* @since 0.1.0
+* @category media types
+*/
+const resultsMediaTypes = Arr.dedupe(Arr.flatMap(Results.codecs, (codec) => codec.format.mediaTypes));
+/**
+* Every media type a query response can have: the results formats for
+* `SELECT` / `ASK`, then the RDF formats for `CONSTRUCT` / `DESCRIBE` and the
+* service description.
+*
+* @since 0.1.0
+* @category media types
+*/
+const queryMediaTypes = Arr.dedupe(Arr.appendAll(resultsMediaTypes, rdfMediaTypes));
+/**
+* A query response body: a byte stream under any of `queryMediaTypes`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const QueryResponse = HttpApiSchema.StreamUint8Array({ contentType: queryMediaTypes });
+/**
+* An RDF document response body: a byte stream under any of `rdfMediaTypes`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const RdfResponse = HttpApiSchema.StreamUint8Array({ contentType: rdfMediaTypes });
+const iris = Schema.optionalKey(Schema.Array(Schema.String));
+/**
+* The `Accept` request header, which selects the response format.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const AcceptHeader = Schema.Struct({ accept: Schema.optionalKey(Schema.String) });
+/**
+* The query string of a query: the query and its protocol dataset.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const QueryParams = Schema.Struct({
+	query: Schema.optionalKey(Schema.String),
+	"default-graph-uri": iris,
+	"named-graph-uri": iris
+});
+/**
+* The query string of a `POST`: the protocol dataset of a query
+* (`default-graph-uri` / `named-graph-uri`) or of an update
+* (`using-graph-uri` / `using-named-graph-uri`).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DatasetParams = Schema.Struct({
+	"default-graph-uri": iris,
+	"named-graph-uri": iris,
+	"using-graph-uri": iris,
+	"using-named-graph-uri": iris
+});
+/**
+* An `application/x-www-form-urlencoded` `POST` body holding a `query` or an
+* `update` and its protocol dataset.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const FormBody = Schema.Struct({
+	query: Schema.optionalKey(Schema.String),
+	update: Schema.optionalKey(Schema.String),
+	"default-graph-uri": iris,
+	"named-graph-uri": iris,
+	"using-graph-uri": iris,
+	"using-named-graph-uri": iris
+}).pipe(HttpApiSchema.asFormUrlEncoded());
+/**
+* An `application/sparql-query` `POST` body, decoded as
+* `{ _tag: 'DirectQuery', query }`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DirectQueryBody = Schema.String.pipe(Schema.decodeTo(Schema.TaggedStruct("DirectQuery", { query: Schema.String }), SchemaTransformation.transform({
+	decode: (query) => ({
+		_tag: "DirectQuery",
+		query
+	}),
+	encode: (body) => body.query
+})), HttpApiSchema.asText({ contentType: Protocol.SPARQL_QUERY }));
+/**
+* An `application/sparql-update` `POST` body, decoded as
+* `{ _tag: 'DirectUpdate', update }`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DirectUpdateBody = Schema.String.pipe(Schema.decodeTo(Schema.TaggedStruct("DirectUpdate", { update: Schema.String }), SchemaTransformation.transform({
+	decode: (update) => ({
+		_tag: "DirectUpdate",
+		update
+	}),
+	encode: (body) => body.update
+})), HttpApiSchema.asText({ contentType: Protocol.SPARQL_UPDATE }));
+const rdfDocument = (mediaType) => Schema.String.pipe(Schema.decodeTo(Schema.Struct({
+	mediaType: Schema.Literal(mediaType),
+	document: Schema.String
+}), SchemaTransformation.transform({
+	decode: (document) => ({
+		mediaType,
+		document
+	}),
+	encode: (body) => body.document
+})), HttpApiSchema.asText({ contentType: mediaType }));
+/**
+* Graph Store request bodies: an RDF document under one of `rdfMediaTypes`,
+* decoded as `{ mediaType, document }` (the media type selects the request's
+* `Content-Type`).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const RdfDocumentBody = Arr.map(rdfMediaTypes, rdfDocument);
+/**
+* The query string of a Graph Store request: `graph=<iri>` (indirect
+* identification) or `default` (the default graph).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const GraphParams = Schema.Struct({
+	graph: Schema.optionalKey(Schema.String),
+	default: Schema.optionalKey(Schema.String)
+});
+/**
+* The error response of a status: a `text/plain` message, decoded as an
+* `ProtocolErrors.ProtocolError` with that status.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const ProtocolErrorResponse = (status) => Schema.String.pipe(Schema.decodeTo(ProtocolErrors.ProtocolError.pipe(Schema.check(Schema.makeFilter((error) => error.status === status, {
+	identifier: `ProtocolError${status}`,
+	title: `ProtocolError (${status})`,
+	description: `A protocol error with status ${status}`
+}))), SchemaTransformation.transform({
+	decode: (message) => ({
+		_tag: "ProtocolError",
+		status,
+		message: message.trimEnd()
+	}),
+	encode: (error) => `${error.message}\n`
+})), HttpApiSchema.asText({ contentType: "text/plain" }), HttpApiSchema.status(status));
+const BadRequest = ProtocolErrorResponse(400);
+const Forbidden = ProtocolErrorResponse(403);
+const NotFound = ProtocolErrorResponse(404);
+const MethodNotAllowed = ProtocolErrorResponse(405);
+const NotAcceptable = ProtocolErrorResponse(406);
+const UnsupportedMediaType = ProtocolErrorResponse(415);
+const InternalServerError = ProtocolErrorResponse(500);
+const ServiceUnavailable = ProtocolErrorResponse(503);
+/**
+* Middleware on every endpoint that answers a request whose parameters or
+* headers fail the API's schemas with the protocol handler instead of an
+* empty `400` (see `SparqlApiBuilder.layerSchemaFallback`). It needs the
+* server's services and nothing on the client side.
+*
+* @since 0.1.0
+* @category middleware
+*/
+var SchemaFallback = class extends HttpApiMiddleware.Service()("@thomasfosterau/effect-sparql-node/SparqlApi/SchemaFallback") {};
+const sparqlGroup = (path) => HttpApiGroup.make("sparql").add(HttpApiEndpoint.get("query", path, {
+	query: QueryParams,
+	headers: AcceptHeader,
+	success: QueryResponse,
+	error: [
+		BadRequest,
+		NotAcceptable,
+		InternalServerError,
+		ServiceUnavailable
+	]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Query, or read the service description",
+	description: "A SPARQL query in `query`, with its dataset in `default-graph-uri` / `named-graph-uri`. Without `query`, answers the service description. The response format is negotiated from `Accept`."
+})), HttpApiEndpoint.post("post", path, {
+	query: DatasetParams,
+	headers: AcceptHeader,
+	payload: [
+		DirectQueryBody,
+		DirectUpdateBody,
+		FormBody
+	],
+	success: [QueryResponse, HttpApiSchema.NoContent],
+	error: [
+		BadRequest,
+		Forbidden,
+		NotAcceptable,
+		UnsupportedMediaType,
+		InternalServerError,
+		ServiceUnavailable
+	]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Query or update",
+	description: "A query (`200` with the results) or an update (`204`), as a form or as an `application/sparql-query` / `application/sparql-update` body. A read-only endpoint answers updates with `403`."
+}))).annotateMerge(OpenApi.annotations({
+	title: "SPARQL",
+	description: "The SPARQL 1.1 Protocol"
+}));
+const writeErrors = [
+	BadRequest,
+	NotFound,
+	MethodNotAllowed,
+	UnsupportedMediaType,
+	InternalServerError
+];
+const graphStoreGroup = (path) => HttpApiGroup.make("graphStore").add(HttpApiEndpoint.get("get", path, {
+	query: GraphParams,
+	headers: AcceptHeader,
+	success: RdfResponse,
+	error: [
+		BadRequest,
+		NotFound,
+		NotAcceptable,
+		InternalServerError
+	]
+}).annotateMerge(OpenApi.annotations({ summary: "Read a graph" })), HttpApiEndpoint.head("head", path, {
+	query: GraphParams,
+	headers: AcceptHeader,
+	success: HttpApiSchema.Empty(200),
+	error: [
+		BadRequest,
+		NotFound,
+		NotAcceptable,
+		InternalServerError
+	]
+}).annotateMerge(OpenApi.annotations({ summary: "Check that a graph exists" })), HttpApiEndpoint.put("put", path, {
+	query: GraphParams,
+	payload: RdfDocumentBody,
+	success: [HttpApiSchema.NoContent, HttpApiSchema.Created],
+	error: writeErrors
+}).annotateMerge(OpenApi.annotations({
+	summary: "Replace a graph",
+	description: "`201` when the graph is new, `204` when it existed."
+})), HttpApiEndpoint.post("post", path, {
+	query: GraphParams,
+	payload: RdfDocumentBody,
+	success: [HttpApiSchema.NoContent, HttpApiSchema.Created],
+	error: writeErrors
+}).annotateMerge(OpenApi.annotations({
+	summary: "Add to a graph, or create one",
+	description: "Merges the document into the graph (`201` when it is new). Without `graph` or `default`, creates a new graph and answers `201` with its IRI in `Location`."
+})), HttpApiEndpoint.delete("delete", path, {
+	query: GraphParams,
+	success: HttpApiSchema.NoContent,
+	error: [
+		BadRequest,
+		NotFound,
+		MethodNotAllowed,
+		InternalServerError
+	]
+}).annotateMerge(OpenApi.annotations({ summary: "Delete a graph" }))).annotateMerge(OpenApi.annotations({
+	title: "Graph Store",
+	description: "The SPARQL 1.1 Graph Store HTTP Protocol (indirect identification; URLs below the graph store identify graphs directly)"
+}));
+/**
+* Builds the API at the given paths.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (paths) => HttpApi.make("effect-sparql-node").add(sparqlGroup(paths?.path ?? "/sparql")).add(graphStoreGroup(paths?.graphStorePath ?? "/rdf-graph-store")).middleware(SchemaFallback).annotateMerge(OpenApi.annotations({
+	title: "SPARQL 1.1 Protocol and Graph Store HTTP Protocol",
+	description: "Every response format is negotiated from `Accept`; methods an endpoint does not support are answered with `405` and `Allow`."
+}));
+/**
+* The API at the default paths, `/sparql` and `/rdf-graph-store`.
+*
+* @since 0.1.0
+* @category api
+*/
+const SparqlApi = make();
+/**
+* The OpenAPI document of an API (the default one when omitted).
+*
+* @since 0.1.0
+* @category openapi
+*/
+const openApi = (api = SparqlApi) => OpenApi.fromApi(api);
+export { queryMediaTypes as _, FormBody as a, QueryParams as c, RdfResponse as d, SchemaFallback as f, openApi as g, make as h, DirectUpdateBody as i, QueryResponse as l, SparqlApi_exports as m, DatasetParams as n, GraphParams as o, SparqlApi as p, DirectQueryBody as r, ProtocolErrorResponse as s, AcceptHeader as t, RdfDocumentBody as u, rdfMediaTypes as v, resultsMediaTypes as y };
+
+//# sourceMappingURL=SparqlApi-BuycDkWu.mjs.map

package/dist/SparqlApi-BuycDkWu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparqlApi-BuycDkWu.mjs","names":[],"sources":["../src/SparqlApi.ts"],"sourcesContent":["/**\n * The SPARQL 1.1 Protocol and Graph Store HTTP Protocol as an Effect\n * `HttpApi` definition: the endpoints, their parameters, request media types,\n * response media types and error statuses, shared by the server\n * (`SparqlApiBuilder`), the derived client\n * (`SparqlApiClient`) and the OpenAPI document\n * (`openApi`).\n *\n * The API has two groups:\n *\n * - `sparql`: `query` (`GET` with `?query=`, or without it for the service\n *   description) and `post` (`POST` with an\n *   `application/x-www-form-urlencoded`, `application/sparql-query` or\n *   `application/sparql-update` body);\n * - `graphStore`: `get`, `head`, `put`, `post` and `delete` on the graph store\n *   with `?graph=<iri>` or `?default`, with RDF bodies under every media type\n *   of the default `Formats`.\n *\n * Content negotiation (`Accept`) and `405 Method Not Allowed` are not part of\n * the definition: the server's handlers negotiate with the same code as\n * `SparqlServer`, and `SparqlApiBuilder` answers the methods the API does not\n * declare. A request whose parameters the API's schemas reject (a repeated\n * `query` or `graph`, say) is handed to the protocol handler too, by the\n * `SchemaFallback` middleware, so it gets the protocol's own `400` and\n * message. Error bodies are `text/plain` messages decoded into\n * `ProtocolErrors.ProtocolError`.\n *\n * This module only describes the API, so a client can import it without the\n * server. `effect/http-api` is `@stability unstable` in Effect 4, and this\n * definition follows it.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as HttpApi from 'effect/http-api/HttpApi';\nimport * as HttpApiEndpoint from 'effect/http-api/HttpApiEndpoint';\nimport * as HttpApiGroup from 'effect/http-api/HttpApiGroup';\nimport * as HttpApiMiddleware from 'effect/http-api/HttpApiMiddleware';\nimport * as HttpApiSchema from 'effect/http-api/HttpApiSchema';\nimport * as OpenApi from 'effect/http-api/OpenApi';\nimport type * as Serialization from '@thomasfosterau/effect-rdf/Serialization';\nimport type * as Engine from '@thomasfosterau/effect-rdf/sparql/Engine';\nimport * as Results from '@thomasfosterau/effect-rdf/sparql/Results';\nimport type * as Store from '@thomasfosterau/effect-rdf/sparql/Store';\nimport * as ProtocolErrors from '@thomasfosterau/effect-rdf/sparql/ProtocolErrors';\nimport * as ServerFormats from '@thomasfosterau/effect-rdf/sparql/ServerFormats';\nimport * as Protocol from '@thomasfosterau/effect-rdf/sparql/Protocol';\n\n// -----------------------------------------------------------------------------\n// Media types\n// -----------------------------------------------------------------------------\n\n/**\n * The media types of the default RDF formats (`ServerFormats.codecs`), in order of\n * preference: Graph Store bodies and `CONSTRUCT` / `DESCRIBE` / service\n * description responses.\n *\n * @since 0.1.0\n * @category media types\n */\nexport const rdfMediaTypes: ReadonlyArray<string> = Arr.dedupe(\n  Arr.flatMap(ServerFormats.codecs, (codec) => codec.format.mediaTypes),\n);\n\n/**\n * The media types of SPARQL results (`Results.codecs`): JSON, XML, CSV and\n * TSV, in order of preference.\n *\n * @since 0.1.0\n * @category media types\n */\nexport const resultsMediaTypes: ReadonlyArray<string> = Arr.dedupe(\n  Arr.flatMap(Results.codecs, (codec) => codec.format.mediaTypes),\n);\n\n/**\n * Every media type a query response can have: the results formats for\n * `SELECT` / `ASK`, then the RDF formats for `CONSTRUCT` / `DESCRIBE` and the\n * service description.\n *\n * @since 0.1.0\n * @category media types\n */\nexport const queryMediaTypes: ReadonlyArray<string> = Arr.dedupe(\n  Arr.appendAll(resultsMediaTypes, rdfMediaTypes),\n);\n\n// -----------------------------------------------------------------------------\n// Schemas\n// -----------------------------------------------------------------------------\n\n/**\n * A query response body: a byte stream under any of `queryMediaTypes`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const QueryResponse: HttpApiSchema.StreamUint8Array = HttpApiSchema.StreamUint8Array({\n  contentType: queryMediaTypes,\n});\n\n/**\n * An RDF document response body: a byte stream under any of `rdfMediaTypes`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const RdfResponse: HttpApiSchema.StreamUint8Array = HttpApiSchema.StreamUint8Array({\n  contentType: rdfMediaTypes,\n});\n\nconst iris = Schema.optionalKey(Schema.Array(Schema.String));\n\n/**\n * The `Accept` request header, which selects the response format.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const AcceptHeader = Schema.Struct({ accept: Schema.optionalKey(Schema.String) });\n\n/**\n * The decoded type of `AcceptHeader`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type AcceptHeader = typeof AcceptHeader.Type;\n\n/**\n * The query string of a query: the query and its protocol dataset.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const QueryParams = Schema.Struct({\n  query: Schema.optionalKey(Schema.String),\n  'default-graph-uri': iris,\n  'named-graph-uri': iris,\n});\n\n/**\n * The decoded type of `QueryParams`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type QueryParams = typeof QueryParams.Type;\n\n/**\n * The query string of a `POST`: the protocol dataset of a query\n * (`default-graph-uri` / `named-graph-uri`) or of an update\n * (`using-graph-uri` / `using-named-graph-uri`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DatasetParams = Schema.Struct({\n  'default-graph-uri': iris,\n  'named-graph-uri': iris,\n  'using-graph-uri': iris,\n  'using-named-graph-uri': iris,\n});\n\n/**\n * The decoded type of `DatasetParams`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type DatasetParams = typeof DatasetParams.Type;\n\n/**\n * An `application/x-www-form-urlencoded` `POST` body holding a `query` or an\n * `update` and its protocol dataset.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const FormBody = Schema.Struct({\n  query: Schema.optionalKey(Schema.String),\n  update: Schema.optionalKey(Schema.String),\n  'default-graph-uri': iris,\n  'named-graph-uri': iris,\n  'using-graph-uri': iris,\n  'using-named-graph-uri': iris,\n}).pipe(HttpApiSchema.asFormUrlEncoded());\n\n/**\n * The decoded type of `FormBody`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type FormBody = typeof FormBody.Type;\n\n/**\n * An `application/sparql-query` `POST` body, decoded as\n * `{ _tag: 'DirectQuery', query }`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DirectQueryBody = Schema.String.pipe(\n  Schema.decodeTo(\n    Schema.TaggedStruct('DirectQuery', { query: Schema.String }),\n    SchemaTransformation.transform({\n      decode: (query) => ({ _tag: 'DirectQuery' as const, query }),\n      encode: (body) => body.query,\n    }),\n  ),\n  HttpApiSchema.asText({ contentType: Protocol.SPARQL_QUERY }),\n);\n\n/**\n * The decoded type of `DirectQueryBody`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type DirectQueryBody = typeof DirectQueryBody.Type;\n\n/**\n * An `application/sparql-update` `POST` body, decoded as\n * `{ _tag: 'DirectUpdate', update }`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DirectUpdateBody = Schema.String.pipe(\n  Schema.decodeTo(\n    Schema.TaggedStruct('DirectUpdate', { update: Schema.String }),\n    SchemaTransformation.transform({\n      decode: (update) => ({ _tag: 'DirectUpdate' as const, update }),\n      encode: (body) => body.update,\n    }),\n  ),\n  HttpApiSchema.asText({ contentType: Protocol.SPARQL_UPDATE }),\n);\n\n/**\n * The decoded type of `DirectUpdateBody`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type DirectUpdateBody = typeof DirectUpdateBody.Type;\n\nconst rdfDocument = (mediaType: string) =>\n  Schema.String.pipe(\n    Schema.decodeTo(\n      Schema.Struct({ mediaType: Schema.Literal(mediaType), document: Schema.String }),\n      SchemaTransformation.transform({\n        decode: (document) => ({ mediaType, document }),\n        encode: (body) => body.document,\n      }),\n    ),\n    HttpApiSchema.asText({ contentType: mediaType }),\n  );\n\n/**\n * Graph Store request bodies: an RDF document under one of `rdfMediaTypes`,\n * decoded as `{ mediaType, document }` (the media type selects the request's\n * `Content-Type`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const RdfDocumentBody = Arr.map(rdfMediaTypes, rdfDocument);\n\n/**\n * The query string of a Graph Store request: `graph=<iri>` (indirect\n * identification) or `default` (the default graph).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const GraphParams = Schema.Struct({\n  graph: Schema.optionalKey(Schema.String),\n  default: Schema.optionalKey(Schema.String),\n});\n\n/**\n * The decoded type of `GraphParams`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type GraphParams = typeof GraphParams.Type;\n\n/**\n * The error response of a status: a `text/plain` message, decoded as an\n * `ProtocolErrors.ProtocolError` with that status.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const ProtocolErrorResponse = (status: number) =>\n  Schema.String.pipe(\n    Schema.decodeTo(\n      ProtocolErrors.ProtocolError.pipe(\n        Schema.check(\n          Schema.makeFilter((error: ProtocolErrors.ProtocolError) => error.status === status, {\n            identifier: `ProtocolError${status}`,\n            title: `ProtocolError (${status})`,\n            description: `A protocol error with status ${status}`,\n          }),\n        ),\n      ),\n      SchemaTransformation.transform({\n        decode: (message) => ({\n          _tag: 'ProtocolError' as const,\n          status,\n          message: message.trimEnd(),\n        }),\n        encode: (error) => `${error.message}\\n`,\n      }),\n    ),\n    HttpApiSchema.asText({ contentType: 'text/plain' }),\n    HttpApiSchema.status(status),\n  );\n\nconst BadRequest = ProtocolErrorResponse(400);\nconst Forbidden = ProtocolErrorResponse(403);\nconst NotFound = ProtocolErrorResponse(404);\nconst MethodNotAllowed = ProtocolErrorResponse(405);\nconst NotAcceptable = ProtocolErrorResponse(406);\nconst UnsupportedMediaType = ProtocolErrorResponse(415);\nconst InternalServerError = ProtocolErrorResponse(500);\nconst ServiceUnavailable = ProtocolErrorResponse(503);\n\n// -----------------------------------------------------------------------------\n// The API\n// -----------------------------------------------------------------------------\n\n/**\n * Middleware on every endpoint that answers a request whose parameters or\n * headers fail the API's schemas with the protocol handler instead of an\n * empty `400` (see `SparqlApiBuilder.layerSchemaFallback`). It needs the\n * server's services and nothing on the client side.\n *\n * @since 0.1.0\n * @category middleware\n */\nexport class SchemaFallback extends HttpApiMiddleware.Service<\n  SchemaFallback,\n  { requires: Engine.SparqlEngine | Store.QuadStore | Serialization.Formats }\n>()('@thomasfosterau/effect-sparql-node/SparqlApi/SchemaFallback') {}\n\n/**\n * The paths an API is served at.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Paths {\n  /** The SPARQL endpoint, for queries and updates (default `/sparql`). */\n  readonly path?: `/${string}` | undefined;\n  /** The Graph Store endpoint (default `/rdf-graph-store`). */\n  readonly graphStorePath?: `/${string}` | undefined;\n}\n\nconst sparqlGroup = (path: `/${string}`) =>\n  HttpApiGroup.make('sparql')\n    .add(\n      HttpApiEndpoint.get('query', path, {\n        query: QueryParams,\n        headers: AcceptHeader,\n        success: QueryResponse,\n        error: [BadRequest, NotAcceptable, InternalServerError, ServiceUnavailable],\n      }).annotateMerge(\n        OpenApi.annotations({\n          summary: 'Query, or read the service description',\n          description:\n            'A SPARQL query in `query`, with its dataset in `default-graph-uri` / `named-graph-uri`. Without `query`, answers the service description. The response format is negotiated from `Accept`.',\n        }),\n      ),\n      HttpApiEndpoint.post('post', path, {\n        query: DatasetParams,\n        headers: AcceptHeader,\n        payload: [DirectQueryBody, DirectUpdateBody, FormBody],\n        success: [QueryResponse, HttpApiSchema.NoContent],\n        error: [\n          BadRequest,\n          Forbidden,\n          NotAcceptable,\n          UnsupportedMediaType,\n          InternalServerError,\n          ServiceUnavailable,\n        ],\n      }).annotateMerge(\n        OpenApi.annotations({\n          summary: 'Query or update',\n          description:\n            'A query (`200` with the results) or an update (`204`), as a form or as an `application/sparql-query` / `application/sparql-update` body. A read-only endpoint answers updates with `403`.',\n        }),\n      ),\n    )\n    .annotateMerge(\n      OpenApi.annotations({ title: 'SPARQL', description: 'The SPARQL 1.1 Protocol' }),\n    );\n\nconst writeErrors = [\n  BadRequest,\n  NotFound,\n  MethodNotAllowed,\n  UnsupportedMediaType,\n  InternalServerError,\n] as const;\n\nconst graphStoreGroup = (path: `/${string}`) =>\n  HttpApiGroup.make('graphStore')\n    .add(\n      HttpApiEndpoint.get('get', path, {\n        query: GraphParams,\n        headers: AcceptHeader,\n        success: RdfResponse,\n        error: [BadRequest, NotFound, NotAcceptable, InternalServerError],\n      }).annotateMerge(OpenApi.annotations({ summary: 'Read a graph' })),\n      HttpApiEndpoint.head('head', path, {\n        query: GraphParams,\n        headers: AcceptHeader,\n        success: HttpApiSchema.Empty(200),\n        error: [BadRequest, NotFound, NotAcceptable, InternalServerError],\n      }).annotateMerge(OpenApi.annotations({ summary: 'Check that a graph exists' })),\n      HttpApiEndpoint.put('put', path, {\n        query: GraphParams,\n        payload: RdfDocumentBody,\n        success: [HttpApiSchema.NoContent, HttpApiSchema.Created],\n        error: writeErrors,\n      }).annotateMerge(\n        OpenApi.annotations({\n          summary: 'Replace a graph',\n          description: '`201` when the graph is new, `204` when it existed.',\n        }),\n      ),\n      HttpApiEndpoint.post('post', path, {\n        query: GraphParams,\n        payload: RdfDocumentBody,\n        success: [HttpApiSchema.NoContent, HttpApiSchema.Created],\n        error: writeErrors,\n      }).annotateMerge(\n        OpenApi.annotations({\n          summary: 'Add to a graph, or create one',\n          description:\n            'Merges the document into the graph (`201` when it is new). Without `graph` or `default`, creates a new graph and answers `201` with its IRI in `Location`.',\n        }),\n      ),\n      HttpApiEndpoint.delete('delete', path, {\n        query: GraphParams,\n        success: HttpApiSchema.NoContent,\n        error: [BadRequest, NotFound, MethodNotAllowed, InternalServerError],\n      }).annotateMerge(OpenApi.annotations({ summary: 'Delete a graph' })),\n    )\n    .annotateMerge(\n      OpenApi.annotations({\n        title: 'Graph Store',\n        description:\n          'The SPARQL 1.1 Graph Store HTTP Protocol (indirect identification; URLs below the graph store identify graphs directly)',\n      }),\n    );\n\n/**\n * Builds the API at the given paths.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (paths?: Paths) =>\n  HttpApi.make('effect-sparql-node')\n    .add(sparqlGroup(paths?.path ?? '/sparql'))\n    .add(graphStoreGroup(paths?.graphStorePath ?? '/rdf-graph-store'))\n    .middleware(SchemaFallback)\n    .annotateMerge(\n      OpenApi.annotations({\n        title: 'SPARQL 1.1 Protocol and Graph Store HTTP Protocol',\n        description:\n          'Every response format is negotiated from `Accept`; methods an endpoint does not support are answered with `405` and `Allow`.',\n      }),\n    );\n\n/**\n * The type of an API built by `make`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Api = ReturnType<typeof make>;\n\n/**\n * The API at the default paths, `/sparql` and `/rdf-graph-store`.\n *\n * @since 0.1.0\n * @category api\n */\nexport const SparqlApi: Api = make();\n\n/**\n * The OpenAPI document of an API (the default one when omitted).\n *\n * @since 0.1.0\n * @category openapi\n */\nexport const openApi = (api: Api = SparqlApi): OpenApi.OpenAPISpec => OpenApi.fromApi(api);\n"],"mappings":"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"}

package/dist/SparqlApi.d.mts

@@ -0,0 +1,2 @@
+import { _ as make, a as DirectUpdateBody, b as rdfMediaTypes, c as Paths, d as QueryResponse, f as RdfDocumentBody, h as SparqlApi, i as DirectQueryBody, l as ProtocolErrorResponse, m as SchemaFallback, n as Api, o as FormBody, p as RdfResponse, r as DatasetParams, s as GraphParams, t as AcceptHeader, u as QueryParams, v as openApi, x as resultsMediaTypes, y as queryMediaTypes } from "./SparqlApi-BKE9nIf4.mjs";
+export { AcceptHeader, Api, DatasetParams, DirectQueryBody, DirectUpdateBody, FormBody, GraphParams, Paths, ProtocolErrorResponse, QueryParams, QueryResponse, RdfDocumentBody, RdfResponse, SchemaFallback, SparqlApi, make, openApi, queryMediaTypes, rdfMediaTypes, resultsMediaTypes };

package/dist/SparqlApi.mjs

@@ -0,0 +1 @@
+export { t as AcceptHeader, n as DatasetParams, r as DirectQueryBody, i as DirectUpdateBody, a as FormBody, o as GraphParams, s as ProtocolErrorResponse, c as QueryParams, l as QueryResponse, u as RdfDocumentBody, d as RdfResponse, f as SchemaFallback, p as SparqlApi, h as make, g as openApi, _ as queryMediaTypes, v as rdfMediaTypes, y as resultsMediaTypes } from "./SparqlApi-BuycDkWu.mjs";

package/dist/SparqlApiBuilder-BAMpMy-Z.d.mts

@@ -0,0 +1,83 @@
+import { c as Paths, m as SchemaFallback } from "./SparqlApi-BKE9nIf4.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SparqlServer from "@thomasfosterau/effect-rdf/sparql/SparqlServer";
+import * as HttpApiMiddleware from "effect/http-api/HttpApiMiddleware";
+import * as Scope from "effect/Scope";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as HttpServer from "effect/http/HttpServer";
+import * as Options from "@thomasfosterau/effect-rdf/sparql/Options";
+import * as HttpClient from "effect/http/HttpClient";
+declare namespace SparqlApiBuilder_d_exports {
+  export { ApiOptions, layerFallback, layerHandlers, layerRoutes, layerSchemaFallback, layerServe, makeTestClient };
+}
+/**
+ * Options of the API server: the server options, with the endpoint paths of
+ * the API (the update endpoint is the query endpoint) and where to serve the
+ * OpenAPI document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ApiOptions extends Omit<Options.Options, 'path' | 'updatePath' | 'graphStorePath'>, Paths {
+  /** Serves the OpenAPI document (`SparqlApi.openApi`) as JSON at this path. */
+  readonly openapiPath?: `/${string}` | undefined;
+}
+/**
+ * The handlers of both API groups (`sparql` and `graphStore`) for the API at
+ * the options' paths, using the server's services from the context.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerHandlers: (options?: ApiOptions) => Layer.Layer<import("effect/http-api/HttpApiGroup").Service<"effect-sparql-node", "sparql"> | import("effect/http-api/HttpApiGroup").Service<"effect-sparql-node", "graphStore">, never, HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/sparql/Engine").SparqlEngine> | (SchemaFallback | HttpApiMiddleware.ApplyServices<SchemaFallback, never> | HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/sparql/Store").QuadStore> | HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/Serialization").Formats>)>;
+/**
+ * The `SparqlApi.SchemaFallback` middleware: a request whose parameters or
+ * headers fail the API's schemas is answered by `SparqlServer.handler`, so
+ * it gets the protocol's own status and message (e.g. `400` "Exactly one
+ * 'query' parameter is allowed"). Response encoding failures stay `500`.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerSchemaFallback: (options?: ApiOptions) => Layer.Layer<SchemaFallback>;
+/**
+ * The fallback routes: every method on `<path>*` and `<graphStorePath>*`
+ * that the API does not declare, answered by `SparqlServer.handler` (`405`
+ * with `Allow`, CORS preflights, direct graph identification, `404` for
+ * other paths).
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerFallback: (options?: ApiOptions) => Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", SparqlServer.Requirements>>;
+/**
+ * Registers the API on the `HttpRouter`: the `HttpApiBuilder` routes with
+ * their handlers and the `SchemaFallback` middleware, the fallback routes and, with `openapiPath`, the OpenAPI
+ * document.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerRoutes: (options?: ApiOptions) => Layer.Layer<never, never, HttpApiMiddleware.ApplyServices<SchemaFallback, never> | HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/sparql/Engine").SparqlEngine> | HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/sparql/Store").QuadStore> | HttpRouter.Request<"Requires", import("@thomasfosterau/effect-rdf/Serialization").Formats> | HttpRouter.HttpRouter | import("effect/http/Etag").Generator | import("effect/FileSystem").FileSystem | import("effect/http/HttpPlatform").HttpPlatform | import("effect/Path").Path>;
+/**
+ * Serves the API routes with `HttpRouter.serve` on an `HttpServer` from the
+ * context (logging requests unless `logging: false`); the server layer (such
+ * as `NodeHttpServer.layer`) also provides the platform services
+ * `HttpApiBuilder` needs.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerServe: (options?: ApiOptions) => Layer.Layer<never, never, HttpApiMiddleware.ApplyServices<SchemaFallback, never> | import("effect/http/Etag").Generator | import("effect/FileSystem").FileSystem | import("effect/http/HttpPlatform").HttpPlatform | import("effect/Path").Path | HttpServer.HttpServer>;
+/**
+ * In-process testing: builds a client for the `SparqlApi` routes
+ * (`layerRoutes(options)`) using the server's services from
+ * the context. The routes live as long as the surrounding scope.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeTestClient: (options?: ApiOptions) => Effect.Effect<HttpClient.HttpClient, never, SparqlServer.Requirements | Scope.Scope>;
+export { layerRoutes as a, makeTestClient as c, layerHandlers as i, SparqlApiBuilder_d_exports as n, layerSchemaFallback as o, layerFallback as r, layerServe as s, ApiOptions as t };
+//# sourceMappingURL=SparqlApiBuilder-BAMpMy-Z.d.mts.map

package/dist/SparqlApiBuilder-GT7EopBq.mjs

@@ -0,0 +1,136 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { f as SchemaFallback, h as make } from "./SparqlApi-BuycDkWu.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SparqlServer from "@thomasfosterau/effect-rdf/sparql/SparqlServer";
+import * as HttpApiMiddleware from "effect/http-api/HttpApiMiddleware";
+import * as Scope from "effect/Scope";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as HttpServer from "effect/http/HttpServer";
+import * as HttpServerError from "effect/http/HttpServerError";
+import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
+import * as Testing from "@thomasfosterau/effect-rdf/sparql/Testing";
+// src/SparqlApiBuilder.ts
+/**
+* Serves the `SparqlApi` definition with `HttpApiBuilder`.
+*
+* Every endpoint is implemented with a raw handler (`handleRaw`) that runs
+* the same code as `SparqlServer`: the request body, `Accept` and
+* `Content-Type` are read by the protocol internals, so responses, statuses
+* and error messages are those of `SparqlServer.handler`. Routes the API does
+* not declare (other methods on the endpoints, which get `405` with
+* `Allow`; `OPTIONS` preflights when CORS is on; graphs identified directly
+* by a URL below the graph store) are registered as plain `HttpRouter`
+* fallback routes to `SparqlServer.handler`.
+*
+* `effect/http-api` is `@stability unstable` in Effect 4.
+*
+* @since 0.1.0
+*/
+var SparqlApiBuilder_exports = /* @__PURE__ */ __exportAll({
+	layerFallback: () => layerFallback,
+	layerHandlers: () => layerHandlers,
+	layerRoutes: () => layerRoutes,
+	layerSchemaFallback: () => layerSchemaFallback,
+	layerServe: () => layerServe,
+	makeTestClient: () => makeTestClient
+});
+const serverOptions = (options) => {
+	const path = options?.path ?? "/sparql";
+	return {
+		...options,
+		path,
+		updatePath: path,
+		graphStorePath: options?.graphStorePath ?? "/rdf-graph-store"
+	};
+};
+const handlersFor = (api, options) => {
+	const sparql = SparqlServer.sparqlHandler(options);
+	const graphStore = SparqlServer.graphStoreHandler(options);
+	return Layer.mergeAll(HttpApiBuilder.group(api, "sparql", (handlers) => handlers.handleRaw("query", () => sparql).handleRaw("post", () => sparql)), HttpApiBuilder.group(api, "graphStore", (handlers) => handlers.handleRaw("get", () => graphStore).handleRaw("head", () => graphStore).handleRaw("put", () => graphStore).handleRaw("post", () => graphStore).handleRaw("delete", () => graphStore)));
+};
+/**
+* The handlers of both API groups (`sparql` and `graphStore`) for the API at
+* the options' paths, using the server's services from the context.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerHandlers = (options) => {
+	const resolved = serverOptions(options);
+	return handlersFor(make(resolved), resolved);
+};
+/**
+* The `SparqlApi.SchemaFallback` middleware: a request whose parameters or
+* headers fail the API's schemas is answered by `SparqlServer.handler`, so
+* it gets the protocol's own status and message (e.g. `400` "Exactly one
+* 'query' parameter is allowed"). Response encoding failures stay `500`.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerSchemaFallback = (options) => {
+	const app = SparqlServer.handler(serverOptions(options));
+	return HttpApiMiddleware.layerSchemaErrorTransform(SchemaFallback, (error) => error.kind === "Body" || error.kind === "ResponseHeaders" ? Effect.fail(error) : app);
+};
+/**
+* The fallback routes: every method on `<path>*` and `<graphStorePath>*`
+* that the API does not declare, answered by `SparqlServer.handler` (`405`
+* with `Allow`, CORS preflights, direct graph identification, `404` for
+* other paths).
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerFallback = (options) => {
+	const resolved = serverOptions(options);
+	const app = SparqlServer.handler(resolved);
+	return HttpRouter.use((router) => Effect.gen(function* () {
+		yield* router.add("*", `${resolved.path}*`, app);
+		yield* router.add("*", `${resolved.graphStorePath}*`, app);
+	}));
+};
+/**
+* Registers the API on the `HttpRouter`: the `HttpApiBuilder` routes with
+* their handlers and the `SchemaFallback` middleware, the fallback routes and, with `openapiPath`, the OpenAPI
+* document.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerRoutes = (options) => {
+	const resolved = serverOptions(options);
+	const api = make(resolved);
+	const schemaFallback = layerSchemaFallback(options);
+	return Layer.mergeAll(HttpApiBuilder.layer(api, { openapiPath: options?.openapiPath }).pipe(Layer.provide(handlersFor(api, resolved).pipe(Layer.provide(schemaFallback)))), layerFallback(options));
+};
+/**
+* Serves the API routes with `HttpRouter.serve` on an `HttpServer` from the
+* context (logging requests unless `logging: false`); the server layer (such
+* as `NodeHttpServer.layer`) also provides the platform services
+* `HttpApiBuilder` needs.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerServe = (options) => HttpRouter.serve(layerRoutes({
+	...options,
+	logging: false
+}), { disableLogger: options?.logging === false });
+/**
+* In-process testing: builds a client for the `SparqlApi` routes
+* (`layerRoutes(options)`) using the server's services from
+* the context. The routes live as long as the surrounding scope.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeTestClient = (options) => Effect.gen(function* () {
+	const scope = yield* Scope.Scope;
+	const context = yield* Effect.context();
+	const app = yield* HttpRouter.toHttpEffect(layerRoutes(options).pipe(Layer.provide(HttpServer.layerServices)));
+	return Testing.fromApp(app.pipe(Effect.catchCause((cause) => Effect.map(HttpServerError.causeResponse(cause), ([response]) => response)), Effect.provideService(Scope.Scope, scope), Effect.provideContext(context)));
+});
+export { layerSchemaFallback as a, layerRoutes as i, layerFallback as n, layerServe as o, layerHandlers as r, makeTestClient as s, SparqlApiBuilder_exports as t };
+
+//# sourceMappingURL=SparqlApiBuilder-GT7EopBq.mjs.map