@thomasfosterau/effect-sparql-node 0.0.0 → 0.1.0

package/dist/SparqlApiBuilder-GT7EopBq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparqlApiBuilder-GT7EopBq.mjs","names":["SparqlApi.make","SparqlApi.SchemaFallback"],"sources":["../src/SparqlApiBuilder.ts"],"sourcesContent":["/**\n * Serves the `SparqlApi` definition with `HttpApiBuilder`.\n *\n * Every endpoint is implemented with a raw handler (`handleRaw`) that runs\n * the same code as `SparqlServer`: the request body, `Accept` and\n * `Content-Type` are read by the protocol internals, so responses, statuses\n * and error messages are those of `SparqlServer.handler`. Routes the API does\n * not declare (other methods on the endpoints, which get `405` with\n * `Allow`; `OPTIONS` preflights when CORS is on; graphs identified directly\n * by a URL below the graph store) are registered as plain `HttpRouter`\n * fallback routes to `SparqlServer.handler`.\n *\n * `effect/http-api` is `@stability unstable` in Effect 4.\n *\n * @since 0.1.0\n */\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Scope from 'effect/Scope';\nimport type * as HttpClient from 'effect/http/HttpClient';\nimport * as HttpRouter from 'effect/http/HttpRouter';\nimport * as HttpServer from 'effect/http/HttpServer';\nimport * as HttpServerError from 'effect/http/HttpServerError';\nimport * as HttpApiBuilder from 'effect/http-api/HttpApiBuilder';\nimport * as HttpApiMiddleware from 'effect/http-api/HttpApiMiddleware';\nimport type * as Options from '@thomasfosterau/effect-rdf/sparql/Options';\nimport * as SparqlApi from './SparqlApi.ts';\nimport * as SparqlServer from '@thomasfosterau/effect-rdf/sparql/SparqlServer';\nimport * as Testing from '@thomasfosterau/effect-rdf/sparql/Testing';\n\n/**\n * Options of the API server: the server options, with the endpoint paths of\n * the API (the update endpoint is the query endpoint) and where to serve the\n * OpenAPI document.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ApiOptions\n  extends Omit<Options.Options, 'path' | 'updatePath' | 'graphStorePath'>, SparqlApi.Paths {\n  /** Serves the OpenAPI document (`SparqlApi.openApi`) as JSON at this path. */\n  readonly openapiPath?: `/${string}` | undefined;\n}\n\ninterface ServerPaths {\n  readonly path: `/${string}`;\n  readonly graphStorePath: `/${string}`;\n}\n\nconst serverOptions = (options?: ApiOptions): Options.Options & ServerPaths => {\n  const path = options?.path ?? '/sparql';\n  return {\n    ...options,\n    path,\n    updatePath: path,\n    graphStorePath: options?.graphStorePath ?? '/rdf-graph-store',\n  };\n};\n\nconst handlersFor = (api: SparqlApi.Api, options: Options.Options) => {\n  const sparql = SparqlServer.sparqlHandler(options);\n  const graphStore = SparqlServer.graphStoreHandler(options);\n  return Layer.mergeAll(\n    HttpApiBuilder.group(api, 'sparql', (handlers) =>\n      handlers.handleRaw('query', () => sparql).handleRaw('post', () => sparql),\n    ),\n    HttpApiBuilder.group(api, 'graphStore', (handlers) =>\n      handlers\n        .handleRaw('get', () => graphStore)\n        .handleRaw('head', () => graphStore)\n        .handleRaw('put', () => graphStore)\n        .handleRaw('post', () => graphStore)\n        .handleRaw('delete', () => graphStore),\n    ),\n  );\n};\n\n/**\n * The handlers of both API groups (`sparql` and `graphStore`) for the API at\n * the options' paths, using the server's services from the context.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerHandlers = (options?: ApiOptions) => {\n  const resolved = serverOptions(options);\n  return handlersFor(SparqlApi.make(resolved), resolved);\n};\n\n/**\n * The `SparqlApi.SchemaFallback` middleware: a request whose parameters or\n * headers fail the API's schemas is answered by `SparqlServer.handler`, so\n * it gets the protocol's own status and message (e.g. `400` \"Exactly one\n * 'query' parameter is allowed\"). Response encoding failures stay `500`.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerSchemaFallback = (\n  options?: ApiOptions,\n): Layer.Layer<SparqlApi.SchemaFallback> => {\n  const app = SparqlServer.handler(serverOptions(options));\n  return HttpApiMiddleware.layerSchemaErrorTransform(SparqlApi.SchemaFallback, (error) =>\n    error.kind === 'Body' || error.kind === 'ResponseHeaders' ? Effect.fail(error) : app,\n  );\n};\n\n/**\n * The fallback routes: every method on `<path>*` and `<graphStorePath>*`\n * that the API does not declare, answered by `SparqlServer.handler` (`405`\n * with `Allow`, CORS preflights, direct graph identification, `404` for\n * other paths).\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerFallback = (\n  options?: ApiOptions,\n): Layer.Layer<\n  never,\n  never,\n  HttpRouter.HttpRouter | HttpRouter.Request.From<'Requires', SparqlServer.Requirements>\n> => {\n  const resolved = serverOptions(options);\n  const app = SparqlServer.handler(resolved);\n  return HttpRouter.use((router) =>\n    Effect.gen(function* () {\n      // A wildcard right after the path matches the path itself (for methods the API does not\n      // declare) and everything below it, without clashing with the API's own routes.\n      yield* router.add('*', `${resolved.path}*`, app);\n      yield* router.add('*', `${resolved.graphStorePath}*`, app);\n    }),\n  );\n};\n\n/**\n * Registers the API on the `HttpRouter`: the `HttpApiBuilder` routes with\n * their handlers and the `SchemaFallback` middleware, the fallback routes and, with `openapiPath`, the OpenAPI\n * document.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerRoutes = (options?: ApiOptions) => {\n  const resolved = serverOptions(options);\n  const api = SparqlApi.make(resolved);\n  const schemaFallback = layerSchemaFallback(options);\n  return Layer.mergeAll(\n    HttpApiBuilder.layer(api, { openapiPath: options?.openapiPath }).pipe(\n      Layer.provide(handlersFor(api, resolved).pipe(Layer.provide(schemaFallback))),\n    ),\n    layerFallback(options),\n  );\n};\n\n/**\n * Serves the API routes with `HttpRouter.serve` on an `HttpServer` from the\n * context (logging requests unless `logging: false`); the server layer (such\n * as `NodeHttpServer.layer`) also provides the platform services\n * `HttpApiBuilder` needs.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerServe = (options?: ApiOptions) =>\n  HttpRouter.serve(layerRoutes({ ...options, logging: false }), {\n    disableLogger: options?.logging === false,\n  });\n\n/**\n * In-process testing: builds a client for the `SparqlApi` routes\n * (`layerRoutes(options)`) using the server's services from\n * the context. The routes live as long as the surrounding scope.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeTestClient = (\n  options?: ApiOptions,\n): Effect.Effect<HttpClient.HttpClient, never, SparqlServer.Requirements | Scope.Scope> =>\n  Effect.gen(function* () {\n    const scope = yield* Scope.Scope;\n    const context = yield* Effect.context<SparqlServer.Requirements>();\n    const app = yield* HttpRouter.toHttpEffect(\n      layerRoutes(options).pipe(Layer.provide(HttpServer.layerServices)),\n    );\n    return Testing.fromApp(\n      app.pipe(\n        Effect.catchCause((cause) =>\n          Effect.map(HttpServerError.causeResponse(cause), ([response]) => response),\n        ),\n        Effect.provideService(Scope.Scope, scope),\n        Effect.provideContext(context),\n      ),\n    );\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAM,iBAAiB,YAAwD;CAC7E,MAAM,OAAO,SAAS,QAAQ;CAC9B,OAAO;EACL,GAAG;EACH;EACA,YAAY;EACZ,gBAAgB,SAAS,kBAAkB;CAC7C;AACF;AAEA,MAAM,eAAe,KAAoB,YAA6B;CACpE,MAAM,SAAS,aAAa,cAAc,OAAO;CACjD,MAAM,aAAa,aAAa,kBAAkB,OAAO;CACzD,OAAO,MAAM,SACX,eAAe,MAAM,KAAK,WAAW,aACnC,SAAS,UAAU,eAAe,MAAM,CAAC,CAAC,UAAU,cAAc,MAAM,CAC1E,GACA,eAAe,MAAM,KAAK,eAAe,aACvC,SACG,UAAU,aAAa,UAAU,CAAC,CAClC,UAAU,cAAc,UAAU,CAAC,CACnC,UAAU,aAAa,UAAU,CAAC,CAClC,UAAU,cAAc,UAAU,CAAC,CACnC,UAAU,gBAAgB,UAAU,CACzC,CACF;AACF;;;;;;;;AASA,MAAa,iBAAiB,YAAyB;CACrD,MAAM,WAAW,cAAc,OAAO;CACtC,OAAO,YAAYA,KAAe,QAAQ,GAAG,QAAQ;AACvD;;;;;;;;;;AAWA,MAAa,uBACX,YAC0C;CAC1C,MAAM,MAAM,aAAa,QAAQ,cAAc,OAAO,CAAC;CACvD,OAAO,kBAAkB,0BAA0BC,iBAA2B,UAC5E,MAAM,SAAS,UAAU,MAAM,SAAS,oBAAoB,OAAO,KAAK,KAAK,IAAI,GACnF;AACF;;;;;;;;;;AAWA,MAAa,iBACX,YAKG;CACH,MAAM,WAAW,cAAc,OAAO;CACtC,MAAM,MAAM,aAAa,QAAQ,QAAQ;CACzC,OAAO,WAAW,KAAK,WACrB,OAAO,IAAI,aAAa;EAGtB,OAAO,OAAO,IAAI,KAAK,GAAG,SAAS,KAAK,IAAI,GAAG;EAC/C,OAAO,OAAO,IAAI,KAAK,GAAG,SAAS,eAAe,IAAI,GAAG;CAC3D,CAAC,CACH;AACF;;;;;;;;;AAUA,MAAa,eAAe,YAAyB;CACnD,MAAM,WAAW,cAAc,OAAO;CACtC,MAAM,MAAMD,KAAe,QAAQ;CACnC,MAAM,iBAAiB,oBAAoB,OAAO;CAClD,OAAO,MAAM,SACX,eAAe,MAAM,KAAK,EAAE,aAAa,SAAS,YAAY,CAAC,CAAC,CAAC,KAC/D,MAAM,QAAQ,YAAY,KAAK,QAAQ,CAAC,CAAC,KAAK,MAAM,QAAQ,cAAc,CAAC,CAAC,CAC9E,GACA,cAAc,OAAO,CACvB;AACF;;;;;;;;;;AAWA,MAAa,cAAc,YACzB,WAAW,MAAM,YAAY;CAAE,GAAG;CAAS,SAAS;AAAM,CAAC,GAAG,EAC5D,eAAe,SAAS,YAAY,MACtC,CAAC;;;;;;;;;AAUH,MAAa,kBACX,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO,MAAM;CAC3B,MAAM,UAAU,OAAO,OAAO,QAAmC;CACjE,MAAM,MAAM,OAAO,WAAW,aAC5B,YAAY,OAAO,CAAC,CAAC,KAAK,MAAM,QAAQ,WAAW,aAAa,CAAC,CACnE;CACA,OAAO,QAAQ,QACb,IAAI,KACF,OAAO,YAAY,UACjB,OAAO,IAAI,gBAAgB,cAAc,KAAK,IAAI,CAAC,cAAc,QAAQ,CAC3E,GACA,OAAO,eAAe,MAAM,OAAO,KAAK,GACxC,OAAO,eAAe,OAAO,CAC/B,CACF;AACF,CAAC"}

package/dist/SparqlApiBuilder.d.mts

@@ -0,0 +1,2 @@
+import { a as layerRoutes, c as makeTestClient, i as layerHandlers, o as layerSchemaFallback, r as layerFallback, s as layerServe, t as ApiOptions } from "./SparqlApiBuilder-BAMpMy-Z.mjs";
+export { ApiOptions, layerFallback, layerHandlers, layerRoutes, layerSchemaFallback, layerServe, makeTestClient };

package/dist/SparqlApiBuilder.mjs

@@ -0,0 +1 @@
+export { n as layerFallback, r as layerHandlers, i as layerRoutes, a as layerSchemaFallback, o as layerServe, s as makeTestClient } from "./SparqlApiBuilder-GT7EopBq.mjs";

package/dist/SparqlApiClient-C82RGMEF.d.mts

@@ -0,0 +1,386 @@
+import { c as Paths, m as SchemaFallback, n as Api } from "./SparqlApi-BKE9nIf4.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Dataset from "@thomasfosterau/effect-rdf/Dataset";
+import * as ProtocolErrors from "@thomasfosterau/effect-rdf/sparql/ProtocolErrors";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+import * as HttpApiClient from "effect/http-api/HttpApiClient";
+import * as ClientErrors from "@thomasfosterau/effect-rdf/sparql/ClientErrors";
+import * as ResultsStream from "@thomasfosterau/effect-rdf/sparql/ResultsStream";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientError from "effect/http/HttpClientError";
+declare namespace SparqlApiClient_d_exports {
+  export { ApiError, Body, Client, GraphTarget, Options, QueryOptions, SparqlApiClient, UpdateOptions, construct, layer, make, query, readGraph, results, update, writeGraph };
+}
+/**
+ * The generated client of the `SparqlApi`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Client = HttpApiClient.ForApi<Api>;
+/**
+ * Options of the derived client.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Options {
+  /** The server's base URL (e.g. `https://example.org`); paths are appended to it. */
+  readonly baseUrl?: string | URL | undefined;
+  /** The endpoint paths, when the server does not use the defaults. */
+  readonly paths?: Paths | undefined;
+  /** Transforms the `HttpClient` (retries, authentication, …). */
+  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
+}
+/**
+ * Derives the client from the API definition, using the `HttpClient` from
+ * the context.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (options?: Options) => Effect.Effect<Client, never, HttpClient.HttpClient>;
+declare const SparqlApiClient_base: Context.ServiceClass<SparqlApiClient, "@thomasfosterau/effect-sparql-node/SparqlApiClient", {
+  readonly sparql: {
+    readonly query: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"query", "GET", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly query: Schema.optionalKey<Schema.String>;
+      readonly 'default-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'named-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly accept: Schema.optionalKey<Schema.String>;
+    }>>, import("effect/http-api/HttpApiSchema").StreamUint8Array, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+    readonly post: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"post", "POST", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly 'default-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'named-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'using-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'using-named-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>, Schema.toCodecJson<Schema.decodeTo<Schema.TaggedStruct<"DirectQuery", {
+      readonly query: Schema.String;
+    }>, Schema.String, never, never> | Schema.decodeTo<Schema.TaggedStruct<"DirectUpdate", {
+      readonly update: Schema.String;
+    }>, Schema.String, never, never> | Schema.Struct<{
+      readonly query: Schema.optionalKey<Schema.String>;
+      readonly update: Schema.optionalKey<Schema.String>;
+      readonly 'default-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'named-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'using-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+      readonly 'using-named-graph-uri': Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>, Schema.toCodecStringTree<Schema.Struct<{
+      readonly accept: Schema.optionalKey<Schema.String>;
+    }>>, import("effect/http-api/HttpApiSchema").StreamUint8Array | Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+  };
+  readonly graphStore: {
+    readonly get: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"get", "GET", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly graph: Schema.optionalKey<Schema.String>;
+      readonly default: Schema.optionalKey<Schema.String>;
+    }>>, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly accept: Schema.optionalKey<Schema.String>;
+    }>>, import("effect/http-api/HttpApiSchema").StreamUint8Array, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+    readonly head: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"head", "HEAD", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly graph: Schema.optionalKey<Schema.String>;
+      readonly default: Schema.optionalKey<Schema.String>;
+    }>>, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly accept: Schema.optionalKey<Schema.String>;
+    }>>, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+    readonly put: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"put", "PUT", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly graph: Schema.optionalKey<Schema.String>;
+      readonly default: Schema.optionalKey<Schema.String>;
+    }>>, Schema.toCodecJson<Schema.decodeTo<Schema.Struct<{
+      readonly mediaType: Schema.Literal<string>;
+      readonly document: Schema.String;
+    }>, Schema.String, never, never>>, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent | import("effect/http-api/HttpApiSchema").Created>, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+    readonly post: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"post", "POST", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly graph: Schema.optionalKey<Schema.String>;
+      readonly default: Schema.optionalKey<Schema.String>;
+    }>>, Schema.toCodecJson<Schema.decodeTo<Schema.Struct<{
+      readonly mediaType: Schema.Literal<string>;
+      readonly document: Schema.String;
+    }>, Schema.String, never, never>>, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent | import("effect/http-api/HttpApiSchema").Created>, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+    readonly delete: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"delete", "DELETE", `/${string}`, never, Schema.toCodecStringTree<Schema.Struct<{
+      readonly graph: Schema.optionalKey<Schema.String>;
+      readonly default: Schema.optionalKey<Schema.String>;
+    }>>, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<Schema.decodeTo<Schema.decodeTo<Schema.declareConstructor<ProtocolErrors.ProtocolError, {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }, readonly [Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>], {
+      readonly status: number;
+      readonly message: string;
+      readonly _tag: "ProtocolError";
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+    }>, Schema.TaggedStruct<"ProtocolError", {
+      readonly status: Schema.Number;
+      readonly message: Schema.String;
+      readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>, never, never>, Schema.String, never, never>>, SchemaFallback, import("effect/http-api/HttpApiMiddleware").ApplyServices<SchemaFallback, never>>, never, never>;
+  };
+}>;
+/**
+ * The derived client as a service.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+declare class SparqlApiClient extends SparqlApiClient_base {}
+/**
+ * A layer providing the derived client.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: (options?: Options) => Layer.Layer<SparqlApiClient, never, HttpClient.HttpClient>;
+/**
+ * Any failure of a derived client call: a protocol error status, a transport
+ * or decoding failure of the generated client, or an unreadable body.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+type ApiError = ProtocolErrors.ProtocolError | HttpClientError.HttpClientError | Schema.SchemaError | ClientErrors.MalformedResponseError | ClientErrors.UnsupportedMediaTypeError;
+/**
+ * A response body and its media type.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Body {
+  /** The media type of the body, without parameters. */
+  readonly mediaType: string;
+  readonly bytes: Stream.Stream<Uint8Array, ApiError>;
+}
+/**
+ * The protocol dataset of a query (`default-graph-uri` / `named-graph-uri`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface QueryOptions {
+  readonly defaultGraphs?: ReadonlyArray<string> | undefined;
+  readonly namedGraphs?: ReadonlyArray<string> | undefined;
+  /** The `Accept` header (default: every results and RDF format). */
+  readonly accept?: string | undefined;
+  /** `get` (default) sends `?query=`, `post` an `application/sparql-query` body. */
+  readonly method?: 'get' | 'post' | undefined;
+}
+/**
+ * The protocol dataset of an update (`using-graph-uri` /
+ * `using-named-graph-uri`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface UpdateOptions {
+  readonly usingGraphs?: ReadonlyArray<string> | undefined;
+  readonly usingNamedGraphs?: ReadonlyArray<string> | undefined;
+}
+/**
+ * The graph of a Graph Store request: the default graph or a graph IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GraphTarget = 'default' | {
+  readonly graph: string;
+};
+/**
+ * Sends a query and returns the response body with its media type, without
+ * parsing it.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const query: (client: Client, sparql: string, options?: QueryOptions) => Effect.Effect<Body, ApiError>;
+/**
+ * Sends a `SELECT` or `ASK` query and parses the results incrementally with
+ * `ResultsStream`.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const results: (client: Client, sparql: string, options?: QueryOptions) => Stream.Stream<ResultsStream.ResultEvent, ApiError>;
+/**
+ * Sends a `CONSTRUCT` or `DESCRIBE` query and parses the graph with the
+ * default `Formats` (relative IRIs resolve against `baseIri`).
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const construct: (client: Client, sparql: string, options?: QueryOptions & {
+  readonly baseIri?: string | undefined;
+}) => Effect.Effect<Dataset.Dataset, ApiError>;
+/**
+ * Sends an update as an `application/sparql-update` body.
+ *
+ * @since 0.1.0
+ * @category updates
+ */
+declare const update: (client: Client, sparql: string, options?: UpdateOptions) => Effect.Effect<void, ApiError>;
+/**
+ * Reads a graph from the graph store and parses it with the default
+ * `Formats`.
+ *
+ * @since 0.1.0
+ * @category graph store
+ */
+declare const readGraph: (client: Client, target: GraphTarget, options?: {
+  readonly accept?: string | undefined;
+  readonly baseIri?: string | undefined;
+}) => Effect.Effect<Dataset.Dataset, ApiError>;
+/**
+ * Writes an RDF document to a graph: `put` (default) replaces the graph,
+ * `post` adds to it. The document's media type must be one of
+ * `SparqlApi.rdfMediaTypes` (default `text/turtle`).
+ *
+ * @since 0.1.0
+ * @category graph store
+ */
+declare const writeGraph: (client: Client, target: GraphTarget, document: string, options?: {
+  readonly mediaType?: string | undefined;
+  readonly method?: "put" | "post" | undefined;
+}) => Effect.Effect<void, ApiError>;
+export { writeGraph as _, Options as a, SparqlApiClient_d_exports as c, layer as d, make as f, update as g, results as h, GraphTarget as i, UpdateOptions as l, readGraph as m, Body as n, QueryOptions as o, query as p, Client as r, SparqlApiClient as s, ApiError as t, construct as u };
+//# sourceMappingURL=SparqlApiClient-C82RGMEF.d.mts.map

