@manta-eu/datalog-parser 0.1.0 → 0.1.2

package/README.md

@@ -1,10 +1,10 @@
 # @manta-eu/datalog-parser
 
-RDFox Datalog parser and AST builder with inference verification.
+Datalog parser and AST builder with inference verification.
 
 ## Features
 
-- **Complete Datalog Parser**: Parses RDFox Datalog rules into type-safe ASTs
+- **Complete Datalog Parser**: Parses Datalog rules into type-safe ASTs
 - **Syntax Validation**: Comprehensive rule validation with error reporting
 - **Built-in Function Support**: CONCAT, STR, IF, IRI, SKOLEM, ROUND, REGEX functions
 - **Advanced Constructs**: Support for FILTER, BIND, AGGREGATE, NOT EXIST patterns
@@ -31,13 +31,13 @@ const equivalent = areRulesEquivalent(rule1, rule2);
 ### Advanced Features
 
 ```typescript
-import { verifyRuleInference, transactionManager } from "@manta-eu/datalog-parser";
+import { verifyRuleInference, withTransaction } from "@manta-eu/datalog-parser";
 
-// Verify rule produces expected inferences
-await verifyRuleInference(rule, expectedFacts, rdfoxConfig);
+// Verify rule produces expected inferences against a running datastore
+await verifyRuleInference(rule, endpointUrl, datastoreId, authorization);
 
 // Manage transactions
-await transactionManager.withTransaction(async () => {
+await withTransaction({ endpointUrl, datastoreName, authorization }, async (connectionId) => {
   // Rule operations here
 });
 ```
@@ -53,5 +53,5 @@ import type { DatalogRule, DatalogAtom, DatalogBodyFormula } from "@manta-eu/dat
 - **Head Atoms**: Property atoms, class atoms, general atoms
 - **Body Formulas**: All atom types plus FILTER, BIND, AGGREGATE, SKOLEM, negation
 - **Expressions**: Binary operators, function calls, literals
-- **Built-in Functions**: Full RDFox function library
+- **Built-in Functions**: The full built-in function library
 - **Complex Patterns**: NOT EXIST clauses with mixed formulas

package/dist/index.d.ts

@@ -39,7 +39,7 @@ export declare type AggregateBinding = AggregateFunctionBinding | ExpressionAggr
 export declare type AggregateBindingTarget = {
     /** Target variable name without its `?`, or the value's text when `groundedTarget` is set. */
     variable: string;
-    /** Set only when the expanded grammar read a value in `AS` position, as RDFox's grounded rules do. */
+    /** Set only when the expanded grammar read a value in `AS` position, as the engine's grounded rules do. */
     groundedTarget?: DatalogTerm;
 };
 
@@ -172,7 +172,7 @@ export declare const BaseDatalogVisitor: new (...args: any[]) => ICstVisitor<any
 /**
  * Begin a read-write transaction on a connection
  */
