my generator no like me

jitsedesmet · jitsedesmet · commit 0bb8f608f63c · 2025-07-03T17:45:12.000+02:00
diff --git a/engines/generator-sparql-1-1/README.md b/engines/generator-sparql-1-1/README.md
@@ -0,0 +1,39 @@
+# TRAQULA SPARQL 1.1 generator
+
+TRAQULA Generator Sparql 1.1 is a [SPARQL 1.1](https://www.w3.org/TR/sparql11-query/#grammar) query generator for TypeScript.
+It can generate SPARQL given the AST created by [TRAQULA parser SPARQL 1-1](https://github.com/comunica/traqula/tree/main/engines/parser-sparql-1-1).
+
+## Installation
+
+```bash
+npm install @traqula/generator-sparql-1-1
+```
+
+or
+
+```bash
+yarn add @traqula/generator-sparql-1-1
+```
+
+## Import
+
+Either through ESM import:
+
+```javascript
+import {Parser} from 'engines/generator-sparql-1-1';
+```
+
+_or_ CJS require:
+
+```javascript
+const Parser = require('engines/generator-sparql-1-1').Parser;
+```
+
+## Usage
+
+This package contains a `Generator` that is able to generate SPARQL 1.1 queries:
+
+```typescript
+const generator = new Generator();
+const abstractSyntaxTree = generator.generate(abstractSyntaxTree);
+```
diff --git a/engines/generator-sparql-1-1/lib/index.ts b/engines/generator-sparql-1-1/lib/index.ts
@@ -0,0 +1,90 @@
+import { GeneratorBuilder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+import type * as T11 from '@traqula/rules-sparql-1-1';
+
+const sparql11GeneratorBuilder = GeneratorBuilder.createBuilder(<const> [
+  gram.query,
+  gram.selectQuery,
+  gram.constructQuery,
+  gram.describeQuery,
+  gram.askQuery,
+  gram.selectClause,
+])
+  .addMany(
+    gram.update,
+    gram.update1,
+    gram.load,
+    gram.clear,
+    gram.drop,
+    gram.create,
+    gram.copy,
+    gram.move,
+    gram.add,
+    gram.insertData,
+    gram.deleteData,
+    gram.deleteWhere,
+    gram.modify,
+    gram.graphRef,
+    gram.graphRefAll,
+    gram.quads,
+    gram.quadsNotTriples,
+  )
+  .addRule(gram.aggregate)
+  .addRule(gram.datasetClauseStar)
+  .addMany(
+    gram.argList,
+    gram.expression,
+    gram.iriOrFunction,
+  )
+  .addMany(
+    gram.prologue,
+    gram.prefixDecl,
+    gram.baseDecl,
+    gram.varOrTerm,
+    gram.var_,
+    gram.graphTerm,
+  )
+  .addMany(
+    gram.rdfLiteral,
+    gram.iri,
+    gram.iriFull,
+    gram.prefixedName,
+    gram.blankNode,
+  )
+  .addRule(gram.path)
+  .addMany(
+    gram.solutionModifier,
+    gram.groupClause,
+    gram.groupCondition,
+    gram.havingClause,
+    gram.orderClause,
+    gram.limitOffsetClauses,
+  )
+  .addMany(
+    gram.triplesBlock,
+    gram.collectionPath,
+    gram.propertyListPath,
+    gram.triplesNodePath,
+    gram.graphNodePath,
+  )
+  .addMany(
+    gram.whereClause,
+    gram.groupGraphPattern,
+    gram.graphPatternNotTriples,
+    gram.optionalGraphPattern,
+    gram.graphGraphPattern,
+    gram.serviceGraphPattern,
+    gram.bind,
+    gram.inlineData,
+    gram.minusGraphPattern,
+    gram.groupOrUnionGraphPattern,
+    gram.filter,
+  );
+
+export class Generator {
+  private readonly generator = sparql11GeneratorBuilder.build();
+
+  public generate(ast: T11.Query): string {
+    return this.generator.query(ast, undefined, undefined);
+  }
+}
diff --git a/engines/generator-sparql-1-1/package.json b/engines/generator-sparql-1-1/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "@traqula/generator-sparql-1-1",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "SPARQL 1.1 generator",
+  "lsd:module": true,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/comunica/traqula.git",
+    "directory": "engines/generator-sparql-1-1"
+  },
+  "bugs": {
+    "url": "https://github.com/comunica/traqula/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    "import": "./lib/index.js",
+    "require": "./lib/index.cjs"
+  },
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib/**/*.cjs",
+    "lib/**/*.d.ts",
+    "lib/**/*.js",
+    "lib/**/*.js.map"
+  ],
+  "engines": {
+    "node": ">=18.0"
+  },
+  "typings": "lib/index",
+  "scripts": {
+    "build": "yarn build:ts && yarn build:transpile",
+    "build:ts": "node \"../../node_modules/typescript/bin/tsc\"",
+    "build:transpile": " node \"../../node_modules/esbuild/bin/esbuild\" --format=cjs --bundle --log-level=error --outfile=lib/index.cjs lib/index.ts"
+  },
+  "dependencies": {
+    "@traqula/core": "^0.0.0",
+    "@traqula/rules-sparql-1-1": "^0.0.0"
+  },
+  "devDependencies": {
+    "@traqula/parser-sparql-1-1": "^0.0.0",
+    "@traqula/rules-sparql-1-1": "^0.0.0"
+  }
+}
diff --git a/engines/generator-sparql-1-1/test/integration.test.ts b/engines/generator-sparql-1-1/test/integration.test.ts
@@ -0,0 +1,16 @@
+import { Parser } from '@traqula/parser-sparql-1-1';
+import type * as T11 from '@traqula/rules-sparql-1-1';
+import { describe, it } from 'vitest';
+import { Generator } from '../lib';
+
+describe('a SPARQL 1.1 generator', () => {
+  const generator = new Generator();
+  const parser = new Parser();
+
+  it ('should generate a simple query', ({ expect }) => {
+    const query = 'SELECT * WHERE { ?s ?p ?o }';
+    const ast = <T11.Query> parser.parse(query);
+    const result = generator.generate(ast);
+    expect(result.replaceAll(/\s+/gu, ' ')).toBe(query);
+  });
+});
diff --git a/packages/core/lib/generator-builder/generatorBuilder.ts b/packages/core/lib/generator-builder/generatorBuilder.ts
@@ -1,5 +1,4 @@
 import { CoreFactory } from '../CoreFactory';
