@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/QueryBuilder-BLK9Vfbz.mjs

@@ -0,0 +1,674 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { G as isTerm$1, it as variable$1 } from "./Term-CFLG1qu4.mjs";
+import { f as fromJs } from "./Xsd-Cdgx5zRB.mjs";
+import { A as pathPattern, D as oneOrMore, E as negated, F as sequence, H as zeroOrMore, M as projection, O as operation, P as select$1, R as triplePattern, T as minus$1, U as zeroOrOne, V as values$1, _ as group$1, a as bgp, c as construct$1, f as exists$1, g as graph$1, h as functionCall, i as ask$1, k as optional$1, m as filter$1, n as aggregate$1, o as bind$1, r as alternative, u as describe$1, w as link, x as isPath, y as inverse, z as union$1 } from "./Ast-CPRZmBvk.mjs";
+import { _ as toRecord } from "./Bindings-Ck3m7JRC.mjs";
+import { n as SparqlEngine } from "./Engine-DF8PN7g-.mjs";
+import { n as print } from "./Generator-D3utCJC7.mjs";
+import * as Arr from "effect/Array";
+import { pipeArguments } from "effect/Pipeable";
+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";
+// src/sparql/QueryBuilder.ts
+/**
+* A strongly-typed, immutable query builder. Builders produce the SPARQL AST
+* (`build()`), print as SPARQL text (`toString()`) and can be executed with
+* the `SparqlEngine`, yielding rows whose type is derived from the selected
+* variables:
+*
+* ```ts
+* import { QueryBuilder as Q } from '@thomasfosterau/effect-rdf/sparql'
+* const v = Q.vars('person', 'name', 'email')
+*
+* const query = Q.select('person', 'name', Q.maybe('email'))
+*   .where(Q.triple(v.person, foaf.name, v.name))
+*   .optional(Q.triple(v.person, foaf.mbox, v.email))
+*   .orderBy(v.name)
+*   .limit(10)
+*
+* // Stream<{ readonly person: GroundTerm; readonly name: GroundTerm; readonly email?: GroundTerm }>
+* const rows = Q.execute(query)
+* // Stream<{ name: string; email?: string }>, decoded with TermSchema
+* const people = Q.decode(query, Schema.Struct({ name: TermSchema.string, email: Schema.optional(TermSchema.iri) }))
+* ```
+*
+* @since 0.1.0
+*/
+var QueryBuilder_exports = /* @__PURE__ */ __exportAll({
+	Builder: () => Builder,
+	add: () => add,
+	and: () => and,
+	as: () => as,
+	asc: () => asc,
+	ask: () => ask,
+	avg: () => avg,
+	bind: () => bind,
+	bound: () => bound,
+	call: () => call,
+	coalesce: () => coalesce,
+	concat: () => concat,
+	construct: () => construct,
+	contains: () => contains,
+	count: () => count,
+	datatype: () => datatype,
+	decode: () => decode,
+	desc: () => desc,
+	describe: () => describe,
+	divide: () => divide,
+	eq: () => eq,
+	execute: () => execute,
+	executeAll: () => executeAll,
+	executeAsk: () => executeAsk,
+	executeGraph: () => executeGraph,
+	exists: () => exists,
+	filter: () => filter,
+	fn: () => fn,
+	ge: () => ge,
+	graph: () => graph,
+	group: () => group,
+	groupConcat: () => groupConcat,
+	gt: () => gt,
+	ifThenElse: () => ifThenElse,
+	iri: () => iri,
+	isBlank: () => isBlank,
+	isIn: () => isIn,
+	isIri: () => isIri,
+	isLiteral: () => isLiteral,
+	isNumeric: () => isNumeric,
+	lang: () => lang,
+	langMatches: () => langMatches,
+	lcase: () => lcase,
+	le: () => le,
+	lt: () => lt,
+	max: () => max,
+	maybe: () => maybe,
+	min: () => min,
+	minus: () => minus,
+	multiply: () => multiply,
+	ne: () => ne,
+	negate: () => negate,
+	not: () => not,
+	notExists: () => notExists,
+	notIn: () => notIn,
+	optional: () => optional,
+	or: () => or,
+	path: () => path,
+	regex: () => regex,
+	replace: () => replace,
+	sameTerm: () => sameTerm,
+	sample: () => sample,
+	select: () => select,
+	str: () => str,
+	strEnds: () => strEnds,
+	strStarts: () => strStarts,
+	strlen: () => strlen,
+	substr: () => substr,
+	subtract: () => subtract,
+	sum: () => sum,
+	toExpression: () => toExpression,
+	triple: () => triple,
+	ucase: () => ucase,
+	union: () => union,
+	v: () => v,
+	values: () => values,
+	variable: () => variable,
+	vars: () => vars
+});
+const isJsValue = (u) => Predicate.isString(u) || Predicate.isNumber(u) || Predicate.isBigInt(u) || Predicate.isBoolean(u) || Predicate.isDate(u);
+const isTerm = (u) => isTerm$1(u);
+const isAlias = (u) => !isJsValue(u) && Predicate.isTagged(u, "Alias");
+const isOrderCondition = (u) => !isJsValue(u) && "descending" in u;
+/**
+* Converts a JS value to a literal (terms and expressions are returned
+* unchanged).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const toExpression = (input) => isJsValue(input) ? fromJs(input) : input;
+const toObject = (input) => isTerm(input) ? input : fromJs(input);
+/**
+* Creates a variable.
+*
+* @since 0.1.0
+* @category variables
+*/
+const variable = (name) => variable$1(name);
+/**
+* A proxy creating variables by property access: `v.name` is `?name`.
+*
+* @since 0.1.0
+* @category variables
+*/
+const v = new Proxy({}, { get: (_, name) => Predicate.isString(name) ? variable$1(name) : void 0 });
+/**
+* Creates several variables at once, typed by name:
+* `const { s, name } = vars('s', 'name')`.
+*
+* @since 0.1.0
+* @category variables
+*/
+const vars = (...names) => Record.fromEntries(names.map((n) => [n, variable$1(n)]));
+/**
+* @since 0.1.0
+* @category projection
+*/
+const maybe = (name) => ({
+	_tag: "Maybe",
+	name
+});
+/**
+* Projects an expression as a variable. Pass `{ optional: true }` when the
+* expression may fail (leaving the variable unbound).
+*
+* @since 0.1.0
+* @category projection
+*/
+const as = (expression, name, options) => ({
+	_tag: "Alias",
+	name,
+	expression: toExpression(expression),
+	optional: options?.optional ?? false
+});
+/**
+* A triple pattern. The predicate may be a property path; the object may be
+* a JS value.
+*
+* @since 0.1.0
+* @category patterns
+*/
+const triple = (subject, predicate, object) => isPath(predicate) ? pathPattern(subject, predicate, toObject(object)) : triplePattern(subject, predicate, toObject(object));
+/**
+* Property path constructors.
+*
+* @since 0.1.0
+* @category patterns
+*/
+const path = {
+	link: (iri) => link(iri),
+	inverse: (p) => inverse(toPath(p)),
+	sequence: (...ps) => sequence(...ps.map(toPath)),
+	alternative: (...ps) => alternative(...ps.map(toPath)),
+	zeroOrMore: (p) => zeroOrMore(toPath(p)),
+	oneOrMore: (p) => oneOrMore(toPath(p)),
+	zeroOrOne: (p) => zeroOrOne(toPath(p)),
+	negated: (iris, inverse = []) => negated(iris, inverse)
+};
+const toPath = (p) => isPath(p) ? p : link(p);
+/** Whether a pattern input is the list form (`Array.isArray` cannot narrow a `ReadonlyArray`). */
+const isPatternList = (input) => Array.isArray(input);
+const isTriplePattern = (p) => Predicate.isTagged(p, "TriplePattern") || Predicate.isTagged(p, "PathPattern");
+const flatten = (inputs) => {
+	const out = [];
+	const go = (input) => {
+		if (isPatternList(input)) {
+			input.forEach(go);
+			return;
+		}
+		if (isTriplePattern(input)) {
+			const last = out[out.length - 1];
+			if (Predicate.isTagged(last, "Bgp")) out[out.length - 1] = bgp([...last.triples, input]);
+			else out.push(bgp([input]));
+		} else out.push(input);
+	};
+	inputs.forEach(go);
+	return out;
+};
+/**
+* A group graph pattern `{ … }`.
+*
+* @since 0.1.0
+* @category patterns
+*/
+const group = (...patterns) => group$1(flatten(patterns));
+/**
+* `OPTIONAL { … }`
+*
+* @since 0.1.0
+* @category patterns
+*/
+const optional = (...patterns) => optional$1(group(...patterns));
+/**
+* `MINUS { … }`
+*
+* @since 0.1.0
+* @category patterns
+*/
+const minus = (...patterns) => minus$1(group(...patterns));
+/**
+* `{ … } UNION { … }`; each argument is one alternative.
+*
+* @since 0.1.0
+* @category patterns
+*/
+const union = (...alternatives) => union$1(alternatives.map((a) => group(a)));
+/**
+* `GRAPH name { … }`
+*
+* @since 0.1.0
+* @category patterns
+*/
+const graph = (name, ...patterns) => graph$1(name, group(...patterns));
+/**
+* `FILTER(expr)`
+*
+* @since 0.1.0
+* @category patterns
+*/
+const filter = (expression) => filter$1(toExpression(expression));
+/**
+* `BIND(expr AS ?name)`
+*
+* @since 0.1.0
+* @category patterns
+*/
+const bind = (expression, name) => bind$1(toExpression(expression), Predicate.isString(name) ? variable$1(name) : name);
+/**
+* Inline data from records: `values([{ x: ex.a, y: 1 }, { x: ex.b }])`.
+* Missing or `undefined` values are `UNDEF`.
+*
+* @since 0.1.0
+* @category patterns
+*/
+const values = (rows) => {
+	const names = Arr.dedupe(rows.flatMap((r) => Record.keys(r)));
+	return values$1(names.map((n) => variable$1(n)), rows.map((r) => names.map((n) => {
+		const x = r[n];
+		return x === void 0 ? void 0 : isTerm(x) ? x : fromJs(x);
+	})));
+};
+const op = (operator) => (...args) => operation(operator, ...args.map(toExpression));
+const binary = (operator) => (a, b) => operation(operator, toExpression(a), toExpression(b));
+const unary = (operator) => (a) => operation(operator, toExpression(a));
+/** @since 0.1.0 @category expressions */
+const eq = binary("=");
+/** @since 0.1.0 @category expressions */
+const ne = binary("!=");
+/** @since 0.1.0 @category expressions */
+const lt = binary("<");
+/** @since 0.1.0 @category expressions */
+const le = binary("<=");
+/** @since 0.1.0 @category expressions */
+const gt = binary(">");
+/** @since 0.1.0 @category expressions */
+const ge = binary(">=");
+/** @since 0.1.0 @category expressions */
+const add = binary("+");
+/** @since 0.1.0 @category expressions */
+const subtract = binary("-");
+/** @since 0.1.0 @category expressions */
+const multiply = binary("*");
+/** @since 0.1.0 @category expressions */
+const divide = binary("/");
+/** @since 0.1.0 @category expressions */
+const negate = unary("UMINUS");
+/** @since 0.1.0 @category expressions */
+const not = unary("!");
+/**
+* Logical conjunction of any number of conditions.
+*
+* @since 0.1.0
+* @category expressions
+*/
+const and = (...args) => args.map(toExpression).reduce((a, b) => operation("&&", a, b));
+/**
+* Logical disjunction of any number of conditions.
+*
+* @since 0.1.0
+* @category expressions
+*/
+const or = (...args) => args.map(toExpression).reduce((a, b) => operation("||", a, b));
+/**
+* `expr IN (…)`
+*
+* @since 0.1.0
+* @category expressions
+*/
+const isIn = (expression, list) => operation("IN", toExpression(expression), ...list.map(toExpression));
+/**
+* `expr NOT IN (…)`
+*
+* @since 0.1.0
+* @category expressions
+*/
+const notIn = (expression, list) => operation("NOT IN", toExpression(expression), ...list.map(toExpression));
+/**
+* Calls any built-in function by name, e.g. `fn('STRLEN', v.name)`.
+*
+* @since 0.1.0
+* @category expressions
+*/
+const fn = (name, ...args) => operation(name, ...args.map(toExpression));
+/**
+* Calls an extension function (or XSD cast) by IRI.
+*
+* @since 0.1.0
+* @category expressions
+*/
+const call = (iri, ...args) => functionCall(iri, args.map(toExpression));
+/** @since 0.1.0 @category expressions */
+const bound = (variable) => operation("BOUND", variable);
+/** @since 0.1.0 @category expressions */
+const str = op("STR");
+/** @since 0.1.0 @category expressions */
+const lang = op("LANG");
+/** @since 0.1.0 @category expressions */
+const langMatches = op("LANGMATCHES");
+/** @since 0.1.0 @category expressions */
+const datatype = op("DATATYPE");
+/** @since 0.1.0 @category expressions */
+const iri = op("IRI");
+/** @since 0.1.0 @category expressions */
+const regex = op("REGEX");
+/** @since 0.1.0 @category expressions */
+const contains = op("CONTAINS");
+/** @since 0.1.0 @category expressions */
+const strStarts = op("STRSTARTS");
+/** @since 0.1.0 @category expressions */
+const strEnds = op("STRENDS");
+/** @since 0.1.0 @category expressions */
+const strlen = op("STRLEN");
+/** @since 0.1.0 @category expressions */
+const ucase = op("UCASE");
+/** @since 0.1.0 @category expressions */
+const lcase = op("LCASE");
+/** @since 0.1.0 @category expressions */
+const concat = op("CONCAT");
+/** @since 0.1.0 @category expressions */
+const substr = op("SUBSTR");
+/** @since 0.1.0 @category expressions */
+const replace = op("REPLACE");
+/** @since 0.1.0 @category expressions */
+const coalesce = op("COALESCE");
+/** @since 0.1.0 @category expressions */
+const ifThenElse = op("IF");
+/** @since 0.1.0 @category expressions */
+const isIri = op("ISIRI");
+/** @since 0.1.0 @category expressions */
+const isBlank = op("ISBLANK");
+/** @since 0.1.0 @category expressions */
+const isLiteral = op("ISLITERAL");
+/** @since 0.1.0 @category expressions */
+const isNumeric = op("ISNUMERIC");
+/** @since 0.1.0 @category expressions */
+const sameTerm = op("SAMETERM");
+/**
+* `EXISTS { … }`
+*
+* @since 0.1.0
+* @category expressions
+*/
+const exists = (...patterns) => exists$1(group(...patterns));
+/**
+* `NOT EXISTS { … }`
+*
+* @since 0.1.0
+* @category expressions
+*/
+const notExists = (...patterns) => exists$1(group(...patterns), true);
+const aggregate = (name) => (expression, options) => aggregate$1(name, toExpression(expression), options);
+/**
+* `COUNT(*)` (no argument) or `COUNT(expr)`.
+*
+* @since 0.1.0
+* @category aggregates
+*/
+const count = (expression, options) => aggregate$1("COUNT", expression === void 0 ? "*" : toExpression(expression), options);
+/** @since 0.1.0 @category aggregates */
+const sum = aggregate("SUM");
+/** @since 0.1.0 @category aggregates */
+const avg = aggregate("AVG");
+/** @since 0.1.0 @category aggregates */
+const min = aggregate("MIN");
+/** @since 0.1.0 @category aggregates */
+const max = aggregate("MAX");
+/** @since 0.1.0 @category aggregates */
+const sample = aggregate("SAMPLE");
+/**
+* `GROUP_CONCAT(expr; SEPARATOR = sep)`
+*
+* @since 0.1.0
+* @category aggregates
+*/
+const groupConcat = (expression, options) => aggregate$1("GROUP_CONCAT", toExpression(expression), options);
+/**
+* A descending `ORDER BY` condition.
+*
+* @since 0.1.0
+* @category modifiers
+*/
+const desc = (expression) => ({
+	expression: toExpression(expression),
+	descending: true
+});
+/**
+* An ascending `ORDER BY` condition.
+*
+* @since 0.1.0
+* @category modifiers
+*/
+const asc = (expression) => ({
+	expression: toExpression(expression),
+	descending: false
+});
+/**
+* An immutable query builder. `K` is the query form; `R` and `O` are the
+* required and optional variables of `SELECT` rows.
+*
+* @since 0.1.0
+* @category models
+*/
+var Builder = class Builder {
+	/** @internal */
+	query;
+	constructor(query) {
+		this.query = query;
+	}
+	with(patch) {
+		return new Builder({
+			...this.query,
+			...patch
+		});
+	}
+	append(patterns) {
+		return this.with({ where: group(this.query.where.patterns, patterns) });
+	}
+	/** Adds patterns to the `WHERE` clause. */
+	where(...patterns) {
+		return this.append(flatten(patterns));
+	}
+	/** Adds an `OPTIONAL { … }` block. */
+	optional(...patterns) {
+		return this.append([optional(...patterns)]);
+	}
+	/** Adds a `MINUS { … }` block. */
+	minus(...patterns) {
+		return this.append([minus(...patterns)]);
+	}
+	/** Adds a `UNION` of alternatives. */
+	union(...alternatives) {
+		return this.append([union(...alternatives)]);
+	}
+	/** Adds a `FILTER`. */
+	filter(expression) {
+		return this.append([filter(expression)]);
+	}
+	/** Adds a `BIND`. */
+	bind(expression, name) {
+		return this.append([bind(expression, name)]);
+	}
+	/** Adds a `GRAPH` block. */
+	graph(name, ...patterns) {
+		return this.append([graph(name, ...patterns)]);
+	}
+	/** Adds inline data. */
+	values(rows) {
+		return this.append([values(rows)]);
+	}
+	/** Adds `GROUP BY` conditions (expressions or `as(expr, name)`). */
+	groupBy(...conditions) {
+		return this.with({ groupBy: [...this.query.groupBy, ...conditions.map((c) => isAlias(c) ? {
+			expression: c.expression,
+			variable: variable$1(c.name)
+		} : { expression: toExpression(c) })] });
+	}
+	/** Adds `HAVING` conditions. */
+	having(...conditions) {
+		return this.with({ having: [...this.query.having, ...conditions.map(toExpression)] });
+	}
+	/** Adds `ORDER BY` conditions (ascending unless wrapped with `desc`). */
+	orderBy(...conditions) {
+		return this.with({ orderBy: [...this.query.orderBy, ...conditions.map((c) => isOrderCondition(c) ? c : asc(c))] });
+	}
+	/** Sets `LIMIT`. */
+	limit(limit) {
+		return this.with({ limit });
+	}
+	/** Sets `OFFSET`. */
+	offset(offset) {
+		return this.with({ offset });
+	}
+	/** Makes a `SELECT` query `DISTINCT`. */
+	distinct() {
+		return this.with({
+			distinct: true,
+			reduced: false
+		});
+	}
+	/** Makes a `SELECT` query `REDUCED`. */
+	reduced() {
+		return this.with({
+			reduced: true,
+			distinct: false
+		});
+	}
+	/** Adds `FROM` graphs. */
+	from(...graphs) {
+		const d = this.query.dataset ?? {
+			default: [],
+			named: []
+		};
+		return this.with({ dataset: {
+			default: [...d.default, ...graphs],
+			named: d.named
+		} });
+	}
+	/** Adds `FROM NAMED` graphs. */
+	fromNamed(...graphs) {
+		const d = this.query.dataset ?? {
+			default: [],
+			named: []
+		};
+		return this.with({ dataset: {
+			default: d.default,
+			named: [...d.named, ...graphs]
+		} });
+	}
+	/** Declares prefixes (used when printing). */
+	prefixes(prefixes) {
+		return this.with({ prologue: {
+			...this.query.prologue,
+			prefixes: {
+				...this.query.prologue.prefixes,
+				...prefixes
+			}
+		} });
+	}
+	/** The query AST. */
+	build() {
+		return this.query;
+	}
+	/** The query as SPARQL text. */
+	toString() {
+		return print(this.query);
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const empty = group$1([]);
+const projectionItem = (item) => {
+	if (Predicate.isString(item)) return variable$1(item);
+	return Match.value(item).pipe(Match.tag("Variable", (x) => x), Match.tag("Maybe", (m) => variable$1(m.name)), Match.tag("Alias", (a) => projection(a.expression, variable$1(a.name))), Match.exhaustive);
+};
+/**
+* Starts a `SELECT` query. With no arguments, `SELECT *` (rows are then
+* untyped records).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const select = (...items) => new Builder(select$1({
+	where: empty,
+	projection: Arr.isReadonlyArrayEmpty(items) ? "*" : items.map(projectionItem)
+}));
+/**
+* Starts an `ASK` query.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const ask = () => new Builder(ask$1({ where: empty }));
+/**
+* Starts a `CONSTRUCT` query with a template.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const construct = (...template) => new Builder(construct$1({
+	where: empty,
+	template: template.filter((t) => Predicate.isTagged(t, "TriplePattern"))
+}));
+/**
+* Starts a `DESCRIBE` query.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const describe = (...terms) => new Builder(describe$1({ terms: Arr.isReadonlyArrayEmpty(terms) ? "*" : terms }));
+/**
+* Executes a `SELECT` builder, streaming typed rows.
+*
+* @since 0.1.0
+* @category execution
+*/
+const execute = (builder, options) => Stream.unwrap(Effect.gen(function* () {
+	const result = yield* (yield* SparqlEngine).select(builder.build(), options);
+	return Stream.map(result.bindings, (b) => toRecord(b));
+}));
+/**
+* Executes a `SELECT` builder and collects all rows.
+*
+* @since 0.1.0
+* @category execution
+*/
+const executeAll = (builder, options) => Stream.runCollect(execute(builder, options));
+/**
+* Executes a `SELECT` builder and decodes each row with a schema (whose
+* fields are typically `TermSchema` codecs).
+*
+* @since 0.1.0
+* @category execution
+*/
+const decode = (builder, schema, options) => Stream.mapEffect(execute(builder, options), (row) => Schema.decodeUnknownEffect(schema)(row));
+/**
+* Executes an `ASK` builder.
+*
+* @since 0.1.0
+* @category execution
+*/
+const executeAsk = (builder, options) => Effect.flatMap(Effect.service(SparqlEngine), (engine) => engine.ask(builder.build(), options));
+/**
+* Executes a `CONSTRUCT` or `DESCRIBE` builder, streaming triples.
+*
+* @since 0.1.0
+* @category execution
+*/
+const executeGraph = (builder, options) => Stream.unwrap(Effect.flatMap(Effect.service(SparqlEngine), (engine) => engine.construct(builder.build(), options)));
+export { negate as $, ge as A, isLiteral as B, execute as C, values as Ct, exists as D, executeGraph as E, ifThenElse as F, le as G, lang as H, iri as I, maybe as J, lt as K, isBlank as L, group as M, groupConcat as N, filter as O, gt as P, ne as Q, isIn as R, eq as S, v as St, executeAsk as T, vars as Tt, langMatches as U, isNumeric as V, lcase as W, minus as X, min as Y, multiply as Z, datatype as _, sum as _t, as as a, path as at, describe as b, ucase as bt, avg as c, sameTerm as ct, call as d, str as dt, not as et, coalesce as f, strEnds as ft, count as g, subtract as gt, contains as h, substr as ht, and as i, or as it, graph as j, fn as k, bind as l, sample as lt, construct as m, strlen as mt, QueryBuilder_exports as n, notIn as nt, asc as o, regex as ot, concat as p, strStarts as pt, max as q, add as r, optional as rt, ask as s, replace as st, Builder as t, notExists as tt, bound as u, select as ut, decode as v, toExpression as vt, executeAll as w, variable as wt, divide as x, union as xt, desc as y, triple as yt, isIri as z };
+
+//# sourceMappingURL=QueryBuilder-BLK9Vfbz.mjs.map