parses constructs

packages/rules-sparql-1-1/lib/Sparql11types.ts

@@ -81,8 +81,8 @@ export interface SelectQuery extends BaseQuery {
   variables: Variable[] | [Wildcard];
   distinct?: true | undefined;
   reduced?: true | undefined;
-  group?: Grouping[] | undefined;
   having?: Expression[] | undefined;
+  group?: Grouping[] | undefined;
   order?: Ordering[] | undefined;
   limit?: number | undefined;
   offset?: number | undefined;
@@ -101,6 +101,11 @@ export interface Ordering {
 export interface ConstructQuery extends BaseQuery {
   queryType: 'CONSTRUCT';
   template?: Triple[] | undefined;
+  having?: Expression[] | undefined;
+  group?: Grouping[] | undefined;
+  order?: Ordering[] | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
 }
 
 export interface AskQuery extends BaseQuery {

packages/rules-sparql-1-1/lib/grammar/general.ts

@@ -3,7 +3,6 @@ import * as l from '../lexer';
 import type {
   GraphTerm,
   Term,
-  Triple,
   VerbA,
   IriTerm,
   VariableTerm,
@@ -12,7 +11,6 @@ import type {
   SparqlRule,
 } from '../Sparql11types';
 import { blankNode, booleanLiteral, iri, numericLiteral, rdfLiteral } from './literals';
-import { triplesSameSubject } from './tripleBlock';
 
 /**
  * [[4]](https://www.w3.org/TR/sparql11-query/#rPrologue)
@@ -94,34 +92,6 @@ export const prefixDecl: SparqlGrammarRule<'prefixDecl', [string, string]> = <co
   },
 };
 
-/**
- * [[52]](https://www.w3.org/TR/sparql11-query/#rTriplesTemplate)
- */
-export const triplesTemplate: SparqlGrammarRule<'triplesTemplate', Triple[]> = <const> {
-  name: 'triplesTemplate',
-  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => () => {
-    const triples: Triple[] = [];
-
-    let parsedDot = true;
-    AT_LEAST_ONE({
-      GATE: () => parsedDot,
-      DEF: () => {
-        parsedDot = false;
-        const template = SUBRULE(triplesSameSubject, undefined);
-        ACTION(() => {
-          triples.push(...template);
-        });
-        OPTION(() => {
-          CONSUME(l.symbols.dot);
-          parsedDot = true;
-        });
-      },
-    });
-
-    return triples;
-  },
-};
-
 /**
  * [[78]](https://www.w3.org/TR/sparql11-query/#rVerb)
  */
@@ -154,7 +124,7 @@ export const varOrTerm: SparqlRule<'varOrTerm', Term> = <const> {
   ]),
   gImpl: ({ SUBRULE }) => (ast) => {
     if (ast.termType === 'Variable') {
-      return SUBRULE(varOrTerm, ast, undefined);
+      return SUBRULE(var_, ast, undefined);
     }
     if (ast.termType === 'NamedNode') {
       return SUBRULE(iri, <IriTerm> ast, undefined);

packages/rules-sparql-1-1/lib/grammar/queryUnit/queryUnit.ts

@@ -22,10 +22,10 @@ import type {
 } from '../../Sparql11types';
 import { datasetClause, type IDatasetClause } from '../dataSetClause';
 import { expression } from '../expression';
-import { prologue, triplesTemplate, var_, varOrIri } from '../general';
+import { prologue, var_, varOrIri } from '../general';
 import { iri } from '../literals';
 import { solutionModifier } from '../solutionModifier';
-import { triplesSameSubject } from '../tripleBlock';
+import { triplesBlock, triplesTemplate } from '../tripleBlock';
 import { dataBlock, groupGraphPattern, inlineDataFull, whereClause } from '../whereClause';
 
 /**
@@ -370,7 +370,7 @@ export const selectClause: SparqlRule<'selectClause', ISelectClause> = <const> {
 /**
  * [[10]](https://www.w3.org/TR/sparql11-query/#rConstructQuery)
  */
-export const constructQuery: SparqlGrammarRule<'constructQuery', Omit<ConstructQuery, HandledByBase>> = <const> {
+export const constructQuery: SparqlRule<'constructQuery', Omit<ConstructQuery, HandledByBase>> = <const> {
   name: 'constructQuery',
   impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OPTION, OR }) => () => {
     CONSUME(l.construct);
@@ -416,6 +416,22 @@ export const constructQuery: SparqlGrammarRule<'constructQuery', Omit<ConstructQ
       },
     ]);
   },
+  gImpl: ({ SUBRULE }) => (ast) => {
+    const selectString = SUBRULE(constructTemplate, ast.template, undefined);
+
+    const fromDefaultString = ast.from?.default.map(clause =>
+      `FROM ${SUBRULE(iri, clause, undefined)}`).join('\n') ?? '';
+
+    const fromNamedString = ast.from?.named.map(clause =>
+      `FROM NAMED ${SUBRULE(iri, clause, undefined)}`).join('\n') ?? '';
+
+    const whereString = ast.where ?
+      `WHERE ${SUBRULE(groupGraphPattern, { type: 'group', patterns: ast.where }, undefined)}` :
+      '';
+
+    const modifierString = SUBRULE(solutionModifier, ast, undefined);
+    return [ 'CONSTRUCT', selectString, fromDefaultString, fromNamedString, whereString, modifierString ].join('\n');
+  },
 };
 
 /**
@@ -490,30 +506,22 @@ export const valuesClause: SparqlRule<'valuesClause', ValuePatternRow[] | undefi
 /**
  * [[73]](https://www.w3.org/TR/sparql11-query/#ConstructTemplate)
  */
-export const constructTemplate: SparqlGrammarRule<'constructTemplate', Triple[] | undefined> = <const> {
+export const constructTemplate: SparqlRule<'constructTemplate', Triple[] | undefined> = <const> {
   name: 'constructTemplate',
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(l.symbols.LCurly);
     const triples = OPTION(() => SUBRULE(constructTriples, undefined));
     CONSUME(l.symbols.RCurly);
     return triples;
   },
+  gImpl: ({ SUBRULE }) => ast =>
+    `{ ${ast ? SUBRULE(triplesBlock, { type: 'bgp', triples: ast }, undefined) : ''} }`,
 };
 
 /**
  * [[12]](https://www.w3.org/TR/sparql11-query/#rConstructTriples)
  */
 export const constructTriples: SparqlGrammarRule<'constructTriples', Triple[]> = <const> {
   name: 'constructTriples',
-  impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const triples: Triple[][] = [];
-    triples.push(SUBRULE(triplesSameSubject, undefined));
-    OPTION1(() => {
-      CONSUME(l.symbols.dot);
-      OPTION2(() => {
-        triples.push(SUBRULE(constructTriples, undefined));
-      });
-    });
-    return triples.flat(1);
-  },
+  impl: triplesTemplate.impl,
 };

