DatasetWrapper

Author: langsamu

src/DatasetCoreBase.ts

@@ -0,0 +1,32 @@
+import type { DataFactory, DatasetCore, Quad, Term } from "@rdfjs/types"
+
+export abstract class DatasetCoreBase implements DatasetCore {
+    public constructor(private readonly dataset: DatasetCore, protected readonly factory: DataFactory) {
+    }
+
+    public get size(): number {
+        return this.dataset.size
+    }
+
+    public [Symbol.iterator](): Iterator<Quad> {
+        return this.dataset[Symbol.iterator]()
+    }
+
+    public add(quad: Quad): this {
+        this.dataset.add(quad)
+        return this
+    }
+
+    public delete(quad: Quad): this {
+        this.dataset.delete(quad)
+        return this
+    }
+
+    public has(quad: Quad): boolean {
+        return this.dataset.has(quad)
+    }
+
+    public match(subject?: Term, predicate?: Term, object?: Term, graph?: Term): DatasetCore {
+        return this.dataset.match(subject, predicate, object, graph)
+    }
+}

src/DatasetWrapper.ts

@@ -0,0 +1,37 @@
+import { DatasetCoreBase } from "./DatasetCoreBase.js"
+import type { DataFactory, DatasetCore, Term } from "@rdfjs/types"
+
+type TermWrapperConstructor<T> = new (term: Term, dataset: DatasetCore, factory: DataFactory) => T
+
+export class DatasetWrapper extends DatasetCoreBase {
+    protected* subjectsOf<T>(termWrapper: TermWrapperConstructor<T>, predicate?: Term, object?: Term, graph?: Term): Iterable<T> {
+        for (const q of this.match(undefined, predicate, object, graph)) {
+            yield new termWrapper(q.subject, this, this.factory)
+        }
+    }
+
+    protected* objectsOf<T>(termWrapper: TermWrapperConstructor<T>, subject?: Term, predicate?: Term, graph?: Term): Iterable<T> {
+        for (const q of this.match(subject, predicate, undefined, graph)) {
+            yield new termWrapper(q.object, this, this.factory)
+        }
+    }
+
+    protected* objectsOfX<T>([s, p, g]: [Term?, Term?, Term?], termWrapper: TermWrapperConstructor<T>): Iterable<T> {
+        for (const q of this.match(s, p, undefined, g)) {
+            yield new termWrapper(q.object, this, this.factory)
+        }
+    }
+
+    protected* subjectsOfX<T>([p, o, g]: [Term?, Term?, Term?], termWrapper: TermWrapperConstructor<T>): Iterable<T> {
+        for (const q of this.match(undefined, p, o, g)) {
+            yield new termWrapper(q.subject, this, this.factory)
+        }
+    }
+
+    protected instancesOf<T>(constructor: TermWrapperConstructor<T>, classTerm: Term): Iterable<T> {
+        // TODO: Vocab
+        const rdfType = this.factory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
+
+        return this.subjectsOf(constructor, rdfType, classTerm)
+    }
+}

src/mod.ts

@@ -4,6 +4,7 @@ export * from "./ValueMapping.js"
 export * from "./ValueMappings.js"
 export * from "./TermWrapper.js"
 export * from "./WrappingSet.js"
+export * from "./DatasetWrapper.js"
 export * from "./decorators/GetterArity.js"
 export * from "./decorators/setterArity.js"
 export * from "./decorators/getter.js"

test/unit/example.test.ts

@@ -1,7 +1,7 @@
 import { DataFactory, Parser, Store } from "n3"
 import assert from "node:assert"
 import { describe, it } from "node:test"
-import { Parent } from "./model/Parent.js"
+import { MyDataset } from "./model/MyDataset.js"
 import { Child } from "./model/Child.js"
 import { SomeModelClass } from "./model/SomeModelClass.js"
 
@@ -21,34 +21,33 @@ prefix : <https://example.org/>
 ] .
 `;
 
-        const dataset = new Store();
-        dataset.addQuads(new Parser().parse(rdf));
-        const x = DataFactory.namedNode("x")
-
-        const p = new Parent(x, dataset, DataFactory)
+        const store = new Store()
+        store.addQuads(new Parser().parse(rdf));
+        const dataset = new MyDataset(store, DataFactory)
 
+        for (const p of dataset.parents) {
+            assert.equal("o1", p.hasString)
+            assert.equal("name", p.hasChild.hasName)
+            for (const c of p.hasChildSet) {
+                // TODO: assertions
+                console.log("p.hasChildSet.hasName", c.hasName);
+            }
 
-        assert.equal("o1", p.hasString)
-        assert.equal("name", p.hasChild.hasName)
-        for (const c of p.hasChildSet) {
-            // TODO: assertions
-            console.log("p.hasChildSet.hasName", c.hasName);
-        }
-
-        p.hasString = "x"
-        assert.equal("x", p.hasString)
+            p.hasString = "x"
+            assert.equal("x", p.hasString)
 
-        const newNode = DataFactory.namedNode("example.com/s")
-        const newChild = new Child(newNode, dataset, DataFactory)
-        newChild.hasName = "new name"
-        p.hasChild = newChild
+            const newNode = DataFactory.namedNode("example.com/s")
+            const newChild = new Child(newNode, dataset, DataFactory)
+            newChild.hasName = "new name"
+            p.hasChild = newChild
 
-        assert.equal("new name", p.hasChild.hasName)
+            assert.equal("new name", p.hasChild.hasName)
 
-        p.hasChildSet.add(newChild)
-        for (const c of p.hasChildSet) {
-            // TODO: assertions
-            console.log("p.hasChildSet.hasName modified", c.hasName);
+            p.hasChildSet.add(newChild)
+            for (const c of p.hasChildSet) {
+                // TODO: assertions
+                console.log("p.hasChildSet.hasName modified", c.hasName);
+            }
         }
     })
 

test/unit/model/MyDataset.ts

@@ -0,0 +1,9 @@
+import { DatasetWrapper } from "rdfjs-wrapper"
+import { Parent } from "./Parent.js"
+import { Vocabulary } from "../Vocabulary.js"
+
+export class MyDataset extends DatasetWrapper {
+    public get parents(): Iterable<Parent> {
+        return this.subjectsOf(Parent, Vocabulary.hasChild)
+    }
+}