refactor: accept Quad_Graph instead of Term | string in namedGraph

Agent-Logs-Url: https://github.com/rdfjs/wrapper/sessions/05cfefef-18c2-4e8e-a838-9ef95107a56d

Co-authored-by: jeswr <63333554+jeswr@users.noreply.github.com>

Author: Copilot

README.md

@@ -187,7 +187,7 @@ import { namedGraph, DatasetWrapper } from "@rdfjs/wrapper"
 // <ex:person2> <ex:name> "Bob" <ex:graph1> .
 // <ex:person1> <ex:name> "Charlie" .                  (default graph)
 
-const graphView = namedGraph("https://example.org/graph1", dataset, DataFactory)
+const graphView = namedGraph(DataFactory.namedNode("https://example.org/graph1"), dataset, DataFactory)
 
 // graphView behaves as a DatasetCore containing only default graph quads:
 // <ex:person1> <ex:name> "Alice" .

src/namedGraph.ts

@@ -2,10 +2,7 @@ import type { DataFactory, DatasetCore, Quad, Quad_Graph, Term } from "@rdfjs/ty
 import { NamedGraphError } from "./errors/NamedGraphError.js"
 
 class NamedGraphDataset implements DatasetCore {
-    private readonly graph: Quad_Graph
-
-    constructor(graph: Term | string, private readonly dataset: DatasetCore, private readonly factory: DataFactory) {
-        this.graph = typeof graph === "string" ? factory.namedNode(graph) : graph as Quad_Graph
+    constructor(private readonly graph: Quad_Graph, private readonly dataset: DatasetCore, private readonly factory: DataFactory) {
     }
 
     get size(): number {
@@ -58,19 +55,19 @@ class NamedGraphDataset implements DatasetCore {
  * underlying dataset. Any attempt to use a non-default graph on the returned dataset throws a
  * {@link NamedGraphError}.
  *
- * @param graph - The named graph to project, either as a {@link Term} or a string IRI.
+ * @param graph - The graph to project as a {@link Quad_Graph}.
  * @param dataset - The underlying dataset containing quads in one or more named graphs.
  * @param factory - A {@link DataFactory} used to construct quads.
  * @returns A {@link DatasetCore} view scoped to the specified named graph.
  *
  * @example
  * ```ts
- * const view = namedGraph("https://example.org/graph1", dataset, DataFactory)
+ * const view = namedGraph(DataFactory.namedNode("https://example.org/graph1"), dataset, DataFactory)
  * for (const quad of view) {
  *     console.log(quad.graph.termType) // "DefaultGraph"
  * }
  * ```
  */
-export function namedGraph(graph: Term | string, dataset: DatasetCore, factory: DataFactory): DatasetCore {
+export function namedGraph(graph: Quad_Graph, dataset: DatasetCore, factory: DataFactory): DatasetCore {
     return new NamedGraphDataset(graph, dataset, factory)
 }

test/unit/named_graph.test.ts

@@ -3,14 +3,14 @@ import { describe, it } from "node:test"
 import { DataFactory, Store } from "n3"
 import { namedGraph, NamedGraphError } from "@rdfjs/wrapper"
 
-const graph = "https://example.org/graph"
+const graph = DataFactory.namedNode("https://example.org/graph")
 const s = DataFactory.namedNode("https://example.org/s")
 const p = DataFactory.namedNode("https://example.org/p")
 const o = DataFactory.literal("value")
 
 function storeWithNamedGraph(): Store {
     const store = new Store()
-    store.addQuad(DataFactory.quad(s, p, o, DataFactory.namedNode(graph)))
+    store.addQuad(DataFactory.quad(s, p, o, graph))
     store.addQuad(DataFactory.quad(s, p, DataFactory.literal("default")))
     return store
 }
@@ -27,14 +27,6 @@ await describe("namedGraph", async () => {
         assert.equal(quads[0]!.graph.termType, "DefaultGraph")
     })
 
-    await it("accepts a Term as the graph parameter", () => {
-        const ds = namedGraph(DataFactory.namedNode(graph), storeWithNamedGraph(), DataFactory)
-        const quads = Array.from(ds)
-
-        assert.equal(quads.length, 1)
-        assert.equal(quads[0]!.graph.termType, "DefaultGraph")
-    })
-
     await it("reports correct size", () => {
         const ds = namedGraph(graph, storeWithNamedGraph(), DataFactory)
         assert.equal(ds.size, 1)
@@ -58,7 +50,7 @@ await describe("namedGraph", async () => {
         ds.add(DataFactory.quad(s, p, newObj))
 
         assert.equal(ds.size, 2)
-        assert.equal(store.has(DataFactory.quad(s, p, newObj, DataFactory.namedNode(graph))), true)
+        assert.equal(store.has(DataFactory.quad(s, p, newObj, graph)), true)
     })
 
     await it("delete removes from the named graph of the underlying dataset", () => {
@@ -68,14 +60,14 @@ await describe("namedGraph", async () => {
         ds.delete(DataFactory.quad(s, p, o))
 
         assert.equal(ds.size, 0)
-        assert.equal(store.has(DataFactory.quad(s, p, o, DataFactory.namedNode(graph))), false)
+        assert.equal(store.has(DataFactory.quad(s, p, o, graph)), false)
     })
 
     await it("match filters by subject/predicate/object within the named graph", () => {
         const store = new Store()
         const p2 = DataFactory.namedNode("https://example.org/p2")
-        store.addQuad(DataFactory.quad(s, p, o, DataFactory.namedNode(graph)))
-        store.addQuad(DataFactory.quad(s, p2, DataFactory.literal("other"), DataFactory.namedNode(graph)))
+        store.addQuad(DataFactory.quad(s, p, o, graph))
+        store.addQuad(DataFactory.quad(s, p2, DataFactory.literal("other"), graph))
 
         const ds = namedGraph(graph, store, DataFactory)
         const matched = Array.from(ds.match(undefined, p2))