@thomasfosterau/effect-sparql-node 0.0.0 → 0.1.0

package/dist/Cli-DFvng1N8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cli-DFvng1N8.mjs","names":["NodeSparqlServer.layerMemory"],"sources":["../src/Cli.ts"],"sourcesContent":["/**\n * The command line entry point: serves RDF files loaded into an in-memory\n * store.\n *\n * ```sh\n * effect-sparql-server --port 3030 data.ttl more.trig\n * ```\n *\n * Files are parsed with the default formats, chosen by file extension.\n * Triples go to the default graph, or with `--graph-per-file` to a named\n * graph per file (named by the file URL); quads keep their graph.\n *\n * The command is built with `effect/cli` (generated `--help`, `--version`\n * and shell completions), and every flag also reads an environment variable\n * through `Config`: `SPARQL_SERVER_` followed by the flag name in upper\n * snake case (`--max-results` is `SPARQL_SERVER_MAX_RESULTS`). A flag on the\n * command line wins over the environment, which wins over the default.\n *\n * @since 0.1.0\n */\nimport * as NodeServices from '@effect/platform-node/NodeServices';\nimport * as NodeFileSystem from '@effect/platform-node/NodeFileSystem';\nimport * as NodePath from '@effect/platform-node/NodePath';\nimport * as Config from 'effect/Config';\nimport * as Console from 'effect/Console';\nimport * as Effect from 'effect/Effect';\nimport * as FileSystem from 'effect/FileSystem';\nimport * as Layer from 'effect/Layer';\nimport * as Match from 'effect/Match';\nimport * as Option from 'effect/Option';\nimport * as Path from 'effect/Path';\nimport * as PlatformError from 'effect/PlatformError';\nimport * as Ref from 'effect/Ref';\nimport * as Schema from 'effect/Schema';\nimport { Argument, Command, Flag } from 'effect/cli';\nimport * as CliErrors from 'effect/cli/CliError';\nimport type * as HttpServerError from 'effect/http/HttpServerError';\nimport * as Iri from '@thomasfosterau/effect-rdf/Iri';\nimport * as Dataset from '@thomasfosterau/effect-rdf/Dataset';\nimport * as Serialization from '@thomasfosterau/effect-rdf/Serialization';\nimport * as Term from '@thomasfosterau/effect-rdf/Term';\nimport * as ServerFormats from '@thomasfosterau/effect-rdf/sparql/ServerFormats';\nimport type * as Options from '@thomasfosterau/effect-rdf/sparql/Options';\nimport * as NodeSparqlServer from './NodeSparqlServer.ts';\n\n/**\n * A command line usage error.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class CliError extends Schema.TaggedError<CliError>()('CliError', {\n  message: Schema.String,\n}) {}\n\n/**\n * The prefix of the environment variables that back the flags:\n * `SPARQL_SERVER_PORT`, `SPARQL_SERVER_READ_ONLY`, …\n *\n * @since 0.1.0\n * @category cli\n */\nexport const envPrefix = 'SPARQL_SERVER_';\n\nconst envName = (flag: string): string => `${envPrefix}${flag.toUpperCase().replaceAll('-', '_')}`;\n\n/**\n * A summary of the flags and their environment variables; `--help` prints\n * the full, generated help.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const usage = `Usage: effect-sparql-server [flags] [files...]\n\nServes the given RDF files from an in-memory store over the SPARQL 1.1\nProtocol and the Graph Store HTTP Protocol.\n\nFlags (environment variable in brackets; a flag wins over the environment):\n  -p, --port <port>          port to listen on (default 3030) [SPARQL_SERVER_PORT]\n      --host <host>          host to bind (default all interfaces) [SPARQL_SERVER_HOST]\n      --path <path>          SPARQL endpoint path (default /sparql) [SPARQL_SERVER_PATH]\n      --update-path <path>   separate update endpoint path [SPARQL_SERVER_UPDATE_PATH]\n      --graph-store <path>   Graph Store Protocol path (default /rdf-graph-store) [SPARQL_SERVER_GRAPH_STORE]\n      --no-graph-store       disable the Graph Store Protocol [SPARQL_SERVER_NO_GRAPH_STORE]\n      --read-only            reject updates and graph store writes [SPARQL_SERVER_READ_ONLY]\n      --timeout <ms>         query timeout in milliseconds [SPARQL_SERVER_TIMEOUT]\n      --max-results <n>      maximum number of results per query [SPARQL_SERVER_MAX_RESULTS]\n      --cors                 enable permissive CORS [SPARQL_SERVER_CORS]\n      --union-default-graph  query the union of all graphs by default [SPARQL_SERVER_UNION_DEFAULT_GRAPH]\n      --graph-per-file       load each file into a named graph (its file URL) [SPARQL_SERVER_GRAPH_PER_FILE]\n      --base-url <url>       public origin of the server [SPARQL_SERVER_BASE_URL]\n  -h, --help                 show the full help\n`;\n\n/**\n * Parsed command line arguments.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Arguments {\n  readonly help: boolean;\n  readonly files: ReadonlyArray<string>;\n  readonly graphPerFile: boolean;\n  readonly unionDefaultGraph: boolean;\n  readonly serve: NodeSparqlServer.ServeOptions;\n}\n\n// A string flag, falling back to its environment variable, absent when neither is set.\nconst stringFlag = (name: string, description: string) =>\n  Flag.String(name).pipe(\n    Flag.withDescription(`${description} [${envName(name)}]`),\n    Flag.withFallbackConfig(Config.String(envName(name))),\n    Flag.optional,\n  );\n\n// An integer flag, falling back to its environment variable.\nconst intFlag = (name: string, description: string) =>\n  Flag.Int(name).pipe(\n    Flag.withDescription(`${description} [${envName(name)}]`),\n    Flag.withFallbackConfig(Config.Int(envName(name))),\n    Flag.optional,\n  );\n\n// A boolean flag, falling back to its environment variable, then to false.\nconst booleanFlag = (name: string, description: string) =>\n  Flag.Boolean(name).pipe(\n    Flag.withDescription(`${description} [${envName(name)}]`),\n    Flag.withFallbackConfig(Config.Boolean(envName(name))),\n    Flag.withDefault(false),\n  );\n\n/**\n * The command's flags and arguments.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const config = {\n  port: intFlag('port', 'port to listen on (default 3030)').pipe(Flag.withAlias('p')),\n  host: stringFlag('host', 'host to bind (default all interfaces)'),\n  path: stringFlag('path', 'SPARQL endpoint path (default /sparql)'),\n  updatePath: stringFlag('update-path', 'separate update endpoint path'),\n  graphStore: stringFlag('graph-store', 'Graph Store Protocol path (default /rdf-graph-store)'),\n  noGraphStore: booleanFlag('no-graph-store', 'disable the Graph Store Protocol'),\n  readOnly: booleanFlag('read-only', 'reject updates and graph store writes'),\n  timeout: intFlag('timeout', 'query timeout in milliseconds'),\n  maxResults: intFlag('max-results', 'maximum number of results per query'),\n  cors: booleanFlag('cors', 'enable permissive CORS'),\n  unionDefaultGraph: booleanFlag('union-default-graph', 'query the union of all graphs by default'),\n  graphPerFile: booleanFlag('graph-per-file', 'load each file into a named graph (its file URL)'),\n  baseUrl: stringFlag('base-url', 'public origin of the server'),\n  files: Argument.String('files').pipe(\n    Argument.withDescription('RDF files to load, in any syntax the server reads'),\n    Argument.variadic(),\n  ),\n} as const;\n\n/**\n * The values of the flags and arguments, as `effect/cli` parses them.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Flags = Command.Command.Config.Infer<typeof config>;\n\nconst nonNegative = (name: string, value: Option.Option<number>) =>\n  Option.match(value, {\n    onNone: () => Effect.succeed(undefined),\n    onSome: (n) =>\n      Number.isInteger(n) && n >= 0\n        ? Effect.succeed(n)\n        : Effect.fail(new CliError({ message: `--${name} expects a non-negative integer` })),\n  });\n\nconst endpointPath = (name: string, value: Option.Option<string>) =>\n  Option.match(value, {\n    onNone: () => Effect.succeed(undefined),\n    onSome: (path) =>\n      Schema.is(EndpointPath)(path)\n        ? Effect.succeed(path)\n        : Effect.fail(new CliError({ message: `--${name} must start with '/'` })),\n  });\n\nconst EndpointPath = Schema.TemplateLiteral(['/', Schema.String]);\n\n/**\n * Validates parsed flags into `Arguments`: integers must be non-negative,\n * paths must start with `/`, and `--base-url` must be an absolute IRI.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const toArguments = (flags: Flags): Effect.Effect<Arguments, CliError> =>\n  Effect.gen(function* () {\n    const baseUrl = Option.getOrUndefined(flags.baseUrl);\n    if (baseUrl !== undefined && !Iri.isValid(baseUrl)) {\n      return yield* new CliError({ message: `--base-url must be an absolute IRI: ${baseUrl}` });\n    }\n    const graphStore = yield* endpointPath('graph-store', flags.graphStore);\n    const options: Options.Options = {\n      path: yield* endpointPath('path', flags.path),\n      updatePath: yield* endpointPath('update-path', flags.updatePath),\n      graphStorePath: flags.noGraphStore ? false : graphStore,\n      readOnly: flags.readOnly,\n      queryTimeout: yield* nonNegative('timeout', flags.timeout),\n      maxResults: yield* nonNegative('max-results', flags.maxResults),\n      cors: flags.cors,\n      logging: true,\n      baseUrl,\n      unionDefaultGraph: flags.unionDefaultGraph,\n    };\n    return {\n      help: false,\n      files: flags.files,\n      graphPerFile: flags.graphPerFile,\n      unionDefaultGraph: flags.unionDefaultGraph,\n      serve: {\n        ...options,\n        port: (yield* nonNegative('port', flags.port)) ?? 3030,\n        host: Option.getOrUndefined(flags.host),\n      },\n    };\n  });\n\n// The `effect/cli` errors as this module's `CliError` (a help request has no message).\nconst fromCliError = (error: CliErrors.CliError): CliError =>\n  new CliError({\n    message: Match.value(error).pipe(\n      Match.tag('ShowHelp', (help) => help.errors.map((e) => e.message).join('\\n')),\n      Match.orElse((e) => e.message),\n    ),\n  });\n\nconst quiet = (): void => undefined;\nconst silentConsole: Console.Console = Object.assign(Object.create(globalThis.console), {\n  log: quiet,\n  error: quiet,\n  info: quiet,\n  warn: quiet,\n});\n\nconst isHelp = (argv: ReadonlyArray<string>): boolean =>\n  argv.includes('--help') || argv.includes('-h');\n\n/**\n * Parses command line arguments, reading unset flags from the environment\n * (`SPARQL_SERVER_*`). `-h` / `--help` sets `help` instead.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const parse = (argv: ReadonlyArray<string>): Effect.Effect<Arguments, CliError> =>\n  isHelp(argv)\n    ? Effect.succeed({\n        help: true,\n        files: [],\n        graphPerFile: false,\n        unionDefaultGraph: false,\n        serve: { port: 3030 },\n      })\n    : Effect.gen(function* () {\n        const parsed = yield* Ref.make(Option.none<Arguments>());\n        const capture = Command.make('effect-sparql-server', config, (flags) =>\n          Effect.flatMap(toArguments(flags), (args) => Ref.set(parsed, Option.some(args))),\n        );\n        yield* Command.runWith(capture, { version: '', renderErrors: false })(argv).pipe(\n          Effect.catchIf(CliErrors.isCliError, (e) => Effect.fail(fromCliError(e))),\n          // Parsing is programmatic: the help `effect/cli` prints for a usage error stays quiet.\n          Effect.provideService(Console.Console, silentConsole),\n          Effect.provide(NodeServices.layer),\n        );\n        return yield* Effect.flatMap(Ref.get(parsed), Effect.fromOption).pipe(\n          Effect.mapError(() => new CliError({ message: 'no arguments were parsed' })),\n        );\n      });\n\n/**\n * Loads RDF files into a dataset through Effect's `FileSystem`, choosing\n * parsers by file extension from the `Formats` service. Relative IRIs\n * resolve against each file's `file:` URL; with `graphPerFile`, a file's\n * default-graph triples go into a graph named by that URL.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const load = (\n  files: ReadonlyArray<string>,\n  graphPerFile: boolean,\n): Effect.Effect<\n  Dataset.Dataset,\n  CliError | Serialization.RdfParseError,\n  Serialization.Formats | FileSystem.FileSystem | Path.Path\n> =>\n  Effect.gen(function* () {\n    const formats = yield* Serialization.Formats;\n    const paths = yield* Path.Path;\n    const perFile = yield* Effect.forEach(\n      files,\n      Effect.fnUntraced(function* (file) {\n        const parser = Serialization.parserForExtension(formats, paths.extname(file));\n        if (Option.isNone(parser)) {\n          return yield* new CliError({ message: `Unknown RDF file extension: ${file}` });\n        }\n        const cannotRead = (e: PlatformError.PlatformError) =>\n          new CliError({ message: `Cannot read ${file}: ${e.message}` });\n        const url = (yield* paths\n          .toFileUrl(paths.resolve(file))\n          .pipe(Effect.mapError((e) => cannotRead(new PlatformError.PlatformError(e))))).href;\n        const result = yield* Serialization.readFile(file, {\n          parser: parser.value,\n          baseIri: url,\n        }).pipe(Effect.catchTag('PlatformError', (e) => Effect.fail(cannotRead(e))));\n        const graph = graphPerFile ? Term.namedNode(url) : undefined;\n        const quads = Array.from(result.dataset, (q) =>\n          graph !== undefined && q.graph._tag === 'DefaultGraph'\n            ? new Term.Quad(q.subject, q.predicate, q.object, graph)\n            : q,\n        );\n        yield* Effect.logInfo(`Loaded ${result.dataset.size} quads from ${file}`);\n        return quads;\n      }),\n      { concurrency: 1 },\n    );\n    return Dataset.fromIterable(perFile.flat());\n  });\n\n/**\n * The `effect/cli` command: parses the flags (and their environment\n * variables), loads the files and serves them until interrupted.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const command = Command.make('effect-sparql-server', config, (flags) =>\n  Effect.gen(function* () {\n    const args = yield* toArguments(flags);\n    const data = yield* Effect.provide(\n      load(args.files, args.graphPerFile),\n      Layer.mergeAll(ServerFormats.layer, NodeFileSystem.layer, NodePath.layer),\n    );\n    const server = NodeSparqlServer.layerMemory({\n      ...args.serve,\n      data,\n      engine: { unionDefaultGraph: args.unionDefaultGraph },\n    });\n    return yield* Layer.launch(server);\n  }),\n).pipe(\n  Command.withDescription(\n    'Serves the given RDF files from an in-memory store over the SPARQL 1.1 Protocol and the Graph Store HTTP Protocol.',\n  ),\n);\n\n/**\n * Runs the command line program: parses arguments (printing the generated\n * help for `--help` or a usage error), loads the files and serves them\n * until interrupted. `version` is what `--version` prints.\n *\n * @since 0.1.0\n * @category cli\n */\nexport const run = (\n  argv: ReadonlyArray<string>,\n  options?: { readonly version?: string | undefined },\n): Effect.Effect<void, CliError | Serialization.RdfParseError | HttpServerError.ServeError> =>\n  Command.runWith(command, { version: options?.version ?? 'unknown', renderErrors: false })(\n    argv,\n  ).pipe(\n    Effect.catchIf(CliErrors.isCliError, (e) => Effect.fail(fromCliError(e))),\n    Effect.provide(NodeServices.layer),\n  );\n"],"mappings":"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"}