-export declare function beginTransaction(params: RDFoxTransactionParams): Promise<void>;
+export declare function beginTransaction(params: DatastoreTransactionParams): Promise<void>;
 
 export declare type BinaryAggregateBinding = AggregateBindingTarget & {
     function: BinaryAggregateFunction;
@@ -254,6 +254,8 @@ export declare const booleanLiteralTokenTypes: Set<TokenType>;
 
 export declare const builtinFunctionTokenTypes: Set<TokenType>;
 
+export declare function canonicalRuleText(rule: string): string;
+
 export declare type ClassAssertion = {
     className: string;
     instance: DatalogTerm;
@@ -280,7 +282,7 @@ export declare const COMMENT: TokenType;
 /**
  * Commit a transaction on a connection
  */
-export declare function commitTransaction(params: RDFoxTransactionParams): Promise<void>;
+export declare function commitTransaction(params: DatastoreTransactionParams): Promise<void>;
 
 export declare type ComparisonOperator = Extract<BinaryExpression["operator"], "=" | "!=" | "<" | ">" | "<=" | ">=">;
 
@@ -327,7 +329,7 @@ export declare const COUNT_MIN: TokenType;
 /**
  * Create a connection to a datastore
  */
-export declare function createConnection(params: RDFoxConnectionParams): Promise<string>;
+export declare function createConnection(params: DatastoreConnectionParams): Promise<string>;
 
 export declare type DatalogAggregate = {
     type: "aggregate";
@@ -340,7 +342,7 @@ export declare type DatalogAggregate = {
      * variable name (`datalog-to-sparql-select`, `ast-utils`) — use authored/strict ASTs there.
      */
     onVars?: string[];
-    /** Set only when the expanded grammar read values in `ON` position, as RDFox's grounded rules do. */
+    /** Set only when the expanded grammar read values in `ON` position, as the engine's grounded rules do. */
     groundedOnTargets?: DatalogTerm[];
     bindings?: AggregateBinding[];
 };
@@ -417,7 +419,7 @@ export declare type DatalogBind = {
     expression: DatalogExpression;
     /** Target variable name without its `?`, or the value's text when `groundedTarget` is set. */
     variable: string;
-    /** Set only when the expanded grammar read a value in `AS` position, as RDFox's grounded rules do. */
+    /** Set only when the expanded grammar read a value in `AS` position, as the engine's grounded rules do. */
     groundedTarget?: DatalogTerm;
 };
 
@@ -544,6 +546,25 @@ export declare type DatalogToken = IToken;
 
 export declare type DataManipulationSubType = "insertdata" | "deletedata" | "modify";
 
+/**
+ * Transaction Management Library
+ *
+ * This module provides side-effecty functions for managing datastore connections and transactions
+ * via the RESTful API. It follows the engine's connection-based transaction model where transactions
+ * are associated with data store connections.
+ *
+ * @see https://docs.oxfordsemantic.tech/apis.html#transactions-in-the-restful-api
+ */
+export declare type DatastoreConnectionParams = {
+    endpointUrl: string;
+    datastoreName: string;
+    authorization: string;
+};
+
+export declare type DatastoreTransactionParams = DatastoreConnectionParams & {
+    connectionId: string;
+};
+
 export declare function datatypeToTermText(datatype: string): string;
 
 export declare const DECIMAL: TokenType;
@@ -570,7 +591,7 @@ export declare interface DefaultGraphAtomCstNode extends CstNode {
 /**
  * Delete a connection
  */
-export declare function deleteConnection(params: RDFoxTransactionParams): Promise<void>;
+export declare function deleteConnection(params: DatastoreTransactionParams): Promise<void>;
 
 export declare const delimiterTokenTypes: Set<TokenType>;
 
@@ -599,7 +620,7 @@ export declare interface ExistsClauseCstNode extends CstNode {
 }
 
 /**
- * Grammar variant for the grounded rules RDFox returns.
+ * Grammar variant for the grounded rules the engine returns.
  *
  * Grounding substitutes an `AS` target with the value it computed, so
  * `BIND(?spend > 500 AS ?highSpend)` comes back as `BIND(901.22 > 500 AS true)`.
@@ -1113,7 +1134,7 @@ export declare function parseDatalogRuleWithIssues(ruleText: string): DatalogPar
 export declare function parseDatalogTermText(termText: string): DatalogTerm | undefined;
 
 /**
- * Parse a grounded rule returned by RDFox, where `AS` targets have been
+ * Parse a grounded rule returned by the engine, where `AS` targets have been
  * substituted with the values they evaluated to. Authored rules must go through
  * `parseDatalogRule` so that those substitutions stay invalid.
  */
@@ -1184,25 +1205,6 @@ export declare type PropertyAtom = {
 
 export declare const RBRACKET: TokenType;
 
-/**
- * RDFox Transaction Management Library
- *
- * This module provides side-effecty functions for managing RDFox connections and transactions
- * via the RESTful API. It follows RDFox's connection-based transaction model where transactions
- * are associated with data store connections.
- *
- * @see https://docs.oxfordsemantic.tech/apis.html#transactions-in-the-restful-api
- */
-export declare type RDFoxConnectionParams = {
-    rdfoxUrl: string;
-    datastoreName: string;
-    authorization: string;
-};
-
-export declare type RDFoxTransactionParams = RDFoxConnectionParams & {
-    connectionId: string;
-};
-
 export declare const REGEX: TokenType;
 
 export declare type RegexFunctionCstChildren = {
@@ -1250,7 +1252,7 @@ export declare function resolveVariableTypes(evidence: VariableTypeEvidence[], l
 /**
  * Rollback a transaction on a connection
  */
-export declare function rollbackTransaction(params: RDFoxTransactionParams): Promise<void>;
+export declare function rollbackTransaction(params: DatastoreTransactionParams): Promise<void>;
 
 export declare const ROUND: TokenType;
 
@@ -1571,7 +1573,7 @@ export declare type VariableTypeSource = "class" | PredicatePosition;
 /**
  * Verify that a rule produces the expected inference
  */
-export declare function verifyRuleInference(rule: DatalogRule, rdfoxUrl: string, datastoreId: string, authorization: string, testTriple?: {
+export declare function verifyRuleInference(rule: DatalogRule, endpointUrl: string, datastoreId: string, authorization: string, testTriple?: {
     subject: string;
     predicate: string;
     object: string;
@@ -1582,7 +1584,7 @@ export declare const WHITESPACE: TokenType;
 /**
  * Execute a function within a transaction context, automatically handling commit/rollback
  */
-export declare function withTransaction<T>(params: RDFoxConnectionParams, fn: (connectionId: string) => Promise<T>): Promise<T>;
+export declare function withTransaction<T>(params: DatastoreConnectionParams, fn: (connectionId: string) => Promise<T>): Promise<T>;
 
 export declare type XsdDatatypeLocalName = keyof typeof xsdDatatypes;
 

package/dist/index.js

@@ -8,17 +8,17 @@ import { sparql11GeneratorBuilder as Mt } from "@traqula/generator-sparql-1-1";
 import { AstFactory as vr, lex as ze, completeGeneratorContext as Cr, gram as n, MinimalSparqlParser as Ir, sparqlCodepointEscape as Mr } from "@traqula/rules-sparql-1-1";
 import { createToken as c, Lexer as Bt, CstParser as Br, EOF as Fr } from "chevrotain";
 import { z as q } from "zod";
-const Mn = (e) => p(e).with({ type: "triple" }, () => !0).otherwise(() => !1), Bn = (e) => p(e).with({ type: "property" }, () => !0).otherwise(() => !1), Fn = (e) => p(e).with({ type: "class" }, () => !0).otherwise(() => !1), Pn = (e) => p(e).with({ type: "general" }, () => !0).otherwise(() => !1), I = (e) => p(e).with({ type: "variable" }, () => !0).otherwise(() => !1), kn = (e) => p(e).with({ type: "iri" }, () => !0).otherwise(() => !1), tt = (e) => p(e).with({ type: "literal" }, () => !0).otherwise(() => !1), Dn = (e) => p(e).with({ type: "blank" }, () => !0).otherwise(() => !1), $n = (e) => p(e).with({ type: "negation" }, () => !0).otherwise(() => !1), Gn = (e) => p(e).with({ type: "filter" }, () => !0).otherwise(() => !1), _n = (e) => p(e).with({ type: "bind" }, () => !0).otherwise(() => !1), Vn = (e) => p(e).with({ type: "aggregate" }, () => !0).otherwise(() => !1), jn = (e) => p(e).with({ type: "skolem" }, () => !0).otherwise(() => !1), qn = (e) => p(e).with({ type: "binary" }, () => !0).otherwise(() => !1), Xn = (e) => p(e).with({ type: "unary" }, () => !0).otherwise(() => !1), Hn = (e) => p(e).with({ type: "term" }, () => !0).otherwise(() => !1), Qn = (e) => p(e).with({ type: "function" }, () => !0).otherwise(() => !1), zn = (e) => p(e).with({ type: "triple" }, () => "triple").with({ type: "property" }, () => "property").with({ type: "class" }, () => "class").with({ type: "general" }, () => "general").exhaustive(), Kn = (e) => p(e).with({ type: "variable" }, () => "variable").with({ type: "iri" }, () => "iri").with({ type: "literal" }, () => "literal").with({ type: "blank" }, () => "blank").exhaustive(), Wn = (e) => p(e).with({ type: "binary" }, () => "binary").with({ type: "unary" }, () => "unary").with({ type: "term" }, () => "term").with({ type: "function" }, () => "function").with({ type: "in" }, () => "in").exhaustive(), Pr = (e) => p(e).with({ type: "triple" }, (t) => [t.subject, t.predicate, t.object].filter(I)).with({ type: "property" }, (t) => [t.subject, t.object].filter(I)).with({ type: "class" }, (t) => [t.instance].filter(I)).with({ type: "general" }, (t) => t.terms.filter(I)).exhaustive(), kr = (e) => {
+const Mn = (e) => p(e).with({ type: "triple" }, () => !0).otherwise(() => !1), Bn = (e) => p(e).with({ type: "property" }, () => !0).otherwise(() => !1), Fn = (e) => p(e).with({ type: "class" }, () => !0).otherwise(() => !1), Pn = (e) => p(e).with({ type: "general" }, () => !0).otherwise(() => !1), I = (e) => p(e).with({ type: "variable" }, () => !0).otherwise(() => !1), kn = (e) => p(e).with({ type: "iri" }, () => !0).otherwise(() => !1), tt = (e) => p(e).with({ type: "literal" }, () => !0).otherwise(() => !1), $n = (e) => p(e).with({ type: "blank" }, () => !0).otherwise(() => !1), Dn = (e) => p(e).with({ type: "negation" }, () => !0).otherwise(() => !1), Gn = (e) => p(e).with({ type: "filter" }, () => !0).otherwise(() => !1), _n = (e) => p(e).with({ type: "bind" }, () => !0).otherwise(() => !1), Vn = (e) => p(e).with({ type: "aggregate" }, () => !0).otherwise(() => !1), jn = (e) => p(e).with({ type: "skolem" }, () => !0).otherwise(() => !1), qn = (e) => p(e).with({ type: "binary" }, () => !0).otherwise(() => !1), Xn = (e) => p(e).with({ type: "unary" }, () => !0).otherwise(() => !1), Hn = (e) => p(e).with({ type: "term" }, () => !0).otherwise(() => !1), Qn = (e) => p(e).with({ type: "function" }, () => !0).otherwise(() => !1), zn = (e) => p(e).with({ type: "triple" }, () => "triple").with({ type: "property" }, () => "property").with({ type: "class" }, () => "class").with({ type: "general" }, () => "general").exhaustive(), Kn = (e) => p(e).with({ type: "variable" }, () => "variable").with({ type: "iri" }, () => "iri").with({ type: "literal" }, () => "literal").with({ type: "blank" }, () => "blank").exhaustive(), Wn = (e) => p(e).with({ type: "binary" }, () => "binary").with({ type: "unary" }, () => "unary").with({ type: "term" }, () => "term").with({ type: "function" }, () => "function").with({ type: "in" }, () => "in").exhaustive(), Pr = (e) => p(e).with({ type: "triple" }, (t) => [t.subject, t.predicate, t.object].filter(I)).with({ type: "property" }, (t) => [t.subject, t.object].filter(I)).with({ type: "class" }, (t) => [t.instance].filter(I)).with({ type: "general" }, (t) => t.terms.filter(I)).exhaustive(), kr = (e) => {
   const t = Pr(e), r = "graph" in e ? e.graph : void 0;
   return r && I(r) ? [...t, r] : t;
-}, Yn = (e) => e.function, Zn = (e) => p(e).with(u.union("+", "-", "*", "/", "<", ">", "<=", ">="), () => !0).with(u.union("=", "!=", "||", "&&"), () => !1).exhaustive(), Jn = (e) => p(e).with(u.union("||", "&&", "=", "!=", "<", ">", "<=", ">="), () => !0).with(u.union("+", "-", "*", "/"), () => !1).exhaustive(), Ke = '[^\\s<>"{}|^`\\\\]', Dr = new RegExp(`^[a-z][a-z0-9+.-]*:${Ke}*$`, "i");
+}, Yn = (e) => e.function, Zn = (e) => p(e).with(u.union("+", "-", "*", "/", "<", ">", "<=", ">="), () => !0).with(u.union("=", "!=", "||", "&&"), () => !1).exhaustive(), Jn = (e) => p(e).with(u.union("||", "&&", "=", "!=", "<", ">", "<=", ">="), () => !0).with(u.union("+", "-", "*", "/"), () => !1).exhaustive(), Ke = '[^\\s<>"{}|^`\\\\]', $r = new RegExp(`^[a-z][a-z0-9+.-]*:${Ke}*$`, "i");
 function ts(e) {
-  return Dr.test(e);
+  return $r.test(e);
 }
 function We(e) {
   return e.includes("://");
 }
-const $r = /^(true|false)$/i, Gr = /^"(true|false)"\^\^<?\S*boolean>?$/i, St = "[eE][+-]?\\d+", _r = new RegExp(
+const Dr = /^(true|false)$/i, Gr = /^"(true|false)"\^\^<?\S*boolean>?$/i, St = "[eE][+-]?\\d+", _r = new RegExp(
   `^[+-]?(?:\\d+\\.\\d*(?:${St})|\\d+\\.\\d+|\\.\\d+(?:${St})?|\\d+(?:${St})?)$`
 );
 function Rt(e) {
@@ -37,7 +37,7 @@ function Xr(e) {
   return h === "0" || r === "+" ? h : `${r}${h}`;
 }
 function es(e) {
-  if ($r.test(e)) return e.toLowerCase() === "true";
+  if (Dr.test(e)) return e.toLowerCase() === "true";
   const t = e.match(Gr);
   if (t != null && t[1]) return t[1].toLowerCase() === "true";
 }
@@ -338,7 +338,7 @@ function H(e, t = {}) {
     ...ke(r.right, r.operator, "right", t)
   ]).with({ type: "unary" }, (r) => [C(r.operator), ...ii(r.operand, t)]).with({ type: "term" }, (r) => ni(r.term, t)).with({ type: "function" }, (r) => [
     C(`${r.name}(`),
-    ...De(
+    ...$e(
       r.args.map((i) => H(i, t)),
       ", "
     ),
@@ -346,7 +346,7 @@ function H(e, t = {}) {
   ]).with({ type: "in" }, (r) => [
     ...H(r.expression, t),
     C(` ${r.negated ? "NOT IN" : "IN"} (`),
-    ...De(
+    ...$e(
       r.list.map((i) => H(i, t)),
       ", "
     ),
@@ -375,7 +375,7 @@ function ni(e, t) {
 function ir(e) {
   return [C("("), ...e, C(")")];
 }
-function De(e, t) {
+function $e(e, t) {
   return e.flatMap((r, i) => i === 0 ? r : [C(t), ...r]);
 }
 function si(e) {
@@ -403,17 +403,15 @@ function Ct(e) {
     ({ groundedOnTargets: t, bindings: r, atoms: i }) => t !== void 0 || ((r == null ? void 0 : r.some((s) => s.groundedTarget !== void 0)) ?? !1) || i.some(Ct)
   ).with({ type: "negation" }, ({ formulas: t }) => t.some(Ct)).with({ type: u.union("triple", "property", "class", "general", "filter", "skolem") }, () => !1).exhaustive();
 }
-const g = new vr(), m = g.gen(), $e = Mt.getRule("aggregate"), Ge = Mt.getRule("expression"), ui = {
-  ...$e,
+const g = new vr(), m = g.gen(), De = Mt.getRule("aggregate"), Ge = Mt.getRule("expression"), ui = {
+  ...De,
   gImpl: (e) => (t, r) => {
     const i = t.secondExpression;
     if (!i)
-      return $e.gImpl(e)(t, r);
+      return De.gImpl(e)(t, r);
     const { PRINT_WORD: s, SUBRULE: a } = e, o = t.expression[0], l = r.astFactory;
     if (l.isWildcard(o))
-      throw new Error(
-        `RDFox aggregate ${t.aggregation.toUpperCase()} cannot combine * with a second expression.`
-      );
+      throw new Error(`Aggregate ${t.aggregation.toUpperCase()} cannot combine * with a second expression.`);
     l.printFilter(t, () => {
       s(t.aggregation.toUpperCase(), "("), t.distinct && s("DISTINCT");
     }), a(Ge, o), l.printFilter(t, () => s(",")), a(Ge, i), l.printFilter(t, () => s(")"));
@@ -424,7 +422,7 @@ const g = new vr(), m = g.gen(), $e = Mt.getRule("aggregate"), Ge = Mt.getRule("
     return [t.LABEL.toLowerCase(), t.LABEL];
   })
 );
-function $(e) {
+function D(e) {
   if (e.includes("://") || e.startsWith("urn:") || e.startsWith("mailto:") || e.startsWith("tel:") || e.startsWith("data:"))
     return g.termNamed(m, e);
   const r = e.indexOf(":");
@@ -436,11 +434,11 @@ function ot(e, t) {
 function di(e, t) {
   const { function: r, expression: i, secondExpression: s } = e, a = pi.has(r), o = s !== void 0;
   if (a && s == null)
-    throw new Error(`RDFox aggregate ${r} requires two expressions.`);
+    throw new Error(`Aggregate ${r} requires two expressions.`);
   if (a && i === "*")
-    throw new Error(`RDFox aggregate ${r} cannot use * as an expression.`);
+    throw new Error(`Aggregate ${r} cannot use * as an expression.`);
   if (!a && o)
-    throw new Error(`RDFox aggregate ${r} accepts only one expression.`);
+    throw new Error(`Aggregate ${r} accepts only one expression.`);
   const l = i === "*" ? g.wildcard(m) : O(i, t), E = g.aggregate(
     r.toLowerCase(),
     e.distinct || !1,
@@ -453,7 +451,7 @@ function di(e, t) {
     secondExpression: O(s, t)
   } : E;
 }
-function D(e, t, r = void 0) {
+function $(e, t, r = void 0) {
   return p(r).with("predicate", () => {
     if (e.type !== "variable" && e.type !== "iri")
       throw new Error(`Invalid predicate term: ${e.type}. RDF predicates cannot be ${e.type} nodes.`);
@@ -464,11 +462,11 @@ function D(e, t, r = void 0) {
     if (e.type !== "variable" && e.type !== "iri")
       throw new Error(`Invalid graph name term: ${e.type}. Graph names can only be variables or IRIs.`);
   }).with(u.nullish, () => {
-  }).exhaustive(), r === "predicate" && e.type === "iri" && e.value === "a" ? $("rdf:type") : p(e).with({ type: "variable" }, (i) => (t.add(i.name), g.termVariable(i.name, m))).with({ type: "iri", prefixed: !0 }, (i) => $(i.value)).with({ type: "iri", prefixed: !1 }, (i) => g.termNamed(m, i.value)).with(
+  }).exhaustive(), r === "predicate" && e.type === "iri" && e.value === "a" ? D("rdf:type") : p(e).with({ type: "variable" }, (i) => (t.add(i.name), g.termVariable(i.name, m))).with({ type: "iri", prefixed: !0 }, (i) => D(i.value)).with({ type: "iri", prefixed: !1 }, (i) => g.termNamed(m, i.value)).with(
     { type: "literal", language: u.string },
     (i) => g.termLiteral(m, i.value, i.language)
   ).with({ type: "literal", datatype: u.string }, (i) => {
-    const s = $(i.datatype);
+    const s = D(i.datatype);
     return g.termLiteral(m, i.value, s);
   }).with({ type: "literal" }, (i) => g.termLiteral(m, i.value)).with({ type: "blank" }, (i) => g.termBlank(i.label, m)).exhaustive();
 }
@@ -476,7 +474,7 @@ function Ei(e, t) {
   const r = e.args.map((a) => O(a, t)), i = hi.get(e.name.toLowerCase());
   if (i)
     return ot(i.toLowerCase(), r);
-  const s = $(e.name);
+  const s = D(e.name);
   return g.expressionFunctionCall(s, r, !1, m);
 }
 function O(e, t) {
@@ -489,7 +487,7 @@ function O(e, t) {
   ).with(
     { type: "unary" },
     (r) => ot(r.operator, [O(r.operand, t)])
-  ).with({ type: "term" }, (r) => D(r.term, t, "expression")).with({ type: "function" }, (r) => Ei(r, t)).with(
+  ).with({ type: "term" }, (r) => $(r.term, t, "expression")).with({ type: "function" }, (r) => Ei(r, t)).with(
     { type: "in" },
     (r) => ot(r.negated ? "notin" : "in", [
       O(r.expression, t),
@@ -501,16 +499,16 @@ function Pt(e, t) {
   const r = p(e).with(
     { type: "triple" },
     (i) => g.triple(
-      D(i.subject, t),
-      D(i.predicate, t, "predicate"),
-      D(i.object, t)
+      $(i.subject, t),
+      $(i.predicate, t, "predicate"),
+      $(i.object, t)
     )
   ).with({ type: "property" }, (i) => {
-    const s = $(i.predicate);
-    return g.triple(D(i.subject, t), s, D(i.object, t));
+    const s = D(i.predicate);
+    return g.triple($(i.subject, t), s, $(i.object, t));
   }).with({ type: "class" }, (i) => {
-    const s = $("rdf:type"), a = $(i.className);
-    return g.triple(D(i.instance, t), s, a);
+    const s = D("rdf:type"), a = D(i.className);
+    return g.triple($(i.instance, t), s, a);
   }).with({ type: "general" }, () => {
     throw new Error("General formulas are not supported as triple patterns.");
   }).exhaustive();
@@ -518,7 +516,7 @@ function Pt(e, t) {
   if ("graph" in e && e.graph) {
     const i = g.patternBgp([r], m);
     return { graph: g.patternGraph(
-      D(e.graph, t, "graph"),
+      $(e.graph, t, "graph"),
       [i],
       m
     ) };
@@ -555,7 +553,7 @@ function mi(e, t) {
   const { triples: r, filters: i, binds: s, graphPatterns: a } = gi(e.atoms, t), o = e.onVars || [], l = o.map((h) => (t.add(h), g.termVariable(h, m))), E = [], y = [];
   return (S = e.bindings) == null || S.forEach((h) => {
     if (t.add(h.variable), h.expression === void 0) {
-      const W = h.function !== void 0 ? `RDFox aggregate ${h.function}` : "Expression-only aggregate binding";
+      const W = h.function !== void 0 ? `Aggregate ${h.function}` : "Expression-only aggregate binding";
       throw new Error(`${W} requires an expression.`);
     }
     if (h.function === void 0 && h.secondExpression !== void 0)
@@ -643,7 +641,7 @@ function yi(e, t) {
     variables: S
   };
 }
-const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", pattern: /NOT/ }), Dt = c({ name: "EXISTS", pattern: /EXISTS?/ }), Z = c({ name: "IN", pattern: /IN/ }), $t = c({ name: "FILTER", pattern: /FILTER/ }), z = c({ name: "BIND", pattern: /BIND/ }), K = c({ name: "AS", pattern: /AS/ }), wt = c({ name: "AGGREGATE", pattern: /AGGREGATE/ }), At = c({ name: "ON", pattern: /ON/ }), Gt = c({ name: "COUNT", pattern: /COUNT/ }), _t = c({ name: "MIN", pattern: /MIN/ }), Vt = c({ name: "MAX", pattern: /MAX/ }), jt = c({ name: "SUM", pattern: /SUM/ }), qt = c({ name: "MUL", pattern: /MUL/ }), Xt = c({ name: "AVG", pattern: /AVG/ }), Ht = c({ name: "COUNT_MIN", pattern: /COUNT_MIN/ }), Qt = c({ name: "COUNT_MAX", pattern: /COUNT_MAX/ }), zt = c({ name: "MIN_ARGMIN", pattern: /MIN_ARGMIN/ }), Kt = c({ name: "MAX_ARGMIN", pattern: /MAX_ARGMIN/ }), Wt = c({ name: "MIN_ARGMAX", pattern: /MIN_ARGMAX/ }), Yt = c({ name: "MAX_ARGMAX", pattern: /MAX_ARGMAX/ }), ut = c({ name: "DISTINCT", pattern: /DISTINCT/ }), Zt = c({ name: "CONCAT", pattern: /CONCAT/ }), Jt = c({ name: "STR", pattern: /STR/ }), te = c({ name: "IF", pattern: /IF/ }), ee = c({ name: "IRI", pattern: /IRI/ }), ct = c({ name: "SKOLEM", pattern: /SKOLEM/ }), re = c({ name: "ROUND", pattern: /ROUND/ }), ie = c({ name: "REGEX", pattern: /REGEX/ }), ne = c({ name: "TRUE", pattern: /true/ }), se = c({ name: "FALSE", pattern: /false/ }), ae = c({ name: "EQUALS", pattern: /=/ }), oe = c({ name: "NOT_EQUALS", pattern: /!=/ }), le = c({ name: "LESS_THAN", pattern: /</ }), ue = c({ name: "LESS_THAN_OR_EQUAL", pattern: /<=/ }), ce = c({ name: "GREATER_THAN", pattern: />/ }), pe = c({ name: "GREATER_THAN_OR_EQUAL", pattern: />=/ }), he = c({ name: "AND", pattern: /&&/ }), de = c({ name: "OR", pattern: /\|\|/ }), pt = c({ name: "PLUS", pattern: /\+/ }), ht = c({ name: "MINUS", pattern: /-/ }), dt = c({ name: "STAR", pattern: /\*/ }), Ee = c({ name: "SLASH", pattern: /\// }), fe = c({ name: "EXCLAMATION", pattern: /!/ }), ge = c({ name: "DOT", pattern: /\./ }), N = c({ name: "COMMA", pattern: /,/ }), U = c({ name: "LPAREN", pattern: /\(/ }), w = c({ name: "RPAREN", pattern: /\)/ }), Et = c({ name: "LBRACKET", pattern: /\[/ }), ft = c({ name: "RBRACKET", pattern: /\]/ }), sr = c({ name: "AT", pattern: /@/ }), gt = c({ name: "HAT", pattern: /\^/ }), ar = c({ name: "COLON", pattern: /:/ }), b = c({ name: "VARIABLE", pattern: /\?[a-zA-Z_][a-zA-Z0-9_]*/ }), me = c({ name: "IRI_REF", pattern: new RegExp(`<${Ke}*>`) }), ye = c({ name: "INTERNAL_FUNCTION", pattern: /<internal:[^>]+>/ }), et = c({ name: "BLANK_NODE", pattern: /_:[\w](?:[\w.-]*[\w-])?/ }), Le = "%[0-9a-fA-F]{2}|\\\\[-_~.!$&'()*+,;=/?#@%]", Li = `(?:[\\w:]|${Le})`, Ui = `(?:[\\w:.-]|${Le})`, wi = `(?:[\\w:-]|${Le})`, or = `${Li}(?:${Ui}*${wi})?`, st = c({
+const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", pattern: /NOT/ }), $t = c({ name: "EXISTS", pattern: /EXISTS?/ }), Z = c({ name: "IN", pattern: /IN/ }), Dt = c({ name: "FILTER", pattern: /FILTER/ }), z = c({ name: "BIND", pattern: /BIND/ }), K = c({ name: "AS", pattern: /AS/ }), wt = c({ name: "AGGREGATE", pattern: /AGGREGATE/ }), At = c({ name: "ON", pattern: /ON/ }), Gt = c({ name: "COUNT", pattern: /COUNT/ }), _t = c({ name: "MIN", pattern: /MIN/ }), Vt = c({ name: "MAX", pattern: /MAX/ }), jt = c({ name: "SUM", pattern: /SUM/ }), qt = c({ name: "MUL", pattern: /MUL/ }), Xt = c({ name: "AVG", pattern: /AVG/ }), Ht = c({ name: "COUNT_MIN", pattern: /COUNT_MIN/ }), Qt = c({ name: "COUNT_MAX", pattern: /COUNT_MAX/ }), zt = c({ name: "MIN_ARGMIN", pattern: /MIN_ARGMIN/ }), Kt = c({ name: "MAX_ARGMIN", pattern: /MAX_ARGMIN/ }), Wt = c({ name: "MIN_ARGMAX", pattern: /MIN_ARGMAX/ }), Yt = c({ name: "MAX_ARGMAX", pattern: /MAX_ARGMAX/ }), ut = c({ name: "DISTINCT", pattern: /DISTINCT/ }), Zt = c({ name: "CONCAT", pattern: /CONCAT/ }), Jt = c({ name: "STR", pattern: /STR/ }), te = c({ name: "IF", pattern: /IF/ }), ee = c({ name: "IRI", pattern: /IRI/ }), ct = c({ name: "SKOLEM", pattern: /SKOLEM/ }), re = c({ name: "ROUND", pattern: /ROUND/ }), ie = c({ name: "REGEX", pattern: /REGEX/ }), ne = c({ name: "TRUE", pattern: /true/ }), se = c({ name: "FALSE", pattern: /false/ }), ae = c({ name: "EQUALS", pattern: /=/ }), oe = c({ name: "NOT_EQUALS", pattern: /!=/ }), le = c({ name: "LESS_THAN", pattern: /</ }), ue = c({ name: "LESS_THAN_OR_EQUAL", pattern: /<=/ }), ce = c({ name: "GREATER_THAN", pattern: />/ }), pe = c({ name: "GREATER_THAN_OR_EQUAL", pattern: />=/ }), he = c({ name: "AND", pattern: /&&/ }), de = c({ name: "OR", pattern: /\|\|/ }), pt = c({ name: "PLUS", pattern: /\+/ }), ht = c({ name: "MINUS", pattern: /-/ }), dt = c({ name: "STAR", pattern: /\*/ }), Ee = c({ name: "SLASH", pattern: /\// }), fe = c({ name: "EXCLAMATION", pattern: /!/ }), ge = c({ name: "DOT", pattern: /\./ }), N = c({ name: "COMMA", pattern: /,/ }), U = c({ name: "LPAREN", pattern: /\(/ }), w = c({ name: "RPAREN", pattern: /\)/ }), Et = c({ name: "LBRACKET", pattern: /\[/ }), ft = c({ name: "RBRACKET", pattern: /\]/ }), sr = c({ name: "AT", pattern: /@/ }), gt = c({ name: "HAT", pattern: /\^/ }), ar = c({ name: "COLON", pattern: /:/ }), b = c({ name: "VARIABLE", pattern: /\?[a-zA-Z_][a-zA-Z0-9_]*/ }), me = c({ name: "IRI_REF", pattern: new RegExp(`<${Ke}*>`) }), ye = c({ name: "INTERNAL_FUNCTION", pattern: /<internal:[^>]+>/ }), et = c({ name: "BLANK_NODE", pattern: /_:[\w](?:[\w.-]*[\w-])?/ }), Le = "%[0-9a-fA-F]{2}|\\\\[-_~.!$&'()*+,;=/?#@%]", Li = `(?:[\\w:]|${Le})`, Ui = `(?:[\\w:.-]|${Le})`, wi = `(?:[\\w:-]|${Le})`, or = `${Li}(?:${Ui}*${wi})?`, st = c({
   name: "PREFIXED_NAME",
   pattern: new RegExp(`[a-zA-Z_][\\w]*:${or}`)
 }), Tt = c({ name: "PREFIX_ONLY", pattern: /[a-zA-Z_][\w]*:/ }), Ue = c({
@@ -684,9 +682,9 @@ const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", patte
   gt,
   // Keywords (before identifiers)
   lt,
-  Dt,
-  Z,
   $t,
+  Z,
+  Dt,
   z,
   K,
   wt,
@@ -746,7 +744,7 @@ const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", patte
   ft,
   sr,
   ar
-], Si = /* @__PURE__ */ new Set([lt, Dt, Z, $t, z, K, wt, At, ut]), Ni = /* @__PURE__ */ new Set([
+], Si = /* @__PURE__ */ new Set([lt, $t, Z, Dt, z, K, wt, At, ut]), Ni = /* @__PURE__ */ new Set([
   Gt,
   _t,
   Vt,
@@ -977,7 +975,7 @@ class xe extends Br {
     }));
     // ExistsClause := 'EXISTS' variable (',' variable)* 'IN'
     d(this, "existsClause", this.RULE("existsClause", () => {
-      this.CONSUME(Dt), this.CONSUME(b), this.MANY(() => {
+      this.CONSUME($t), this.CONSUME(b), this.MANY(() => {
         this.CONSUME(N), this.CONSUME2(b);
       }), this.CONSUME(Z);
     }));
@@ -1003,7 +1001,7 @@ class xe extends Br {
     }));
     // FilterAtom := 'FILTER' '(' Expression ')'
     d(this, "filterAtom", this.RULE("filterAtom", () => {
-      this.CONSUME($t), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
+      this.CONSUME(Dt), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
     }));
     // BindAtom := 'BIND' '(' Expression 'AS' variable ')'
     d(this, "bindAtom", this.RULE("bindAtom", () => {
@@ -1266,7 +1264,7 @@ class vi extends xe {
       this.CONSUME(z), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(K), this.variableOrGroundedTarget(), this.CONSUME(w);
     }));
     // Aggregate := 'AGGREGATE' '(' AtomList? OnClause? AggregateBind* ')'
-    // atomList is optional so RDFox-emitted atom-free forms parse; empty
+    // atomList is optional so engine-emitted atom-free forms parse; empty
     // `AGGREGATE()` / `AGGREGATE(ON ?x)` are rejected after parse (visitor).
     d(this, "expandedAggregate", this.OVERRIDE_RULE("aggregate", () => {
       this.CONSUME(wt), this.CONSUME(U), this.OPTION(() => {
@@ -1363,7 +1361,7 @@ async function Us(e, t, r, i, s) {
         verified: !1,
         error: "Could not generate test triple from rule head"
       };
-    const l = Bi(e), E = await Di(l, t, r, i);
+    const l = Bi(e), E = await $i(l, t, r, i);
     if (E)
       return {
         verified: !1,
@@ -1371,7 +1369,7 @@ async function Us(e, t, r, i, s) {
         candidateQuery: l,
         error: E
       };
-    const y = $i(o), S = new URL(`datastores/${r}/sparql`, t), h = await fetch(S.toString(), {
+    const y = Di(o), S = new URL(`datastores/${r}/sparql`, t), h = await fetch(S.toString(), {
       method: "POST",
       headers: {
         Authorization: i,
@@ -1396,7 +1394,7 @@ async function Us(e, t, r, i, s) {
     };
   }
 }
-async function Di(e, t, r, i) {
+async function $i(e, t, r, i) {
   try {
     const s = new URL(`datastores/${r}/sparql`, t), a = await fetch(s.toString(), {
       method: "POST",
@@ -1421,7 +1419,7 @@ async function Di(e, t, r, i) {
     return `Candidate query failed: ${s instanceof Error ? s.message : "Unknown error"}`;
   }
 }
-function $i(e) {
+function Di(e) {
   return `
     ASK WHERE {
       ${e.subject} ${e.predicate} ${e.object} .
@@ -1825,7 +1823,7 @@ function Ts(e) {
   } : { allowed: !0, operationTypes: r.map((o) => o.subType).filter(_e) };
 }
 async function pn(e) {
-  const { rdfoxUrl: t, datastoreName: r, authorization: i } = e, s = new URL(`datastores/${r}/connections`, t), a = await fetch(s.toString(), {
+  const { endpointUrl: t, datastoreName: r, authorization: i } = e, s = new URL(`datastores/${r}/connections`, t), a = await fetch(s.toString(), {
     method: "POST",
     headers: {
       Authorization: i
@@ -1841,7 +1839,7 @@ async function pn(e) {
   return o.split("/").pop();
 }
 async function hn(e) {
-  const { rdfoxUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
   a.searchParams.set("operation", "begin-read-write-transaction");
   const o = await fetch(a.toString(), {
     method: "PATCH",
@@ -1855,7 +1853,7 @@ async function hn(e) {
   }
 }
 async function dn(e) {
-  const { rdfoxUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
   a.searchParams.set("operation", "commit-transaction");
   const o = await fetch(a.toString(), {
     method: "PATCH",
@@ -1869,7 +1867,7 @@ async function dn(e) {
   }
 }
 async function En(e) {
-  const { rdfoxUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
   a.searchParams.set("operation", "rollback-transaction");
   const o = await fetch(a.toString(), {
     method: "PATCH",
@@ -1883,7 +1881,7 @@ async function En(e) {
   }
 }
 async function fn(e) {
-  const { rdfoxUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}`, t), o = await fetch(a.toString(), {
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}`, t), o = await fetch(a.toString(), {
     method: "DELETE",
     headers: {
       Authorization: s
@@ -2179,7 +2177,7 @@ class Ln extends mn {
       ...this.asTarget(t, "Bind missing variable")
     };
   }
-  // The expanded grammar accepts a value where a variable belongs, because RDFox
+  // The expanded grammar accepts a value where a variable belongs, because the engine
   // substitutes the `AS` target when it grounds a rule.
   asTarget(t, r) {
     var a;
@@ -2211,7 +2209,7 @@ class Ln extends mn {
       bindings: s
     };
   }
-  // RDFox grounds every grouping variable or none of them, so listing the
+  // The engine grounds every grouping variable or none of them, so listing the
   // variables ahead of any substituted values preserves source order in practice.
   onClause(t) {
     var a, o;
@@ -2710,10 +2708,10 @@ export {
   xe as DatalogParser,
   ae as EQUALS,
   fe as EXCLAMATION,
-  Dt as EXISTS,
+  $t as EXISTS,
   vi as ExpandedDatalogParser,
   se as FALSE,
-  $t as FILTER,
+  Dt as FILTER,
   ce as GREATER_THAN,
   pe as GREATER_THAN_OR_EQUAL,
   gt as HAT,
@@ -2768,6 +2766,7 @@ export {
   ei as binaryOperandNeedsParentheses,
   Ri as booleanLiteralTokenTypes,
   Ni as builtinFunctionTokenTypes,
+  Qe as canonicalRuleText,
   Ze as classAssertionFromAtom,
   Ns as collectVariableTypeEvidence,
   dn as commitTransaction,
@@ -2799,7 +2798,7 @@ export {
   ns as isBareNumericLiteral,
   qn as isBinaryExpression,
   _n as isBindFormula,
-  Dn as isBlankNodeTerm,
+  $n as isBlankNodeTerm,
   er as isBooleanLiteral,
   Fn as isClassAtom,
   rs as isComparisonOperator,
@@ -2813,7 +2812,7 @@ export {
   kn as isIriTerm,
   tt as isLiteralTerm,
   Jn as isLogicalOperator,
-  $n as isNegationFormula,
+  Dn as isNegationFormula,
   Q as isNumericLiteral,
   ss as isNumericLiteralTerm,
   Zn as isNumericOperator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/datalog-parser",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "RDFox Datalog parser and AST builder with inference verification",
   "license": "MIT",
   "type": "module",