@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Query-D9A6LOpP.mjs

@@ -0,0 +1,364 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, U as isResource, Z as namedNode, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf } from "./Dataset-BlmlcI7J.mjs";
+import { n as Vocabulary_exports } from "./Vocabulary-CnQl-_Z4.mjs";
+import { n as SparqlEvaluationError } from "./Sparql-BiYFMSpl.mjs";
+import { A as pathPattern, D as oneOrMore, F as sequence, H as zeroOrMore, R as triplePattern, U as zeroOrOne, j as projectedVariables, r as alternative, w as link, y as inverse } from "./Ast-CPRZmBvk.mjs";
+import { a as parseQueryResult } from "./Parser-xARsOWXk.mjs";
+import * as Arr from "effect/Array";
+import { pipe } from "effect/Function";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/sparql/shacl/Query.ts
+/**
+* SHACL-SPARQL queries: reading the `sh:select` / `sh:ask` queries of a
+* shapes graph with their prefix declarations (§5.2.1), enforcing the
+* syntactic restrictions of pre-binding (Appendix A) and substituting the
+* `$PATH` variable with a property path (§5.3, §6.3).
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Query } from "@thomasfosterau/effect-rdf/sparql/shacl"
+*
+* const program = Effect.gen(function* () {
+*   const query = yield* Query.compile(shapesGraph, constraintNode, {
+*     form: "select",
+*     prebound: ["this", "shapesGraph", "currentShape"],
+*     path: shape.path,
+*   })
+* })
+* ```
+*
+* @since 0.1.0
+*/
+var Query_exports = /* @__PURE__ */ __exportAll({
+	checkPrebinding: () => checkPrebinding,
+	compile: () => compile,
+	compileResult: () => compileResult,
+	optionalPrebound: () => optionalPrebound,
+	prefixes: () => prefixes,
+	substitutePath: () => substitutePath,
+	toSparqlPath: () => toSparqlPath
+});
+const { sh } = Vocabulary_exports;
+const owlImports = namedNode("http://www.w3.org/2002/07/owl#imports");
+/**
+* The variables that are optional to pre-bind (and to project from
+* sub-queries): `$shapesGraph` and `$currentShape`.
+*
+* @since 0.1.0
+* @category constants
+*/
+const optionalPrebound = /* @__PURE__ */ new Set(["shapesGraph", "currentShape"]);
+const fail = (message) => Result.fail(new SparqlEvaluationError({ message }));
+const noPrefixes = Result.succeed({});
+/**
+* The prefix mappings of a SPARQL executable: the union of the
+* `sh:prefix` / `sh:namespace` pairs reachable via
+* `sh:prefixes/owl:imports* /sh:declare`. Fails when a prefix is declared
+* with two different namespaces (an ill-formed shapes graph) or a
+* declaration is malformed.
+*
+* @since 0.1.0
+* @category prefixes
+*/
+const prefixes = (shapesGraph, node) => Arr.reduce(Arr.flatMap(prefixNodes(shapesGraph, node), (current) => Arr.map(objectsOf(shapesGraph, current, sh.declare), (declaration) => [current, declaration])), noPrefixes, (acc, [current, declaration]) => Result.flatMap(acc, (declared) => declare(shapesGraph, declared, current, declaration)));
+/**
+* The nodes reachable via `sh:prefixes/owl:imports*` from `node`, depth
+* first (the order in which their declarations are read).
+*/
+const prefixNodes = (shapesGraph, node) => {
+	const seen = MutableHashSet.empty();
+	const visit = (stack) => {
+		const [rest, current] = Arr.unappend(stack);
+		if (MutableHashSet.has(seen, current.key) || !isResource(current)) return [Option.none(), rest];
+		MutableHashSet.add(seen, current.key);
+		return [Option.some(current), [...rest, ...objectsOf(shapesGraph, current, owlImports)]];
+	};
+	return Arr.getSomes(Arr.unfold(objectsOf(shapesGraph, node, sh.prefixes), (stack) => Arr.isReadonlyArrayNonEmpty(stack) ? Option.some(visit(stack)) : Option.none()));
+};
+const singleOf = (values, refinement) => values.length === 1 ? Option.filter(Arr.head(values), refinement) : Option.none();
+const isLiteralOrIri = (t) => isLiteral(t) || isNamedNode(t);
+/** Adds one `sh:declare` prefix declaration to those read before it. */
+const declare = (shapesGraph, declared, current, declaration) => {
+	if (!isResource(declaration)) return fail(`sh:declare of ${current.key} must be an IRI or blank node`);
+	const prefix = singleOf(objectsOf(shapesGraph, declaration, sh.prefix), isLiteral);
+	const namespace = singleOf(objectsOf(shapesGraph, declaration, sh.namespace), isLiteralOrIri);
+	if (Option.isNone(prefix) || Option.isNone(namespace)) return fail(`prefix declaration ${declaration.key} needs exactly one literal sh:prefix and sh:namespace`);
+	const name = prefix.value.value;
+	const iri = namespace.value.value;
+	const existing = Record.get(declared, name);
+	if (Option.isSome(existing) && existing.value !== iri) return fail(`prefix "${name}" is declared with two namespaces: <${existing.value}> and <${iri}>`);
+	return Result.succeed(Record.set(declared, name, iri));
+};
+const noError = () => Option.none();
+const visitNothing = {
+	pattern: noError,
+	query: noError,
+	variable: noError
+};
+const isSelect = (q) => Predicate.isTagged(q, "Select");
+const termVariables = (t, out) => {
+	if (Predicate.isTagged(t, "Variable")) out(t.value);
+	else if (Predicate.isTagged(t, "Triple")) {
+		termVariables(t.subject, out);
+		termVariables(t.predicate, out);
+		termVariables(t.object, out);
+	}
+};
+/** Visits every pattern, (sub-)query and variable occurrence; returns the first error. */
+const walk = (root, visitor) => {
+	const visit = {
+		...visitNothing,
+		...visitor
+	};
+	let error = Option.none();
+	const report = (e) => {
+		if (Option.isNone(error)) error = e;
+	};
+	const variable = (name) => report(visit.variable(name));
+	const term = (t) => termVariables(t, variable);
+	const expression = (expr) => {
+		return Match.value(expr).pipe(Match.tag("Variable", "Triple", (e) => {
+			term(e);
+		}), Match.tag("Operation", "FunctionCall", (e) => {
+			e.args.forEach(expression);
+		}), Match.tag("Aggregate", (e) => {
+			if (e.expression !== "*") expression(e.expression);
+		}), Match.tag("Exists", (e) => {
+			pattern(e.pattern);
+		}), Match.orElse(() => void 0));
+	};
+	const pathTerms = (p) => {
+		Match.value(p).pipe(Match.tag("PathLink", "PathNegated", () => void 0), Match.tag("PathSequence", "PathAlternative", (list) => list.paths.forEach(pathTerms)), Match.orElse((unary) => pathTerms(unary.path)));
+	};
+	const pattern = (pat) => {
+		report(visit.pattern(pat));
+		return Match.value(pat).pipe(Match.tag("Bgp", (p) => {
+			Arr.forEach(p.triples, (t) => {
+				term(t.subject);
+				if (Predicate.isTagged(t, "TriplePattern")) term(t.predicate);
+				else pathTerms(t.path);
+				term(t.object);
+			});
+		}), Match.tag("Group", (p) => {
+			p.patterns.forEach(pattern);
+		}), Match.tag("Optional", "Minus", (p) => {
+			pattern(p.pattern);
+		}), Match.tag("Union", (p) => {
+			p.patterns.forEach(pattern);
+		}), Match.tag("Graph", "Service", (p) => {
+			term(p.name);
+			pattern(p.pattern);
+		}), Match.tag("Filter", (p) => {
+			expression(p.expression);
+		}), Match.tag("Bind", (p) => {
+			expression(p.expression);
+			variable(p.variable.value);
+		}), Match.tag("Values", (p) => {
+			p.variables.forEach((v) => variable(v.value));
+		}), Match.tag("SubSelect", (p) => {
+			query(p.query, true);
+		}), Match.exhaustive);
+	};
+	const query = (q, nested) => {
+		report(visit.query(q, nested));
+		if (isSelect(q) && q.projection !== "*") Arr.forEach(q.projection, (p) => {
+			if (Predicate.isTagged(p, "Variable")) variable(p.value);
+			else {
+				expression(p.expression);
+				variable(p.variable.value);
+			}
+		});
+		if (Predicate.isTagged(q, "Construct")) Arr.forEach(q.template, (t) => [
+			t.subject,
+			t.predicate,
+			t.object
+		].forEach(term));
+		if (Predicate.isTagged(q, "Describe") && q.terms !== "*") q.terms.forEach(term);
+		pattern(q.where);
+		Arr.forEach(q.groupBy, (g) => {
+			expression(g.expression);
+			if (g.variable !== void 0) variable(g.variable.value);
+		});
+		q.having.forEach(expression);
+		Arr.forEach(q.orderBy, (o) => expression(o.expression));
+		if (q.values !== void 0) pattern(q.values);
+	};
+	query(root, false);
+	return error;
+};
+/**
+* Checks the restrictions that SHACL places on queries evaluated with
+* pre-bound variables (Appendix A "Pre-binding of Variables in SPARQL
+* Queries"): no `MINUS`, no `SERVICE`, no `VALUES`, no `AS ?var` for a
+* potentially pre-bound variable, and sub-queries must project every
+* potentially pre-bound variable (except `shapesGraph` and `currentShape`).
+*
+* @since 0.1.0
+* @category validation
+*/
+const checkPrebinding = (query, prebound) => {
+	const ordered = Arr.dedupe(Arr.fromIterable(prebound));
+	const potential = MutableHashSet.fromIterable(ordered);
+	const rebinds = (v) => MutableHashSet.has(potential, v.value) ? Option.some(`the pre-bound variable ?${v.value} must not be assigned with AS`) : Option.none();
+	const unprojected = (q) => {
+		const projected = MutableHashSet.fromIterable(projectedVariables(q));
+		return Option.map(Arr.findFirst(ordered, (v) => !optionalPrebound.has(v) && !MutableHashSet.has(projected, v)), (v) => `sub-queries must project the pre-bound variable ?${v}`);
+	};
+	const error = walk(query, {
+		pattern: (pat) => {
+			return Match.value(pat).pipe(Match.withReturnType(), Match.tag("Minus", () => Option.some("MINUS is not allowed in SHACL-SPARQL queries with pre-bound variables")), Match.tag("Service", () => Option.some("SERVICE is not allowed in SHACL-SPARQL queries with pre-bound variables")), Match.tag("Values", () => Option.some("VALUES is not allowed in SHACL-SPARQL queries with pre-bound variables")), Match.tag("Bind", (p) => rebinds(p.variable)), Match.orElse(() => Option.none()));
+		},
+		query: (q, nested) => {
+			if (q.values !== void 0) return Option.some("VALUES is not allowed in SHACL-SPARQL queries with pre-bound variables");
+			const projections = isSelect(q) && q.projection !== "*" ? Arr.filter(q.projection, (p) => Predicate.isTagged(p, "Projection")) : [];
+			return pipe(Arr.findFirst(projections, (p) => rebinds(p.variable)), Option.orElse(() => Arr.findFirst(q.groupBy, (g) => g.variable === void 0 ? Option.none() : rebinds(g.variable))), Option.orElse(() => nested && isSelect(q) ? unprojected(q) : Option.none()));
+		}
+	});
+	return Option.match(error, {
+		onNone: () => Result.succeed(query),
+		onSome: fail
+	});
+};
+/**
+* Converts a SHACL property path to a SPARQL property path.
+*
+* @since 0.1.0
+* @category paths
+*/
+const toSparqlPath = (path) => {
+	return Match.value(path).pipe(Match.tag("PredicatePath", (step) => link(step.predicate)), Match.tag("SequencePath", (step) => sequence(...step.paths.map(toSparqlPath))), Match.tag("AlternativePath", (step) => alternative(...step.paths.map(toSparqlPath))), Match.tag("InversePath", (step) => inverse(toSparqlPath(step.path))), Match.tag("ZeroOrMorePath", (step) => zeroOrMore(toSparqlPath(step.path))), Match.tag("OneOrMorePath", (step) => oneOrMore(toSparqlPath(step.path))), Match.tag("ZeroOrOnePath", (step) => zeroOrOne(toSparqlPath(step.path))), Match.exhaustive);
+};
+const PATH = "PATH";
+const isPathLink = (p) => Predicate.isTagged(p, "PathLink");
+const mapGroup = (g, f) => ({
+	...g,
+	patterns: g.patterns.map((p) => mapPattern(p, f))
+});
+const mapExpression = (expr, f) => {
+	return Match.value(expr).pipe(Match.tag("Operation", (e) => ({
+		...e,
+		args: e.args.map((a) => mapExpression(a, f))
+	})), Match.tag("FunctionCall", (e) => ({
+		...e,
+		args: e.args.map((a) => mapExpression(a, f))
+	})), Match.tag("Aggregate", (e) => e.expression === "*" ? e : {
+		...e,
+		expression: mapExpression(e.expression, f)
+	}), Match.tag("Exists", (e) => ({
+		...e,
+		pattern: mapGroup(e.pattern, f)
+	})), Match.orElse((e) => e));
+};
+const mapPattern = (pat, f) => {
+	return Match.value(pat).pipe(Match.tag("Bgp", (p) => ({
+		...p,
+		triples: p.triples.map(f)
+	})), Match.tag("Group", (p) => mapGroup(p, f)), Match.tag("Optional", "Minus", "Graph", "Service", (p) => ({
+		...p,
+		pattern: mapGroup(p.pattern, f)
+	})), Match.tag("Union", (p) => ({
+		...p,
+		patterns: p.patterns.map((g) => mapGroup(g, f))
+	})), Match.tag("Filter", (p) => ({
+		...p,
+		expression: mapExpression(p.expression, f)
+	})), Match.tag("Bind", (p) => ({
+		...p,
+		expression: mapExpression(p.expression, f)
+	})), Match.tag("Values", (p) => p), Match.tag("SubSelect", (p) => ({
+		...p,
+		query: mapQuery(p.query, f)
+	})), Match.exhaustive);
+};
+const mapQuery = (q, f) => {
+	const expression = (e) => mapExpression(e, f);
+	const mapped = {
+		...q,
+		where: mapGroup(q.where, f),
+		having: q.having.map(expression),
+		orderBy: q.orderBy.map((o) => ({
+			...o,
+			expression: expression(o.expression)
+		})),
+		groupBy: q.groupBy.map((g) => ({
+			...g,
+			expression: expression(g.expression)
+		}))
+	};
+	if (!isSelect(q) || q.projection === "*") return mapped;
+	return {
+		...mapped,
+		projection: q.projection.map((p) => Predicate.isTagged(p, "Projection") ? {
+			...p,
+			expression: expression(p.expression)
+		} : p)
+	};
+};
+/**
+* Substitutes the variable `$PATH` in the predicate position of triple
+* patterns with a property path (the `sh:path` of the current property
+* shape). Any other use of `$PATH` makes the query ill-formed.
+*
+* @since 0.1.0
+* @category paths
+*/
+const substitutePath = (query, path) => {
+	const sparqlPath = toSparqlPath(path);
+	const substituted = mapQuery(query, (t) => Predicate.isTagged(t, "TriplePattern") && Predicate.isTagged(t.predicate, "Variable") && t.predicate.value === PATH ? isPathLink(sparqlPath) ? triplePattern(t.subject, sparqlPath.iri, t.object) : pathPattern(t.subject, sparqlPath, t.object) : t);
+	const error = walk(substituted, { variable: (name) => name === PATH ? Option.some("$PATH may only be used in the predicate position of triple patterns") : Option.none() });
+	return Option.match(error, {
+		onNone: () => Result.succeed(substituted),
+		onSome: fail
+	});
+};
+/** The first of `required` that a `SELECT` query does not project. */
+const unprojectedOf = (query, required) => {
+	const projected = MutableHashSet.fromIterable(projectedVariables(query));
+	return Arr.findFirst(required, (v) => !MutableHashSet.has(projected, v));
+};
+/**
+* Reads, parses and checks the `sh:select` or `sh:ask` query of a node of
+* the shapes graph (a SPARQL-based constraint, validator, target or target
+* type), using its prefix declarations. Fails with a
+* `SparqlEvaluationError` when the query is missing, ambiguous, does not
+* parse, has the wrong form or violates the pre-binding restrictions.
+*
+* @since 0.1.0
+* @category compiling
+*/
+const compileResult = (shapesGraph, node, options) => {
+	const property = options.form === "select" ? sh.select : sh.ask;
+	const literal = singleOf(objectsOf(shapesGraph, node, property), isLiteral);
+	if (Option.isNone(literal)) return fail(`${node.key} must have exactly one literal value for ${property.key}`);
+	const text = literal.value.value;
+	return Result.flatMap(prefixes(shapesGraph, node), (declared) => {
+		const parsed = parseQueryResult(text, { prefixes: declared });
+		if (Result.isFailure(parsed)) return Result.fail(new SparqlEvaluationError({
+			message: `the ${property.key} query of ${node.key} does not parse: ${parsed.failure.message}`,
+			cause: parsed.failure
+		}));
+		const query = parsed.success;
+		const expected = options.form === "select" ? "Select" : "Ask";
+		if (!Predicate.isTagged(query, expected)) return fail(`the ${property.key} query of ${node.key} must be a ${expected.toUpperCase()} query`);
+		const missing = isSelect(query) ? unprojectedOf(query, options.project ?? []) : Option.none();
+		if (Option.isSome(missing)) return fail(`the query of ${node.key} must project ?${missing.value}`);
+		return Result.flatMap(checkPrebinding(query, options.prebound), (checked) => options.path === void 0 ? Result.succeed(checked) : substitutePath(checked, options.path));
+	});
+};
+/**
+* `compileResult` as an `Effect`.
+*
+* @since 0.1.0
+* @category compiling
+*/
+const compile = (shapesGraph, node, options) => Effect.suspend(() => Effect.fromResult(compileResult(shapesGraph, node, options)));
+export { optionalPrebound as a, toSparqlPath as c, compileResult as i, checkPrebinding as n, prefixes as o, compile as r, substitutePath as s, Query_exports as t };
+
+//# sourceMappingURL=Query-D9A6LOpP.mjs.map