package/dist/SparqlApiClient-CJcoFy5b.mjs

@@ -0,0 +1,203 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { _ as queryMediaTypes, h as make$1, v as rdfMediaTypes, y as resultsMediaTypes } from "./SparqlApi-BuycDkWu.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Serialization from "@thomasfosterau/effect-rdf/Serialization";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+import * as HttpApiClient from "effect/http-api/HttpApiClient";
+import * as ClientErrors from "@thomasfosterau/effect-rdf/sparql/ClientErrors";
+import * as ClientFormats from "@thomasfosterau/effect-rdf/sparql/ClientFormats";
+import * as ResultsStream from "@thomasfosterau/effect-rdf/sparql/ResultsStream";
+import * as SparqlClient from "@thomasfosterau/effect-rdf/sparql/SparqlClient";
+// src/SparqlApiClient.ts
+/**
+* A client derived with `HttpApiClient` from the `SparqlApi` definition,
+* alongside the hand-written `SparqlClient`.
+*
+* `make` returns the generated client: one method per endpoint
+* (`client.sparql.query`, `client.sparql.post`, `client.graphStore.get`, …)
+* taking the endpoint's typed `query`, `headers` and `payload` and returning
+* response bodies as byte streams. Error statuses decode into the server's
+* `ProtocolErrors.ProtocolError`. The helpers below (`query`, `results`,
+* `construct`, `update`, `readGraph`, `writeGraph`) send the common
+* requests and parse the bodies with the results parsers (`ResultsStream`)
+* and the default `Formats`.
+*
+* `effect/http-api` is `@stability unstable` in Effect 4, and so is this
+* client.
+*
+* @since 0.1.0
+*/
+var SparqlApiClient_exports = /* @__PURE__ */ __exportAll({
+	SparqlApiClient: () => SparqlApiClient,
+	construct: () => construct,
+	layer: () => layer,
+	make: () => make,
+	query: () => query,
+	readGraph: () => readGraph,
+	results: () => results,
+	update: () => update,
+	writeGraph: () => writeGraph
+});
+/**
+* Derives the client from the API definition, using the `HttpClient` from
+* the context.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (options) => HttpApiClient.make(make$1(options?.paths), {
+	baseUrl: options?.baseUrl,
+	transformClient: options?.transformClient
+});
+/**
+* The derived client as a service.
+*
+* @since 0.1.0
+* @category services
+*/
+var SparqlApiClient = class extends Context.Service()("@thomasfosterau/effect-sparql-node/SparqlApiClient") {};
+/**
+* A layer providing the derived client.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (options) => Layer.effect(SparqlApiClient, make(options));
+const mediaTypeOf = (response) => (response.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+const graphParams = (target) => target === "default" ? { default: "" } : { graph: target.graph };
+const queryDataset = (options) => ({
+	"default-graph-uri": options?.defaultGraphs ?? [],
+	"named-graph-uri": options?.namedGraphs ?? []
+});
+const updateDataset = (options) => ({
+	"using-graph-uri": options?.usingGraphs ?? [],
+	"using-named-graph-uri": options?.usingNamedGraphs ?? []
+});
+const queryHeaders = (accept) => ({ accept: accept ?? queryMediaTypes.join(", ") });
+/**
+* Sends a query and returns the response body with its media type, without
+* parsing it.
+*
+* @since 0.1.0
+* @category queries
+*/
+const query = (client, sparql, options) => {
+	const dataset = queryDataset(options);
+	const headers = queryHeaders(options?.accept);
+	const sent = options?.method === "post" ? client.sparql.post({
+		query: dataset,
+		headers,
+		payload: {
+			_tag: "DirectQuery",
+			query: sparql
+		},
+		responseMode: "decoded-and-response"
+	}) : client.sparql.query({
+		query: {
+			query: sparql,
+			...dataset
+		},
+		headers,
+		responseMode: "decoded-and-response"
+	});
+	return Effect.flatMap(sent, ([bytes, response]) => bytes === void 0 ? Effect.fail(new ClientErrors.MalformedResponseError({ message: `Expected a query result, got status ${response.status}` })) : Effect.succeed({
+		mediaType: mediaTypeOf(response),
+		bytes
+	}));
+};
+/**
+* Sends a `SELECT` or `ASK` query and parses the results incrementally with
+* `ResultsStream`.
+*
+* @since 0.1.0
+* @category queries
+*/
+const results = (client, sparql, options) => Stream.unwrap(Effect.flatMap(query(client, sparql, {
+	...options,
+	accept: options?.accept ?? SparqlClient.DEFAULT_RESULTS_ACCEPT
+}), (body) => Option.match(ResultsStream.parse(body.mediaType, Stream.decodeText(body.bytes)), {
+	onNone: () => Effect.fail(new ClientErrors.UnsupportedMediaTypeError({
+		contentType: body.mediaType,
+		expected: resultsMediaTypes
+	})),
+	onSome: (events) => Effect.succeed(Stream.mapError(events, (e) => ClientErrors.isSparqlClientError(e) ? e : new ClientErrors.MalformedResponseError({
+		message: e.message,
+		contentType: body.mediaType,
+		cause: e
+	})))
+})));
+const parseRdf = (body, baseIri) => Option.match(Serialization.parserFor(ClientFormats.defaults, body.mediaType), {
+	onNone: () => Effect.fail(new ClientErrors.UnsupportedMediaTypeError({
+		contentType: body.mediaType,
+		expected: rdfMediaTypes
+	})),
+	onSome: (parser) => Stream.mkString(Stream.decodeText(body.bytes)).pipe(Effect.flatMap((text) => parser.parse(text, { baseIri }).pipe(Effect.mapError((e) => new ClientErrors.MalformedResponseError({
+		message: Serialization.formatError(e),
+		contentType: body.mediaType,
+		cause: e
+	})))), Effect.map((parsed) => parsed.dataset))
+});
+/**
+* Sends a `CONSTRUCT` or `DESCRIBE` query and parses the graph with the
+* default `Formats` (relative IRIs resolve against `baseIri`).
+*
+* @since 0.1.0
+* @category queries
+*/
+const construct = (client, sparql, options) => Effect.flatMap(query(client, sparql, {
+	...options,
+	accept: options?.accept ?? ClientFormats.acceptHeader(ClientFormats.defaults)
+}), (body) => parseRdf(body, options?.baseIri ?? "urn:x-base:"));
+/**
+* Sends an update as an `application/sparql-update` body.
+*
+* @since 0.1.0
+* @category updates
+*/
+const update = (client, sparql, options) => Effect.asVoid(client.sparql.post({
+	query: updateDataset(options),
+	headers: {},
+	payload: {
+		_tag: "DirectUpdate",
+		update: sparql
+	}
+}));
+/**
+* Reads a graph from the graph store and parses it with the default
+* `Formats`.
+*
+* @since 0.1.0
+* @category graph store
+*/
+const readGraph = (client, target, options) => client.graphStore.get({
+	query: graphParams(target),
+	headers: { accept: options?.accept ?? ClientFormats.acceptHeader(ClientFormats.defaults) },
+	responseMode: "decoded-and-response"
+}).pipe(Effect.flatMap(([bytes, response]) => parseRdf({
+	mediaType: mediaTypeOf(response),
+	bytes
+}, options?.baseIri ?? (target === "default" ? "urn:x-base:" : target.graph))));
+/**
+* Writes an RDF document to a graph: `put` (default) replaces the graph,
+* `post` adds to it. The document's media type must be one of
+* `SparqlApi.rdfMediaTypes` (default `text/turtle`).
+*
+* @since 0.1.0
+* @category graph store
+*/
+const writeGraph = (client, target, document, options) => {
+	const request = {
+		query: graphParams(target),
+		payload: {
+			mediaType: options?.mediaType ?? "text/turtle",
+			document
+		}
+	};
+	return Effect.asVoid(options?.method === "post" ? client.graphStore.post(request) : client.graphStore.put(request));
+};
+export { make as a, results as c, layer as i, update as l, SparqlApiClient_exports as n, query as o, construct as r, readGraph as s, SparqlApiClient as t, writeGraph as u };
+
+//# sourceMappingURL=SparqlApiClient-CJcoFy5b.mjs.map

