@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/src/sparql/Options.ts

@@ -0,0 +1,191 @@
+/**
+ * Server configuration.
+ *
+ * @since 0.1.0
+ */
+import * as Duration from 'effect/Duration';
+import * as Result from 'effect/Result';
+import type * as HttpServerRequest from 'effect/http/HttpServerRequest';
+
+/**
+ * CORS settings.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface CorsOptions {
+  /** Allowed origins (default: any, `*`). */
+  readonly allowedOrigins?: ReadonlyArray<string> | undefined;
+  /** Allowed request headers (default: whatever the preflight asks for). */
+  readonly allowedHeaders?: ReadonlyArray<string> | undefined;
+  /** Response headers exposed to scripts. */
+  readonly exposedHeaders?: ReadonlyArray<string> | undefined;
+  /** Preflight cache duration in seconds. */
+  readonly maxAge?: number | undefined;
+  /** Whether to allow credentials. */
+  readonly credentials?: boolean | undefined;
+}
+
+/**
+ * Server options. Every field is optional.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Options {
+  /** Path of the SPARQL query endpoint (default `/sparql`). */
+  readonly path?: `/${string}` | undefined;
+  /**
+   * Path of the SPARQL update endpoint (default: the query endpoint, which
+   * then accepts both).
+   */
+  readonly updatePath?: `/${string}` | undefined;
+  /**
+   * Path of the Graph Store Protocol endpoint (default `/rdf-graph-store`),
+   * or `false` to disable it. Graphs are identified indirectly with
+   * `?default` / `?graph=<iri>` on this path, or directly by any URL below it.
+   */
+  readonly graphStorePath?: `/${string}` | false | undefined;
+  /**
+   * The public origin of the server (e.g. `https://data.example.org`), used to
+   * build the request URLs that serve as base IRIs and as directly
+   * identified graph IRIs. Defaults to the request's `Host` header (and
+   * `X-Forwarded-Proto`).
+   */
+  readonly baseUrl?: string | undefined;
+  /**
+   * The base IRI for queries and updates. Defaults to the endpoint URL, as
+   * suggested by the protocol.
+   */
+  readonly baseIri?: string | undefined;
+  /** Rejects updates and Graph Store writes (default `false`). */
+  readonly readOnly?: boolean | undefined;
+  /**
+   * Time limit for evaluating a query. A query that produces no result in
+   * time is answered with `503 Service Unavailable`; a streaming response
+   * that exceeds it is aborted.
+   */
+  readonly queryTimeout?: Duration.Input | undefined;
+  /** Time limit for an update request (`503` when exceeded). */
+  readonly updateTimeout?: Duration.Input | undefined;
+  /** The maximum number of solutions or triples returned by a query. */
+  readonly maxResults?: number | undefined;
+  /** Enables CORS (`true` for permissive defaults). */
+  readonly cors?: boolean | CorsOptions | undefined;
+  /** Logs every request with Effect logging (default `false` for the handler). */
+  readonly logging?: boolean | undefined;
+  /** Serve a service description on `GET` without a query (default `true`). */
+  readonly serviceDescription?: boolean | undefined;
+  /** Advertised in the service description: `sd:UnionDefaultGraph`. */
+  readonly unionDefaultGraph?: boolean | undefined;
+  /** Advertised in the service description: `sd:BasicFederatedQuery`. */
+  readonly federation?: boolean | undefined;
+  /** Prefixes used when serialising graphs in syntaxes that support them. */
+  readonly prefixes?: Readonly<Record<string, string>> | undefined;
+}
+
+/**
+ * Options with defaults applied.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Resolved {
+  readonly path: `/${string}`;
+  readonly updatePath: `/${string}`;
+  readonly graphStorePath: `/${string}` | undefined;
+  readonly baseUrl: string | undefined;
+  readonly baseIri: string | undefined;
+  readonly readOnly: boolean;
+  readonly queryTimeout: Duration.Duration | undefined;
+  readonly updateTimeout: Duration.Duration | undefined;
+  readonly maxResults: number | undefined;
+  readonly cors: CorsOptions | undefined;
+  readonly logging: boolean;
+  readonly serviceDescription: boolean;
+  readonly unionDefaultGraph: boolean;
+  readonly federation: boolean;
+  readonly prefixes: Readonly<Record<string, string>>;
+}
+
+/** Removes a trailing slash (but not the root's): the path still starts with `/`. */
+const trimSlash = (path: `/${string}`): `/${string}` =>
+  path.length > 1 && path.endsWith('/') ? `/${path.slice(1, -1)}` : path;
+
+/**
+ * Applies the defaults.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const resolve = (options: Options = {}): Resolved => {
+  const path = trimSlash(options.path ?? '/sparql');
+  return {
+    path,
+    updatePath: trimSlash(options.updatePath ?? path),
+    graphStorePath:
+      options.graphStorePath === false
+        ? undefined
+        : trimSlash(options.graphStorePath ?? '/rdf-graph-store'),
+    baseUrl: options.baseUrl,
+    baseIri: options.baseIri,
+    readOnly: options.readOnly ?? false,
+    queryTimeout:
+      options.queryTimeout === undefined
+        ? undefined
+        : Duration.fromInputUnsafe(options.queryTimeout),
+    updateTimeout:
+      options.updateTimeout === undefined
+        ? undefined
+        : Duration.fromInputUnsafe(options.updateTimeout),
+    maxResults: options.maxResults,
+    cors: options.cors === true ? {} : options.cors === false ? undefined : options.cors,
+    logging: options.logging ?? false,
+    serviceDescription: options.serviceDescription ?? true,
+    unionDefaultGraph: options.unionDefaultGraph ?? false,
+    federation: options.federation ?? false,
+    prefixes: options.prefixes ?? {},
+  };
+};
+
+const stripTrailing = (path: string): string =>
+  path.length > 1 && path.endsWith('/') ? path.slice(0, -1) : path;
+
+/**
+ * The absolute URL of a request (without fragment), using `baseUrl`, the
+ * request's absolute URL, or its `Host` header.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export const requestUrl = (
+  request: HttpServerRequest.HttpServerRequest,
+  options: Resolved,
+): URL => {
+  const raw = request.originalUrl;
+  const parsed = new URL(raw, 'http://localhost');
+  if (options.baseUrl !== undefined) {
+    return new URL(parsed.pathname + parsed.search, options.baseUrl);
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(raw)) return parsed;
+  const host = request.headers['host'] ?? 'localhost';
+  const proto = ((request.headers['x-forwarded-proto'] ?? 'http').split(',', 1)[0] ?? '').trim();
+  return new URL(parsed.pathname + parsed.search, `${proto}://${host}`);
+};
+
+/**
+ * The path of a request URL, without query string and trailing slash.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export const requestPath = (url: string): string => {
+  const pathname = new URL(url, 'http://localhost').pathname;
+  // A malformed percent-encoding is matched as written.
+  return stripTrailing(
+    Result.getOrElse(
+      Result.try(() => decodeURI(pathname)),
+      () => pathname,
+    ),
+  );
+};

package/src/sparql/Parser.ts

@@ -0,0 +1,173 @@
+/**
+ * A complete parser for SPARQL 1.1 Query and Update, written with
+ * `@thomasfosterau/effect-parse` (see `internal/parser.ts`), including the SPARQL 1.2 additions (triple terms, reified triples,
+ * annotations, `VERSION`, directional language tags and the new built-in
+ * functions).
+ *
+ * The parser expands all abbreviations (prefixed names, relative IRIs,
+ * `a`, blank node property lists, collections, reifiers and annotations)
+ * and enforces the static constraints of the specification (blank node
+ * label scoping, grouping rules, `BIND`/`AS` scoping, `VALUES` arity,
+ * variable-free `INSERT DATA`, blank-node-free `DELETE` templates, …).
+ *
+ * @since 0.1.0
+ */
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Result from 'effect/Result';
+import * as Schema from 'effect/Schema';
+import type * as Ast from './Ast.ts';
+import * as Internal from './internal/parser.ts';
+
+// -----------------------------------------------------------------------------
+// Errors and options
+// -----------------------------------------------------------------------------
+
+/**
+ * A syntax (or static semantic) error in a SPARQL query or update.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export class SparqlParseError extends Schema.TaggedError<SparqlParseError>()('SparqlParseError', {
+  message: Schema.String,
+  /** 1-based line of the error. */
+  line: Schema.Number,
+  /** 1-based column of the error. */
+  column: Schema.Number,
+  /** 0-based character offset of the error. */
+  offset: Schema.Number,
+}) {}
+
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface ParseOptions {
+  /** The base IRI used to resolve relative IRIs (unless overridden by `BASE`). */
+  readonly baseIri?: string | undefined;
+  /** Prefixes available without declaration. */
+  readonly prefixes?: Readonly<Record<string, string>> | undefined;
+}
+
+// -----------------------------------------------------------------------------
+// Entry points
+// -----------------------------------------------------------------------------
+
+const position = (input: string, offset: number) => {
+  const before = input.slice(0, Math.max(0, Math.min(offset, input.length)));
+  const lineStart = before.lastIndexOf('\n') + 1;
+  return { line: before.split('\n').length, column: offset - lineStart + 1 };
+};
+
+/** The base IRI and prefixes of `options`, as the internal parser takes them. */
+const internalOptions = (
+  options?: ParseOptions,
+): readonly [Option.Option<string>, Readonly<Record<string, string>>] => [
+  Option.fromUndefinedOr(options?.baseIri),
+  options?.prefixes ?? {},
+];
+
+const toError =
+  (input: string) =>
+  (e: Internal.Failure): SparqlParseError => {
+    const { line, column } = position(input, e.offset);
+    return new SparqlParseError({
+      message: `${e.message} (line ${line}, column ${column})`,
+      line,
+      column,
+      offset: e.offset,
+    });
+  };
+
+/**
+ * Parses a SPARQL query, returning a `Result`.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseQueryResult = (
+  input: string,
+  options?: ParseOptions,
+): Result.Result<Ast.Query, SparqlParseError> =>
+  Result.mapError(Internal.parseQuery(input, ...internalOptions(options)), toError(input));
+
+/**
+ * Parses a SPARQL update request, returning a `Result`.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseUpdateResult = (
+  input: string,
+  options?: ParseOptions,
+): Result.Result<Ast.Update, SparqlParseError> =>
+  Result.mapError(Internal.parseUpdate(input, ...internalOptions(options)), toError(input));
+
+/**
+ * Parses a SPARQL query.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseQuery = (
+  input: string,
+  options?: ParseOptions,
+): Effect.Effect<Ast.Query, SparqlParseError> =>
+  Effect.suspend(() => Effect.fromResult(parseQueryResult(input, options)));
+
+/**
+ * Parses a SPARQL update request.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseUpdate = (
+  input: string,
+  options?: ParseOptions,
+): Effect.Effect<Ast.Update, SparqlParseError> =>
+  Effect.suspend(() => Effect.fromResult(parseUpdateResult(input, options)));
+
+/**
+ * Parses either a query or an update request: the text is parsed as a query
+ * first and, if that fails, as an update.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parse = (
+  input: string,
+  options?: ParseOptions,
+): Effect.Effect<Ast.Query | Ast.Update, SparqlParseError> =>
+  Effect.suspend((): Effect.Effect<Ast.Query | Ast.Update, SparqlParseError> => {
+    const q = parseQueryResult(input, options);
+    if (Result.isSuccess(q)) return Effect.succeed(q.success);
+    const u = parseUpdateResult(input, options);
+    if (Result.isSuccess(u)) return Effect.succeed(u.success);
+    // Report the error of the parse that got further.
+    return Effect.fail(q.failure.offset >= u.failure.offset ? q.failure : u.failure);
+  });
+
+/**
+ * Parses a SPARQL query, throwing a `SparqlParseError` on failure.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseQueryUnsafe = (input: string, options?: ParseOptions): Ast.Query => {
+  const r = parseQueryResult(input, options);
+  if (Result.isFailure(r)) throw r.failure;
+  return r.success;
+};
+
+/**
+ * Parses a SPARQL update request, throwing a `SparqlParseError` on failure.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseUpdateUnsafe = (input: string, options?: ParseOptions): Ast.Update => {
+  const r = parseUpdateResult(input, options);
+  if (Result.isFailure(r)) throw r.failure;
+  return r.success;
+};

package/src/sparql/Protocol.ts

@@ -0,0 +1,342 @@
+/**
+ * Decoding of SPARQL 1.1 Protocol requests.
+ *
+ * A request to the SPARQL endpoint is one of
+ *
+ * - a query: `GET` with a `query` parameter, `POST` with an
+ *   `application/x-www-form-urlencoded` body holding `query`, or `POST` with
+ *   an `application/sparql-query` body;
+ * - an update: `POST` with an `application/x-www-form-urlencoded` body
+ *   holding `update`, or `POST` with an `application/sparql-update` body;
+ * - a service description request: `GET` without `query`.
+ *
+ * The dataset parameters (`default-graph-uri` / `named-graph-uri` for
+ * queries, `using-graph-uri` / `using-named-graph-uri` for updates) come from
+ * the URL query string, and also from the body of a form request.
+ *
+ * @since 0.1.0
+ */
+import * as Match from 'effect/Match';
+import * as Arr from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type * as HttpServerRequest from 'effect/http/HttpServerRequest';
+import * as Iri from '../Iri.ts';
+import * as Term from '../Term.ts';
+import type * as Store from './Store.ts';
+import * as ProtocolErrors from './ProtocolErrors.ts';
+
+/**
+ * The media type of a direct `POST` query body.
+ *
+ * @since 0.1.0
+ * @category media types
+ */
+export const SPARQL_QUERY = 'application/sparql-query';
+
+/**
+ * The media type of a direct `POST` update body.
+ *
+ * @since 0.1.0
+ * @category media types
+ */
+export const SPARQL_UPDATE = 'application/sparql-update';
+
+/**
+ * The media type of form-encoded requests.
+ *
+ * @since 0.1.0
+ * @category media types
+ */
+export const FORM = 'application/x-www-form-urlencoded';
+
+/**
+ * A decoded protocol operation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Operation =
+  | {
+      readonly _tag: 'Query';
+      readonly query: string;
+      /** The protocol dataset (`default-graph-uri` / `named-graph-uri`), if any. */
+      readonly dataset: Store.DatasetSpec | undefined;
+    }
+  | {
+      readonly _tag: 'Update';
+      readonly update: string;
+      /** The protocol dataset (`using-graph-uri` / `using-named-graph-uri`), if any. */
+      readonly using: Store.DatasetSpec | undefined;
+    }
+  | { readonly _tag: 'ServiceDescription' };
+
+/**
+ * A parsed `Content-Type` header.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ContentType {
+  readonly mediaType: string;
+  readonly parameters: Readonly<Record<string, string>>;
+}
+
+/**
+ * Parses a `Content-Type` header (media type lower-cased, parameter names
+ * lower-cased, quotes removed).
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseContentType = (header: string | undefined): ContentType | undefined => {
+  if (header === undefined || header.trim() === '') return undefined;
+  const [type, ...params] = header.split(';');
+  const parameters: Record<string, string> = {};
+  params.forEach((p) => {
+    const eq = p.indexOf('=');
+    if (eq < 0) return;
+    const key = p.slice(0, eq).trim().toLowerCase();
+    const raw = p.slice(eq + 1).trim();
+    parameters[key] =
+      raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2 ? raw.slice(1, -1) : raw;
+  });
+  return { mediaType: (type ?? '').trim().toLowerCase(), parameters };
+};
+
+/**
+ * Whether a content type declares a charset other than UTF-8.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const isNonUtf8 = (contentType: ContentType): boolean => {
+  const charset = contentType.parameters['charset'];
+  return charset !== undefined && !/^utf-?8$/i.test(charset);
+};
+
+/**
+ * The query string parameters of a request URL.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const searchParams = (url: string): URLSearchParams => {
+  const q = url.indexOf('?');
+  if (q < 0) return new URLSearchParams();
+  const hash = url.indexOf('#', q);
+  return new URLSearchParams(url.slice(q + 1, hash < 0 ? undefined : hash));
+};
+
+const graphList = (
+  values: ReadonlyArray<string>,
+  baseIri: string,
+): Effect.Effect<Array<Term.NamedNode>, ProtocolErrors.ProtocolError> =>
+  Effect.forEach(
+    values,
+    (value) => {
+      const iri = Iri.resolve(value, baseIri);
+      return Iri.isAbsolute(iri) && !/[\s<>"{}|^`\\]/.test(iri)
+        ? Effect.succeed(Term.namedNode(iri))
+        : Effect.fail(ProtocolErrors.badRequest(`Invalid graph IRI: ${value}`));
+    },
+    { concurrency: 1 },
+  );
+
+/**
+ * Builds the dataset described by protocol parameters (`undefined` when no
+ * parameter is present). When only named graphs are given the default graph
+ * is empty, as for `FROM NAMED` in a query.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const datasetFromParams = (
+  params: URLSearchParams,
+  defaultName: string,
+  namedName: string,
+  baseIri: string,
+): Effect.Effect<Store.DatasetSpec | undefined, ProtocolErrors.ProtocolError> =>
+  Effect.gen(function* () {
+    const defaults = params.getAll(defaultName);
+    const named = params.getAll(namedName);
+    if (Arr.isReadonlyArrayEmpty(defaults) && Arr.isReadonlyArrayEmpty(named)) return undefined;
+    return {
+      defaultGraph: yield* graphList(defaults, baseIri),
+      namedGraphs: yield* graphList(named, baseIri),
+    };
+  });
+
+const merge = (a: URLSearchParams, b: URLSearchParams): URLSearchParams => {
+  const out = new URLSearchParams(a);
+  b.forEach((v, k) => out.append(k, v));
+  return out;
+};
+
+const single = (
+  params: URLSearchParams,
+  name: string,
+): Effect.Effect<Option.Option<string>, ProtocolErrors.ProtocolError> => {
+  const values = params.getAll(name);
+  if (values.length > 1) {
+    return Effect.fail(ProtocolErrors.badRequest(`Exactly one '${name}' parameter is allowed`));
+  }
+  return Effect.succeed(Arr.head(values));
+};
+
+const readBody = (
+  request: HttpServerRequest.HttpServerRequest,
+): Effect.Effect<string, ProtocolErrors.ProtocolError> =>
+  Effect.mapError(request.text, (e) =>
+    ProtocolErrors.badRequest(`Could not read the request body: ${e.message}`),
+  );
+
+/**
+ * What a SPARQL endpoint accepts.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EndpointKind {
+  readonly query: boolean;
+  readonly update: boolean;
+}
+
+const fromParams = (
+  params: URLSearchParams,
+  kind: EndpointKind,
+  method: string,
+  baseIri: string,
+): Effect.Effect<Operation, ProtocolErrors.ProtocolError> =>
+  Effect.gen(function* () {
+    const query = yield* single(params, 'query');
+    const update = yield* single(params, 'update');
+    if (Option.isSome(query) && Option.isSome(update)) {
+      return yield* ProtocolErrors.badRequest("A request cannot have both 'query' and 'update'");
+    }
+    if (Option.isSome(update)) {
+      if (method !== 'POST') {
+        return yield* ProtocolErrors.badRequest('Updates must be sent with POST');
+      }
+      if (!kind.update)
+        return yield* ProtocolErrors.badRequest('This endpoint does not accept updates');
+      const using = yield* datasetFromParams(
+        params,
+        'using-graph-uri',
+        'using-named-graph-uri',
+        baseIri,
+      );
+      return { _tag: 'Update', update: update.value, using } as const;
+    }
+    if (Option.isSome(query)) {
+      if (!kind.query)
+        return yield* ProtocolErrors.badRequest('This endpoint does not accept queries');
+      const dataset = yield* datasetFromParams(
+        params,
+        'default-graph-uri',
+        'named-graph-uri',
+        baseIri,
+      );
+      return { _tag: 'Query', query: query.value, dataset } as const;
+    }
+    if (method === 'GET' || method === 'HEAD') return { _tag: 'ServiceDescription' } as const;
+    return yield* ProtocolErrors.badRequest("Missing 'query' or 'update' parameter");
+  });
+
+/**
+ * Decodes a request to the SPARQL endpoint. `baseIri` resolves relative
+ * graph IRIs in the dataset parameters.
+ *
+ * @since 0.1.0
+ * @category decoding
+ */
+export const decode = (
+  request: HttpServerRequest.HttpServerRequest,
+  kind: EndpointKind,
+  baseIri: string,
+): Effect.Effect<Operation, ProtocolErrors.ProtocolError> =>
+  Effect.gen(function* () {
+    const method = request.method;
+    const urlParams = searchParams(request.url);
+    if (method === 'GET' || method === 'HEAD') {
+      return yield* fromParams(urlParams, kind, method, baseIri);
+    }
+    if (method !== 'POST') {
+      return yield* ProtocolErrors.methodNotAllowed(method, ['GET', 'POST']);
+    }
+    const contentType = parseContentType(request.headers['content-type']);
+    if (contentType === undefined) {
+      return yield* ProtocolErrors.unsupportedMediaType(
+        `A POST request needs a Content-Type of ${FORM}, ${SPARQL_QUERY} or ${SPARQL_UPDATE}`,
+      );
+    }
+    if (isNonUtf8(contentType)) {
+      return yield* ProtocolErrors.unsupportedMediaType(
+        `Unsupported charset '${contentType.parameters['charset']}' (only UTF-8 is accepted)`,
+      );
+    }
+    return yield* Match.value(contentType).pipe(
+      Match.when({ mediaType: FORM }, () =>
+        Effect.gen(function* () {
+          const body = yield* readBody(request);
+          return yield* fromParams(
+            merge(urlParams, new URLSearchParams(body)),
+            kind,
+            method,
+            baseIri,
+          );
+        }),
+      ),
+      Match.when({ mediaType: SPARQL_QUERY }, () =>
+        Effect.gen(function* () {
+          if (!kind.query) {
+            return yield* ProtocolErrors.unsupportedMediaType(
+              'This endpoint does not accept queries',
+            );
+          }
+          if (urlParams.has('query') || urlParams.has('update')) {
+            return yield* ProtocolErrors.badRequest(
+              `A ${SPARQL_QUERY} request cannot also have a 'query' or 'update' parameter`,
+            );
+          }
+          const query = yield* readBody(request);
+          const dataset = yield* datasetFromParams(
+            urlParams,
+            'default-graph-uri',
+            'named-graph-uri',
+            baseIri,
+          );
+          return { _tag: 'Query', query, dataset } as const;
+        }),
+      ),
+      Match.when({ mediaType: SPARQL_UPDATE }, () =>
+        Effect.gen(function* () {
+          if (!kind.update) {
+            return yield* ProtocolErrors.unsupportedMediaType(
+              'This endpoint does not accept updates',
+            );
+          }
+          if (urlParams.has('query') || urlParams.has('update')) {
+            return yield* ProtocolErrors.badRequest(
+              `A ${SPARQL_UPDATE} request cannot also have a 'query' or 'update' parameter`,
+            );
+          }
+          const update = yield* readBody(request);
+          const using = yield* datasetFromParams(
+            urlParams,
+            'using-graph-uri',
+            'using-named-graph-uri',
+            baseIri,
+          );
+          return { _tag: 'Update', update, using } as const;
+        }),
+      ),
+      Match.orElse((other) =>
+        Effect.gen(function* () {
+          return yield* ProtocolErrors.unsupportedMediaType(
+            `Unsupported Content-Type '${other.mediaType}'; expected ${FORM}, ${SPARQL_QUERY} or ${SPARQL_UPDATE}`,
+          );
+        }),
+      ),
+    );
+  });