@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -1,415 +1,236 @@
-import { Scope, StructureKind, } from "ts-morph";
+import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const typeParameters = {
-        ObjectT: {
-            name: "ObjectT",
-        },
-        ObjectIdentifierT: {
-            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
-            name: "ObjectIdentifierT",
-        },
-    };
-    const sparqlWherePatternsFunctionType = `(parameters?: { subject?: sparqljs.Triple["subject"]; }) => readonly sparqljs.Pattern[]`;
+    const sparqlWherePatternsFunctionType = code `(parameters?: { filter?: ObjectFilterT; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; }) => readonly ${imports.sparqljs}.Pattern[]`;
     const parameters = {
-        constructObjectType: {
-            name: "objectType",
-            type: `{\
-  ${syntheticNamePrefix}fromRdf: (resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
-  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions) => string;
+        constructObjectType: code `objectType: {\
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { filter?: ObjectFilterT; subject?: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
   ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
 }`,
-        },
-        query: {
-            hasQuestionToken: true,
-            name: "query",
-            type: `${syntheticNamePrefix}SparqlObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
-        },
-        selectObjectTypeType: {
-            name: "objectType",
-            type: `{ ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType} }`,
-        },
-        where: {
-            hasQuestionToken: true,
-            name: "where",
-            type: `${syntheticNamePrefix}SparqlObjectSet.Where<${typeParameters.ObjectIdentifierT.name}>`,
-        },
+        query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+        selectObjectTypeType: code `objectType: { ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType} }`,
     };
-    return [
-        {
-            ctors: [
-                {
-                    parameters: [
-                        {
-                            name: "{ sparqlClient }",
-                            type: `{ sparqlClient: ${syntheticNamePrefix}SparqlObjectSet["${syntheticNamePrefix}sparqlClient"] }`,
-                        },
-                    ],
-                    statements: [
-                        `this.${syntheticNamePrefix}sparqlClient = sparqlClient;`,
-                    ],
-                },
-            ],
-            implements: [`${syntheticNamePrefix}ObjectSet`],
-            isExported: true,
-            kind: StructureKind.Class,
-            name: `${syntheticNamePrefix}SparqlObjectSet`,
-            // methods: [
-            methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
-                if (!objectType.features.has("sparql")) {
-                    return unsupportedObjectSetMethodDeclarations({
-                        objectType,
-                    });
-                }
-                const methodSignatures = objectSetMethodSignatures({
-                    objectType,
-                    queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
-                });
-                const runtimeObjectType = objectType.staticModuleName;
-                return [
-                    {
-                        ...methodSignatures.object,
-                        kind: StructureKind.Method,
-                        isAsync: true,
-                        statements: [
-                            `return (await this.${methodSignatures.objects.name}({ where: { identifiers: [identifier], type: "identifiers" } })).map(objects => objects[0]);`,
-                        ],
-                    },
-                    {
-                        ...methodSignatures.objectIdentifiers,
-                        kind: StructureKind.Method,
-                        isAsync: true,
-                        statements: [
-                            `return this.${syntheticNamePrefix}objectIdentifiers<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                        ],
-                    },
-                    {
-                        ...methodSignatures.objects,
-                        kind: StructureKind.Method,
-                        isAsync: true,
-                        statements: [
-                            `return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                        ],
-                    },
-                    {
-                        ...methodSignatures.objectsCount,
-                        isAsync: true,
-                        kind: StructureKind.Method,
-                        statements: [
-                            `return this.${syntheticNamePrefix}objectsCount<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                        ],
-                    },
-                ];
-            }).concat({
-                kind: StructureKind.Method,
-                name: `${syntheticNamePrefix}mapBindingsToCount`,
-                parameters: [
-                    {
-                        name: "bindings",
-                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
-                    },
-                    {
-                        name: "variable",
-                        type: "string",
-                    },
-                ],
-                returnType: "purify.Either<Error, number>",
-                scope: Scope.Protected,
-                statements: [
-                    `\
-if (bindings.length === 0) {
-  return purify.Left(new Error("empty result rows"));
-}
-if (bindings.length > 1) {
-  return purify.Left(new Error("more than one result row"));
-}
-const count = bindings[0][variable];
-if (typeof count === "undefined") {
-  return purify.Left(new Error("no 'count' variable in result row"));
-}
-if (count.termType !== "Literal") {
-  return purify.Left(new Error("'count' variable is not a Literal"));
-}
-const parsedCount = Number.parseInt(count.value);
-if (Number.isNaN(parsedCount)) {
-  return purify.Left(new Error("'count' variable is NaN"));
-}
-return purify.Either.of(parsedCount);`,
-                ],
-            }, {
-                kind: StructureKind.Method,
-                name: `${syntheticNamePrefix}mapBindingsToIdentifiers`,
-                parameters: [
-                    {
-                        name: "bindings",
-                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
-                    },
-                    {
-                        name: "variable",
-                        type: "string",
-                    },
-                ],
-                returnType: "readonly rdfjs.NamedNode[]",
-                scope: Scope.Protected,
-                statements: [
-                    `\
-const identifiers: rdfjs.NamedNode[] = [];
-for (const bindings_ of bindings) {
-  const identifier = bindings_[variable];
-  if (
-    typeof identifier !== "undefined" &&
-    identifier.termType === "NamedNode"
-  ) {
-    identifiers.push(identifier);
+    const typeParameters = {
+        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectFilterT: code `ObjectFilterT`,
+        ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
+    };
+    return code `\
+export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
+  protected readonly ${syntheticNamePrefix}countVariable = ${imports.dataFactory}.variable!("count");;
+  protected readonly graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+  protected readonly ${syntheticNamePrefix}objectVariable = ${imports.dataFactory}.variable!("object");
+  protected readonly ${syntheticNamePrefix}sparqlGenerator = new ${imports.sparqljs}.Generator();
+
+  constructor(protected readonly ${syntheticNamePrefix}sparqlClient: { queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+    this.graph = options?.graph;
   }
-}
-return identifiers;`,
-                ],
-            }, {
-                kind: StructureKind.Method,
-                isAsync: true,
-                name: `${syntheticNamePrefix}objectIdentifiers`,
-                parameters: [parameters.selectObjectTypeType, parameters.query],
-                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>>`,
-                scope: Scope.Protected,
-                statements: [
-                    `\
-const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
-if (limit <= 0) {
-  return purify.Either.of([]);
-}
 
-let offset = query?.offset ?? 0;
-if (offset < 0) {
-  offset = 0;
-}
+${joinCode([...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
+        if (!objectType.features.has("sparql")) {
+            return Object.values(unsupportedObjectSetMethodDeclarations({
+                objectType,
+            }));
+        }
+        const methodSignatures = objectSetMethodSignatures({
+            objectType,
+            queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+        });
+        const runtimeObjectType = objectType.staticModuleName;
+        return [
+            code `\
+async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
+  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier] })).map(objects => objects[0]);
+}`,
+            code `\
+async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
+  return this.${syntheticNamePrefix}objectCount<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+            code `\
+async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
+  return this.${syntheticNamePrefix}objectIdentifiers<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+            code `\
+async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
+  return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+        ];
+    }), { on: "\n\n" })}
 
-const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
-if (wherePatterns.length === 0) {
-  return purify.Left(new Error("no required SPARQL WHERE patterns for identifiers"));
-}
+  protected ${syntheticNamePrefix}mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
+    if (bindings.length === 0) {
+      return ${imports.Left}(new Error("empty result rows"));
+    }
+    if (bindings.length > 1) {
+      return ${imports.Left}(new Error("more than one result row"));
+    }
+    const count = bindings[0][variable];
+    if (count === undefined) {
+      return ${imports.Left}(new Error("no 'count' variable in result row"));
+    }
+    if (count.termType !== "Literal") {
+      return ${imports.Left}(new Error("'count' variable is not a Literal"));
+    }
+    const parsedCount = Number.parseInt(count.value, 10);
+    if (Number.isNaN(parsedCount)) {
+      return ${imports.Left}(new Error("'count' variable is NaN"));
+    }
+    return ${imports.Right}(parsedCount);
+  }
 
-const selectQueryString = \
-  this.${syntheticNamePrefix}sparqlGenerator.stringify({
-    distinct: true,
-    limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
-    offset,
-    order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
-    prefixes: {},
-    queryType: "SELECT",
-    type: "query",
-    variables: [this.${syntheticNamePrefix}objectVariable],
-    where: wherePatterns
-  });
-  
-return purify.EitherAsync(async () =>
-  this.${syntheticNamePrefix}mapBindingsToIdentifiers(
-    await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-    this.${syntheticNamePrefix}objectVariable.value,
-  ) as readonly ${typeParameters.ObjectIdentifierT.name}[],
-);`,
-                ],
-                typeParameters: [typeParameters.ObjectIdentifierT],
-            }, {
-                isAsync: true,
-                kind: StructureKind.Method,
-                name: `${syntheticNamePrefix}objects`,
-                parameters: [parameters.constructObjectType, parameters.query],
-                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>>`,
-                statements: [
-                    `\
-const identifiersEither = await this.${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectIdentifierT.name}>(objectType, query);
-if (identifiersEither.isLeft()) {
-  return identifiersEither;
-}
-const identifiers = identifiersEither.unsafeCoerce();
-if (identifiers.length === 0) {
-  return purify.Either.of([]);
-}
+  protected ${syntheticNamePrefix}mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
+    const identifiers: ${imports.NamedNode}[] = [];
+    for (const bindings_ of bindings) {
+      const identifier = bindings_[variable];
+      if (
+        identifier !== undefined &&
+        identifier.termType === "NamedNode"
+      ) {
+        identifiers.push(identifier);
+      }
+    }
+    return identifiers;
+  }
 
-const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
-  subject: this.${syntheticNamePrefix}objectVariable,
-  where: [{
-    type: "values" as const,
-    values: identifiers.map((identifier) => {
-      const valuePatternRow: sparqljs.ValuePatternRow = {};
-      valuePatternRow["?object"] = identifier as rdfjs.NamedNode;
-      return valuePatternRow;
-    }),
-  }]
-});
+  protected async ${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+    if (query?.identifiers) {
+      return ${imports.Right}(query.identifiers);
+    }
 
-let quads: readonly rdfjs.Quad[];
-try {
-  quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
-} catch (e) {
-  return purify.Left(e as Error);
-}
+    const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+    if (limit <= 0) {
+      return ${imports.Right}([]);
+    }
 
-const dataset = datasetFactory.dataset(quads.concat());
-const objects: ${typeParameters.ObjectT.name}[] = [];
-for (const identifier of identifiers) {
-  const objectEither = objectType.${syntheticNamePrefix}fromRdf(
-    new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode }),
-    { objectSet: this }
-  );
-  if (objectEither.isLeft()) {
-    return objectEither;
+    let offset = query?.offset ?? 0;
+    if (offset < 0) {
+      offset = 0;
+    }
+
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    if (wherePatterns.length === 0) {
+      return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
+    }
+
+    const selectQueryString = \
+      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+        distinct: true,
+        limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
+        offset,
+        order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
+        prefixes: {},
+        queryType: "SELECT",
+        type: "query",
+        variables: [this.${syntheticNamePrefix}objectVariable],
+        where: wherePatterns.concat()
+      });
+      
+    return ${imports.EitherAsync}(async () =>
+      this.${syntheticNamePrefix}mapBindingsToIdentifiers(
+        await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+        this.${syntheticNamePrefix}objectVariable.value,
+      ) as readonly ObjectIdentifierT[],
+    );  
   }
-  objects.push(objectEither.unsafeCoerce());
-}
-return purify.Either.of(objects);`,
-                ],
-                typeParameters: [
-                    typeParameters.ObjectT,
-                    typeParameters.ObjectIdentifierT,
-                ],
-            }, {
-                kind: StructureKind.Method,
-                isAsync: true,
-                name: `${syntheticNamePrefix}objectsCount`,
-                parameters: [parameters.selectObjectTypeType, parameters.query],
-                returnType: "Promise<purify.Either<Error, number>>",
-                scope: Scope.Protected,
-                statements: [
-                    `\
-const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
-if (wherePatterns.length === 0) {
-  return purify.Left(new Error("no required SPARQL WHERE patterns for count"));
-}
 
-const selectQueryString = \
-  this.${syntheticNamePrefix}sparqlGenerator.stringify({
-    prefixes: {},
-    queryType: "SELECT",
-    type: "query",
-    variables: [
-      {
-        expression: {
-          aggregation: "COUNT",
-          distinct: true,
-          expression: this.${syntheticNamePrefix}objectVariable,
-          type: "aggregate",
-        },
-        variable: this.${syntheticNamePrefix}countVariable,
-      },
-    ],
-    where: wherePatterns
-  });
+  protected async ${syntheticNamePrefix}objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
+    return ${imports.EitherAsync}(async ({ liftEither }) => {
+      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(objectType, query));
+      if (identifiers.length === 0) {
+        return [];
+      }
 
-return purify.EitherAsync(async ({ liftEither }) =>
-  liftEither(
-    this.${syntheticNamePrefix}mapBindingsToCount(
-      await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-      this.${syntheticNamePrefix}countVariable.value,
-    ),
-  ),
-);`,
-                ],
-                typeParameters: [typeParameters.ObjectIdentifierT],
-            }, {
-                kind: StructureKind.Method,
-                name: `${syntheticNamePrefix}wherePatterns`,
-                parameters: [parameters.selectObjectTypeType, parameters.where],
-                returnType: "sparqljs.Pattern[]",
-                scope: Scope.Protected,
-                statements: [
-                    `\
-const patterns: sparqljs.Pattern[] = [];
+      const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
+        subject: this.${syntheticNamePrefix}objectVariable,
+        where: [{
+          type: "values" as const,
+          values: identifiers.map((identifier) => {
+            const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
+            valuePatternRow["?object"] = identifier as ${imports.NamedNode};
+            return valuePatternRow;
+          }),
+        }]
+      });
 
-// Patterns should be most to least specific.
+      const quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
 
-if (where) {
-  // Assign a separate variable so the compiler catches any missing cases
-  let wherePatterns: readonly sparqljs.Pattern[];
-  switch (where.type) {
-    case "identifiers": {
-      const valuePatternRowKey = \`?\${this.${syntheticNamePrefix}objectVariable.value}\`;
-      wherePatterns = [{
-        type: "values" as const,
-        values: where.identifiers.map((identifier) => {
-          const valuePatternRow: sparqljs.ValuePatternRow = {};
-          valuePatternRow[valuePatternRowKey] = identifier as rdfjs.NamedNode;
-          return valuePatternRow;
-        }),
-      }];
-      break;
+      const dataset = ${imports.datasetFactory}.dataset(quads.concat());
+      const objects: ObjectT[] = [];
+      for (const identifier of identifiers) {
+        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this })));
+      }
+      return objects;
+    });
+  }
+
+  protected async ${syntheticNamePrefix}objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    if (wherePatterns.length === 0) {
+      return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
-    case "sparql-patterns": {
-      wherePatterns = where.sparqlPatterns(this.${syntheticNamePrefix}objectVariable);
-      break;
+
+    const selectQueryString = \
+      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+        prefixes: {},
+        queryType: "SELECT",
+        type: "query",
+        variables: [
+          {
+            expression: {
+              aggregation: "COUNT",
+              distinct: true,
+              expression: this.${syntheticNamePrefix}objectVariable,
+              type: "aggregate",
+            },
+            variable: this.${syntheticNamePrefix}countVariable,
+          },
+        ],
+        where: wherePatterns.concat()
+      });
+
+    return ${imports.EitherAsync}(async ({ liftEither }) =>
+      liftEither(
+        this.${syntheticNamePrefix}mapBindingsToCount(
+          await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+          this.${syntheticNamePrefix}countVariable.value,
+        ),
+      ),
+    );
+  }
+
+  protected ${syntheticNamePrefix}wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
+    // Patterns should be most to least specific.
+    let patterns: ${imports.sparqljs}.Pattern[] = [];
+
+    if (query?.where) {
+      patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
     }
-    case "triple-objects": {
-      wherePatterns = [{
-        triples: [{
-          subject: where.subject,
-          predicate: where.predicate,
-          object: this.${syntheticNamePrefix}objectVariable
-        }],
-        type: "bgp"
-      }];
-      break;
+
+    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable }));
+
+    patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
+
+    const graph = query?.graph ?? this.graph;
+    if (graph) {
+      switch (graph.termType) {
+        case "DefaultGraph":
+          return patterns; // Patterns without a GRAPH pattern around them query the default graph
+        case "NamedNode":
+          return [{ name: graph, patterns, type: "graph" }];
+      }
     }
+    // Union of all graphs: { ... patterns covering default graph ... } UNION { GRAPH ?g { ... patterns covering named graphs ... } }
+    return [{ patterns: [{ patterns, type: "group" }, { name: ${imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
   }
-  patterns.push(...wherePatterns);
 }
-
-patterns.push(...objectType.${syntheticNamePrefix}sparqlWherePatterns({ subject: this.${syntheticNamePrefix}objectVariable }));
-
-return patterns;`,
-                ],
-                typeParameters: [typeParameters.ObjectIdentifierT],
-            }),
-            properties: [
-                {
-                    initializer: `dataFactory.variable!("count");`,
-                    isReadonly: true,
-                    name: `${syntheticNamePrefix}countVariable`,
-                    scope: Scope.Protected,
-                },
-                {
-                    initializer: `dataFactory.variable!("object");`,
-                    isReadonly: true,
-                    name: `${syntheticNamePrefix}objectVariable`,
-                    scope: Scope.Protected,
-                },
-                {
-                    isReadonly: true,
-                    name: `${syntheticNamePrefix}sparqlClient`,
-                    scope: Scope.Protected,
-                    type: "{ queryBindings: (query: string) => Promise<readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]>; queryQuads: (query: string) => Promise<readonly rdfjs.Quad[]>; }",
-                },
-                {
-                    initializer: "new sparqljs.Generator()",
-                    isReadonly: true,
-                    name: `${syntheticNamePrefix}sparqlGenerator`,
-                    scope: Scope.Protected,
-                },
-            ],
-        },
-        {
-            isExported: true,
-            kind: StructureKind.Module,
-            name: `${syntheticNamePrefix}SparqlObjectSet`,
-            statements: [
-                {
-                    isExported: true,
-                    kind: StructureKind.TypeAlias,
-                    name: "Query",
-                    type: `Omit<${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>, "where"> & { readonly order?: (objectVariable: rdfjs.Variable) => readonly sparqljs.Ordering[]; readonly where?: Where<${typeParameters.ObjectIdentifierT.name}> }`,
-                    typeParameters: [typeParameters.ObjectIdentifierT],
-                },
-                {
-                    kind: StructureKind.TypeAlias,
-                    isExported: true,
-                    name: "Where",
-                    type: `${syntheticNamePrefix}ObjectSet.Where<${typeParameters.ObjectIdentifierT.name}> | { readonly sparqlPatterns: (objectVariable: rdfjs.Variable) => readonly sparqljs.Pattern[]; readonly type: "sparql-patterns" }`,
-                    typeParameters: [typeParameters.ObjectIdentifierT],
-                },
-            ],
-        },
-    ];
+  
+export namespace ${syntheticNamePrefix}SparqlObjectSet {
+  export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Pattern[] };
+}`;
 }
 //# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map

package/dist/generators/ts/synthesizeUberObjectUnionType.d.ts

@@ -0,0 +1,9 @@
+import type { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+/**
+ * Synthesize the $Object union.
+ */
+export declare function synthesizeUberObjectUnionType(parameters: {
+    objectTypes: readonly ObjectType[];
+}): ObjectUnionType;
+//# sourceMappingURL=synthesizeUberObjectUnionType.d.ts.map