package/dist/Query-D9A6LOpP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Query-D9A6LOpP.mjs","names":["Vocabulary","Term.namedNode","Sparql.SparqlEvaluationError","Dataset.objectsOf","Term.isResource","Term.isLiteral","Term.isNamedNode","Ast.projectedVariables","Ast.link","Ast.sequence","Ast.alternative","Ast.inverse","Ast.zeroOrMore","Ast.oneOrMore","Ast.zeroOrOne","Ast.triplePattern","Ast.pathPattern","Parser.parseQueryResult"],"sources":["../src/sparql/shacl/Query.ts"],"sourcesContent":["/**\n * SHACL-SPARQL queries: reading the `sh:select` / `sh:ask` queries of a\n * shapes graph with their prefix declarations (§5.2.1), enforcing the\n * syntactic restrictions of pre-binding (Appendix A) and substituting the\n * `$PATH` variable with a property path (§5.3, §6.3).\n *\n * ```ts\n * import { Effect } from \"effect\"\n * import { Query } from \"@thomasfosterau/effect-rdf/sparql/shacl\"\n *\n * const program = Effect.gen(function* () {\n *   const query = yield* Query.compile(shapesGraph, constraintNode, {\n *     form: \"select\",\n *     prebound: [\"this\", \"shapesGraph\", \"currentShape\"],\n *     path: shape.path,\n *   })\n * })\n * ```\n *\n * @since 0.1.0\n */\nimport { Dataset, Term } from '../../index.ts';\nimport { Path, Sparql, Vocabulary } from '../../shacl/index.ts';\nimport { Ast, Parser } from '../index.ts';\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport { pipe } from 'effect/Function';\nimport * as Match from 'effect/Match';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Record from 'effect/Record';\nimport * as Result from 'effect/Result';\n\nconst { sh } = Vocabulary;\nconst owlImports = Term.namedNode('http://www.w3.org/2002/07/owl#imports');\n\n/**\n * The variables that are optional to pre-bind (and to project from\n * sub-queries): `$shapesGraph` and `$currentShape`.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const optionalPrebound: ReadonlySet<string> = new Set(['shapesGraph', 'currentShape']);\n\nconst fail = (message: string): Result.Result<never, Sparql.SparqlEvaluationError> =>\n  Result.fail(new Sparql.SparqlEvaluationError({ message }));\n\n// -----------------------------------------------------------------------------\n// Prefixes\n// -----------------------------------------------------------------------------\n\nconst noPrefixes: Result.Result<\n  Record.ReadonlyRecord<string, string>,\n  Sparql.SparqlEvaluationError\n> = Result.succeed({});\n\n/**\n * The prefix mappings of a SPARQL executable: the union of the\n * `sh:prefix` / `sh:namespace` pairs reachable via\n * `sh:prefixes/owl:imports* /sh:declare`. Fails when a prefix is declared\n * with two different namespaces (an ill-formed shapes graph) or a\n * declaration is malformed.\n *\n * @since 0.1.0\n * @category prefixes\n */\nexport const prefixes = (\n  shapesGraph: Dataset.Dataset,\n  node: Term.NamedNode | Term.BlankNode,\n): Result.Result<Record.ReadonlyRecord<string, string>, Sparql.SparqlEvaluationError> =>\n  Arr.reduce(\n    Arr.flatMap(prefixNodes(shapesGraph, node), (current) =>\n      Arr.map(\n        Dataset.objectsOf(shapesGraph, current, sh.declare),\n        (declaration) => [current, declaration] as const,\n      ),\n    ),\n    noPrefixes,\n    (acc, [current, declaration]) =>\n      Result.flatMap(acc, (declared) => declare(shapesGraph, declared, current, declaration)),\n  );\n\n/**\n * The nodes reachable via `sh:prefixes/owl:imports*` from `node`, depth\n * first (the order in which their declarations are read).\n */\nconst prefixNodes = (\n  shapesGraph: Dataset.Dataset,\n  node: Term.NamedNode | Term.BlankNode,\n): ReadonlyArray<Term.Resource> => {\n  const seen = MutableHashSet.empty<string>();\n  const visit = (\n    stack: Arr.NonEmptyReadonlyArray<Term.GroundTerm>,\n  ): readonly [Option.Option<Term.Resource>, ReadonlyArray<Term.GroundTerm>] => {\n    const [rest, current] = Arr.unappend(stack);\n    if (MutableHashSet.has(seen, current.key) || !Term.isResource(current))\n      return [Option.none(), rest];\n    MutableHashSet.add(seen, current.key);\n    return [\n      Option.some(current),\n      [...rest, ...Dataset.objectsOf(shapesGraph, current, owlImports)],\n    ];\n  };\n  return Arr.getSomes(\n    Arr.unfold(Dataset.objectsOf(shapesGraph, node, sh.prefixes), (stack) =>\n      Arr.isReadonlyArrayNonEmpty(stack) ? Option.some(visit(stack)) : Option.none(),\n    ),\n  );\n};\n\nconst singleOf = <A extends Term.GroundTerm>(\n  values: ReadonlyArray<Term.GroundTerm>,\n  refinement: (t: Term.GroundTerm) => t is A,\n): Option.Option<A> =>\n  values.length === 1 ? Option.filter(Arr.head(values), refinement) : Option.none();\n\nconst isLiteralOrIri = (t: Term.GroundTerm): t is Term.Literal | Term.NamedNode =>\n  Term.isLiteral(t) || Term.isNamedNode(t);\n\n/** Adds one `sh:declare` prefix declaration to those read before it. */\nconst declare = (\n  shapesGraph: Dataset.Dataset,\n  declared: Record.ReadonlyRecord<string, string>,\n  current: Term.Resource,\n  declaration: Term.GroundTerm,\n): Result.Result<Record.ReadonlyRecord<string, string>, Sparql.SparqlEvaluationError> => {\n  if (!Term.isResource(declaration))\n    return fail(`sh:declare of ${current.key} must be an IRI or blank node`);\n  const prefix = singleOf(Dataset.objectsOf(shapesGraph, declaration, sh.prefix), Term.isLiteral);\n  const namespace = singleOf(\n    Dataset.objectsOf(shapesGraph, declaration, sh.namespace),\n    isLiteralOrIri,\n  );\n  if (Option.isNone(prefix) || Option.isNone(namespace)) {\n    return fail(\n      `prefix declaration ${declaration.key} needs exactly one literal sh:prefix and sh:namespace`,\n    );\n  }\n  const name = prefix.value.value;\n  const iri = namespace.value.value;\n  const existing = Record.get(declared, name);\n  if (Option.isSome(existing) && existing.value !== iri) {\n    return fail(\n      `prefix \"${name}\" is declared with two namespaces: <${existing.value}> and <${iri}>`,\n    );\n  }\n  return Result.succeed(Record.set(declared, name, iri));\n};\n\n// -----------------------------------------------------------------------------\n// Walking queries\n// -----------------------------------------------------------------------------\n\n/** A check of a query part: the error it finds, if any. */\ntype Check<A extends ReadonlyArray<unknown>> = (...args: A) => Option.Option<string>;\n\ninterface Visitor {\n  readonly pattern: Check<[p: Ast.Pattern]>;\n  readonly query: Check<[q: Ast.Query, nested: boolean]>;\n  readonly variable: Check<[name: string]>;\n}\n\nconst noError = (): Option.Option<string> => Option.none();\n\nconst visitNothing: Visitor = { pattern: noError, query: noError, variable: noError };\n\nconst isSelect = (q: Ast.Query): q is Ast.SelectQuery => Predicate.isTagged(q, 'Select');\n\nconst termVariables = (t: Ast.TermPattern | Term.Term, out: (name: string) => void): void => {\n  if (Predicate.isTagged(t, 'Variable')) out(t.value);\n  else if (Predicate.isTagged(t, 'Triple')) {\n    termVariables(t.subject, out);\n    termVariables(t.predicate, out);\n    termVariables(t.object, out);\n  }\n};\n\n/** Visits every pattern, (sub-)query and variable occurrence; returns the first error. */\nconst walk = (root: Ast.Query, visitor: Partial<Visitor>): Option.Option<string> => {\n  const visit: Visitor = { ...visitNothing, ...visitor };\n  let error = Option.none<string>();\n  const report = (e: Option.Option<string>) => {\n    if (Option.isNone(error)) error = e;\n  };\n  const variable = (name: string) => report(visit.variable(name));\n  const term = (t: Ast.TermPattern | Term.Term) => termVariables(t, variable);\n\n  const expression = (expr: Ast.Expression): void => {\n    return Match.value(expr).pipe(\n      Match.tag('Variable', 'Triple', (e) => {\n        term(e);\n        return;\n      }),\n      Match.tag('Operation', 'FunctionCall', (e) => {\n        e.args.forEach(expression);\n        return;\n      }),\n      Match.tag('Aggregate', (e) => {\n        if (e.expression !== '*') expression(e.expression);\n        return;\n      }),\n      Match.tag('Exists', (e) => {\n        pattern(e.pattern);\n        return;\n      }),\n      Match.orElse(() => undefined),\n    );\n  };\n\n  const pathTerms = (p: Ast.Path): void => {\n    Match.value(p).pipe(\n      Match.tag('PathLink', 'PathNegated', () => undefined),\n      Match.tag('PathSequence', 'PathAlternative', (list) => list.paths.forEach(pathTerms)),\n      Match.orElse((unary) => pathTerms(unary.path)),\n    );\n  };\n\n  const pattern = (pat: Ast.Pattern): void => {\n    report(visit.pattern(pat));\n    return Match.value(pat).pipe(\n      Match.tag('Bgp', (p) => {\n        Arr.forEach(p.triples, (t) => {\n          term(t.subject);\n          if (Predicate.isTagged(t, 'TriplePattern')) term(t.predicate);\n          else pathTerms(t.path);\n          term(t.object);\n        });\n        return;\n      }),\n      Match.tag('Group', (p) => {\n        p.patterns.forEach(pattern);\n        return;\n      }),\n      Match.tag('Optional', 'Minus', (p) => {\n        pattern(p.pattern);\n        return;\n      }),\n      Match.tag('Union', (p) => {\n        p.patterns.forEach(pattern);\n        return;\n      }),\n      Match.tag('Graph', 'Service', (p) => {\n        term(p.name);\n        pattern(p.pattern);\n        return;\n      }),\n      Match.tag('Filter', (p) => {\n        expression(p.expression);\n        return;\n      }),\n      Match.tag('Bind', (p) => {\n        expression(p.expression);\n        variable(p.variable.value);\n        return;\n      }),\n      Match.tag('Values', (p) => {\n        p.variables.forEach((v) => variable(v.value));\n        return;\n      }),\n      Match.tag('SubSelect', (p) => {\n        query(p.query, true);\n        return;\n      }),\n      Match.exhaustive,\n    );\n  };\n\n  const query = (q: Ast.Query, nested: boolean): void => {\n    report(visit.query(q, nested));\n    if (isSelect(q) && q.projection !== '*') {\n      Arr.forEach(q.projection, (p) => {\n        if (Predicate.isTagged(p, 'Variable')) variable(p.value);\n        else {\n          expression(p.expression);\n          variable(p.variable.value);\n        }\n      });\n    }\n    if (Predicate.isTagged(q, 'Construct'))\n      Arr.forEach(q.template, (t) => [t.subject, t.predicate, t.object].forEach(term));\n    if (Predicate.isTagged(q, 'Describe') && q.terms !== '*') q.terms.forEach(term);\n    pattern(q.where);\n    Arr.forEach(q.groupBy, (g) => {\n      expression(g.expression);\n      if (g.variable !== undefined) variable(g.variable.value);\n    });\n    q.having.forEach(expression);\n    Arr.forEach(q.orderBy, (o) => expression(o.expression));\n    if (q.values !== undefined) pattern(q.values);\n  };\n\n  query(root, false);\n  return error;\n};\n\n/**\n * Checks the restrictions that SHACL places on queries evaluated with\n * pre-bound variables (Appendix A \"Pre-binding of Variables in SPARQL\n * Queries\"): no `MINUS`, no `SERVICE`, no `VALUES`, no `AS ?var` for a\n * potentially pre-bound variable, and sub-queries must project every\n * potentially pre-bound variable (except `shapesGraph` and `currentShape`).\n *\n * @since 0.1.0\n * @category validation\n */\nexport const checkPrebinding = (\n  query: Ast.Query,\n  prebound: Iterable<string>,\n): Result.Result<Ast.Query, Sparql.SparqlEvaluationError> => {\n  const ordered = Arr.dedupe(Arr.fromIterable(prebound));\n  const potential = MutableHashSet.fromIterable(ordered);\n  const rebinds = (v: Term.Variable): Option.Option<string> =>\n    MutableHashSet.has(potential, v.value)\n      ? Option.some(`the pre-bound variable ?${v.value} must not be assigned with AS`)\n      : Option.none();\n  const unprojected = (q: Ast.SelectQuery): Option.Option<string> => {\n    const projected = MutableHashSet.fromIterable(Ast.projectedVariables(q));\n    return Option.map(\n      Arr.findFirst(ordered, (v) => !optionalPrebound.has(v) && !MutableHashSet.has(projected, v)),\n      (v) => `sub-queries must project the pre-bound variable ?${v}`,\n    );\n  };\n  const error = walk(query, {\n    pattern: (pat) => {\n      return Match.value(pat).pipe(\n        Match.withReturnType<Option.Option<string>>(),\n        Match.tag('Minus', () =>\n          Option.some('MINUS is not allowed in SHACL-SPARQL queries with pre-bound variables'),\n        ),\n        Match.tag('Service', () =>\n          Option.some('SERVICE is not allowed in SHACL-SPARQL queries with pre-bound variables'),\n        ),\n        Match.tag('Values', () =>\n          Option.some('VALUES is not allowed in SHACL-SPARQL queries with pre-bound variables'),\n        ),\n        Match.tag('Bind', (p) => rebinds(p.variable)),\n        Match.orElse(() => Option.none()),\n      );\n    },\n    query: (q, nested) => {\n      if (q.values !== undefined)\n        return Option.some(\n          'VALUES is not allowed in SHACL-SPARQL queries with pre-bound variables',\n        );\n      const projections =\n        isSelect(q) && q.projection !== '*'\n          ? Arr.filter(q.projection, (p): p is Ast.Projection =>\n              Predicate.isTagged(p, 'Projection'),\n            )\n          : [];\n      return pipe(\n        Arr.findFirst(projections, (p) => rebinds(p.variable)),\n        Option.orElse(() =>\n          Arr.findFirst(q.groupBy, (g) =>\n            g.variable === undefined ? Option.none() : rebinds(g.variable),\n          ),\n        ),\n        Option.orElse(() => (nested && isSelect(q) ? unprojected(q) : Option.none())),\n      );\n    },\n  });\n  return Option.match(error, { onNone: () => Result.succeed(query), onSome: fail });\n};\n\n// -----------------------------------------------------------------------------\n// $PATH substitution\n// -----------------------------------------------------------------------------\n\n/**\n * Converts a SHACL property path to a SPARQL property path.\n *\n * @since 0.1.0\n * @category paths\n */\nexport const toSparqlPath = (path: Path.Path): Ast.Path => {\n  return Match.value(path).pipe(\n    Match.tag('PredicatePath', (step) => Ast.link(step.predicate)),\n    Match.tag('SequencePath', (step) => Ast.sequence(...step.paths.map(toSparqlPath))),\n    Match.tag('AlternativePath', (step) => Ast.alternative(...step.paths.map(toSparqlPath))),\n    Match.tag('InversePath', (step) => Ast.inverse(toSparqlPath(step.path))),\n    Match.tag('ZeroOrMorePath', (step) => Ast.zeroOrMore(toSparqlPath(step.path))),\n    Match.tag('OneOrMorePath', (step) => Ast.oneOrMore(toSparqlPath(step.path))),\n    Match.tag('ZeroOrOnePath', (step) => Ast.zeroOrOne(toSparqlPath(step.path))),\n    Match.exhaustive,\n  );\n};\n\nconst PATH = 'PATH';\n\nconst isPathLink = (p: Ast.Path): p is Ast.PathLink => Predicate.isTagged(p, 'PathLink');\n\nconst mapGroup = (\n  g: Ast.GroupPattern,\n  f: (t: Ast.TriplePattern | Ast.PathPattern) => Ast.TriplePattern | Ast.PathPattern,\n): Ast.GroupPattern => ({ ...g, patterns: g.patterns.map((p) => mapPattern(p, f)) });\n\nconst mapExpression = (\n  expr: Ast.Expression,\n  f: (t: Ast.TriplePattern | Ast.PathPattern) => Ast.TriplePattern | Ast.PathPattern,\n): Ast.Expression => {\n  return Match.value(expr).pipe(\n    Match.tag('Operation', (e) => ({ ...e, args: e.args.map((a) => mapExpression(a, f)) })),\n    Match.tag('FunctionCall', (e) => ({ ...e, args: e.args.map((a) => mapExpression(a, f)) })),\n    Match.tag('Aggregate', (e) =>\n      e.expression === '*' ? e : { ...e, expression: mapExpression(e.expression, f) },\n    ),\n    Match.tag('Exists', (e) => ({ ...e, pattern: mapGroup(e.pattern, f) })),\n    Match.orElse((e) => e),\n  );\n};\n\nconst mapPattern = (\n  pat: Ast.Pattern,\n  f: (t: Ast.TriplePattern | Ast.PathPattern) => Ast.TriplePattern | Ast.PathPattern,\n): Ast.Pattern => {\n  return Match.value(pat).pipe(\n    Match.tag('Bgp', (p) => ({ ...p, triples: p.triples.map(f) })),\n    Match.tag('Group', (p) => mapGroup(p, f)),\n    Match.tag('Optional', 'Minus', 'Graph', 'Service', (p) => ({\n      ...p,\n      pattern: mapGroup(p.pattern, f),\n    })),\n    Match.tag('Union', (p) => ({ ...p, patterns: p.patterns.map((g) => mapGroup(g, f)) })),\n    Match.tag('Filter', (p) => ({ ...p, expression: mapExpression(p.expression, f) })),\n    Match.tag('Bind', (p) => ({ ...p, expression: mapExpression(p.expression, f) })),\n    Match.tag('Values', (p) => p),\n    Match.tag('SubSelect', (p) => ({ ...p, query: mapQuery(p.query, f) })),\n    Match.exhaustive,\n  );\n};\n\nconst mapQuery = <Q extends Ast.Query>(\n  q: Q,\n  f: (t: Ast.TriplePattern | Ast.PathPattern) => Ast.TriplePattern | Ast.PathPattern,\n): Q => {\n  const expression = (e: Ast.Expression) => mapExpression(e, f);\n  const mapped: Q = {\n    ...q,\n    where: mapGroup(q.where, f),\n    having: q.having.map(expression),\n    orderBy: q.orderBy.map((o) => ({ ...o, expression: expression(o.expression) })),\n    groupBy: q.groupBy.map((g) => ({ ...g, expression: expression(g.expression) })),\n  };\n  if (!isSelect(q) || q.projection === '*') return mapped;\n  return {\n    ...mapped,\n    projection: q.projection.map((p) =>\n      Predicate.isTagged(p, 'Projection') ? { ...p, expression: expression(p.expression) } : p,\n    ),\n  };\n};\n\n/**\n * Substitutes the variable `$PATH` in the predicate position of triple\n * patterns with a property path (the `sh:path` of the current property\n * shape). Any other use of `$PATH` makes the query ill-formed.\n *\n * @since 0.1.0\n * @category paths\n */\nexport const substitutePath = <Q extends Ast.Query>(\n  query: Q,\n  path: Path.Path,\n): Result.Result<Q, Sparql.SparqlEvaluationError> => {\n  const sparqlPath = toSparqlPath(path);\n  const substituted = mapQuery(query, (t) =>\n    Predicate.isTagged(t, 'TriplePattern') &&\n    Predicate.isTagged(t.predicate, 'Variable') &&\n    t.predicate.value === PATH\n      ? isPathLink(sparqlPath)\n        ? Ast.triplePattern(t.subject, sparqlPath.iri, t.object)\n        : Ast.pathPattern(t.subject, sparqlPath, t.object)\n      : t,\n  );\n  const error = walk(substituted, {\n    variable: (name) =>\n      name === PATH\n        ? Option.some('$PATH may only be used in the predicate position of triple patterns')\n        : Option.none(),\n  });\n  return Option.match(error, { onNone: () => Result.succeed(substituted), onSome: fail });\n};\n\n// -----------------------------------------------------------------------------\n// Compiling\n// -----------------------------------------------------------------------------\n\n/** The first of `required` that a `SELECT` query does not project. */\nconst unprojectedOf = (\n  query: Ast.SelectQuery,\n  required: ReadonlyArray<string>,\n): Option.Option<string> => {\n  const projected = MutableHashSet.fromIterable(Ast.projectedVariables(query));\n  return Arr.findFirst(required, (v) => !MutableHashSet.has(projected, v));\n};\n\n/**\n * How to compile a SHACL-SPARQL query.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface CompileOptions {\n  /** Read `sh:select` (a `SELECT` query) or `sh:ask` (an `ASK` query). */\n  readonly form: 'select' | 'ask';\n  /** The potentially pre-bound variables (checked against the pre-binding restrictions). */\n  readonly prebound: ReadonlyArray<string>;\n  /** The property path substituted for `$PATH`, for property shapes. */\n  readonly path?: Path.Path | undefined;\n  /** Variables a `SELECT` query must project (e.g. `this`). */\n  readonly project?: ReadonlyArray<string> | undefined;\n}\n\n/**\n * Reads, parses and checks the `sh:select` or `sh:ask` query of a node of\n * the shapes graph (a SPARQL-based constraint, validator, target or target\n * type), using its prefix declarations. Fails with a\n * `SparqlEvaluationError` when the query is missing, ambiguous, does not\n * parse, has the wrong form or violates the pre-binding restrictions.\n *\n * @since 0.1.0\n * @category compiling\n */\nexport const compileResult = (\n  shapesGraph: Dataset.Dataset,\n  node: Term.NamedNode | Term.BlankNode,\n  options: CompileOptions,\n): Result.Result<Ast.Query, Sparql.SparqlEvaluationError> => {\n  const property = options.form === 'select' ? sh.select : sh.ask;\n  const literal = singleOf(Dataset.objectsOf(shapesGraph, node, property), Term.isLiteral);\n  if (Option.isNone(literal)) {\n    return fail(`${node.key} must have exactly one literal value for ${property.key}`);\n  }\n  const text = literal.value.value;\n  return Result.flatMap(prefixes(shapesGraph, node), (declared) => {\n    const parsed = Parser.parseQueryResult(text, { prefixes: declared });\n    if (Result.isFailure(parsed)) {\n      return Result.fail(\n        new Sparql.SparqlEvaluationError({\n          message: `the ${property.key} query of ${node.key} does not parse: ${parsed.failure.message}`,\n          cause: parsed.failure,\n        }),\n      );\n    }\n    const query = parsed.success;\n    const expected = options.form === 'select' ? 'Select' : 'Ask';\n    if (!Predicate.isTagged(query, expected)) {\n      return fail(\n        `the ${property.key} query of ${node.key} must be a ${expected.toUpperCase()} query`,\n      );\n    }\n    const missing = isSelect(query) ? unprojectedOf(query, options.project ?? []) : Option.none();\n    if (Option.isSome(missing))\n      return fail(`the query of ${node.key} must project ?${missing.value}`);\n    return Result.flatMap(checkPrebinding(query, options.prebound), (checked) =>\n      options.path === undefined ? Result.succeed(checked) : substitutePath(checked, options.path),\n    );\n  });\n};\n\n/**\n * `compileResult` as an `Effect`.\n *\n * @since 0.1.0\n * @category compiling\n */\nexport const compile = (\n  shapesGraph: Dataset.Dataset,\n  node: Term.NamedNode | Term.BlankNode,\n  options: CompileOptions,\n): Effect.Effect<Ast.Query, Sparql.SparqlEvaluationError> =>\n  Effect.suspend(() => Effect.fromResult(compileResult(shapesGraph, node, options)));\n"],"mappings":"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"}