package/dist/SparqlApiClient-CJcoFy5b.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparqlApiClient-CJcoFy5b.mjs","names":["SparqlApi.make","SparqlApi.resultsMediaTypes","SparqlApi.rdfMediaTypes"],"sources":["../src/SparqlApiClient.ts"],"sourcesContent":["/**\n * A client derived with `HttpApiClient` from the `SparqlApi` definition,\n * alongside the hand-written `SparqlClient`.\n *\n * `make` returns the generated client: one method per endpoint\n * (`client.sparql.query`, `client.sparql.post`, `client.graphStore.get`, …)\n * taking the endpoint's typed `query`, `headers` and `payload` and returning\n * response bodies as byte streams. Error statuses decode into the server's\n * `ProtocolErrors.ProtocolError`. The helpers below (`query`, `results`,\n * `construct`, `update`, `readGraph`, `writeGraph`) send the common\n * requests and parse the bodies with the results parsers (`ResultsStream`)\n * and the default `Formats`.\n *\n * `effect/http-api` is `@stability unstable` in Effect 4, and so is this\n * client.\n *\n * @since 0.1.0\n */\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Stream from 'effect/Stream';\nimport type * as Schema from 'effect/Schema';\nimport type * as HttpClient from 'effect/http/HttpClient';\nimport type * as HttpClientError from 'effect/http/HttpClientError';\nimport type * as HttpClientResponse from 'effect/http/HttpClientResponse';\nimport * as HttpApiClient from 'effect/http-api/HttpApiClient';\nimport type * as Dataset from '@thomasfosterau/effect-rdf/Dataset';\nimport * as Serialization from '@thomasfosterau/effect-rdf/Serialization';\nimport type * as ProtocolErrors from '@thomasfosterau/effect-rdf/sparql/ProtocolErrors';\nimport * as SparqlApi from './SparqlApi.ts';\nimport * as ClientErrors from '@thomasfosterau/effect-rdf/sparql/ClientErrors';\nimport * as ClientFormats from '@thomasfosterau/effect-rdf/sparql/ClientFormats';\nimport * as ResultsStream from '@thomasfosterau/effect-rdf/sparql/ResultsStream';\nimport * as SparqlClient from '@thomasfosterau/effect-rdf/sparql/SparqlClient';\n\n// -----------------------------------------------------------------------------\n// The client\n// -----------------------------------------------------------------------------\n\n/**\n * The generated client of the `SparqlApi`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Client = HttpApiClient.ForApi<SparqlApi.Api>;\n\n/**\n * Options of the derived client.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Options {\n  /** The server's base URL (e.g. `https://example.org`); paths are appended to it. */\n  readonly baseUrl?: string | URL | undefined;\n  /** The endpoint paths, when the server does not use the defaults. */\n  readonly paths?: SparqlApi.Paths | undefined;\n  /** Transforms the `HttpClient` (retries, authentication, …). */\n  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;\n}\n\n/**\n * Derives the client from the API definition, using the `HttpClient` from\n * the context.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (options?: Options): Effect.Effect<Client, never, HttpClient.HttpClient> =>\n  HttpApiClient.make(SparqlApi.make(options?.paths), {\n    baseUrl: options?.baseUrl,\n    transformClient: options?.transformClient,\n  });\n\n/**\n * The derived client as a service.\n *\n * @since 0.1.0\n * @category services\n */\nexport class SparqlApiClient extends Context.Service<SparqlApiClient, Client>()(\n  '@thomasfosterau/effect-sparql-node/SparqlApiClient',\n) {}\n\n/**\n * A layer providing the derived client.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = (\n  options?: Options,\n): Layer.Layer<SparqlApiClient, never, HttpClient.HttpClient> =>\n  Layer.effect(SparqlApiClient, make(options));\n\n// -----------------------------------------------------------------------------\n// Helpers\n// -----------------------------------------------------------------------------\n\n/**\n * Any failure of a derived client call: a protocol error status, a transport\n * or decoding failure of the generated client, or an unreadable body.\n *\n * @since 0.1.0\n * @category errors\n */\nexport type ApiError =\n  | ProtocolErrors.ProtocolError\n  | HttpClientError.HttpClientError\n  | Schema.SchemaError\n  | ClientErrors.MalformedResponseError\n  | ClientErrors.UnsupportedMediaTypeError;\n\n/**\n * A response body and its media type.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Body {\n  /** The media type of the body, without parameters. */\n  readonly mediaType: string;\n  readonly bytes: Stream.Stream<Uint8Array, ApiError>;\n}\n\n/**\n * The protocol dataset of a query (`default-graph-uri` / `named-graph-uri`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface QueryOptions {\n  readonly defaultGraphs?: ReadonlyArray<string> | undefined;\n  readonly namedGraphs?: ReadonlyArray<string> | undefined;\n  /** The `Accept` header (default: every results and RDF format). */\n  readonly accept?: string | undefined;\n  /** `get` (default) sends `?query=`, `post` an `application/sparql-query` body. */\n  readonly method?: 'get' | 'post' | undefined;\n}\n\n/**\n * The protocol dataset of an update (`using-graph-uri` /\n * `using-named-graph-uri`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface UpdateOptions {\n  readonly usingGraphs?: ReadonlyArray<string> | undefined;\n  readonly usingNamedGraphs?: ReadonlyArray<string> | undefined;\n}\n\n/**\n * The graph of a Graph Store request: the default graph or a graph IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport type GraphTarget = 'default' | { readonly graph: string };\n\nconst mediaTypeOf = (response: HttpClientResponse.HttpClientResponse): string =>\n  (response.headers['content-type'] ?? '').split(';')[0]?.trim().toLowerCase() ?? '';\n\nconst graphParams = (target: GraphTarget) =>\n  target === 'default' ? { default: '' } : { graph: target.graph };\n\n// An empty list sends no parameter.\nconst queryDataset = (options?: QueryOptions) => ({\n  'default-graph-uri': options?.defaultGraphs ?? [],\n  'named-graph-uri': options?.namedGraphs ?? [],\n});\n\nconst updateDataset = (options?: UpdateOptions) => ({\n  'using-graph-uri': options?.usingGraphs ?? [],\n  'using-named-graph-uri': options?.usingNamedGraphs ?? [],\n});\n\nconst queryHeaders = (accept?: string) => ({\n  accept: accept ?? SparqlApi.queryMediaTypes.join(', '),\n});\n\n/**\n * Sends a query and returns the response body with its media type, without\n * parsing it.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const query = (\n  client: Client,\n  sparql: string,\n  options?: QueryOptions,\n): Effect.Effect<Body, ApiError> => {\n  const dataset = queryDataset(options);\n  const headers = queryHeaders(options?.accept);\n  const sent =\n    options?.method === 'post'\n      ? client.sparql.post({\n          query: dataset,\n          headers,\n          payload: { _tag: 'DirectQuery', query: sparql },\n          responseMode: 'decoded-and-response',\n        })\n      : client.sparql.query({\n          query: { query: sparql, ...dataset },\n          headers,\n          responseMode: 'decoded-and-response',\n        });\n  return Effect.flatMap(sent, ([bytes, response]) =>\n    bytes === undefined\n      ? Effect.fail(\n          new ClientErrors.MalformedResponseError({\n            message: `Expected a query result, got status ${response.status}`,\n          }),\n        )\n      : Effect.succeed({ mediaType: mediaTypeOf(response), bytes }),\n  );\n};\n\n/**\n * Sends a `SELECT` or `ASK` query and parses the results incrementally with\n * `ResultsStream`.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const results = (\n  client: Client,\n  sparql: string,\n  options?: QueryOptions,\n): Stream.Stream<ResultsStream.ResultEvent, ApiError> =>\n  Stream.unwrap(\n    Effect.flatMap(\n      query(client, sparql, {\n        ...options,\n        accept: options?.accept ?? SparqlClient.DEFAULT_RESULTS_ACCEPT,\n      }),\n      (body) =>\n        Option.match(ResultsStream.parse(body.mediaType, Stream.decodeText(body.bytes)), {\n          onNone: () =>\n            Effect.fail(\n              new ClientErrors.UnsupportedMediaTypeError({\n                contentType: body.mediaType,\n                expected: SparqlApi.resultsMediaTypes,\n              }),\n            ),\n          onSome: (events) =>\n            Effect.succeed(\n              Stream.mapError(events, (e) =>\n                ClientErrors.isSparqlClientError(e)\n                  ? e\n                  : new ClientErrors.MalformedResponseError({\n                      message: e.message,\n                      contentType: body.mediaType,\n                      cause: e,\n                    }),\n              ),\n            ),\n        }),\n    ),\n  );\n\nconst parseRdf = (body: Body, baseIri: string): Effect.Effect<Dataset.Dataset, ApiError> =>\n  Option.match(Serialization.parserFor(ClientFormats.defaults, body.mediaType), {\n    onNone: () =>\n      Effect.fail(\n        new ClientErrors.UnsupportedMediaTypeError({\n          contentType: body.mediaType,\n          expected: SparqlApi.rdfMediaTypes,\n        }),\n      ),\n    onSome: (parser) =>\n      Stream.mkString(Stream.decodeText(body.bytes)).pipe(\n        Effect.flatMap((text) =>\n          parser.parse(text, { baseIri }).pipe(\n            Effect.mapError(\n              (e) =>\n                new ClientErrors.MalformedResponseError({\n                  message: Serialization.formatError(e),\n                  contentType: body.mediaType,\n                  cause: e,\n                }),\n            ),\n          ),\n        ),\n        Effect.map((parsed) => parsed.dataset),\n      ),\n  });\n\n/**\n * Sends a `CONSTRUCT` or `DESCRIBE` query and parses the graph with the\n * default `Formats` (relative IRIs resolve against `baseIri`).\n *\n * @since 0.1.0\n * @category queries\n */\nexport const construct = (\n  client: Client,\n  sparql: string,\n  options?: QueryOptions & { readonly baseIri?: string | undefined },\n): Effect.Effect<Dataset.Dataset, ApiError> =>\n  Effect.flatMap(\n    query(client, sparql, {\n      ...options,\n      accept: options?.accept ?? ClientFormats.acceptHeader(ClientFormats.defaults),\n    }),\n    (body) => parseRdf(body, options?.baseIri ?? 'urn:x-base:'),\n  );\n\n/**\n * Sends an update as an `application/sparql-update` body.\n *\n * @since 0.1.0\n * @category updates\n */\nexport const update = (\n  client: Client,\n  sparql: string,\n  options?: UpdateOptions,\n): Effect.Effect<void, ApiError> =>\n  Effect.asVoid(\n    client.sparql.post({\n      query: updateDataset(options),\n      headers: {},\n      payload: { _tag: 'DirectUpdate', update: sparql },\n    }),\n  );\n\n/**\n * Reads a graph from the graph store and parses it with the default\n * `Formats`.\n *\n * @since 0.1.0\n * @category graph store\n */\nexport const readGraph = (\n  client: Client,\n  target: GraphTarget,\n  options?: { readonly accept?: string | undefined; readonly baseIri?: string | undefined },\n): Effect.Effect<Dataset.Dataset, ApiError> =>\n  client.graphStore\n    .get({\n      query: graphParams(target),\n      headers: { accept: options?.accept ?? ClientFormats.acceptHeader(ClientFormats.defaults) },\n      responseMode: 'decoded-and-response',\n    })\n    .pipe(\n      Effect.flatMap(([bytes, response]) =>\n        parseRdf(\n          { mediaType: mediaTypeOf(response), bytes },\n          options?.baseIri ?? (target === 'default' ? 'urn:x-base:' : target.graph),\n        ),\n      ),\n    );\n\n/**\n * Writes an RDF document to a graph: `put` (default) replaces the graph,\n * `post` adds to it. The document's media type must be one of\n * `SparqlApi.rdfMediaTypes` (default `text/turtle`).\n *\n * @since 0.1.0\n * @category graph store\n */\nexport const writeGraph = (\n  client: Client,\n  target: GraphTarget,\n  document: string,\n  options?: {\n    readonly mediaType?: string | undefined;\n    readonly method?: 'put' | 'post' | undefined;\n  },\n): Effect.Effect<void, ApiError> => {\n  const request = {\n    query: graphParams(target),\n    payload: { mediaType: options?.mediaType ?? 'text/turtle', document },\n  };\n  return Effect.asVoid(\n    options?.method === 'post' ? client.graphStore.post(request) : client.graphStore.put(request),\n  );\n};\n"],"mappings":"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"}

package/dist/SparqlApiClient.d.mts

@@ -0,0 +1,2 @@
+import { _ as writeGraph, a as Options, d as layer, f as make, g as update, h as results, i as GraphTarget, l as UpdateOptions, m as readGraph, n as Body, o as QueryOptions, p as query, r as Client, s as SparqlApiClient, t as ApiError, u as construct } from "./SparqlApiClient-C82RGMEF.mjs";
+export { ApiError, Body, Client, GraphTarget, Options, QueryOptions, SparqlApiClient, UpdateOptions, construct, layer, make, query, readGraph, results, update, writeGraph };

package/dist/SparqlApiClient.mjs

@@ -0,0 +1 @@
+export { t as SparqlApiClient, r as construct, i as layer, a as make, o as query, s as readGraph, c as results, l as update, u as writeGraph } from "./SparqlApiClient-CJcoFy5b.mjs";