-import type { Node } from '../nodeTypings';
 import type { CheckOverlap } from '../utils';
 import type { GeneratorFromRules, GenRuleMap, GenRulesToObject, GenNamesFromList } from './builderTypes';
 import type { GeneratorRule, RuleDefArg } from './generatorTypes';
@@ -21,7 +20,7 @@ export class GeneratorBuilder<Context, Names extends string, RuleDefs extends Ge
    * If a GeneratorBuilder is provided, a new copy will be created.
    */
   public static createBuilder<
-    Rules extends readonly GeneratorRule<any, any, any & Node>[] = readonly GeneratorRule<any, any, any & Node>[],
+    Rules extends readonly GeneratorRule[] = readonly GeneratorRule[],
     Context = Rules[0] extends GeneratorRule<infer context> ? context : never,
     Names extends string = GenNamesFromList<Rules>,
     RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>,
@@ -36,14 +35,14 @@ export class GeneratorBuilder<Context, Names extends string, RuleDefs extends Ge
 
   private rules: RuleDefs;
 
-  protected constructor(startRules: RuleDefs) {
+  private constructor(startRules: RuleDefs) {
     this.rules = startRules;
   }
 
   /**
    * Change the implementation of an existing generator rule.
    */
-  public patchRule<U extends Names, RET extends Node, ARGS>(patch: GeneratorRule<Context, U, RET, ARGS>):
+  public patchRule<U extends Names, RET, ARGS>(patch: GeneratorRule<Context, U, RET, ARGS>):
   GeneratorBuilder<Context, Names, {[Key in Names]: Key extends U ?
     GeneratorRule<Context, Key, RET, ARGS> :
       (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never)
@@ -59,7 +58,7 @@ export class GeneratorBuilder<Context, Names extends string, RuleDefs extends Ge
   /**
    * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
    */
-  public addRuleRedundant<U extends string, RET extends Node, ARGS>(rule: GeneratorRule<Context, U, RET, ARGS>):
+  public addRuleRedundant<U extends string, RET, ARGS>(rule: GeneratorRule<Context, U, RET, ARGS>):
   GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?
       (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)
     : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never)
@@ -79,7 +78,7 @@ export class GeneratorBuilder<Context, Names extends string, RuleDefs extends Ge
   /**
    * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
    */
-  public addRule<U extends string, RET extends Node, ARGS>(
+  public addRule<U extends string, RET, ARGS>(
     rule: CheckOverlap<U, Names, GeneratorRule<Context, U, RET, ARGS>>,
   ): GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?
       (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)
@@ -88,7 +87,7 @@ export class GeneratorBuilder<Context, Names extends string, RuleDefs extends Ge
     return this.addRuleRedundant(rule);
   }
 
-  public addMany<U extends readonly GeneratorRule<Context, any, Node>[]>(
+  public addMany<U extends readonly GeneratorRule<Context>[]>(
     ...rules: CheckOverlap<GenNamesFromList<U>, Names, U>
   ): GeneratorBuilder<
     Context,
diff --git a/packages/rules-sparql-1-1/lib/RoundTripTypes.ts b/packages/rules-sparql-1-1/lib/RoundTripTypes.ts
@@ -28,7 +28,7 @@ export type Quads = PatternBgp | GraphQuads;
 export type GraphQuads = Node & {
   type: 'graph';
   graph: TermIri | TermVariable;
-  triples: BasicGraphPattern;
+  triples: PatternBgp;
 };
 
 // https://www.w3.org/TR/sparql11-query/#rUpdate1
@@ -138,8 +138,7 @@ export type SparqlQuery = Query | Update;
 // https://www.w3.org/TR/sparql11-query/#rDatasetClause
 export type DatasetClauses = Node & {
   type: 'datasetClauses';
-  default: TermIri[];
-  named: TermIri[];
+  clauses: { clauseType: 'default' | 'named'; value: TermIri }[];
 };
 
 // https://www.w3.org/TR/sparql11-query/#rGraphNode
diff --git a/packages/rules-sparql-1-1/lib/factory.ts b/packages/rules-sparql-1-1/lib/factory.ts
@@ -41,6 +41,10 @@ import type {
   PropertyPathChain,
   Quads,
   Query,
+  QueryAsk,
+  QueryConstruct,
+  QueryDescribe,
+  QuerySelect,
   SolutionModifierHaving,
   SolutionModifierLimitOffset,
   SolutionModifierOrder,
@@ -263,6 +267,22 @@ export class TraqulaFactory extends CoreFactory {
     return x.type === 'query';
   }
 
+  public isQuerySelect(query: Query): query is QuerySelect {
+    return query.queryType === 'select';
+  }
+
+  public isQueryConstruc(query: Query): query is QueryConstruct {
+    return query.queryType === 'construct';
+  }
+
+  public isQueryDescribe(query: Query): query is QueryDescribe {
+    return query.queryType === 'describe';
+  }
+
+  public isQueryAsk(query: Query): query is QueryAsk {
+    return query.queryType === 'ask';
+  }
+
   public patternBgp(triples: BasicGraphPattern, loc: SourceLocation): PatternBgp {
     return { type: 'pattern', patternType: 'bgp', triples, loc };
   }
diff --git a/packages/rules-sparql-1-1/lib/grammar/dataSetClause.ts b/packages/rules-sparql-1-1/lib/grammar/dataSetClause.ts
@@ -8,20 +8,23 @@ import { iri } from './literals';
 export function datasetClauseUsing<RuleName extends 'usingClause' | 'datasetClause'>(
   name: RuleName,
   token: TokenType,
-): SparqlGrammarRule<RuleName, Wrap<{ named: boolean; value: TermIri }>> {
+): SparqlGrammarRule<RuleName, Wrap<DatasetClauses['clauses'][0]>> {
   return {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
       const start = CONSUME(token);
       return OR<RuleDefReturn<typeof datasetClause>>([
         { ALT: () => {
           const iri = SUBRULE(defaultGraphClause, undefined);
-          return ACTION(() => C.factory.wrap({ named: false, value: iri }, C.factory.sourceLocation(start, iri)));
+          return ACTION(() =>
+            C.factory.wrap({ clauseType: 'default', value: iri }, C.factory.sourceLocation(start, iri)));
         } },
         { ALT: () => {
           const namedClause = SUBRULE(namedGraphClause, undefined);
-          return ACTION(() =>
-            C.factory.wrap({ named: true, value: namedClause.val }, C.factory.sourceLocation(start, namedClause)));
+          return ACTION(() => C.factory.wrap({
+            clauseType: 'named',
+            value: namedClause.val,
+          }, C.factory.sourceLocation(start, namedClause)));
         } },
       ]);
     },
@@ -52,33 +55,27 @@ export function datasetClauseUsingStar<RuleName extends string>(
   return {
     name,
     impl: ({ ACTION, MANY, SUBRULE }) => (C) => {
-      const _default: TermIri[] = [];
-      const named: TermIri[] = [];
-      let first: RuleDefReturn<typeof datasetClause> | undefined;
-      let last: RuleDefReturn<typeof datasetClause> | undefined;
+      const clauses: RuleDefReturn<typeof datasetClause>[] = [];
 
       MANY(() => {
         const clause = SUBRULE(subRule, undefined);
-        if (!first) {
-          first = clause;
-        }
-        last = clause;
-        ACTION(() => {
-          if (clause.val.named) {
-            named.push(clause.val.value);
-          } else {
-            _default.push(clause.val.value);
-          }
-        });
+        clauses.push(clause);
       });
+
       return ACTION(() => ({
         type: 'datasetClauses',
-        default: _default,
-        named,
-        loc: C.factory.sourceLocation(...[ first, last ].filter(x => x !== undefined)),
+        clauses: clauses.map(clause => clause.val),
+        loc: C.factory.sourceLocation(...clauses),
       }));
     },
-    gImpl: () => () => '',
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+      for (const clause of ast.clauses) {
+        if (clause.clauseType === 'named') {
+          F.printFilter(ast, () => PRINT_WORD('NAMED'));
+        }
+        SUBRULE(iri, clause.value, undefined);
+      }
+    },
   };
 }
 
diff --git a/packages/rules-sparql-1-1/lib/grammar/queryUnit/queryUnit.ts b/packages/rules-sparql-1-1/lib/grammar/queryUnit/queryUnit.ts
diff --git a/packages/rules-sparql-1-1/lib/grammar/updateUnit/updateUnit.ts b/packages/rules-sparql-1-1/lib/grammar/updateUnit/updateUnit.ts