package/dist/Cli.d.mts

@@ -0,0 +1,2 @@
+import { a as command, c as load, d as toArguments, f as usage, i as Flags, l as parse, n as CliError, o as config, s as envPrefix, t as Arguments, u as run } from "./Cli-DE0eXMJr.mjs";
+export { Arguments, CliError, Flags, command, config, envPrefix, load, parse, run, toArguments, usage };

package/dist/Cli.mjs

@@ -0,0 +1 @@
+export { t as CliError, r as command, i as config, a as envPrefix, o as load, s as parse, c as run, l as toArguments, u as usage } from "./Cli-DFvng1N8.mjs";

package/dist/NodeSparqlServer-1vSrPk3J.d.mts

@@ -0,0 +1,41 @@
+import * as Layer from "effect/Layer";
+import * as Dataset from "@thomasfosterau/effect-rdf/Dataset";
+import * as SparqlServer from "@thomasfosterau/effect-rdf/sparql/SparqlServer";
+import * as HttpServer from "effect/http/HttpServer";
+import * as HttpServerError from "effect/http/HttpServerError";
+import * as Engine from "@thomasfosterau/effect-rdf/sparql/Engine";
+import * as Options from "@thomasfosterau/effect-rdf/sparql/Options";
+declare namespace NodeSparqlServer_d_exports {
+  export { ServeOptions, layer, layerMemory };
+}
+/**
+ * Options of the Node server.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ServeOptions extends Options.Options {
+  /** The port to listen on (`0` for an ephemeral port). */
+  readonly port: number;
+  /** The host to bind (default: all interfaces). */
+  readonly host?: string | undefined;
+}
+/**
+ * A Node HTTP server serving the SPARQL endpoint and graph store.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: (options: ServeOptions) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, SparqlServer.Requirements>;
+/**
+ * A Node server over an in-memory store.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerMemory: (options: ServeOptions & {
+  readonly data?: Dataset.Dataset | undefined;
+  readonly engine?: Engine.EngineOptions | undefined;
+}) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError>;
+export { layerMemory as i, ServeOptions as n, layer as r, NodeSparqlServer_d_exports as t };
+//# sourceMappingURL=NodeSparqlServer-1vSrPk3J.d.mts.map

package/dist/NodeSparqlServer-CYAd_6BG.mjs

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Layer from "effect/Layer";
+import { createServer } from "node:http";
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import * as SparqlServer from "@thomasfosterau/effect-rdf/sparql/SparqlServer";
+// src/NodeSparqlServer.ts
+/**
+* The SPARQL 1.1 Protocol and Graph Store HTTP Protocol server of
+* `@thomasfosterau/effect-rdf/sparql` (`SparqlServer`) on a Node
+* `node:http` server, through `@effect/platform-node`'s `NodeHttpServer`.
+*
+* `SparqlServer` itself is platform-neutral (`handler`, `layerRoutes`,
+* `layerServe`); this module adds the listening socket.
+*
+* @since 0.1.0
+*/
+var NodeSparqlServer_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	layerMemory: () => layerMemory
+});
+/**
+* A Node HTTP server serving the SPARQL endpoint and graph store.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (options) => {
+	const { port, host, ...rest } = options;
+	return SparqlServer.layerServe(rest).pipe(Layer.provideMerge(NodeHttpServer.layer(createServer, host === void 0 ? { port } : {
+		port,
+		host
+	})));
+};
+/**
+* A Node server over an in-memory store.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerMemory = (options) => {
+	const { data, engine, ...rest } = options;
+	return layer({
+		...rest,
+		unionDefaultGraph: rest.unionDefaultGraph ?? engine?.unionDefaultGraph,
+		federation: rest.federation ?? engine?.service !== void 0
+	}).pipe(Layer.provide(SparqlServer.layerMemoryServices(data, engine)));
+};
+export { layer as n, layerMemory as r, NodeSparqlServer_exports as t };
+
+//# sourceMappingURL=NodeSparqlServer-CYAd_6BG.mjs.map

package/dist/NodeSparqlServer-CYAd_6BG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeSparqlServer-CYAd_6BG.mjs","names":[],"sources":["../src/NodeSparqlServer.ts"],"sourcesContent":["/**\n * The SPARQL 1.1 Protocol and Graph Store HTTP Protocol server of\n * `@thomasfosterau/effect-rdf/sparql` (`SparqlServer`) on a Node\n * `node:http` server, through `@effect/platform-node`'s `NodeHttpServer`.\n *\n * `SparqlServer` itself is platform-neutral (`handler`, `layerRoutes`,\n * `layerServe`); this module adds the listening socket.\n *\n * @since 0.1.0\n */\nimport { createServer } from 'node:http';\nimport * as Layer from 'effect/Layer';\nimport type * as HttpServer from 'effect/http/HttpServer';\nimport type * as HttpServerError from 'effect/http/HttpServerError';\nimport * as NodeHttpServer from '@effect/platform-node/NodeHttpServer';\nimport type * as Dataset from '@thomasfosterau/effect-rdf/Dataset';\nimport type * as Engine from '@thomasfosterau/effect-rdf/sparql/Engine';\nimport type * as Options from '@thomasfosterau/effect-rdf/sparql/Options';\nimport * as SparqlServer from '@thomasfosterau/effect-rdf/sparql/SparqlServer';\n\n/**\n * Options of the Node server.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ServeOptions extends Options.Options {\n  /** The port to listen on (`0` for an ephemeral port). */\n  readonly port: number;\n  /** The host to bind (default: all interfaces). */\n  readonly host?: string | undefined;\n}\n\n/**\n * A Node HTTP server serving the SPARQL endpoint and graph store.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = (\n  options: ServeOptions,\n): Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, SparqlServer.Requirements> => {\n  const { port, host, ...rest } = options;\n  // SAFETY: providing the Node HTTP server leaves `HttpServer` and `SparqlServer.Requirements`; the cast\n  // restates the layer type.\n  return SparqlServer.layerServe(rest).pipe(\n    Layer.provideMerge(\n      NodeHttpServer.layer(createServer, host === undefined ? { port } : { port, host }),\n    ),\n  );\n};\n\n/**\n * A Node server over an in-memory store.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerMemory = (\n  options: ServeOptions & {\n    readonly data?: Dataset.Dataset | undefined;\n    readonly engine?: Engine.EngineOptions | undefined;\n  },\n): Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError> => {\n  const { data, engine, ...rest } = options;\n  return layer({\n    ...rest,\n    unionDefaultGraph: rest.unionDefaultGraph ?? engine?.unionDefaultGraph,\n    federation: rest.federation ?? engine?.service !== undefined,\n  }).pipe(Layer.provide(SparqlServer.layerMemoryServices(data, engine)));\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,SACX,YAC8F;CAC9F,MAAM,EAAE,MAAM,MAAM,GAAG,SAAS;CAGhC,OAAO,aAAa,WAAW,IAAI,CAAC,CAAC,KACnC,MAAM,aACJ,eAAe,MAAM,cAAc,SAAS,KAAA,IAAY,EAAE,KAAK,IAAI;EAAE;EAAM;CAAK,CAAC,CACnF,CACF;AACF;;;;;;;AAQA,MAAa,eACX,YAImE;CACnE,MAAM,EAAE,MAAM,QAAQ,GAAG,SAAS;CAClC,OAAO,MAAM;EACX,GAAG;EACH,mBAAmB,KAAK,qBAAqB,QAAQ;EACrD,YAAY,KAAK,cAAc,QAAQ,YAAY,KAAA;CACrD,CAAC,CAAC,CAAC,KAAK,MAAM,QAAQ,aAAa,oBAAoB,MAAM,MAAM,CAAC,CAAC;AACvE"}

package/dist/NodeSparqlServer.d.mts

@@ -0,0 +1,2 @@
+import { i as layerMemory, n as ServeOptions, r as layer } from "./NodeSparqlServer-1vSrPk3J.mjs";
+export { ServeOptions, layer, layerMemory };

package/dist/NodeSparqlServer.mjs

@@ -0,0 +1 @@
+export { n as layer, r as layerMemory } from "./NodeSparqlServer-CYAd_6BG.mjs";

package/dist/SparqlApi-BKE9nIf4.d.mts

@@ -0,0 +1,488 @@
+import * as Schema from "effect/Schema";
+import * as Serialization from "@thomasfosterau/effect-rdf/Serialization";
+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 ProtocolErrors from "@thomasfosterau/effect-rdf/sparql/ProtocolErrors";
+import * as Engine from "@thomasfosterau/effect-rdf/sparql/Engine";
+import * as Store from "@thomasfosterau/effect-rdf/sparql/Store";
+declare namespace SparqlApi_d_exports {
+  export { AcceptHeader, Api, DatasetParams, DirectQueryBody, DirectUpdateBody, FormBody, GraphParams, Paths, ProtocolErrorResponse, QueryParams, QueryResponse, RdfDocumentBody, RdfResponse, SchemaFallback, SparqlApi, make, openApi, queryMediaTypes, rdfMediaTypes, 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
+ */
+declare const rdfMediaTypes: ReadonlyArray<string>;
+/**
+ * The media types of SPARQL results (`Results.codecs`): JSON, XML, CSV and
+ * TSV, in order of preference.
+ *
+ * @since 0.1.0
+ * @category media types
+ */
+declare const resultsMediaTypes: ReadonlyArray<string>;
+/**
+ * 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
+ */
+declare const queryMediaTypes: ReadonlyArray<string>;
+/**
+ * A query response body: a byte stream under any of `queryMediaTypes`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const QueryResponse: HttpApiSchema.StreamUint8Array;
+/**
+ * An RDF document response body: a byte stream under any of `rdfMediaTypes`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const RdfResponse: HttpApiSchema.StreamUint8Array;
+/**
+ * The `Accept` request header, which selects the response format.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const AcceptHeader: Schema.Struct<{
+  readonly accept: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * The decoded type of `AcceptHeader`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type AcceptHeader = typeof AcceptHeader.Type;
+/**
+ * The query string of a query: the query and its protocol dataset.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const QueryParams: 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>>;
+}>;
+/**
+ * The decoded type of `QueryParams`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type QueryParams = typeof QueryParams.Type;
+/**
+ * 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
+ */
+declare const DatasetParams: 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>>;
+}>;
+/**
+ * The decoded type of `DatasetParams`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type DatasetParams = typeof DatasetParams.Type;
+/**
+ * An `application/x-www-form-urlencoded` `POST` body holding a `query` or an
+ * `update` and its protocol dataset.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const FormBody: 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>>;
+}>;
+/**
+ * The decoded type of `FormBody`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type FormBody = typeof FormBody.Type;
+/**
+ * An `application/sparql-query` `POST` body, decoded as
+ * `{ _tag: 'DirectQuery', query }`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const DirectQueryBody: Schema.decodeTo<Schema.TaggedStruct<"DirectQuery", {
+  readonly query: Schema.String;
+}>, Schema.String, never, never>;
+/**
+ * The decoded type of `DirectQueryBody`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type DirectQueryBody = typeof DirectQueryBody.Type;
+/**
+ * An `application/sparql-update` `POST` body, decoded as
+ * `{ _tag: 'DirectUpdate', update }`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const DirectUpdateBody: Schema.decodeTo<Schema.TaggedStruct<"DirectUpdate", {
+  readonly update: Schema.String;
+}>, Schema.String, never, never>;
+/**
+ * The decoded type of `DirectUpdateBody`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type DirectUpdateBody = typeof DirectUpdateBody.Type;
+/**
+ * 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
+ */
+declare const RdfDocumentBody: Schema.decodeTo<Schema.Struct<{
+  readonly mediaType: Schema.Literal<string>;
+  readonly document: Schema.String;
+}>, Schema.String, never, never>[];
+/**
+ * The query string of a Graph Store request: `graph=<iri>` (indirect
+ * identification) or `default` (the default graph).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const GraphParams: Schema.Struct<{
+  readonly graph: Schema.optionalKey<Schema.String>;
+  readonly default: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * The decoded type of `GraphParams`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type GraphParams = typeof GraphParams.Type;
+/**
+ * The error response of a status: a `text/plain` message, decoded as an
+ * `ProtocolErrors.ProtocolError` with that status.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const ProtocolErrorResponse: (status: number) => 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>;
+declare const SchemaFallback_base: HttpApiMiddleware.ServiceClass<SchemaFallback, "@thomasfosterau/effect-sparql-node/SparqlApi/SchemaFallback", {
+  requires: Engine.SparqlEngine | Store.QuadStore | Serialization.Formats;
+  provides: never;
+  error: never;
+  clientError: never;
+  requiredForClient: false;
+  security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, never, Engine.SparqlEngine | Store.QuadStore | Serialization.Formats>>;
+/**
+ * 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
+ */
+declare class SchemaFallback extends SchemaFallback_base {}
+/**
+ * The paths an API is served at.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Paths {
+  /** The SPARQL endpoint, for queries and updates (default `/sparql`). */
+  readonly path?: `/${string}` | undefined;
+  /** The Graph Store endpoint (default `/rdf-graph-store`). */
+  readonly graphStorePath?: `/${string}` | undefined;
+}
+/**
+ * Builds the API at the given paths.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (paths?: Paths) => HttpApi.HttpApi<"effect-sparql-node", HttpApiGroup.HttpApiGroup<"sparql", 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>;
+}>>, 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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>> | 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>;
+}>>, HttpApiSchema.StreamUint8Array | Schema.toCodecJson<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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>>, false> | HttpApiGroup.HttpApiGroup<"graphStore", 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>;
+}>>, 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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>> | 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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>> | 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<HttpApiSchema.NoContent | 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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>> | 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<HttpApiSchema.NoContent | 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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>> | 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<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, HttpApiMiddleware.ApplyServices<SchemaFallback, never>>, false>>;
+/**
+ * The type of an API built by `make`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Api = ReturnType<typeof make>;
+/**
+ * The API at the default paths, `/sparql` and `/rdf-graph-store`.
+ *
+ * @since 0.1.0
+ * @category api
+ */
+declare const SparqlApi: Api;
+/**
+ * The OpenAPI document of an API (the default one when omitted).
+ *
+ * @since 0.1.0
+ * @category openapi
+ */
+declare const openApi: (api?: Api) => OpenApi.OpenAPISpec;
+export { make as _, DirectUpdateBody as a, rdfMediaTypes as b, Paths as c, QueryResponse as d, RdfDocumentBody as f, SparqlApi_d_exports as g, SparqlApi as h, DirectQueryBody as i, ProtocolErrorResponse as l, SchemaFallback as m, Api as n, FormBody as o, RdfResponse as p, DatasetParams as r, GraphParams as s, AcceptHeader as t, QueryParams as u, openApi as v, resultsMediaTypes as x, queryMediaTypes as y };
+//# sourceMappingURL=SparqlApi-BKE9nIf4.d.mts.map