@thomasfosterau/effect-sparql-node 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Foster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,221 @@
 # @thomasfosterau/effect-sparql-node
 
-Placeholder reserved for npm trusted publishing; the first real release is 0.1.0, from https://github.com/thomasfosterau/effect-rdf.
+The Node side of [`@thomasfosterau/effect-rdf/sparql`](https://github.com/thomasfosterau/effect-rdf/tree/main/packages/core#sparql-thomasfosteraueffect-rdfsparql):
+
+- **`NodeSparqlServer`** — the platform-neutral SPARQL 1.1 Protocol and Graph
+  Store HTTP Protocol server (`SparqlServer` in effect-rdf) on a `node:http`
+  socket, through `@effect/platform-node`'s `NodeHttpServer`: `layer(options)`
+  and `layerMemory(options)` (over an in-memory store).
+- **`Cli`** and the `effect-sparql-server` executable — serve RDF files from
+  the command line.
+- **`SparqlApi`**, **`SparqlApiBuilder`**, **`SparqlApiClient`** — the two
+  protocols as an Effect `HttpApi` definition with an OpenAPI document, the
+  routes that serve it with `SparqlServer`'s behaviour, and the client derived
+  from it.
+
+```sh
+pnpm add effect @thomasfosterau/effect-parse @thomasfosterau/effect-rdf @thomasfosterau/effect-sparql-node
+```
+
+Peers: `effect` (`^4.1.2`: its runtime dependency `@effect/platform-node`
+needs it, and `SparqlApi` declares a list of response content types per
+stream, a 4.1 form of `HttpApiSchema.StreamUint8Array`) and
+`@thomasfosterau/effect-parse` (the SPARQL parser behind effect-rdf's
+`/sparql`). `@thomasfosterau/effect-rdf` and `@effect/platform-node` are
+dependencies.
+
+## Serving data
+
+```ts
+import { Layer } from 'effect';
+import { NodeRuntime } from '@effect/platform-node';
+import { Dataset } from '@thomasfosterau/effect-rdf';
+import { NodeSparqlServer } from '@thomasfosterau/effect-sparql-node';
+
+const data: Dataset.Dataset = /* … */ Dataset.empty;
+
+// SPARQL endpoint on /sparql, graph store on /rdf-graph-store.
+const Server = NodeSparqlServer.layerMemory({
+  port: 3030,
+  data,
+  queryTimeout: '30 seconds',
+  maxResults: 100_000,
+  cors: true,
+});
+
+Layer.launch(Server).pipe(NodeRuntime.runMain);
+```
+
+With your own store or engine (e.g. a SQL backend), provide the
+`SparqlEngine`, `QuadStore` and `Serialization.Formats` services:
+
+```ts
+import { Layer } from 'effect';
+import { Engine, ServerFormats, Store } from '@thomasfosterau/effect-rdf/sparql';
+import { NodeSparqlServer } from '@thomasfosterau/effect-sparql-node';
+
+const Server = NodeSparqlServer.layer({ port: 3030, readOnly: true }).pipe(
+  Layer.provide(Engine.layer({ unionDefaultGraph: true })),
+  Layer.provide(Store.layerMemory()),
+  Layer.provide(ServerFormats.layer),
+);
+```
+
+`NodeSparqlServer` takes the options of `SparqlServer` (see effect-rdf's
+README) plus `port` and `host`. To mount the routes into a server of your own,
+or to serve them on another platform, use `SparqlServer.layerRoutes`,
+`SparqlServer.handler` or `SparqlServer.layerServe` from
+`@thomasfosterau/effect-rdf/sparql`.
+
+## HttpApi definition and OpenAPI
+
+`SparqlApi` describes both protocols as an Effect `HttpApi`, so the
+endpoints, their parameters, request and response media types and error
+statuses are typed and documented in one place:
+
+- group `sparql`: `query` (`GET` with `query`, `default-graph-uri`,
+  `named-graph-uri`; without `query` it answers the service description) and
+  `post` (`POST` with an `application/x-www-form-urlencoded`,
+  `application/sparql-query` or `application/sparql-update` body; `200` with
+  results or `204` after an update);
+- group `graphStore`: `get`, `head`, `put`, `post` and `delete` with
+  `graph=<iri>` or `default`, bodies under every RDF media type of
+  `ServerFormats.codecs`;
+- responses are byte streams listing every format
+  (`SparqlApi.queryMediaTypes`, `SparqlApi.rdfMediaTypes`); errors are
+  `text/plain` messages decoded into `ProtocolErrors.ProtocolError` at `400`, `403`,
+  `404`, `405`, `406`, `415`, `500` and `503`.
+
+`SparqlApi.make({ path, graphStorePath })` builds it at other paths and
+`SparqlApi.openApi(api)` returns its OpenAPI document.
+
+`SparqlApiBuilder.layerRoutes(options)` serves it with `HttpApiBuilder`. Its
+handlers are raw (`handleRaw`) and run the same code as `SparqlServer`:
+`Accept` is negotiated and bodies are read by the protocol internals, so
+statuses, headers and messages are identical. Methods the API does not
+declare (`405` with `Allow`), CORS preflights and graphs identified directly
+by a URL below the graph store go to plain `HttpRouter` fallback routes, and
+the `SparqlApi.SchemaFallback` middleware hands a request whose parameters
+fail the API's schemas (e.g. a repeated `query`) to the protocol handler, so
+it gets the protocol's own `400`. The conformance suites run against both
+servers. `effect/http-api` is `@stability unstable` in Effect 4.
+
+```ts
+import { Layer } from 'effect';
+import { HttpRouter } from 'effect/http';
+import { NodeHttpServer } from '@effect/platform-node';
+import { createServer } from 'node:http';
+import { SparqlServer } from '@thomasfosterau/effect-rdf/sparql';
+import { SparqlApiBuilder } from '@thomasfosterau/effect-sparql-node';
+
+const Main = HttpRouter.serve(SparqlApiBuilder.layerRoutes({ openapiPath: '/openapi.json' })).pipe(
+  Layer.provide(SparqlServer.layerMemoryServices()),
+  Layer.provide(NodeHttpServer.layer(createServer, { port: 8080 })),
+);
+```
+
+`SparqlApiBuilder.layerServe(options)` is the same with request logging, and
+`layerHandlers` / `layerSchemaFallback` / `layerFallback` are the pieces, for
+mounting the API next to other `HttpApiBuilder` groups. The API takes the
+options of `SparqlServer` except `updatePath` (updates go to the query
+endpoint) and `graphStorePath: false`. `SparqlApiBuilder.makeTestClient(options)` is an
+in-process `HttpClient` for the API routes.
+
+## Command line
+
+This package installs an `effect-sparql-server` executable
+(`bin/effect-sparql-server.mjs`):
+
+```sh
+effect-sparql-server --port 3030 --cors data.ttl more.trig
+effect-sparql-server --read-only --timeout 10000 --graph-per-file a.ttl b.nt
+```
+
+Files are parsed by extension with the default formats; run
+`effect-sparql-server --help` for every option (the help, `--version` and
+`--completions <shell>` come from `effect/cli`). (From the repository:
+`pnpm --filter @thomasfosterau/effect-sparql-node start -- data.ttl`.)
+
+Every flag can also be set by an environment variable — `SPARQL_SERVER_`
+followed by the flag name in upper snake case — which suits containers. A flag
+on the command line wins over the environment, which wins over the default:
+
+| Flag                    | Environment variable                | Default            |
+| ----------------------- | ----------------------------------- | ------------------ |
+| `-p`, `--port`          | `SPARQL_SERVER_PORT`                | `3030`             |
+| `--host`                | `SPARQL_SERVER_HOST`                | all interfaces     |
+| `--path`                | `SPARQL_SERVER_PATH`                | `/sparql`          |
+| `--update-path`         | `SPARQL_SERVER_UPDATE_PATH`         | the query path     |
+| `--graph-store`         | `SPARQL_SERVER_GRAPH_STORE`         | `/rdf-graph-store` |
+| `--no-graph-store`      | `SPARQL_SERVER_NO_GRAPH_STORE`      | `false`            |
+| `--read-only`           | `SPARQL_SERVER_READ_ONLY`           | `false`            |
+| `--timeout`             | `SPARQL_SERVER_TIMEOUT`             | none               |
+| `--max-results`         | `SPARQL_SERVER_MAX_RESULTS`         | none               |
+| `--cors`                | `SPARQL_SERVER_CORS`                | `false`            |
+| `--union-default-graph` | `SPARQL_SERVER_UNION_DEFAULT_GRAPH` | `false`            |
+| `--graph-per-file`      | `SPARQL_SERVER_GRAPH_PER_FILE`      | `false`            |
+| `--base-url`            | `SPARQL_SERVER_BASE_URL`            | the request origin |
+
+```sh
+SPARQL_SERVER_PORT=8080 SPARQL_SERVER_READ_ONLY=true effect-sparql-server data.ttl
+```
+
+Programmatically, `Cli.command` is the `effect/cli` command, `Cli.parse(argv)`
+validates arguments (and the environment) into `Cli.Arguments`, and
+`Cli.run(argv, { version })` runs the server.
+
+## Derived client
+
+`SparqlApiClient.make(options)` derives a client with `HttpApiClient` from
+the server's `SparqlApi` definition (above): one typed method
+per endpoint (`client.sparql.query`, `client.sparql.post`,
+`client.graphStore.get` / `head` / `put` / `post` / `delete`), returning
+response bodies as byte streams and failing with the server's
+`ProtocolErrors.ProtocolError` (with the status and message) on error statuses. The
+helpers send the common requests and parse the bodies with `ResultsStream`
+and `ClientFormats.defaults`:
+
+```ts
+import { Effect, Stream } from 'effect';
+import { FetchHttpClient } from 'effect/http';
+import { SparqlApiClient } from '@thomasfosterau/effect-sparql-node';
+
+const program = Effect.gen(function* () {
+  const client = yield* SparqlApiClient.SparqlApiClient;
+  // Raw: the generated method, with `responseMode` to see the response.
+  const [body, response] = yield* client.sparql.query({
+    query: { query: 'ASK {}' },
+    headers: { accept: 'application/sparql-results+json' },
+    responseMode: 'decoded-and-response',
+  });
+  // Parsed: SELECT / ASK events, CONSTRUCT graphs, updates, Graph Store.
+  const events = yield* Stream.runCollect(SparqlApiClient.results(client, 'SELECT * { ?s ?p ?o }'));
+  yield* SparqlApiClient.update(client, 'INSERT DATA { <urn:a> <urn:b> <urn:c> }');
+  yield* SparqlApiClient.writeGraph(client, { graph: 'urn:g' }, '<urn:a> <urn:b> "c" .');
+  return yield* SparqlApiClient.readGraph(client, { graph: 'urn:g' });
+}).pipe(
+  Effect.provide(SparqlApiClient.layer({ baseUrl: 'https://example.org' })),
+  Effect.provide(FetchHttpClient.layer),
+);
+```
+
+`options.paths` targets a server at other paths and `transformClient` adds
+retries or authentication. Direct bodies are tagged payloads
+(`{ _tag: 'DirectQuery', query }`, `{ _tag: 'DirectUpdate', update }`),
+forms are plain records, and Graph Store bodies are `{ mediaType, document }`.
+It works against `SparqlServer.handler` too: the definition describes the
+same protocol. `effect/http-api` is `@stability unstable` in Effect 4.
+
+## Conformance
+
+The SPARQL 1.1 Protocol suites (`.test-suites/rdf-tests/sparql/sparql11`, or
+`$RDF_TEST_SUITES`) run in-process (`test/ProtocolConformance.test.ts`), once
+against `SparqlServer.handler` and once against the `SparqlApi` routes, with
+the same results: Protocol 34 / 34, Graph Store Protocol 14 / 14, Service
+Description 3 / 3 (the deprecated `http-rdf-update` suite is skipped). The
+tests of `SparqlApi`, `SparqlApiClient` (against both servers), the CLI and
+the Node server sit beside it in `test/`.
+
+## License
+
+MIT

package/bin/effect-sparql-server.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env -S node --no-warnings
+// Serves RDF files over the SPARQL 1.1 Protocol and Graph Store Protocol.
+// Uses the built `dist/` when available, otherwise the TypeScript sources
+// (run directly with Node's built-in type stripping).
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const dist = new URL('../dist/Cli.mjs', import.meta.url);
+const Cli = await import(
+  existsSync(dist) ? dist.href : new URL('../src/Cli.ts', import.meta.url).href
+);
+const { NodeRuntime } = await import('@effect/platform-node');
+const { Effect } = await import('effect');
+const { version } = createRequire(import.meta.url)('../package.json');
+
+NodeRuntime.runMain(
+  Cli.run(process.argv.slice(2), { version }).pipe(
+    // Usage errors: `effect/cli` has printed the help; say what was wrong.
+    Effect.catchTag('CliError', (e) =>
+      Effect.sync(() => {
+        if (e.message !== '') process.stderr.write(`${e.message}\n`);
+        process.exitCode = 2;
+      }),
+    ),
+  ),
+);

package/dist/Cli-DE0eXMJr.d.mts

@@ -0,0 +1,143 @@
+import { n as ServeOptions } from "./NodeSparqlServer-1vSrPk3J.mjs";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { Argument, Command, Flag } from "effect/cli";
+import * as Dataset from "@thomasfosterau/effect-rdf/Dataset";
+import * as Serialization from "@thomasfosterau/effect-rdf/Serialization";
+import * as HttpServerError from "effect/http/HttpServerError";
+declare namespace Cli_d_exports {
+  export { Arguments, CliError, Flags, command, config, envPrefix, load, parse, run, toArguments, usage };
+}
+declare const CliError_base: Schema.Class<CliError, Schema.TaggedStruct<"CliError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A command line usage error.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class CliError extends CliError_base {}
+/**
+ * The prefix of the environment variables that back the flags:
+ * `SPARQL_SERVER_PORT`, `SPARQL_SERVER_READ_ONLY`, …
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const envPrefix = "SPARQL_SERVER_";
+/**
+ * A summary of the flags and their environment variables; `--help` prints
+ * the full, generated help.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare 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";
+/**
+ * Parsed command line arguments.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Arguments {
+  readonly help: boolean;
+  readonly files: ReadonlyArray<string>;
+  readonly graphPerFile: boolean;
+  readonly unionDefaultGraph: boolean;
+  readonly serve: ServeOptions;
+}
+/**
+ * The command's flags and arguments.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const config: {
+  readonly port: Flag.Flag<Option.Option<number>>;
+  readonly host: Flag.Flag<Option.Option<string>>;
+  readonly path: Flag.Flag<Option.Option<string>>;
+  readonly updatePath: Flag.Flag<Option.Option<string>>;
+  readonly graphStore: Flag.Flag<Option.Option<string>>;
+  readonly noGraphStore: Flag.Flag<boolean>;
+  readonly readOnly: Flag.Flag<boolean>;
+  readonly timeout: Flag.Flag<Option.Option<number>>;
+  readonly maxResults: Flag.Flag<Option.Option<number>>;
+  readonly cors: Flag.Flag<boolean>;
+  readonly unionDefaultGraph: Flag.Flag<boolean>;
+  readonly graphPerFile: Flag.Flag<boolean>;
+  readonly baseUrl: Flag.Flag<Option.Option<string>>;
+  readonly files: Argument.Argument<readonly string[]>;
+};
+/**
+ * The values of the flags and arguments, as `effect/cli` parses them.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Flags = Command.Command.Config.Infer<typeof config>;
+/**
+ * Validates parsed flags into `Arguments`: integers must be non-negative,
+ * paths must start with `/`, and `--base-url` must be an absolute IRI.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const toArguments: (flags: Flags) => Effect.Effect<Arguments, CliError>;
+/**
+ * Parses command line arguments, reading unset flags from the environment
+ * (`SPARQL_SERVER_*`). `-h` / `--help` sets `help` instead.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const parse: (argv: ReadonlyArray<string>) => Effect.Effect<Arguments, CliError>;
+/**
+ * Loads RDF files into a dataset through Effect's `FileSystem`, choosing
+ * parsers by file extension from the `Formats` service. Relative IRIs
+ * resolve against each file's `file:` URL; with `graphPerFile`, a file's
+ * default-graph triples go into a graph named by that URL.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const load: (files: ReadonlyArray<string>, graphPerFile: boolean) => Effect.Effect<Dataset.Dataset, CliError | Serialization.RdfParseError, Serialization.Formats | FileSystem.FileSystem | Path.Path>;
+/**
+ * The `effect/cli` command: parses the flags (and their environment
+ * variables), loads the files and serves them until interrupted.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const command: Command.Command<"effect-sparql-server", {
+  readonly port: Option.Option<number>;
+  readonly host: Option.Option<string>;
+  readonly path: Option.Option<string>;
+  readonly updatePath: Option.Option<string>;
+  readonly graphStore: Option.Option<string>;
+  readonly noGraphStore: boolean;
+  readonly readOnly: boolean;
+  readonly timeout: Option.Option<number>;
+  readonly maxResults: Option.Option<number>;
+  readonly cors: boolean;
+  readonly unionDefaultGraph: boolean;
+  readonly graphPerFile: boolean;
+  readonly baseUrl: Option.Option<string>;
+  readonly files: readonly string[];
+}, {}, CliError | Serialization.RdfParseError | HttpServerError.ServeError, never>;
+/**
+ * Runs the command line program: parses arguments (printing the generated
+ * help for `--help` or a usage error), loads the files and serves them
+ * until interrupted. `version` is what `--version` prints.
+ *
+ * @since 0.1.0
+ * @category cli
+ */
+declare const run: (argv: ReadonlyArray<string>, options?: {
+  readonly version?: string | undefined;
+}) => Effect.Effect<void, CliError | Serialization.RdfParseError | HttpServerError.ServeError>;
+export { command as a, load as c, toArguments as d, usage as f, Flags as i, parse as l, CliError as n, config as o, Cli_d_exports as r, envPrefix as s, Arguments as t, run as u };
+//# sourceMappingURL=Cli-DE0eXMJr.d.mts.map

package/dist/Cli-DFvng1N8.mjs

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