transactionDataset readability refactor

packages/ldo/src/LdoDatasetFactory.ts

@@ -34,7 +34,7 @@ export class LdoDatasetFactory implements DatasetFactory<Quad, Quad> {
    */
   dataset(quads?: Dataset<Quad, Quad> | Quad[]): LdoDataset {
     return new LdoDataset(
-      this.datasetFactory,
+      this,
       quads
         ? Array.isArray(quads)
           ? this.datasetFactory.dataset(quads)

packages/ldo/src/LdoTransactionalDataset.ts

@@ -0,0 +1,23 @@
+import type { TransactionalDataset } from "@ldo/subscribable-dataset";
+import { LdoDataset } from "../dist/LdoDataset";
+import type { Quad } from "@rdfjs/types";
+import type { DatasetChanges } from "@ldo/rdf-utils";
+
+export class LdoTransactionalDataset
+  extends LdoDataset
+  implements TransactionalDataset<Quad>
+{
+  constructor() {
+    
+  }
+
+  rollback(): void {
+    throw new Error("Method not implemented.");
+  }
+  commit(): void {
+    throw new Error("Method not implemented.");
+  }
+  getChanges(): DatasetChanges<Quad> {
+    throw new Error("Method not implemented.");
+  }
+}

packages/subscribable-dataset/src/SubscribableDataset.ts

@@ -17,31 +17,34 @@ import type {
 } from "@rdfjs/types";
 import type {
   nodeEventListener,
-  SubscribableDataset,
+  ISubscribableDataset,
-  TransactionalDataset,
+  ITransactionDataset,
+  ITransactionDatasetFactory,
 } from "./types";
-import { ProxyTransactionalDataset } from "./ProxyTransactionalDataset";
 
 /**
  * A wrapper for a dataset that allows subscriptions to be made on nodes to
  * be triggered whenever a quad containing that added or removed.
  */
-export class WrapperSubscribableDataset<
+export class SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
-  InAndOutQuad extends BaseQuad = BaseQuad,
+  implements ISubscribableDataset<InAndOutQuad>
-> implements SubscribableDataset<InAndOutQuad>
 {
   /**
    * The underlying dataset factory
    */
-  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
+  protected datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
   /**
    * The underlying dataset
    */
-  private dataset: Dataset<InAndOutQuad, InAndOutQuad>;
+  protected dataset: Dataset<InAndOutQuad, InAndOutQuad>;
   /**
    * The underlying event emitter
    */
-  private eventEmitter: EventEmitter;
+  protected eventEmitter: EventEmitter;
+  /**
+   * The underlying dataset factory for creating transaction datasets
+   */
+  protected transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
   /**
    * Helps find all the events for a given listener
    */
@@ -54,9 +57,11 @@ export class WrapperSubscribableDataset<
    */
   constructor(
     datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
+    transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
     initialDataset?: Dataset<InAndOutQuad, InAndOutQuad>,
   ) {
     this.datasetFactory = datasetFactory;
+    this.transactionDatasetFactory = transactionDatasetFactory;
     this.dataset = initialDataset || this.datasetFactory.dataset();
     this.eventEmitter = new EventEmitter();
   }
@@ -249,6 +254,7 @@ export class WrapperSubscribableDataset<
    * Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.
    */
   public toArray(): InAndOutQuad[] {
+    console.log("Calling toArray");
     return this.dataset.toArray();
   }
 
@@ -609,7 +615,7 @@ export class WrapperSubscribableDataset<
   /**
    * Returns a transactional dataset that will update this dataset when its transaction is committed.
    */
-  public startTransaction(): TransactionalDataset<InAndOutQuad> {
+  public startTransaction(): ITransactionDataset<InAndOutQuad> {
-    return new ProxyTransactionalDataset(this, this.datasetFactory);
+    return this.transactionDatasetFactory.transactionDataset(this);
   }
 }

packages/subscribable-dataset/src/SubscribableDatasetFactory.ts

@@ -0,0 +1,31 @@
+import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
+import type { ITransactionDatasetFactory } from "./types";
+import { SubscribableDataset } from "./SubscribableDataset";
+
+/**
+ * A DatasetFactory that returns a SubscribableDataset given a generic DatasetFactory.
+ */
+export class SubscribableDatasetFactory<
+  InAndOutQuad extends BaseQuad = BaseQuad,
+> implements DatasetFactory<InAndOutQuad, InAndOutQuad>
+{
+  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
+  private transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
+  constructor(
+    datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
+    transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
+  ) {
+    this.datasetFactory = datasetFactory;
+    this.transactionDatasetFactory = transactionDatasetFactory;
+  }
+
+  dataset(
+    quads?: Dataset<InAndOutQuad, InAndOutQuad> | InAndOutQuad[],
+  ): SubscribableDataset<InAndOutQuad> {
+    return new SubscribableDataset(
+      this.datasetFactory,
+      this.transactionDatasetFactory,
+      quads ? this.datasetFactory.dataset(quads) : undefined,
+    );
+  }
+}

packages/subscribable-dataset/src/TransactionDataset.ts

@@ -1,27 +1,26 @@
 import type { Dataset, BaseQuad, Term, DatasetFactory } from "@rdfjs/types";
 import type { DatasetChanges } from "@ldo/rdf-utils";
-import type { BulkEditableDataset, TransactionalDataset } from "./types";
+import type {
-import { ExtendedDataset } from "@ldo/dataset";
+  ISubscribableDataset,
+  ITransactionDataset,
+  ITransactionDatasetFactory,
+} from "./types";
 import { mergeDatasetChanges } from "./mergeDatasetChanges";
+import { SubscribableDataset } from "./SubscribableDataset";
 
 /**
  * Proxy Transactional Dataset is a transactional dataset that does not duplicate
  * the parent dataset, it will dynamically determine the correct return value for
  * methods in real time when the method is called.
  */
-export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
+export class TransactionDataset<InAndOutQuad extends BaseQuad = BaseQuad>
-  extends ExtendedDataset<InAndOutQuad>
+  extends SubscribableDataset<InAndOutQuad>
-  implements TransactionalDataset<InAndOutQuad>
+  implements ITransactionDataset<InAndOutQuad>
 {
   /**
    * The parent dataset that will be updated upon commit
    */
-  private parentDataset: Dataset<InAndOutQuad, InAndOutQuad>;
+  public readonly parentDataset: ISubscribableDataset<InAndOutQuad>;
-
-  /**
-   * A factory for creating new datasets to be added to the update method
-   */
-  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
 
   /**
    * The changes made that are ready to commit
@@ -42,12 +41,12 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
    * @param parentDataset The dataset that will be updated upon commit
    */
   constructor(
-    parentDataset: Dataset<InAndOutQuad, InAndOutQuad>,
+    parentDataset: ISubscribableDataset<InAndOutQuad>,
     datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
+    transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
   ) {
-    super(datasetFactory.dataset(), datasetFactory);
+    super(datasetFactory, transactionDatasetFactory, datasetFactory.dataset());
     this.parentDataset = parentDataset;
-    this.datasetFactory = datasetFactory;
     this.datasetChanges = {};
   }
 
@@ -179,6 +178,7 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
    * Returns an iterator
    */
   public [Symbol.iterator](): Iterator<InAndOutQuad> {
+    console.log("Getting Iterator");
     const addedIterator = (this.datasetChanges.added || [])[Symbol.iterator]();
     let addedNext = addedIterator.next();
     const parentIterator = this.parentDataset[Symbol.iterator]();
@@ -253,9 +253,7 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
   private updateParentDataset(datasetChanges: DatasetChanges<InAndOutQuad>) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     if ((this.parentDataset as any).bulk) {
-      (this.parentDataset as BulkEditableDataset<InAndOutQuad>).bulk(
+      this.parentDataset.bulk(datasetChanges);
-        datasetChanges,
-      );
     } else {
       if (datasetChanges.added) {
         this.parentDataset.addAll(datasetChanges.added);
@@ -296,17 +294,6 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
     this.committedDatasetChanges = undefined;
   }
 
-  /**
-   * Starts a new transaction with this transactional dataset as the parent
-   * @returns
-   */
-  public startTransaction(): TransactionalDataset<InAndOutQuad> {
-    // This is caused by the typings being incorrect for the intersect method
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return new ProxyTransactionalDataset(this, this.datasetFactory);
-  }
-
   public getChanges(): DatasetChanges<InAndOutQuad> {
     return this.datasetChanges;
   }

packages/subscribable-dataset/src/TransactionDatasetFactory.ts

@@ -0,0 +1,27 @@
+import type { BaseQuad, DatasetFactory } from "@rdfjs/types";
+import type { ISubscribableDataset, ITransactionDatasetFactory } from "./types";
+import { TransactionDataset } from "./TransactionDataset";
+
+export class TransactionDatasetFactory<InAndOutQuad extends BaseQuad>
+  implements ITransactionDatasetFactory<InAndOutQuad>
+{
+  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
+  private transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
+  constructor(
+    datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
+    transactionDatasetFactory?: ITransactionDatasetFactory<InAndOutQuad>,
+  ) {
+    this.datasetFactory = datasetFactory;
+    this.transactionDatasetFactory = transactionDatasetFactory || this;
+  }
+
+  transactionDataset(
+    parentDataset: ISubscribableDataset<InAndOutQuad>,
+  ): TransactionDataset<InAndOutQuad> {
+    return new TransactionDataset<InAndOutQuad>(
+      parentDataset,
+      this.datasetFactory,
+      this.transactionDatasetFactory,
+    );
+  }
+}

packages/subscribable-dataset/src/WrapperSubscribableDatasetFactory.ts

@@ -1,27 +0,0 @@
-import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
-import { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
-
-/**
- * A DatasetFactory that returns a WrapperSubscribableDataset given a generic DatasetFactory.
- */
-export class WrapperSubscribableDatasetFactory<
-  InAndOutQuad extends BaseQuad = BaseQuad,
-> implements DatasetFactory<InAndOutQuad, InAndOutQuad>
-{
-  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
-  constructor(datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>) {
-    this.datasetFactory = datasetFactory;
-  }
-
-  dataset(
-    quads?: Dataset<InAndOutQuad, InAndOutQuad> | InAndOutQuad[],
-  ): WrapperSubscribableDataset<InAndOutQuad> {
-    // Typings are wrong
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return new WrapperSubscribableDataset(
-      this.datasetFactory,
-      quads ? this.datasetFactory.dataset(quads) : undefined,
-    );
-  }
-}

packages/subscribable-dataset/src/createSubscribableDataset.ts

@@ -0,0 +1,46 @@
+import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
+import { createDataset } from "@ldo/dataset";
+import { SubscribableDatasetFactory } from "./SubscribableDatasetFactory";
+import type {
+  ISubscribableDataset,
+  ISubscribableDatasetFactory,
+  ITransactionDatasetFactory,
+} from "./types";
+import { TransactionDatasetFactory } from "./TransactionDatasetFactory";
+
+const datasetFactory: DatasetFactory<Quad> = {
+  dataset: (quads?: Dataset<Quad> | Quad[]): Dataset<Quad> => {
+    return createDataset(quads);
+  },
+};
+
+/**
+ * Creates a factory that generates TransactionDatasets
+ * @returns TransactionDatasetFactory
+ */
+export function createTransactionDatasetFactory(): ITransactionDatasetFactory<Quad> {
+  return new TransactionDatasetFactory(datasetFactory);
+}
+
+/**
+ * Creates a dataset factory that generates a SubscribableDataset
+ * @returns DatasetFactory for SubscribableDataset
+ */
+export function createSubscribableDatasetFactory(): ISubscribableDatasetFactory<Quad> {
+  return new SubscribableDatasetFactory(
+    datasetFactory,
+    createTransactionDatasetFactory(),
+  );
+}
+
+/**
+ * Creates a SubscribableDataset
+ * @param quads: A dataset or array of Quads to initialize the dataset.
+ * @returns Dataset
+ */
+export function createSubscribableDataset(
+  quads?: Dataset<Quad> | Quad[],
+): ISubscribableDataset<Quad> {
+  const subscribableDatasetFactory = createSubscribableDatasetFactory();
+  return subscribableDatasetFactory.dataset(quads);
+}

packages/subscribable-dataset/src/createSubscribableDatasetFromSerializedInput.ts

@@ -1,8 +1,8 @@
 import type { Quad } from "@rdfjs/types";
 import type { ParserOptions } from "@ldo/rdf-utils";
 import { createDatasetFromSerializedInput } from "@ldo/dataset";
-import { createWrapperSubscribableDatasetFactory } from "./createWrapperSubscribableDataset";
+import { createSubscribableDatasetFactory } from "./createSubscribableDataset";
-import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
+import type { ISubscribableDataset } from "./types";
 
 /**
  * Creates a SubscribableDataset with a string input that could be JSON-LD, Turtle, N-Triples, TriG, RDF*, or N3.
@@ -18,9 +18,9 @@ import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
 export async function createWrapperSubscribableDatasetFromSerializedInput(
   data: string,
   options?: ParserOptions,
-): Promise<WrapperSubscribableDataset<Quad>> {
+): Promise<ISubscribableDataset<Quad>> {
-  const datasetFactory = createWrapperSubscribableDatasetFactory();
+  const datasetFactory = createSubscribableDatasetFactory();
-  return createDatasetFromSerializedInput<WrapperSubscribableDataset<Quad>>(
+  return createDatasetFromSerializedInput<ISubscribableDataset<Quad>>(
     datasetFactory,
     data,
     options,

packages/subscribable-dataset/src/createWrapperSubscribableDataset.ts

@@ -1,30 +0,0 @@
-import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
-import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
-import { createDataset } from "@ldo/dataset";
-import { WrapperSubscribableDatasetFactory } from "./WrapperSubscribableDatasetFactory";
-
-/**
- * Creates a dataset factory that generates a SubscribableDataset
- * @returns DatasetFactory for SubscribableDataset
- */
-export function createWrapperSubscribableDatasetFactory(): WrapperSubscribableDatasetFactory<Quad> {
-  const datasetFactory: DatasetFactory<Quad> = {
-    dataset: (quads?: Dataset<Quad> | Quad[]): Dataset<Quad> => {
-      return createDataset(quads);
-    },
-  };
-  return new WrapperSubscribableDatasetFactory(datasetFactory);
-}
-
-/**
- * Creates a SubscribableDataset
- * @param quads: A dataset or array of Quads to initialize the dataset.
- * @returns Dataset
- */
-export function createWrapperSubscribableDataset(
-  quads?: Dataset<Quad> | Quad[],
-): WrapperSubscribableDataset<Quad> {
-  const wrapperSubscribableDatasetFactory =
-    createWrapperSubscribableDatasetFactory();
-  return wrapperSubscribableDatasetFactory.dataset(quads);
-}

packages/subscribable-dataset/src/index.ts

@@ -1,10 +1,8 @@
-export {
+export * from "./createSubscribableDataset";
-  createWrapperSubscribableDataset as createSubscribableDataset,
+export { createWrapperSubscribableDatasetFromSerializedInput as serializedToSubscribableDataset } from "./createSubscribableDatasetFromSerializedInput";
-  createWrapperSubscribableDatasetFactory as createSubscribableDatasetFactory,
+export * from "./TransactionDataset";
-} from "./createWrapperSubscribableDataset";
+export * from "./TransactionDatasetFactory";
-export { createWrapperSubscribableDatasetFromSerializedInput as serializedToSubscribableDataset } from "./createWrapperSubscribableDatasetFromSerializedInput";
+export * from "./SubscribableDataset";
-export * from "./ProxyTransactionalDataset";
+export * from "./SubscribableDatasetFactory";
-export * from "./WrapperSubscribableDataset";
-export * from "./WrapperSubscribableDatasetFactory";
 export * from "./types";
 export * from "./mergeDatasetChanges";

packages/subscribable-dataset/src/types.ts

@@ -1,5 +1,5 @@
 import type { DatasetChanges, QuadMatch } from "@ldo/rdf-utils";
-import type { Dataset, BaseQuad } from "@rdfjs/types";
+import type { Dataset, BaseQuad, DatasetFactory } from "@rdfjs/types";
 
 /**
  * An event listeners for nodes
@@ -11,28 +11,29 @@ export type nodeEventListener<InAndOutQuad extends BaseQuad = BaseQuad> = (
 /**
  * Adds the bulk method for add and remove
  */
-export interface BulkEditableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
+export interface IBulkEditableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
   extends Dataset<InAndOutQuad, InAndOutQuad> {
   bulk(changes: DatasetChanges<InAndOutQuad>): this;
 }
 
 /**
- * A dataset that allows you to modify the dataset and
+ * Factory for creating SubscribableDatasets
  */
-export interface TransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
+export type ISubscribableDatasetFactory<
-  extends BulkEditableDataset<InAndOutQuad> {
+  InAndOutQuad extends BaseQuad = BaseQuad,
-  rollback(): void;
+> = DatasetFactory<
-  commit(): void;
+  InAndOutQuad,
-  getChanges(): DatasetChanges<InAndOutQuad>;
+  InAndOutQuad,
-}
+  ISubscribableDataset<InAndOutQuad>
+>;
 
 /**
  * Dataset that allows developers to subscribe to a sepecific term and be alerted
  * if a quad is added or removed containing that term. It's methods follow the
  * EventEmitter interface except take in namedNodes as keys.
  */
-export interface SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
+export interface ISubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
-  extends BulkEditableDataset<InAndOutQuad> {
+  extends IBulkEditableDataset<InAndOutQuad> {
   /**
    * Alias for emitter.on(eventName, listener).
    * @param eventName
@@ -140,5 +141,27 @@ export interface SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
   /**
    * Returns a transactional dataset that will update this dataset when its transaction is committed.
    */
-  startTransaction(): TransactionalDataset<InAndOutQuad>;
+  startTransaction(): ITransactionDataset<InAndOutQuad>;
+}
+
+/**
+ * Creates a TransactionDataset
+ */
+export interface ITransactionDatasetFactory<
+  InAndOutQuad extends BaseQuad = BaseQuad,
+> {
+  transactionDataset(
+    parent: ISubscribableDataset<InAndOutQuad>,
+  ): ITransactionDataset<InAndOutQuad>;
+}
+
+/**
+ * A dataset that allows you to modify the dataset and
+ */
+export interface ITransactionDataset<InAndOutQuad extends BaseQuad = BaseQuad>
+  extends ISubscribableDataset<InAndOutQuad> {
+  readonly parentDataset: ISubscribableDataset<InAndOutQuad>;
+  rollback(): void;
+  commit(): void;
+  getChanges(): DatasetChanges<InAndOutQuad>;
 }

packages/subscribable-dataset/test/SubscribableDataset.test.ts

@@ -1,5 +1,5 @@
-import type { SubscribableDataset } from "../src";
+import type { ISubscribableDataset } from "../src";
-import { ProxyTransactionalDataset, createSubscribableDataset } from "../src";
+import { TransactionDataset, createSubscribableDataset } from "../src";
 import { createDataset } from "@ldo/dataset";
 import {
   namedNode,
@@ -11,14 +11,14 @@ import {
 import type { Quad, BlankNode } from "@rdfjs/types";
 import testDataset from "@ldo/dataset/test/dataset.testHelper";
 
-describe("WrapperSubscribableDataset", () => {
+describe("SubscribableDataset", () => {
   // Regular dataset tests
   testDataset({
     dataset: createSubscribableDataset,
   });
 
   // Subscribable Dataset tests
-  let subscribableDatastet: SubscribableDataset<Quad>;
+  let subscribableDatastet: ISubscribableDataset<Quad>;
   const tomTypeQuad = quad(
     namedNode("http://example.org/cartoons#Tom"),
     namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
@@ -449,8 +449,7 @@ describe("WrapperSubscribableDataset", () => {
 
   it("Returns a transaction", () => {
     expect(
-      subscribableDatastet.startTransaction() instanceof
+      subscribableDatastet.startTransaction() instanceof TransactionDataset,
-        ProxyTransactionalDataset,
     ).toBe(true);
   });
 });

packages/subscribable-dataset/test/TransactionalDataset.test.ts

@@ -5,14 +5,18 @@ import type {
   Quad,
   DatasetCore,
 } from "@rdfjs/types";
-import type { BulkEditableDataset } from "../src";
+import type { ISubscribableDataset } from "../src";
 import { ExtendedDatasetFactory } from "@ldo/dataset";
-import { ProxyTransactionalDataset } from "../src";
+import {
+  TransactionDataset,
+  createSubscribableDataset,
+  createTransactionDatasetFactory,
+} from "../src";
 import datasetCoreFactory from "@rdfjs/dataset";
 
-describe("ProxyTransactionalDataset", () => {
+describe("TransactionDataset", () => {
-  let parentDataset: Dataset<Quad>;
+  let parentDataset: ISubscribableDataset<Quad>;
-  let transactionalDataset: ProxyTransactionalDataset<Quad>;
+  let transactionalDataset: TransactionDataset<Quad>;
   const tomTypeQuad = quad(
     namedNode("http://example.org/cartoons#Tom"),
     namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
@@ -41,12 +45,13 @@ describe("ProxyTransactionalDataset", () => {
   const extendedDatasetFactory = new ExtendedDatasetFactory(datasetFactory);
 
   const initializeWithExtendedDatasetParent = (quads?: Quad[]) => {
-    parentDataset = extendedDatasetFactory.dataset(
+    parentDataset = createSubscribableDataset(
       quads || [tomTypeQuad, tomNameQuad],
     );
-    transactionalDataset = new ProxyTransactionalDataset(
+    transactionalDataset = new TransactionDataset(
       parentDataset,
       extendedDatasetFactory,
+      createTransactionDatasetFactory(),
     );
   };
 
@@ -301,14 +306,15 @@ describe("ProxyTransactionalDataset", () => {
     // Disable for tests
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    const mockParent: BulkEditableDataset<Quad> = {
+    const mockParent: ISubscribableDataset<Quad> = {
       bulk: jest.fn(),
       has: (curQuad) => parentDataset.has(curQuad),
       [Symbol.iterator]: () => parentDataset[Symbol.iterator](),
     };
-    transactionalDataset = new ProxyTransactionalDataset<Quad>(
+    transactionalDataset = new TransactionDataset<Quad>(
       mockParent,
       extendedDatasetFactory,
+      createTransactionDatasetFactory(),
     );
 
     transactionalDataset.add(lickyNameQuad);
@@ -319,8 +325,7 @@ describe("ProxyTransactionalDataset", () => {
 
   it("Returns a transactional dataset", () => {
     expect(
-      transactionalDataset.startTransaction() instanceof
+      transactionalDataset.startTransaction() instanceof TransactionDataset,
-        ProxyTransactionalDataset,
     ).toBe(true);
   });
 

packages/subscribable-dataset/test/index.test.ts

@@ -2,17 +2,19 @@ import {
   createSubscribableDataset,
   createSubscribableDatasetFactory,
   serializedToSubscribableDataset,
-  ProxyTransactionalDataset,
+  SubscribableDataset,
-  WrapperSubscribableDataset,
+  SubscribableDatasetFactory,
-  WrapperSubscribableDatasetFactory,
+  TransactionDataset,
+  TransactionDatasetFactory,
 } from "../src";
 
 describe("Exports", () => {
   it("Has all exports", () => {
     expect(createSubscribableDataset);
-    expect(ProxyTransactionalDataset);
+    expect(SubscribableDataset);
-    expect(WrapperSubscribableDataset);
+    expect(TransactionDataset);
-    expect(WrapperSubscribableDatasetFactory);
+    expect(SubscribableDatasetFactory);
+    expect(TransactionDatasetFactory);
     expect(serializedToSubscribableDataset);
     expect(createSubscribableDatasetFactory);
   });