refactor: simplify Dataset implementations

.changeset/wet-rice-kiss.md

@@ -0,0 +1,5 @@
+---
+"@zazuko/env": patch
+---
+
+`DatasetExt#filter` was annotated with wrong return type

packages/env/lib/Dataset.ts

@@ -28,19 +28,15 @@ export class Dataset extends DatasetCore {
     Array.from(this).forEach(quad => callback(quad, this))
   }
 
-  filter(filter: (quad: Rdf.Quad, dataset: typeof this) => boolean) {
-    return new Dataset([...this].filter(quad => filter(quad, this)))
+  filter(filter: (quad: Rdf.Quad, dataset: typeof this) => boolean): this {
+    return new (this.constructor as any)([...this].filter(quad => filter(quad, this))) as any
   }
 
   map(callback: (quad: Rdf.Quad, dataset: typeof this) => Rdf.Quad): this {
-    return new Dataset([...this].map(quad => callback(quad, this))) as any
-  }
-
-  match(...args: Parameters<DatasetCore['match']>): this {
-    return super.match(...args) as any
+    return new (this.constructor as any)([...this].map(quad => callback(quad, this))) as any
   }
 
   merge(...[other]: Rest<Parameters<typeof addAll>>): this {
-    return addAll(new Dataset([...this]), other) as any
+    return addAll(new (this.constructor as any)([...this]), other) as any
   }
 }

packages/env/lib/DatasetExt.ts

@@ -1,10 +1,6 @@
 import type { Readable } from 'stream'
-import DatasetCore from '@rdfjs/dataset/DatasetCore.js'
 import toCanonical from 'rdf-dataset-ext/toCanonical.js'
 import toStream from 'rdf-dataset-ext/toStream.js'
-import addAll from 'rdf-dataset-ext/addAll.js'
-import deleteMatch from 'rdf-dataset-ext/deleteMatch.js'
-import equals from 'rdf-dataset-ext/equals.js'
 import fromStream from 'rdf-dataset-ext/fromStream.js'
 import type * as Rdf from '@rdfjs/types'
 import type { Environment } from '@rdfjs/environment/Environment.js'
@@ -13,7 +9,7 @@ import getStream from 'get-stream'
 import knownPrefixes from '@zazuko/prefixes'
 import type { Prefixes } from '@zazuko/prefixes/prefixes'
 import { MediaType } from '../formats.js'
-import type { Dataset as SimplerDataset } from './Dataset.js'
+import { Dataset as SimplerDataset } from './Dataset.js'
 
 type Rest<A extends unknown[]> = A extends [unknown, ...infer U] ? U : never
 
@@ -44,43 +40,11 @@ export interface DatasetCtor {
 }
 
 export function createConstructor(env: Environment<FormatsFactory>): DatasetCtor {
-  return class Dataset extends DatasetCore {
-    addAll(...[quads]: Rest<Parameters<typeof addAll>>) {
-      return addAll(this, quads)
-    }
-
-    deleteMatches(...args: Rest<Parameters<typeof deleteMatch>>) {
-      return deleteMatch(this, ...args)
-    }
-
-    equals(...[other]: Rest<Parameters<typeof equals>>) {
-      return equals(this, other)
-    }
-
-    forEach(callback:(quad: Rdf.Quad, dataset: typeof this) => void) {
-      Array.from(this).forEach(quad => callback(quad, this))
-    }
-
+  return class Dataset extends SimplerDataset {
     import(...[stream]: Rest<Parameters<typeof fromStream>>) {
       return fromStream(this, stream)
     }
 
-    filter(filter: (quad: Rdf.Quad, dataset: typeof this) => boolean) {
-      return new Dataset([...this].filter(quad => filter(quad, this)))
-    }
-
-    map(callback: (quad: Rdf.Quad, dataset: typeof this) => Rdf.Quad) {
-      return new Dataset([...this].map(quad => callback(quad, this)))
-    }
-
-    match(...args: Parameters<DatasetCore['match']>) {
-      return super.match(...args) as unknown as Dataset
-    }
-
-    merge(...[other]: Rest<Parameters<typeof addAll>>) {
-      return addAll(new Dataset([...this]), other)
-    }
-
     toCanonical() {
       return toCanonical(this)
     }

packages/env/test/lib/Dataset.test.ts

@@ -0,0 +1,56 @@
+import { expect } from 'chai'
+import { Dataset } from '../../lib/Dataset.js'
+
+describe('Dataset', () => {
+  describe('.filter', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const filtered = dataset.filter(() => true)
+
+      // then
+      expect(filtered).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.match', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const matched = dataset.match()
+
+      // then
+      expect(matched).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.merge', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const merged = dataset.merge([])
+
+      // then
+      expect(merged).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.map', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const mapped = dataset.map(quad => quad)
+
+      // then
+      expect(mapped).to.be.instanceOf(Dataset)
+    })
+  })
+})

packages/env/test/lib/DatasetExt.test.ts

@@ -0,0 +1,60 @@
+import FormatsFactory from '@rdfjs/formats/Factory.js'
+import { expect } from 'chai'
+import { createConstructor } from '../../lib/DatasetExt.js'
+import Environment from '../../Environment.js'
+
+describe('DatasetExt', () => {
+  const Dataset = createConstructor(new Environment([FormatsFactory]))
+
+  describe('.filter', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const filtered = dataset.filter(() => true)
+
+      // then
+      expect(filtered).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.match', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const matched = dataset.match()
+
+      // then
+      expect(matched).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.merge', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const merged = dataset.merge([])
+
+      // then
+      expect(merged).to.be.instanceOf(Dataset)
+    })
+  })
+
+  describe('.map', () => {
+    it('returns instance of its type', () => {
+      // given
+      const dataset = new Dataset()
+
+      // when
+      const mapped = dataset.map(quad => quad)
+
+      // then
+      expect(mapped).to.be.instanceOf(Dataset)
+    })
+  })
+})