@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/ResultsStream-BhF0OcNn.mjs

@@ -0,0 +1,639 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { o as fromEntries } from "./Bindings-Ck3m7JRC.mjs";
+import { a as ResultsParseError, c as Xml, g as termFromJson, h as parseTerm, i as JsonTermSchema, l as codecFor, n as Json, s as Tsv, t as Csv, y as parse$1 } from "./Results-peJjGA2V.mjs";
+import * as Arr from "effect/Array";
+import * as Iterable from "effect/Iterable";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Record from "effect/Record";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+// src/sparql/ResultsStream.ts
+/**
+* Incremental parsing of SPARQL results documents: solutions are emitted as
+* soon as they have been received, without buffering the whole response.
+*
+* - JSON (`application/sparql-results+json`): an incremental scanner finds
+*   the `head`, `boolean` and each element of `results.bindings`, decoded
+*   with `Results.JsonTermSchema`;
+* - XML (`application/sparql-results+xml`): complete `<result>` elements are
+*   cut from the input and parsed with `Results.Xml.parse`;
+* - TSV (`text/tab-separated-values`): line by line with
+*   `Results.parseTerm`;
+* - CSV (`text/csv`): complete records (whose quoted cells may span lines)
+*   are parsed with `Results.Csv.parse` as they arrive.
+*
+* @since 0.1.0
+*/
+var ResultsStream_exports = /* @__PURE__ */ __exportAll({
+	buffered: () => buffered,
+	csv: () => csv,
+	json: () => json,
+	parse: () => parse,
+	parserFor: () => parserFor,
+	run: () => run,
+	tsv: () => tsv,
+	xml: () => xml
+});
+const fail = (format, message) => {
+	throw new ResultsParseError({
+		format,
+		message
+	});
+};
+const variablesEvent = (variables) => ({
+	_tag: "Variables",
+	variables
+});
+const isBooleanResult = Predicate.isTagged("Boolean");
+const fromParsed = (parsed) => isBooleanResult(parsed) ? [{
+	_tag: "Boolean",
+	value: parsed.value
+}] : [variablesEvent(parsed.variables), ...parsed.bindings.map((bindings) => ({
+	_tag: "Solution",
+	bindings
+}))];
+/** Appends a solution event per row of a parsed result set (none for a boolean). */
+const pushSolutions = (parsed, out) => {
+	if (isBooleanResult(parsed)) return;
+	parsed.bindings.forEach((bindings) => {
+		out.push({
+			_tag: "Solution",
+			bindings
+		});
+	});
+};
+const runSyncParse = (effect) => {
+	const result = Effect.runSync(Effect.result(effect));
+	if (Result.isFailure(result)) throw result.failure;
+	return result.success;
+};
+const decodeJsonString = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.String));
+const decodeRow = Schema.decodeUnknownResult(Schema.Record(Schema.String, JsonTermSchema));
+const decodeHead = Schema.decodeUnknownResult(Schema.Struct({ vars: Schema.optional(Schema.Array(Schema.String)) }));
+/**
+* One token of JSON outside a string, as capture groups: (1) a run of
+* whitespace, (2) an opening and (3) a closing bracket, (4) `:` or `,`, (5)
+* the body of a string that starts here, followed by (6) its closing quote or
+* (7) a lone backslash at the end of the chunk (neither: the chunk ends inside
+* the string); no group: a run of primitive (number, literal) characters.
+*/
+const JSON_TOKEN = /([ \t\n\r]+)|([{[])|([}\]])|([:,])|"([^"\\]*(?:\\[^][^"\\]*)*)(?:(")|(\\))?|[^ \t\n\r{}[\]:,"]+/g;
+/** The rest of a string a chunk starts inside: up to its closing quote, a lone final backslash or the end. */
+const STRING_REST = /[^"\\]*(?:\\[^][^"\\]*)*/y;
+/**
+* An incremental parser for SPARQL JSON results.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const json = () => {
+	const stack = [];
+	let inString = false;
+	let escape = false;
+	let stringIsKey = false;
+	let keyRaw = "";
+	let primitive = false;
+	let capturing = false;
+	let capture = "head";
+	let captureDepth = 0;
+	let captureBuf = "";
+	let captureStart = -1;
+	let done = false;
+	let sawHead = false;
+	let sawBody = false;
+	let chunk = "";
+	let out = [];
+	/** Whether a value starting here is one to capture, and which. */
+	const interesting = () => {
+		const top = stack[stack.length - 1];
+		if (top === void 0) return Option.none();
+		if (stack.length === 1 && top.type === "object") {
+			if (top.key === "head") return Option.some("head");
+			if (top.key === "boolean") return Option.some("boolean");
+			return Option.none();
+		}
+		if (stack.length === 3 && top.type === "array" && stack[0]?.key === "results" && stack[1]?.type === "object" && stack[1].key === "bindings") return Option.some("binding");
+		return Option.none();
+	};
+	const emit = (kind, text) => {
+		const parsed = parse$1(text);
+		if (Result.isFailure(parsed)) fail("json", `Invalid JSON: ${parsed.failure}`);
+		const value = parsed.success;
+		if (kind === "head") {
+			const head = decodeHead(value);
+			if (Result.isFailure(head)) fail("json", `Invalid head: ${head.failure.message}`);
+			sawHead = true;
+			out.push(variablesEvent(head.success.vars ?? []));
+		} else if (kind === "boolean") {
+			if (!Predicate.isBoolean(value)) fail("json", "\"boolean\" must be true or false");
+			sawBody = true;
+			out.push({
+				_tag: "Boolean",
+				value
+			});
+		} else {
+			const row = decodeRow(value);
+			if (Result.isFailure(row)) fail("json", `Invalid binding: ${row.failure.message}`);
+			sawBody = true;
+			out.push({
+				_tag: "Solution",
+				bindings: fromEntries(Arr.map(Record.toEntries(row.success), ([k, v]) => [k, termFromJson(v)]))
+			});
+		}
+	};
+	/** Emits the captured value if it ends (exclusively) at `end` of the chunk. */
+	const finish = (end) => {
+		if (!capturing || stack.length !== captureDepth) return;
+		const text = captureBuf + chunk.slice(captureStart, end);
+		capturing = false;
+		captureBuf = "";
+		captureStart = -1;
+		emit(capture, text);
+	};
+	const valueStart = (i) => {
+		if (capturing) return;
+		const kind = interesting();
+		if (Option.isSome(kind)) {
+			capturing = true;
+			capture = kind.value;
+			captureDepth = stack.length;
+			captureStart = i;
+			captureBuf = "";
+		}
+	};
+	const endPrimitive = (i) => {
+		if (!primitive) return;
+		primitive = false;
+		finish(i);
+	};
+	/** Ends the current string at its closing quote, `quote`. */
+	const endString = (quote) => {
+		inString = false;
+		if (stringIsKey) {
+			const key = decodeJsonString(`"${keyRaw}"`);
+			if (Result.isFailure(key)) fail("json", "Invalid object key");
+			const top = stack[stack.length - 1];
+			if (top !== void 0) {
+				top.key = key.success;
+				top.expectKey = false;
+			}
+		} else finish(quote + 1);
+	};
+	/** Continues a string that the previous chunk ended inside; returns where it stops. */
+	const continueString = () => {
+		let start = 0;
+		if (escape) {
+			escape = false;
+			if (stringIsKey) keyRaw += chunk[0];
+			start = 1;
+		}
+		STRING_REST.lastIndex = start;
+		const body = STRING_REST.exec(chunk)?.[0] ?? "";
+		const end = start + body.length;
+		if (stringIsKey) keyRaw += body;
+		if (end >= chunk.length) return end;
+		if (chunk.charCodeAt(end) === 34) {
+			endString(end);
+			return end + 1;
+		}
+		escape = true;
+		if (stringIsKey) keyRaw += "\\";
+		return chunk.length;
+	};
+	/** Scans one token at `i` of the chunk (the groups are `JSON_TOKEN`'s, absent when unmatched). */
+	const token = (i, ws, open, close, punct, body, quote, backslash) => {
+		if (done) {
+			if (ws === void 0) fail("json", "Trailing data");
+			return;
+		}
+		if (ws !== void 0) endPrimitive(i);
+		else if (open !== void 0) {
+			endPrimitive(i);
+			valueStart(i);
+			const isObject = open === "{";
+			stack.push({
+				type: isObject ? "object" : "array",
+				key: "",
+				expectKey: isObject
+			});
+		} else if (close !== void 0) {
+			endPrimitive(i);
+			const frame = stack.pop();
+			if (frame === void 0 || frame.type !== (close === "}" ? "object" : "array")) fail("json", "Unbalanced brackets");
+			finish(i + 1);
+			if (Arr.isReadonlyArrayEmpty(stack)) done = true;
+		} else if (punct !== void 0) {
+			endPrimitive(i);
+			const top = stack[stack.length - 1];
+			if (punct === "," && top !== void 0 && top.type === "object") top.expectKey = true;
+		} else if (body !== void 0) {
+			endPrimitive(i);
+			const top = stack[stack.length - 1];
+			inString = true;
+			if (top !== void 0 && top.type === "object" && top.expectKey) {
+				stringIsKey = true;
+				keyRaw = body;
+			} else {
+				stringIsKey = false;
+				valueStart(i);
+			}
+			if (quote !== void 0) endString(i + 1 + body.length);
+			else if (backslash !== void 0) {
+				escape = true;
+				if (stringIsKey) keyRaw += "\\";
+			}
+		} else {
+			if (Arr.isReadonlyArrayEmpty(stack)) fail("json", "Expected a JSON object");
+			if (!primitive) {
+				primitive = true;
+				valueStart(i);
+			}
+		}
+	};
+	const push = (text) => {
+		out = [];
+		chunk = text;
+		if (capturing) captureStart = 0;
+		const from = inString && chunk !== "" ? continueString() : 0;
+		if (from < chunk.length) (from === 0 ? chunk : chunk.slice(from)).replace(JSON_TOKEN, (_m, ws, open, close, punct, body, quote, backslash, offset) => {
+			token(from + offset, ws, open, close, punct, body, quote, backslash);
+			return "";
+		});
+		if (capturing) {
+			captureBuf += chunk.slice(captureStart);
+			captureStart = 0;
+		}
+		chunk = "";
+		return out;
+	};
+	return {
+		push,
+		end: () => {
+			if (!done || inString) fail("json", "Unexpected end of document");
+			if (!sawHead && !sawBody) fail("json", "Missing \"head\"");
+			return [];
+		}
+	};
+};
+/**
+* An incremental parser for SPARQL TSV results.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const tsv = () => {
+	let buffer = "";
+	/** Whether the first line (the variables, or a boolean) has been read. */
+	let started = false;
+	let variables = [];
+	let boolean = false;
+	const line = (raw, out) => {
+		const text = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+		if (!started) {
+			started = true;
+			const first = text.trim();
+			if (first === "true" || first === "false") {
+				boolean = true;
+				out.push({
+					_tag: "Boolean",
+					value: first === "true"
+				});
+				return;
+			}
+			variables = text === "" ? [] : text.split("	").map((v) => v.trim().replace(/^[?$]/, ""));
+			out.push(variablesEvent(variables));
+			return;
+		}
+		if (boolean) {
+			if (text.trim() !== "") fail("tsv", "Unexpected data after a boolean result");
+			return;
+		}
+		const cells = text.split("	");
+		const entries = [];
+		variables.forEach((variable, i) => {
+			const cell = (cells[i] ?? "").trim();
+			if (cell === "") return;
+			const term = parseTerm(cell);
+			if (Option.isNone(term)) fail("tsv", `Invalid term: ${cell}`);
+			entries.push([variable, term.value]);
+		});
+		out.push({
+			_tag: "Solution",
+			bindings: fromEntries(entries)
+		});
+	};
+	return {
+		push: (chunk) => {
+			const out = [];
+			buffer += chunk;
+			const nl = buffer.lastIndexOf("\n");
+			if (nl >= 0) {
+				const complete = buffer.slice(0, nl);
+				buffer = buffer.slice(nl + 1);
+				complete.split("\n").forEach((l) => line(l, out));
+			}
+			return out;
+		},
+		end: () => {
+			const out = [];
+			if (buffer !== "") line(buffer, out);
+			buffer = "";
+			if (!started) fail("tsv", "Empty document");
+			return out;
+		}
+	};
+};
+const ROOT = /<([A-Za-z_][\w.-]*:)?sparql\b[^>]*>/;
+const HEAD_END = /<\/head\s*>|<head\b[^>]*\/>/;
+const RESULTS_START = /<results\b[^>]*?(\/?)>/;
+const RESULT_END = /<result\b[^>]*\/>|<\/result\s*>/g;
+const parseXmlResults = (doc) => runSyncParse(Xml.parse(doc));
+/**
+* An incremental parser for SPARQL XML results.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const xml = () => {
+	let buffer = "";
+	let phase = "root";
+	let root = "";
+	let head = "";
+	const step = (out) => {
+		return Match.value(phase).pipe(Match.when("root", () => {
+			const m = ROOT.exec(buffer);
+			if (m === null) return false;
+			if (m[1] !== void 0 || m[0].endsWith("/>")) {
+				phase = "whole";
+				return false;
+			}
+			root = buffer.slice(0, m.index + m[0].length);
+			buffer = buffer.slice(m.index + m[0].length);
+			phase = "head";
+			return true;
+		}), Match.when("head", () => {
+			const m = HEAD_END.exec(buffer);
+			if (m === null) return false;
+			head = buffer.slice(0, m.index + m[0].length);
+			buffer = buffer.slice(m.index + m[0].length);
+			const parsed = parseXmlResults(`${root}${head}</sparql>`);
+			out.push(variablesEvent(isBooleanResult(parsed) ? [] : parsed.variables));
+			phase = "body";
+			return true;
+		}), Match.when("body", () => {
+			const results = RESULTS_START.exec(buffer);
+			const boolean = buffer.indexOf("<boolean");
+			if (boolean >= 0 && (results === null || boolean < results.index)) {
+				const end = buffer.indexOf("</boolean>");
+				if (end < 0) return false;
+				const parsed = parseXmlResults(`${root}<head/>${buffer.slice(boolean, end + 10)}</sparql>`);
+				if (isBooleanResult(parsed)) out.push({
+					_tag: "Boolean",
+					value: parsed.value
+				});
+				buffer = "";
+				phase = "done";
+				return false;
+			}
+			if (results === null) return false;
+			buffer = buffer.slice(results.index + results[0].length);
+			phase = results[1] === "/" ? "done" : "results";
+			return true;
+		}), Match.when("results", () => {
+			const last = Iterable.reduce(buffer.matchAll(RESULT_END), -1, (_, m) => m.index + m[0].length);
+			if (last < 0) return false;
+			pushSolutions(parseXmlResults(`${root}<head/><results>${buffer.slice(0, last)}</results></sparql>`), out);
+			buffer = buffer.slice(last);
+			return false;
+		}), Match.orElse(() => false));
+	};
+	/** Steps until a phase waits for more input (each `true` is a phase change). */
+	const drain = (out) => {
+		if (step(out)) drain(out);
+	};
+	/** Read through a function: `drain` may move `phase` to `whole`, which TypeScript cannot see. */
+	const isWhole = () => phase === "whole";
+	let whole = "";
+	return {
+		push: (chunk) => {
+			const out = [];
+			if (phase === "whole") {
+				whole += chunk;
+				return out;
+			}
+			if (phase === "done") return out;
+			buffer += chunk;
+			drain(out);
+			if (isWhole()) {
+				whole = buffer;
+				buffer = "";
+			}
+			return out;
+		},
+		end: () => {
+			if (phase === "whole" || phase === "root") return fromParsed(parseXmlResults(whole + buffer));
+			if (phase === "head" || phase === "body") {
+				if (phase === "head") fail("xml", "Unexpected end of document");
+				const parsed = parseXmlResults(`${root}${head}${buffer}`);
+				return isBooleanResult(parsed) ? [{
+					_tag: "Boolean",
+					value: parsed.value
+				}] : [];
+			}
+			if (phase === "results" && !/<\/results\s*>/.test(buffer)) fail("xml", "Unexpected end of document");
+			return [];
+		}
+	};
+};
+const QUOTE_OR_LINE_BREAK = /["\n]/g;
+/** Scans `text` from `from`, starting inside quotes or not, for the line breaks that end records. */
+const scanRecords = (text, from, quoted) => {
+	const scan = {
+		quoted,
+		first: -1,
+		last: -1
+	};
+	(from === 0 ? text : text.slice(from)).replace(QUOTE_OR_LINE_BREAK, (c, offset) => {
+		if (c === "\"") scan.quoted = !scan.quoted;
+		else if (!scan.quoted) {
+			if (scan.first < 0) scan.first = from + offset;
+			scan.last = from + offset;
+		}
+		return "";
+	});
+	return scan;
+};
+/**
+* An incremental parser for SPARQL CSV results: records are parsed (with the
+* header, by `Results.Csv.parse`) once they are complete, that is, once a line
+* break outside quotes has arrived.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const csv = () => {
+	let buffer = "";
+	/** How far `buffer` has been scanned for record ends, and whether that is inside quotes. */
+	let scanned = 0;
+	let quoted = false;
+	let header = Option.none();
+	let boolean = false;
+	/** The lines of the header, and of the records parsed so far (header included). */
+	let headerLines = 0;
+	let lines = 0;
+	const parse = (records) => {
+		const parsed = Result.try(() => runSyncParse(Csv.parse(Option.match(header, {
+			onNone: () => records,
+			onSome: (h) => h + records
+		}))));
+		if (Result.isSuccess(parsed)) return parsed.success;
+		const e = parsed.failure;
+		if (e instanceof ResultsParseError && e.line !== void 0 && Option.isSome(header)) {
+			const line = e.line - headerLines + lines;
+			throw e.column === void 0 ? new ResultsParseError({
+				format: e.format,
+				message: e.message,
+				line
+			}) : new ResultsParseError({
+				format: e.format,
+				message: e.message,
+				line,
+				column: e.column
+			});
+		}
+		throw e;
+	};
+	const records = (input, out) => {
+		if (boolean || input === "") return;
+		let text = input;
+		if (Option.isNone(header)) {
+			const end = recordEnd(text);
+			const first = text.slice(0, end);
+			const parsed = parse(first);
+			if (isBooleanResult(parsed)) {
+				boolean = true;
+				out.push({
+					_tag: "Boolean",
+					value: parsed.value
+				});
+				return;
+			}
+			out.push(variablesEvent(parsed.variables));
+			header = Option.some(first);
+			headerLines = countLines(first);
+			lines = headerLines;
+			text = text.slice(end);
+			if (text === "") return;
+		}
+		pushSolutions(parse(text), out);
+		lines += countLines(text);
+	};
+	return {
+		push: (chunk) => {
+			const out = [];
+			buffer += chunk;
+			const scan = scanRecords(buffer, scanned, quoted);
+			quoted = scan.quoted;
+			scanned = buffer.length;
+			if (scan.last >= 0) {
+				records(buffer.slice(0, scan.last + 1), out);
+				buffer = buffer.slice(scan.last + 1);
+				scanned = buffer.length;
+			}
+			return out;
+		},
+		end: () => {
+			const out = [];
+			if (Option.isNone(header) && !boolean) return fromParsed(parse(buffer));
+			records(buffer, out);
+			buffer = "";
+			return out;
+		}
+	};
+};
+/** The end of the first record of complete records (after its line break). */
+const recordEnd = (text) => {
+	const { first } = scanRecords(text, 0, false);
+	return first < 0 ? text.length : first + 1;
+};
+const countLines = (text) => text.split("\n").length - 1;
+/**
+* A parser that buffers the whole document and parses it with a complete
+* results codec (used for CSV).
+*
+* @since 0.1.0
+* @category parsers
+*/
+const buffered = (codec) => {
+	let buffer = "";
+	return {
+		push: (chunk) => {
+			buffer += chunk;
+			return [];
+		},
+		end: () => fromParsed(runSyncParse(codec.parse(buffer)))
+	};
+};
+/**
+* Runs an incremental parser over a stream of text chunks.
+*
+* @since 0.1.0
+* @category streams
+*/
+const run = (input, make, format) => {
+	const step = (f) => Effect.try({
+		try: f,
+		catch: (e) => e instanceof ResultsParseError ? e : new ResultsParseError({
+			format,
+			message: Predicate.hasProperty(e, "message") && Predicate.isString(e.message) ? e.message : String(e)
+		})
+	});
+	return Stream.suspend(() => {
+		const parser = make();
+		return Stream.concat(Stream.flattenIterable(Stream.mapEffect(input, (chunk) => step(() => parser.push(chunk)))), Stream.flattenIterable(Stream.fromEffect(step(() => parser.end()))));
+	});
+};
+/**
+* Finds the incremental parser for a results media type.
+*
+* @since 0.1.0
+* @category streams
+*/
+const parserFor = (mediaType) => {
+	const codec = codecFor(mediaType);
+	if (Option.isNone(codec)) return Option.none();
+	return Match.value(codec).pipe(Match.when(({ value }) => value === Json, () => Option.some({
+		make: json,
+		format: "json"
+	})), Match.when(({ value }) => value === Xml, () => Option.some({
+		make: xml,
+		format: "xml"
+	})), Match.when(({ value }) => value === Tsv, () => Option.some({
+		make: tsv,
+		format: "tsv"
+	})), Match.when(({ value }) => value === Csv, () => Option.some({
+		make: csv,
+		format: "csv"
+	})), Match.orElse((found) => {
+		const c = found.value;
+		return Option.some({
+			make: () => buffered(c),
+			format: c.format.extensions[0] ?? "csv"
+		});
+	}));
+};
+/**
+* Parses a results document of the given media type incrementally.
+* Returns `None` for unsupported media types.
+*
+* @since 0.1.0
+* @category streams
+*/
+const parse = (mediaType, input) => Option.map(parserFor(mediaType), ({ make, format }) => run(input, make, format));
+export { parse as a, tsv as c, json as i, xml as l, buffered as n, parserFor as o, csv as r, run as s, ResultsStream_exports as t };
+
+//# sourceMappingURL=ResultsStream-BhF0OcNn.mjs.map