@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/QueryBuilder-BLK9Vfbz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilder-BLK9Vfbz.mjs","names":["Term.isTerm","Xsd.fromJs","Term.variable","Ast.isPath","Ast.pathPattern","Ast.triplePattern","Ast.link","Ast.inverse","Ast.sequence","Ast.alternative","Ast.zeroOrMore","Ast.oneOrMore","Ast.zeroOrOne","Ast.negated","Ast.bgp","Ast.group","Ast.optional","Ast.minus","Ast.union","Ast.graph","Ast.filter","Ast.bind","Ast.values","Ast.operation","Ast.functionCall","Ast.exists","Ast.aggregate","Generator.print","Ast.projection","Ast.select","Ast.ask","Ast.construct","Ast.describe","Engine.SparqlEngine","B.toRecord"],"sources":["../src/sparql/QueryBuilder.ts"],"sourcesContent":["/**\n * A strongly-typed, immutable query builder. Builders produce the SPARQL AST\n * (`build()`), print as SPARQL text (`toString()`) and can be executed with\n * the `SparqlEngine`, yielding rows whose type is derived from the selected\n * variables:\n *\n * ```ts\n * import { QueryBuilder as Q } from '@thomasfosterau/effect-rdf/sparql'\n * const v = Q.vars('person', 'name', 'email')\n *\n * const query = Q.select('person', 'name', Q.maybe('email'))\n *   .where(Q.triple(v.person, foaf.name, v.name))\n *   .optional(Q.triple(v.person, foaf.mbox, v.email))\n *   .orderBy(v.name)\n *   .limit(10)\n *\n * // Stream<{ readonly person: GroundTerm; readonly name: GroundTerm; readonly email?: GroundTerm }>\n * const rows = Q.execute(query)\n * // Stream<{ name: string; email?: string }>, decoded with TermSchema\n * const people = Q.decode(query, Schema.Struct({ name: TermSchema.string, email: Schema.optional(TermSchema.iri) }))\n * ```\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Match from 'effect/Match';\nimport { pipeArguments, type Pipeable } from 'effect/Pipeable';\nimport * as Record from 'effect/Record';\nimport * as Schema from 'effect/Schema';\nimport * as Stream from 'effect/Stream';\nimport type { Simplify } from 'effect/Types';\nimport * as Term from '../Term.ts';\nimport * as Xsd from '../Xsd.ts';\nimport * as Ast from './Ast.ts';\nimport * as B from './Bindings.ts';\nimport * as Engine from './Engine.ts';\nimport * as Generator from './Generator.ts';\nimport * as Predicate from 'effect/Predicate';\n\n// -----------------------------------------------------------------------------\n// Inputs\n// -----------------------------------------------------------------------------\n\n/**\n * A JavaScript value usable as a literal.\n *\n * @since 0.1.0\n * @category models\n */\nexport type JsValue = string | number | bigint | boolean | Date;\n\n/**\n * An expression, or a JS value (converted to a literal).\n *\n * @since 0.1.0\n * @category models\n */\nexport type ExpressionInput = Ast.Expression | JsValue;\n\n/**\n * An object position input: a term pattern or a JS value (literal).\n *\n * @since 0.1.0\n * @category models\n */\nexport type ObjectInput = Ast.TermPattern | JsValue;\n\n/**\n * Anything accepted as (part of) a group graph pattern.\n *\n * @since 0.1.0\n * @category models\n */\nexport type PatternInput =\n  | Ast.TriplePattern\n  | Ast.PathPattern\n  | Ast.Pattern\n  | ReadonlyArray<PatternInput>;\n\nconst isJsValue = (\n  u: ExpressionInput | Alias<string, boolean> | Ast.OrderCondition,\n): u is JsValue =>\n  Predicate.isString(u) ||\n  Predicate.isNumber(u) ||\n  Predicate.isBigInt(u) ||\n  Predicate.isBoolean(u) ||\n  Predicate.isDate(u);\n\nconst isTerm = <T extends Term.Term>(u: T | JsValue): u is T => Term.isTerm(u);\n\nconst isAlias = (u: ExpressionInput | Alias<string, boolean>): u is Alias<string, boolean> =>\n  !isJsValue(u) && Predicate.isTagged(u, 'Alias');\n\nconst isOrderCondition = (u: ExpressionInput | Ast.OrderCondition): u is Ast.OrderCondition =>\n  !isJsValue(u) && 'descending' in u;\n\n/**\n * Converts a JS value to a literal (terms and expressions are returned\n * unchanged).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const toExpression = (input: ExpressionInput): Ast.Expression =>\n  isJsValue(input) ? Xsd.fromJs(input) : input;\n\nconst toObject = (input: ObjectInput): Ast.TermPattern =>\n  isTerm(input) ? input : Xsd.fromJs(input);\n\n// -----------------------------------------------------------------------------\n// Variables\n// -----------------------------------------------------------------------------\n\n/**\n * Creates a variable.\n *\n * @since 0.1.0\n * @category variables\n */\nexport const variable = <const N extends string>(name: N): Term.Variable<N> => Term.variable(name);\n\n/**\n * Variables by name, as `v` provides them.\n *\n * @since 0.1.0\n * @category variables\n */\nexport interface Variables {\n  readonly [name: string]: Term.Variable;\n}\n\n/**\n * A proxy creating variables by property access: `v.name` is `?name`.\n *\n * @since 0.1.0\n * @category variables\n */\nexport const v: Variables = new Proxy<Variables>(\n  {},\n  { get: (_, name) => (Predicate.isString(name) ? Term.variable(name) : undefined) },\n);\n\n/**\n * Creates several variables at once, typed by name:\n * `const { s, name } = vars('s', 'name')`.\n *\n * @since 0.1.0\n * @category variables\n */\nexport const vars = <const N extends ReadonlyArray<string>>(\n  ...names: N\n): { readonly [K in N[number]]: Term.Variable<K> } =>\n  // SAFETY: one entry per name in `names`, each the variable of that name.\n  Record.fromEntries(names.map((n) => [n, Term.variable(n)])) as {\n    readonly [K in N[number]]: Term.Variable<K>;\n  };\n\n/**\n * The `as` constructor: an alias that is required unless marked optional.\n *\n * @since 0.1.0\n * @category projection\n */\nexport interface AsAlias {\n  <const N extends string>(expression: ExpressionInput, name: N): Alias<N>;\n  <const N extends string>(\n    expression: ExpressionInput,\n    name: N,\n    options: { readonly optional: true },\n  ): Alias<N, true>;\n}\n\n/**\n * Marks a selected variable as possibly unbound (e.g. bound in an\n * `OPTIONAL`): its row field becomes optional.\n *\n * @since 0.1.0\n * @category projection\n */\nexport interface MaybeVariable<N extends string> {\n  readonly _tag: 'Maybe';\n  readonly name: N;\n}\n\n/**\n * @since 0.1.0\n * @category projection\n */\nexport const maybe = <const N extends string>(name: N): MaybeVariable<N> => ({\n  _tag: 'Maybe',\n  name,\n});\n\n/**\n * A projected expression `(expr AS ?name)`.\n *\n * @since 0.1.0\n * @category projection\n */\nexport interface Alias<N extends string, Optional extends boolean = false> {\n  readonly _tag: 'Alias';\n  readonly name: N;\n  readonly expression: Ast.Expression;\n  readonly optional: Optional;\n}\n\n/**\n * Projects an expression as a variable. Pass `{ optional: true }` when the\n * expression may fail (leaving the variable unbound).\n *\n * @since 0.1.0\n * @category projection\n */\nexport const as: AsAlias = (\n  expression: ExpressionInput,\n  name: string,\n  options?: { readonly optional: true },\n): any => ({\n  _tag: 'Alias',\n  name,\n  expression: toExpression(expression),\n  optional: options?.optional ?? false,\n});\n\n/**\n * An item of a `SELECT` list.\n *\n * @since 0.1.0\n * @category projection\n */\nexport type SelectItem = string | Term.Variable | MaybeVariable<string> | Alias<string, boolean>;\n\ntype RequiredOf<I> = I extends string\n  ? I\n  : I extends Term.Variable<infer N>\n    ? N\n    : I extends Alias<infer N>\n      ? N\n      : never;\n\ntype OptionalOf<I> =\n  I extends MaybeVariable<infer N> ? N : I extends Alias<infer N, true> ? N : never;\n\n/**\n * The row type of a `SELECT` query with required variables `R` and\n * possibly-unbound variables `O`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Row<R extends string, O extends string> = Simplify<\n  { readonly [K in R]: Term.GroundTerm } & { readonly [K in O]?: Term.GroundTerm | undefined }\n>;\n\n// -----------------------------------------------------------------------------\n// Patterns\n// -----------------------------------------------------------------------------\n\n/**\n * A triple pattern. The predicate may be a property path; the object may be\n * a JS value.\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const triple = (\n  subject: Ast.TermPattern,\n  predicate: Ast.VarOrIri | Ast.Path,\n  object: ObjectInput,\n): Ast.TriplePattern | Ast.PathPattern =>\n  Ast.isPath(predicate)\n    ? Ast.pathPattern(subject, predicate, toObject(object))\n    : Ast.triplePattern(subject, predicate, toObject(object));\n\n/**\n * Property path constructors.\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const path = {\n  link: (iri: Term.NamedNode): Ast.Path => Ast.link(iri),\n  inverse: (p: Ast.Path | Term.NamedNode): Ast.Path => Ast.inverse(toPath(p)),\n  sequence: (...ps: ReadonlyArray<Ast.Path | Term.NamedNode>): Ast.Path =>\n    Ast.sequence(...ps.map(toPath)),\n  alternative: (...ps: ReadonlyArray<Ast.Path | Term.NamedNode>): Ast.Path =>\n    Ast.alternative(...ps.map(toPath)),\n  zeroOrMore: (p: Ast.Path | Term.NamedNode): Ast.Path => Ast.zeroOrMore(toPath(p)),\n  oneOrMore: (p: Ast.Path | Term.NamedNode): Ast.Path => Ast.oneOrMore(toPath(p)),\n  zeroOrOne: (p: Ast.Path | Term.NamedNode): Ast.Path => Ast.zeroOrOne(toPath(p)),\n  negated: (\n    iris: ReadonlyArray<Term.NamedNode>,\n    inverse: ReadonlyArray<Term.NamedNode> = [],\n  ): Ast.Path => Ast.negated(iris, inverse),\n} as const;\n\nconst toPath = (p: Ast.Path | Term.NamedNode): Ast.Path => (Ast.isPath(p) ? p : Ast.link(p));\n\n/** Whether a pattern input is the list form (`Array.isArray` cannot narrow a `ReadonlyArray`). */\nconst isPatternList = (input: PatternInput): input is ReadonlyArray<PatternInput> =>\n  Array.isArray(input);\n\nconst isTriplePattern = (\n  p: Ast.TriplePattern | Ast.PathPattern | Ast.Pattern,\n): p is Ast.TriplePattern | Ast.PathPattern =>\n  Predicate.isTagged(p, 'TriplePattern') || Predicate.isTagged(p, 'PathPattern');\n\nconst flatten = (inputs: ReadonlyArray<PatternInput>): Array<Ast.Pattern> => {\n  const out: Array<Ast.Pattern> = [];\n  const go = (input: PatternInput): void => {\n    if (isPatternList(input)) {\n      input.forEach(go);\n      return;\n    }\n    if (isTriplePattern(input)) {\n      const last = out[out.length - 1];\n      if (Predicate.isTagged(last, 'Bgp')) {\n        out[out.length - 1] = Ast.bgp([...last.triples, input]);\n      } else out.push(Ast.bgp([input]));\n    } else out.push(input);\n  };\n  inputs.forEach(go);\n  return out;\n};\n\n/**\n * A group graph pattern `{ … }`.\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const group = (...patterns: ReadonlyArray<PatternInput>): Ast.GroupPattern =>\n  Ast.group(flatten(patterns));\n\n/**\n * `OPTIONAL { … }`\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const optional = (...patterns: ReadonlyArray<PatternInput>): Ast.OptionalPattern =>\n  Ast.optional(group(...patterns));\n\n/**\n * `MINUS { … }`\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const minus = (...patterns: ReadonlyArray<PatternInput>): Ast.MinusPattern =>\n  Ast.minus(group(...patterns));\n\n/**\n * `{ … } UNION { … }`; each argument is one alternative.\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const union = (...alternatives: ReadonlyArray<PatternInput>): Ast.UnionPattern =>\n  Ast.union(alternatives.map((a) => group(a)));\n\n/**\n * `GRAPH name { … }`\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const graph = (\n  name: Ast.VarOrIri,\n  ...patterns: ReadonlyArray<PatternInput>\n): Ast.GraphPattern => Ast.graph(name, group(...patterns));\n\n/**\n * `FILTER(expr)`\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const filter = (expression: ExpressionInput): Ast.FilterPattern =>\n  Ast.filter(toExpression(expression));\n\n/**\n * `BIND(expr AS ?name)`\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const bind = (expression: ExpressionInput, name: string | Term.Variable): Ast.BindPattern =>\n  Ast.bind(toExpression(expression), Predicate.isString(name) ? Term.variable(name) : name);\n\n/**\n * Inline data from records: `values([{ x: ex.a, y: 1 }, { x: ex.b }])`.\n * Missing or `undefined` values are `UNDEF`.\n *\n * @since 0.1.0\n * @category patterns\n */\nexport const values = (\n  rows: ReadonlyArray<Readonly<Record<string, Term.GroundTerm | JsValue | undefined>>>,\n): Ast.ValuesPattern => {\n  const names = Arr.dedupe(rows.flatMap((r) => Record.keys(r)));\n  return Ast.values(\n    names.map((n) => Term.variable(n)),\n    rows.map((r) =>\n      names.map((n) => {\n        const x = r[n];\n        return x === undefined ? undefined : isTerm(x) ? x : Xsd.fromJs(x);\n      }),\n    ),\n  );\n};\n\n// -----------------------------------------------------------------------------\n// Expressions\n// -----------------------------------------------------------------------------\n\nconst op =\n  (operator: Ast.Operator) =>\n  (...args: ReadonlyArray<ExpressionInput>): Ast.Expression =>\n    Ast.operation(operator, ...args.map(toExpression));\n\nconst binary =\n  (operator: Ast.Operator) =>\n  (a: ExpressionInput, b: ExpressionInput): Ast.Expression =>\n    Ast.operation(operator, toExpression(a), toExpression(b));\n\nconst unary =\n  (operator: Ast.Operator) =>\n  (a: ExpressionInput): Ast.Expression =>\n    Ast.operation(operator, toExpression(a));\n\n/** @since 0.1.0 @category expressions */\nexport const eq = binary('=');\n/** @since 0.1.0 @category expressions */\nexport const ne = binary('!=');\n/** @since 0.1.0 @category expressions */\nexport const lt = binary('<');\n/** @since 0.1.0 @category expressions */\nexport const le = binary('<=');\n/** @since 0.1.0 @category expressions */\nexport const gt = binary('>');\n/** @since 0.1.0 @category expressions */\nexport const ge = binary('>=');\n/** @since 0.1.0 @category expressions */\nexport const add = binary('+');\n/** @since 0.1.0 @category expressions */\nexport const subtract = binary('-');\n/** @since 0.1.0 @category expressions */\nexport const multiply = binary('*');\n/** @since 0.1.0 @category expressions */\nexport const divide = binary('/');\n/** @since 0.1.0 @category expressions */\nexport const negate = unary('UMINUS');\n/** @since 0.1.0 @category expressions */\nexport const not = unary('!');\n\n/**\n * Logical conjunction of any number of conditions.\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const and = (...args: ReadonlyArray<ExpressionInput>): Ast.Expression =>\n  args.map(toExpression).reduce((a, b) => Ast.operation('&&', a, b));\n\n/**\n * Logical disjunction of any number of conditions.\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const or = (...args: ReadonlyArray<ExpressionInput>): Ast.Expression =>\n  args.map(toExpression).reduce((a, b) => Ast.operation('||', a, b));\n\n/**\n * `expr IN (…)`\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const isIn = (\n  expression: ExpressionInput,\n  list: ReadonlyArray<ExpressionInput>,\n): Ast.Expression => Ast.operation('IN', toExpression(expression), ...list.map(toExpression));\n\n/**\n * `expr NOT IN (…)`\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const notIn = (\n  expression: ExpressionInput,\n  list: ReadonlyArray<ExpressionInput>,\n): Ast.Expression => Ast.operation('NOT IN', toExpression(expression), ...list.map(toExpression));\n\n/**\n * Calls any built-in function by name, e.g. `fn('STRLEN', v.name)`.\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const fn = (\n  name: Ast.BuiltInName,\n  ...args: ReadonlyArray<ExpressionInput>\n): Ast.Expression => Ast.operation(name, ...args.map(toExpression));\n\n/**\n * Calls an extension function (or XSD cast) by IRI.\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const call = (\n  iri: Term.NamedNode,\n  ...args: ReadonlyArray<ExpressionInput>\n): Ast.Expression => Ast.functionCall(iri, args.map(toExpression));\n\n/** @since 0.1.0 @category expressions */\nexport const bound = (variable: Term.Variable): Ast.Expression => Ast.operation('BOUND', variable);\n/** @since 0.1.0 @category expressions */\nexport const str = op('STR');\n/** @since 0.1.0 @category expressions */\nexport const lang = op('LANG');\n/** @since 0.1.0 @category expressions */\nexport const langMatches = op('LANGMATCHES');\n/** @since 0.1.0 @category expressions */\nexport const datatype = op('DATATYPE');\n/** @since 0.1.0 @category expressions */\nexport const iri = op('IRI');\n/** @since 0.1.0 @category expressions */\nexport const regex = op('REGEX');\n/** @since 0.1.0 @category expressions */\nexport const contains = op('CONTAINS');\n/** @since 0.1.0 @category expressions */\nexport const strStarts = op('STRSTARTS');\n/** @since 0.1.0 @category expressions */\nexport const strEnds = op('STRENDS');\n/** @since 0.1.0 @category expressions */\nexport const strlen = op('STRLEN');\n/** @since 0.1.0 @category expressions */\nexport const ucase = op('UCASE');\n/** @since 0.1.0 @category expressions */\nexport const lcase = op('LCASE');\n/** @since 0.1.0 @category expressions */\nexport const concat = op('CONCAT');\n/** @since 0.1.0 @category expressions */\nexport const substr = op('SUBSTR');\n/** @since 0.1.0 @category expressions */\nexport const replace = op('REPLACE');\n/** @since 0.1.0 @category expressions */\nexport const coalesce = op('COALESCE');\n/** @since 0.1.0 @category expressions */\nexport const ifThenElse = op('IF');\n/** @since 0.1.0 @category expressions */\nexport const isIri = op('ISIRI');\n/** @since 0.1.0 @category expressions */\nexport const isBlank = op('ISBLANK');\n/** @since 0.1.0 @category expressions */\nexport const isLiteral = op('ISLITERAL');\n/** @since 0.1.0 @category expressions */\nexport const isNumeric = op('ISNUMERIC');\n/** @since 0.1.0 @category expressions */\nexport const sameTerm = op('SAMETERM');\n\n/**\n * `EXISTS { … }`\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const exists = (...patterns: ReadonlyArray<PatternInput>): Ast.Expression =>\n  Ast.exists(group(...patterns));\n\n/**\n * `NOT EXISTS { … }`\n *\n * @since 0.1.0\n * @category expressions\n */\nexport const notExists = (...patterns: ReadonlyArray<PatternInput>): Ast.Expression =>\n  Ast.exists(group(...patterns), true);\n\nconst aggregate =\n  (name: Ast.AggregateName) =>\n  (expression: ExpressionInput, options?: { readonly distinct?: boolean }): Ast.Expression =>\n    Ast.aggregate(name, toExpression(expression), options);\n\n/**\n * `COUNT(*)` (no argument) or `COUNT(expr)`.\n *\n * @since 0.1.0\n * @category aggregates\n */\nexport const count = (\n  expression?: ExpressionInput,\n  options?: { readonly distinct?: boolean },\n): Ast.Expression =>\n  Ast.aggregate('COUNT', expression === undefined ? '*' : toExpression(expression), options);\n/** @since 0.1.0 @category aggregates */\nexport const sum = aggregate('SUM');\n/** @since 0.1.0 @category aggregates */\nexport const avg = aggregate('AVG');\n/** @since 0.1.0 @category aggregates */\nexport const min = aggregate('MIN');\n/** @since 0.1.0 @category aggregates */\nexport const max = aggregate('MAX');\n/** @since 0.1.0 @category aggregates */\nexport const sample = aggregate('SAMPLE');\n\n/**\n * `GROUP_CONCAT(expr; SEPARATOR = sep)`\n *\n * @since 0.1.0\n * @category aggregates\n */\nexport const groupConcat = (\n  expression: ExpressionInput,\n  options?: { readonly distinct?: boolean; readonly separator?: string },\n): Ast.Expression => Ast.aggregate('GROUP_CONCAT', toExpression(expression), options);\n\n/**\n * A descending `ORDER BY` condition.\n *\n * @since 0.1.0\n * @category modifiers\n */\nexport const desc = (expression: ExpressionInput): Ast.OrderCondition => ({\n  expression: toExpression(expression),\n  descending: true,\n});\n\n/**\n * An ascending `ORDER BY` condition.\n *\n * @since 0.1.0\n * @category modifiers\n */\nexport const asc = (expression: ExpressionInput): Ast.OrderCondition => ({\n  expression: toExpression(expression),\n  descending: false,\n});\n\n// -----------------------------------------------------------------------------\n// Builders\n// -----------------------------------------------------------------------------\n\ntype Kind = Ast.Query['_tag'];\n\ntype QueryOf<K extends Kind> = Extract<Ast.Query, { readonly _tag: K }>;\n\n/**\n * An immutable query builder. `K` is the query form; `R` and `O` are the\n * required and optional variables of `SELECT` rows.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Builder<\n  K extends Kind,\n  R extends string = never,\n  O extends string = never,\n> implements Pipeable {\n  /** @internal */\n  readonly query: QueryOf<K>;\n  constructor(query: QueryOf<K>) {\n    this.query = query;\n  }\n\n  private with(\n    patch: Partial<Ast.QueryBase> & Partial<Pick<Ast.SelectQuery, 'distinct' | 'reduced'>>,\n  ): Builder<K, R, O> {\n    // SAFETY: patching fields of a query keeps its kind `K`; the spread only loses the\n    // discriminant's narrowing.\n    return new Builder({ ...this.query, ...patch } as QueryOf<K>);\n  }\n\n  private append(patterns: ReadonlyArray<Ast.Pattern>): Builder<K, R, O> {\n    return this.with({ where: group(this.query.where.patterns, patterns) });\n  }\n\n  /** Adds patterns to the `WHERE` clause. */\n  where(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O> {\n    return this.append(flatten(patterns));\n  }\n\n  /** Adds an `OPTIONAL { … }` block. */\n  optional(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O> {\n    return this.append([optional(...patterns)]);\n  }\n\n  /** Adds a `MINUS { … }` block. */\n  minus(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O> {\n    return this.append([minus(...patterns)]);\n  }\n\n  /** Adds a `UNION` of alternatives. */\n  union(...alternatives: ReadonlyArray<PatternInput>): Builder<K, R, O> {\n    return this.append([union(...alternatives)]);\n  }\n\n  /** Adds a `FILTER`. */\n  filter(expression: ExpressionInput): Builder<K, R, O> {\n    return this.append([filter(expression)]);\n  }\n\n  /** Adds a `BIND`. */\n  bind(expression: ExpressionInput, name: string | Term.Variable): Builder<K, R, O> {\n    return this.append([bind(expression, name)]);\n  }\n\n  /** Adds a `GRAPH` block. */\n  graph(name: Ast.VarOrIri, ...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O> {\n    return this.append([graph(name, ...patterns)]);\n  }\n\n  /** Adds inline data. */\n  values(rows: Parameters<typeof values>[0]): Builder<K, R, O> {\n    return this.append([values(rows)]);\n  }\n\n  /** Adds `GROUP BY` conditions (expressions or `as(expr, name)`). */\n  groupBy(\n    ...conditions: ReadonlyArray<ExpressionInput | Alias<string, boolean>>\n  ): Builder<K, R, O> {\n    return this.with({\n      groupBy: [\n        ...this.query.groupBy,\n        ...conditions.map((c): Ast.GroupCondition =>\n          isAlias(c)\n            ? { expression: c.expression, variable: Term.variable(c.name) }\n            : { expression: toExpression(c) },\n        ),\n      ],\n    });\n  }\n\n  /** Adds `HAVING` conditions. */\n  having(...conditions: ReadonlyArray<ExpressionInput>): Builder<K, R, O> {\n    return this.with({ having: [...this.query.having, ...conditions.map(toExpression)] });\n  }\n\n  /** Adds `ORDER BY` conditions (ascending unless wrapped with `desc`). */\n  orderBy(...conditions: ReadonlyArray<ExpressionInput | Ast.OrderCondition>): Builder<K, R, O> {\n    return this.with({\n      orderBy: [\n        ...this.query.orderBy,\n        ...conditions.map((c) => (isOrderCondition(c) ? c : asc(c))),\n      ],\n    });\n  }\n\n  /** Sets `LIMIT`. */\n  limit(limit: number): Builder<K, R, O> {\n    return this.with({ limit });\n  }\n\n  /** Sets `OFFSET`. */\n  offset(offset: number): Builder<K, R, O> {\n    return this.with({ offset });\n  }\n\n  /** Makes a `SELECT` query `DISTINCT`. */\n  distinct(): Builder<K, R, O> {\n    return this.with({ distinct: true, reduced: false });\n  }\n\n  /** Makes a `SELECT` query `REDUCED`. */\n  reduced(): Builder<K, R, O> {\n    return this.with({ reduced: true, distinct: false });\n  }\n\n  /** Adds `FROM` graphs. */\n  from(...graphs: ReadonlyArray<Term.NamedNode>): Builder<K, R, O> {\n    const d = this.query.dataset ?? { default: [], named: [] };\n    return this.with({ dataset: { default: [...d.default, ...graphs], named: d.named } });\n  }\n\n  /** Adds `FROM NAMED` graphs. */\n  fromNamed(...graphs: ReadonlyArray<Term.NamedNode>): Builder<K, R, O> {\n    const d = this.query.dataset ?? { default: [], named: [] };\n    return this.with({ dataset: { default: d.default, named: [...d.named, ...graphs] } });\n  }\n\n  /** Declares prefixes (used when printing). */\n  prefixes(prefixes: Readonly<Record<string, string>>): Builder<K, R, O> {\n    return this.with({\n      prologue: {\n        ...this.query.prologue,\n        prefixes: { ...this.query.prologue.prefixes, ...prefixes },\n      },\n    });\n  }\n\n  /** The query AST. */\n  build(): QueryOf<K> {\n    return this.query;\n  }\n\n  /** The query as SPARQL text. */\n  toString(): string {\n    return Generator.print(this.query);\n  }\n\n  pipe() {\n    return pipeArguments(this, arguments);\n  }\n}\n\nconst empty = Ast.group([]);\n\nconst projectionItem = (item: SelectItem): Term.Variable | Ast.Projection => {\n  if (Predicate.isString(item)) return Term.variable(item);\n  return Match.value(item).pipe(\n    Match.tag('Variable', (x): Term.Variable | Ast.Projection => x),\n    Match.tag('Maybe', (m) => Term.variable(m.name)),\n    Match.tag('Alias', (a) => Ast.projection(a.expression, Term.variable(a.name))),\n    Match.exhaustive,\n  );\n};\n\n/**\n * Starts a `SELECT` query. With no arguments, `SELECT *` (rows are then\n * untyped records).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const select = <const Items extends ReadonlyArray<SelectItem>>(\n  ...items: Items\n): Builder<'Select', RequiredOf<Items[number]>, OptionalOf<Items[number]>> =>\n  new Builder(\n    Ast.select({\n      where: empty,\n      projection: Arr.isReadonlyArrayEmpty(items) ? '*' : items.map(projectionItem),\n    }),\n  );\n\n/**\n * Starts an `ASK` query.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const ask = (): Builder<'Ask'> => new Builder(Ast.ask({ where: empty }));\n\n/**\n * Starts a `CONSTRUCT` query with a template.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const construct = (\n  ...template: ReadonlyArray<Ast.TriplePattern | Ast.PathPattern>\n): Builder<'Construct'> =>\n  new Builder(\n    Ast.construct({\n      where: empty,\n      template: template.filter((t): t is Ast.TriplePattern =>\n        Predicate.isTagged(t, 'TriplePattern'),\n      ),\n    }),\n  );\n\n/**\n * Starts a `DESCRIBE` query.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const describe = (...terms: ReadonlyArray<Ast.VarOrIri>): Builder<'Describe'> =>\n  new Builder(Ast.describe({ terms: Arr.isReadonlyArrayEmpty(terms) ? '*' : terms }));\n\n// -----------------------------------------------------------------------------\n// Execution\n// -----------------------------------------------------------------------------\n\n/**\n * Executes a `SELECT` builder, streaming typed rows.\n *\n * @since 0.1.0\n * @category execution\n */\nexport const execute = <R extends string, O extends string>(\n  builder: Builder<'Select', R, O>,\n  options?: Engine.RequestOptions,\n): Stream.Stream<Row<R, O>, Engine.SparqlError, Engine.SparqlEngine> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const engine = yield* Engine.SparqlEngine;\n      const result = yield* engine.select(builder.build(), options);\n      // SAFETY: the builder's type parameters track the projected variables, so a row has exactly\n      // `R` and optional `O` keys.\n      return Stream.map(result.bindings, (b) => B.toRecord(b) as Row<R, O>);\n    }),\n  );\n\n/**\n * Executes a `SELECT` builder and collects all rows.\n *\n * @since 0.1.0\n * @category execution\n */\nexport const executeAll = <R extends string, O extends string>(\n  builder: Builder<'Select', R, O>,\n  options?: Engine.RequestOptions,\n): Effect.Effect<ReadonlyArray<Row<R, O>>, Engine.SparqlError, Engine.SparqlEngine> =>\n  Stream.runCollect(execute(builder, options));\n\n/**\n * Executes a `SELECT` builder and decodes each row with a schema (whose\n * fields are typically `TermSchema` codecs).\n *\n * @since 0.1.0\n * @category execution\n */\nexport const decode = <R extends string, O extends string, A, RD>(\n  builder: Builder<'Select', R, O>,\n  schema: Schema.Decoder<A, RD>,\n  options?: Engine.RequestOptions,\n): Stream.Stream<A, Engine.SparqlError | Schema.SchemaError, Engine.SparqlEngine | RD> =>\n  Stream.mapEffect(execute(builder, options), (row) => Schema.decodeUnknownEffect(schema)(row));\n\n/**\n * Executes an `ASK` builder.\n *\n * @since 0.1.0\n * @category execution\n */\nexport const executeAsk = (\n  builder: Builder<'Ask'>,\n  options?: Engine.RequestOptions,\n): Effect.Effect<boolean, Engine.SparqlError, Engine.SparqlEngine> =>\n  Effect.flatMap(Effect.service(Engine.SparqlEngine), (engine) =>\n    engine.ask(builder.build(), options),\n  );\n\n/**\n * Executes a `CONSTRUCT` or `DESCRIBE` builder, streaming triples.\n *\n * @since 0.1.0\n * @category execution\n */\nexport const executeGraph = (\n  builder: Builder<'Construct'> | Builder<'Describe'>,\n  options?: Engine.RequestOptions,\n): Stream.Stream<Term.Quad, Engine.SparqlError, Engine.SparqlEngine> =>\n  Stream.unwrap(\n    Effect.flatMap(Effect.service(Engine.SparqlEngine), (engine) =>\n      engine.construct(builder.build(), options),\n    ),\n  );\n"],"mappings":"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"}