package/dist/Query-KqSkTYyG.d.mts

@@ -0,0 +1,96 @@
+import { d as NamedNode, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import "./index-Cms2TYfC.mjs";
+import { i as Path } from "./Path-DRB8e-Zn.mjs";
+import { r as SparqlEvaluationError } from "./Sparql-DecpWTPh.mjs";
+import "./index-Ct8xFmRs.mjs";
+import { N as Path$1, q as Query } from "./Ast-vcw2W-lf.mjs";
+import "./index-D4QFwOjm.mjs";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+declare namespace Query_d_exports {
+  export { CompileOptions, checkPrebinding, compile, compileResult, optionalPrebound, prefixes, substitutePath, toSparqlPath };
+}
+/**
+ * The variables that are optional to pre-bind (and to project from
+ * sub-queries): `$shapesGraph` and `$currentShape`.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+declare const optionalPrebound: ReadonlySet<string>;
+/**
+ * The prefix mappings of a SPARQL executable: the union of the
+ * `sh:prefix` / `sh:namespace` pairs reachable via
+ * `sh:prefixes/owl:imports* /sh:declare`. Fails when a prefix is declared
+ * with two different namespaces (an ill-formed shapes graph) or a
+ * declaration is malformed.
+ *
+ * @since 0.1.0
+ * @category prefixes
+ */
+declare const prefixes: (shapesGraph: Dataset, node: NamedNode | BlankNode) => Result.Result<Record.ReadonlyRecord<string, string>, SparqlEvaluationError>;
+/**
+ * Checks the restrictions that SHACL places on queries evaluated with
+ * pre-bound variables (Appendix A "Pre-binding of Variables in SPARQL
+ * Queries"): no `MINUS`, no `SERVICE`, no `VALUES`, no `AS ?var` for a
+ * potentially pre-bound variable, and sub-queries must project every
+ * potentially pre-bound variable (except `shapesGraph` and `currentShape`).
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const checkPrebinding: (query: Query, prebound: Iterable<string>) => Result.Result<Query, SparqlEvaluationError>;
+/**
+ * Converts a SHACL property path to a SPARQL property path.
+ *
+ * @since 0.1.0
+ * @category paths
+ */
+declare const toSparqlPath: (path: Path) => Path$1;
+/**
+ * Substitutes the variable `$PATH` in the predicate position of triple
+ * patterns with a property path (the `sh:path` of the current property
+ * shape). Any other use of `$PATH` makes the query ill-formed.
+ *
+ * @since 0.1.0
+ * @category paths
+ */
+declare const substitutePath: <Q extends Query>(query: Q, path: Path) => Result.Result<Q, SparqlEvaluationError>;
+/**
+ * How to compile a SHACL-SPARQL query.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface CompileOptions {
+  /** Read `sh:select` (a `SELECT` query) or `sh:ask` (an `ASK` query). */
+  readonly form: 'select' | 'ask';
+  /** The potentially pre-bound variables (checked against the pre-binding restrictions). */
+  readonly prebound: ReadonlyArray<string>;
+  /** The property path substituted for `$PATH`, for property shapes. */
+  readonly path?: Path | undefined;
+  /** Variables a `SELECT` query must project (e.g. `this`). */
+  readonly project?: ReadonlyArray<string> | undefined;
+}
+/**
+ * Reads, parses and checks the `sh:select` or `sh:ask` query of a node of
+ * the shapes graph (a SPARQL-based constraint, validator, target or target
+ * type), using its prefix declarations. Fails with a
+ * `SparqlEvaluationError` when the query is missing, ambiguous, does not
+ * parse, has the wrong form or violates the pre-binding restrictions.
+ *
+ * @since 0.1.0
+ * @category compiling
+ */
+declare const compileResult: (shapesGraph: Dataset, node: NamedNode | BlankNode, options: CompileOptions) => Result.Result<Query, SparqlEvaluationError>;
+/**
+ * `compileResult` as an `Effect`.
+ *
+ * @since 0.1.0
+ * @category compiling
+ */
+declare const compile: (shapesGraph: Dataset, node: NamedNode | BlankNode, options: CompileOptions) => Effect.Effect<Query, SparqlEvaluationError>;
+export { compileResult as a, substitutePath as c, compile as i, toSparqlPath as l, Query_d_exports as n, optionalPrebound as o, checkPrebinding as r, prefixes as s, CompileOptions as t };
+//# sourceMappingURL=Query-KqSkTYyG.d.mts.map