packages/rules-sparql-1-1/lib/grammar/tripleBlock.ts

@@ -15,22 +15,38 @@ import type {
 import { var_, varOrTerm, verb } from './general';
 import { path } from './propertyPaths';
 
+function triplesDotSeperated(subRule: SparqlGrammarRule<any, Triple[]>): SparqlGrammarRule<any, Triple[]>['impl'] {
+  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => () => {
+    const triples: Triple[] = [];
+
+    let parsedDot = true;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(subRule, undefined);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          CONSUME(l.symbols.dot);
+          parsedDot = true;
+        });
+      },
+    });
+    return triples;
+  };
+}
+
 /**
  * [[55]](https://www.w3.org/TR/sparql11-query/#rTriplesBlock)
  */
 export const triplesBlock: SparqlRule<'triplesBlock', BgpPattern> = <const> {
   name: 'triplesBlock',
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const triples = SUBRULE(triplesSameSubjectPath, undefined);
-    const pattern = OPTION1(() => {
-      CONSUME(l.symbols.dot);
-      return OPTION2(() => SUBRULE(triplesBlock, undefined));
-    });
-    return ACTION(() => ({
-      type: 'bgp',
-      triples: [ ...triples, ...(pattern?.triples ?? []) ],
-    }));
-  },
+  impl: implArgs => C => ({
+    type: 'bgp',
+    triples: triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C, undefined),
+  }),
   gImpl: ({ SUBRULE }) => ast => ast.triples.map((triple) => {
     const { subject, predicate, object } = triple;
     return [ subject, predicate, object ].map((part) => {
@@ -72,6 +88,14 @@ function triplesSameSubjectImpl<T extends string>(name: T, allowPaths: boolean):
 export const triplesSameSubject = triplesSameSubjectImpl('triplesSameSubject', false);
 export const triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubjectPath', true);
 
+/**
+ * [[52]](https://www.w3.org/TR/sparql11-query/#rTriplesTemplate)
+ */
+export const triplesTemplate: SparqlGrammarRule<'triplesTemplate', Triple[]> = <const> {
+  name: 'triplesTemplate',
+  impl: triplesDotSeperated(triplesSameSubject),
+};
+
 /**
  * [[76]](https://www.w3.org/TR/sparql11-query/#rPropertyList)
  * [[82]](https://www.w3.org/TR/sparql11-query/#rPropertyListPath)

packages/rules-sparql-1-1/lib/grammar/updateUnit/updateUnit.ts

@@ -17,6 +17,7 @@ import type {
 } from '../../Sparql11types';
 import { prologue, triplesTemplate, varOrIri } from '../general';
 import { iri } from '../literals';
+import { triplesTemplate } from '../tripleBlock';
 import { groupGraphPattern } from '../whereClause';
 
 /**