package/dist/QueryBuilder-DUqh4ECe.d.mts

@@ -0,0 +1,529 @@
+import { _ as Quad, d as NamedNode, j as Variable, s as GroundTerm } from "./Term-B_4ezyXq.mjs";
+import { D as MinusPattern, M as OrderCondition, N as Path, Q as TermPattern, U as Pattern, _ as Expression, at as VarOrIri, et as TriplePattern, it as ValuesPattern, j as OptionalPattern, o as BindPattern, q as Query, s as BuiltInName, tt as UnionPattern, v as FilterPattern, w as GroupPattern, x as GraphPattern, z as PathPattern } from "./Ast-vcw2W-lf.mjs";
+import { c as SparqlError, i as RequestOptions, o as SparqlEngine } from "./Engine-CYPB3g4h.mjs";
+import { Pipeable } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { Simplify } from "effect/Types";
+declare namespace QueryBuilder_d_exports {
+  export { Alias, AsAlias, Builder, ExpressionInput, JsValue, MaybeVariable, ObjectInput, PatternInput, Row, SelectItem, Variables, add, and, as, asc, ask, avg, bind, bound, call, coalesce, concat, construct, contains, count, datatype, decode, desc, describe, divide, eq, execute, executeAll, executeAsk, executeGraph, exists, filter, fn, ge, graph, group, groupConcat, gt, ifThenElse, iri, isBlank, isIn, isIri, isLiteral, isNumeric, lang, langMatches, lcase, le, lt, max, maybe, min, minus, multiply, ne, negate, not, notExists, notIn, optional, or, path, regex, replace, sameTerm, sample, select, str, strEnds, strStarts, strlen, substr, subtract, sum, toExpression, triple, ucase, union, v, values, variable, vars };
+}
+/**
+ * A JavaScript value usable as a literal.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type JsValue = string | number | bigint | boolean | Date;
+/**
+ * An expression, or a JS value (converted to a literal).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type ExpressionInput = Expression | JsValue;
+/**
+ * An object position input: a term pattern or a JS value (literal).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type ObjectInput = TermPattern | JsValue;
+/**
+ * Anything accepted as (part of) a group graph pattern.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type PatternInput = TriplePattern | PathPattern | Pattern | ReadonlyArray<PatternInput>;
+/**
+ * Converts a JS value to a literal (terms and expressions are returned
+ * unchanged).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const toExpression: (input: ExpressionInput) => Expression;
+/**
+ * Creates a variable.
+ *
+ * @since 0.1.0
+ * @category variables
+ */
+declare const variable: <const N extends string>(name: N) => Variable<N>;
+/**
+ * Variables by name, as `v` provides them.
+ *
+ * @since 0.1.0
+ * @category variables
+ */
+interface Variables {
+  readonly [name: string]: Variable;
+}
+/**
+ * A proxy creating variables by property access: `v.name` is `?name`.
+ *
+ * @since 0.1.0
+ * @category variables
+ */
+declare const v: Variables;
+/**
+ * Creates several variables at once, typed by name:
+ * `const { s, name } = vars('s', 'name')`.
+ *
+ * @since 0.1.0
+ * @category variables
+ */
+declare const vars: <const N extends ReadonlyArray<string>>(...names: N) => { readonly [K in N[number]]: Variable<K>; };
+/**
+ * The `as` constructor: an alias that is required unless marked optional.
+ *
+ * @since 0.1.0
+ * @category projection
+ */
+interface AsAlias {
+  <const N extends string>(expression: ExpressionInput, name: N): Alias<N>;
+  <const N extends string>(expression: ExpressionInput, name: N, options: {
+    readonly optional: true;
+  }): Alias<N, true>;
+}
+/**
+ * Marks a selected variable as possibly unbound (e.g. bound in an
+ * `OPTIONAL`): its row field becomes optional.
+ *
+ * @since 0.1.0
+ * @category projection
+ */
+interface MaybeVariable<N extends string> {
+  readonly _tag: 'Maybe';
+  readonly name: N;
+}
+/**
+ * @since 0.1.0
+ * @category projection
+ */
+declare const maybe: <const N extends string>(name: N) => MaybeVariable<N>;
+/**
+ * A projected expression `(expr AS ?name)`.
+ *
+ * @since 0.1.0
+ * @category projection
+ */
+interface Alias<N extends string, Optional extends boolean = false> {
+  readonly _tag: 'Alias';
+  readonly name: N;
+  readonly expression: Expression;
+  readonly optional: Optional;
+}
+/**
+ * Projects an expression as a variable. Pass `{ optional: true }` when the
+ * expression may fail (leaving the variable unbound).
+ *
+ * @since 0.1.0
+ * @category projection
+ */
+declare const as: AsAlias;
+/**
+ * An item of a `SELECT` list.
+ *
+ * @since 0.1.0
+ * @category projection
+ */
+type SelectItem = string | Variable | MaybeVariable<string> | Alias<string, boolean>;
+type RequiredOf<I> = I extends string ? I : I extends Variable<infer N> ? N : I extends Alias<infer N> ? N : never;
+type OptionalOf<I> = I extends MaybeVariable<infer N> ? N : I extends Alias<infer N, true> ? N : never;
+/**
+ * The row type of a `SELECT` query with required variables `R` and
+ * possibly-unbound variables `O`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Row<R extends string, O extends string> = Simplify<{ readonly [K in R]: GroundTerm; } & { readonly [K in O]?: GroundTerm | undefined; }>;
+/**
+ * A triple pattern. The predicate may be a property path; the object may be
+ * a JS value.
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const triple: (subject: TermPattern, predicate: VarOrIri | Path, object: ObjectInput) => TriplePattern | PathPattern;
+/**
+ * Property path constructors.
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const path: {
+  readonly link: (iri: NamedNode) => Path;
+  readonly inverse: (p: Path | NamedNode) => Path;
+  readonly sequence: (...ps: ReadonlyArray<Path | NamedNode>) => Path;
+  readonly alternative: (...ps: ReadonlyArray<Path | NamedNode>) => Path;
+  readonly zeroOrMore: (p: Path | NamedNode) => Path;
+  readonly oneOrMore: (p: Path | NamedNode) => Path;
+  readonly zeroOrOne: (p: Path | NamedNode) => Path;
+  readonly negated: (iris: ReadonlyArray<NamedNode>, inverse?: ReadonlyArray<NamedNode>) => Path;
+};
+/**
+ * A group graph pattern `{ … }`.
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const group: (...patterns: ReadonlyArray<PatternInput>) => GroupPattern;
+/**
+ * `OPTIONAL { … }`
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const optional: (...patterns: ReadonlyArray<PatternInput>) => OptionalPattern;
+/**
+ * `MINUS { … }`
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const minus: (...patterns: ReadonlyArray<PatternInput>) => MinusPattern;
+/**
+ * `{ … } UNION { … }`; each argument is one alternative.
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const union: (...alternatives: ReadonlyArray<PatternInput>) => UnionPattern;
+/**
+ * `GRAPH name { … }`
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const graph: (name: VarOrIri, ...patterns: ReadonlyArray<PatternInput>) => GraphPattern;
+/**
+ * `FILTER(expr)`
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const filter: (expression: ExpressionInput) => FilterPattern;
+/**
+ * `BIND(expr AS ?name)`
+ *
+ * @since 0.1.0
+ * @category patterns
+ */
+declare const bind: (expression: ExpressionInput, name: string | Variable) => BindPattern;
+/**
+ * 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
+ */
+declare const values: (rows: ReadonlyArray<Readonly<Record<string, GroundTerm | JsValue | undefined>>>) => ValuesPattern;
+/** @since 0.1.0 @category expressions */
+declare const eq: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const ne: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const lt: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const le: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const gt: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const ge: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const add: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const subtract: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const multiply: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const divide: (a: ExpressionInput, b: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const negate: (a: ExpressionInput) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const not: (a: ExpressionInput) => Expression;
+/**
+ * Logical conjunction of any number of conditions.
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const and: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * Logical disjunction of any number of conditions.
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const or: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * `expr IN (…)`
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const isIn: (expression: ExpressionInput, list: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * `expr NOT IN (…)`
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const notIn: (expression: ExpressionInput, list: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * Calls any built-in function by name, e.g. `fn('STRLEN', v.name)`.
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const fn: (name: BuiltInName, ...args: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * Calls an extension function (or XSD cast) by IRI.
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const call: (iri: NamedNode, ...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const bound: (variable: Variable) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const str: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const lang: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const langMatches: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const datatype: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const iri: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const regex: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const contains: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const strStarts: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const strEnds: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const strlen: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const ucase: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const lcase: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const concat: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const substr: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const replace: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const coalesce: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const ifThenElse: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const isIri: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const isBlank: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const isLiteral: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const isNumeric: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/** @since 0.1.0 @category expressions */
+declare const sameTerm: (...args: ReadonlyArray<ExpressionInput>) => Expression;
+/**
+ * `EXISTS { … }`
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const exists: (...patterns: ReadonlyArray<PatternInput>) => Expression;
+/**
+ * `NOT EXISTS { … }`
+ *
+ * @since 0.1.0
+ * @category expressions
+ */
+declare const notExists: (...patterns: ReadonlyArray<PatternInput>) => Expression;
+/**
+ * `COUNT(*)` (no argument) or `COUNT(expr)`.
+ *
+ * @since 0.1.0
+ * @category aggregates
+ */
+declare const count: (expression?: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/** @since 0.1.0 @category aggregates */
+declare const sum: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/** @since 0.1.0 @category aggregates */
+declare const avg: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/** @since 0.1.0 @category aggregates */
+declare const min: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/** @since 0.1.0 @category aggregates */
+declare const max: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/** @since 0.1.0 @category aggregates */
+declare const sample: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+}) => Expression;
+/**
+ * `GROUP_CONCAT(expr; SEPARATOR = sep)`
+ *
+ * @since 0.1.0
+ * @category aggregates
+ */
+declare const groupConcat: (expression: ExpressionInput, options?: {
+  readonly distinct?: boolean;
+  readonly separator?: string;
+}) => Expression;
+/**
+ * A descending `ORDER BY` condition.
+ *
+ * @since 0.1.0
+ * @category modifiers
+ */
+declare const desc: (expression: ExpressionInput) => OrderCondition;
+/**
+ * An ascending `ORDER BY` condition.
+ *
+ * @since 0.1.0
+ * @category modifiers
+ */
+declare const asc: (expression: ExpressionInput) => OrderCondition;
+type Kind = Query['_tag'];
+type QueryOf<K extends Kind> = Extract<Query, {
+  readonly _tag: K;
+}>;
+/**
+ * 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
+ */
+declare class Builder<K extends Kind, R extends string = never, O extends string = never> implements Pipeable {
+  /** @internal */
+  readonly query: QueryOf<K>;
+  constructor(query: QueryOf<K>);
+  private with;
+  private append;
+  /** Adds patterns to the `WHERE` clause. */
+  where(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O>;
+  /** Adds an `OPTIONAL { … }` block. */
+  optional(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O>;
+  /** Adds a `MINUS { … }` block. */
+  minus(...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O>;
+  /** Adds a `UNION` of alternatives. */
+  union(...alternatives: ReadonlyArray<PatternInput>): Builder<K, R, O>;
+  /** Adds a `FILTER`. */
+  filter(expression: ExpressionInput): Builder<K, R, O>;
+  /** Adds a `BIND`. */
+  bind(expression: ExpressionInput, name: string | Variable): Builder<K, R, O>;
+  /** Adds a `GRAPH` block. */
+  graph(name: VarOrIri, ...patterns: ReadonlyArray<PatternInput>): Builder<K, R, O>;
+  /** Adds inline data. */
+  values(rows: Parameters<typeof values>[0]): Builder<K, R, O>;
+  /** Adds `GROUP BY` conditions (expressions or `as(expr, name)`). */
+  groupBy(...conditions: ReadonlyArray<ExpressionInput | Alias<string, boolean>>): Builder<K, R, O>;
+  /** Adds `HAVING` conditions. */
+  having(...conditions: ReadonlyArray<ExpressionInput>): Builder<K, R, O>;
+  /** Adds `ORDER BY` conditions (ascending unless wrapped with `desc`). */
+  orderBy(...conditions: ReadonlyArray<ExpressionInput | OrderCondition>): Builder<K, R, O>;
+  /** Sets `LIMIT`. */
+  limit(limit: number): Builder<K, R, O>;
+  /** Sets `OFFSET`. */
+  offset(offset: number): Builder<K, R, O>;
+  /** Makes a `SELECT` query `DISTINCT`. */
+  distinct(): Builder<K, R, O>;
+  /** Makes a `SELECT` query `REDUCED`. */
+  reduced(): Builder<K, R, O>;
+  /** Adds `FROM` graphs. */
+  from(...graphs: ReadonlyArray<NamedNode>): Builder<K, R, O>;
+  /** Adds `FROM NAMED` graphs. */
+  fromNamed(...graphs: ReadonlyArray<NamedNode>): Builder<K, R, O>;
+  /** Declares prefixes (used when printing). */
+  prefixes(prefixes: Readonly<Record<string, string>>): Builder<K, R, O>;
+  /** The query AST. */
+  build(): QueryOf<K>;
+  /** The query as SPARQL text. */
+  toString(): string;
+  pipe(): unknown;
+}
+/**
+ * Starts a `SELECT` query. With no arguments, `SELECT *` (rows are then
+ * untyped records).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const select: <const Items extends ReadonlyArray<SelectItem>>(...items: Items) => Builder<"Select", RequiredOf<Items[number]>, OptionalOf<Items[number]>>;
+/**
+ * Starts an `ASK` query.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const ask: () => Builder<"Ask">;
+/**
+ * Starts a `CONSTRUCT` query with a template.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const construct: (...template: ReadonlyArray<TriplePattern | PathPattern>) => Builder<"Construct">;
+/**
+ * Starts a `DESCRIBE` query.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const describe: (...terms: ReadonlyArray<VarOrIri>) => Builder<"Describe">;
+/**
+ * Executes a `SELECT` builder, streaming typed rows.
+ *
+ * @since 0.1.0
+ * @category execution
+ */
+declare const execute: <R extends string, O extends string>(builder: Builder<"Select", R, O>, options?: RequestOptions) => Stream.Stream<Row<R, O>, SparqlError, SparqlEngine>;
+/**
+ * Executes a `SELECT` builder and collects all rows.
+ *
+ * @since 0.1.0
+ * @category execution
+ */
+declare const executeAll: <R extends string, O extends string>(builder: Builder<"Select", R, O>, options?: RequestOptions) => Effect.Effect<ReadonlyArray<Row<R, O>>, SparqlError, SparqlEngine>;
+/**
+ * Executes a `SELECT` builder and decodes each row with a schema (whose
+ * fields are typically `TermSchema` codecs).
+ *
+ * @since 0.1.0
+ * @category execution
+ */
+declare const decode: <R extends string, O extends string, A, RD>(builder: Builder<"Select", R, O>, schema: Schema.Decoder<A, RD>, options?: RequestOptions) => Stream.Stream<A, SparqlError | Schema.SchemaError, SparqlEngine | RD>;
+/**
+ * Executes an `ASK` builder.
+ *
+ * @since 0.1.0
+ * @category execution
+ */
+declare const executeAsk: (builder: Builder<"Ask">, options?: RequestOptions) => Effect.Effect<boolean, SparqlError, SparqlEngine>;
+/**
+ * Executes a `CONSTRUCT` or `DESCRIBE` builder, streaming triples.
+ *
+ * @since 0.1.0
+ * @category execution
+ */
+declare const executeGraph: (builder: Builder<"Construct"> | Builder<"Describe">, options?: RequestOptions) => Stream.Stream<Quad, SparqlError, SparqlEngine>;
+export { langMatches as $, describe as A, ucase as At, ge as B, concat as C, strStarts as Ct, datatype as D, sum as Dt, count as E, subtract as Et, executeAsk as F, vars as Ft, ifThenElse as G, group as H, executeGraph as I, isIn as J, iri as K, exists as L, eq as M, v as Mt, execute as N, values as Nt, decode as O, toExpression as Ot, executeAll as P, variable as Pt, lang as Q, filter as R, coalesce as S, strEnds as St, contains as T, substr as Tt, groupConcat as U, graph as V, gt as W, isLiteral as X, isIri as Y, isNumeric as Z, ask as _, replace as _t, JsValue as a, min as at, bound as b, select as bt, PatternInput as c, ne as ct, SelectItem as d, notExists as dt, lcase as et, Variables as f, notIn as ft, asc as g, regex as gt, as as h, path as ht, ExpressionInput as i, maybe as it, divide as j, union as jt, desc as k, triple as kt, QueryBuilder_d_exports as l, negate as lt, and as m, or as mt, AsAlias as n, lt as nt, MaybeVariable as o, minus as ot, add as p, optional as pt, isBlank as q, Builder as r, max as rt, ObjectInput as s, multiply as st, Alias as t, le as tt, Row as u, not as ut, avg as v, sameTerm as vt, construct as w, strlen as wt, call as x, str as xt, bind as y, sample as yt, fn as z };
+//# sourceMappingURL=QueryBuilder-DUqh4ECe.d.mts.map