Updated @ldo/ldo to have a transaction dataset

packages/ldo/src/LdoDataset.ts

@@ -1,9 +1,11 @@
 import type { Quad } from "@rdfjs/types";
 import jsonldDatasetProxy from "@ldo/jsonld-dataset-proxy";
-import { WrapperSubscribableDataset } from "@ldo/subscribable-dataset";
+import { SubscribableDataset } from "@ldo/subscribable-dataset";
 import { LdoBuilder } from "./LdoBuilder";
 import type { ShapeType } from "./ShapeType";
 import type { LdoBase } from "./index";
+import { LdoTransactionDataset } from "./LdoTransactionDataset";
+import type { ILdoDataset } from "./types";
 
 /**
  * @category Getting an LdoDataset
@@ -22,7 +24,10 @@ import type { LdoBase } from "./index";
  * const ldoBuilder = ldoDataset.usingType(FoafProfileShapeType);
  * ```
  */
-export class LdoDataset extends WrapperSubscribableDataset<Quad> {
+export class LdoDataset
+  extends SubscribableDataset<Quad>
+  implements ILdoDataset
+{
   /**
    * Creates an LdoBuilder for a given shapeType
    *
@@ -35,4 +40,12 @@ export class LdoDataset extends WrapperSubscribableDataset<Quad> {
     const proxyBuilder = jsonldDatasetProxy(this, shapeType.context);
     return new LdoBuilder(proxyBuilder, shapeType);
   }
+
+  public startTransaction(): LdoTransactionDataset {
+    return new LdoTransactionDataset(
+      this,
+      this.datasetFactory,
+      this.transactionDatasetFactory,
+    );
+  }
 }

packages/ldo/src/LdoDatasetFactory.ts

@@ -1,4 +1,6 @@
-import type { DatasetFactory, Dataset, Quad } from "@rdfjs/types";
+import type { Dataset, Quad } from "@rdfjs/types";
+import type { ISubscribableDatasetFactory } from "@ldo/subscribable-dataset";
+import { SubscribableDatasetFactory } from "@ldo/subscribable-dataset";
 import { LdoDataset } from "./LdoDataset";
 
 /**
@@ -9,37 +11,28 @@ import { LdoDataset } from "./LdoDataset";
  *
  * @example
  * ```typescript
- * import { createLdoDatasetFactory } from "ldo";
+ * import { createLdoDatasetFactory } from "@ldo/ldo";
+ * import { createExtendedDatasetFactory } from "@ldo/dataset";
+ * import { createTransactionDatasetFactory } from "@ldo/subscribable-dataset";
  *
- * const datasetFactory = // some RDF/JS Dataset Factory
- * const ldoDatasetFactory = new LdoDatasetFactory(datasetFactory);
+ * const datasetFactory = createExtendedDatasetFactory();
+ * const transactionDatasetFactory = createTransactionDatasetFactroy();
+ * const ldoDatasetFactory = new LdoDatasetFactory(
+ *   datasetFactory,
+ *   transactionDatasetFactory
+ * );
  * const ldoDataset = ldoDatasetFactory.dataset(initialDataset);
  * ```
  */
-export class LdoDatasetFactory implements DatasetFactory<Quad, Quad> {
-  private datasetFactory: DatasetFactory<Quad, Quad>;
-
-  /**
-   * @constructor
-   * @param datasetFactory - A generic dataset factory this factory will wrap
-   */
-  constructor(datasetFactory: DatasetFactory<Quad, Quad>) {
-    this.datasetFactory = datasetFactory;
-  }
-
-  /**
-   * Creates an LdoDataset
-   * @param quads - A list of quads to initialize the dataset
-   * @returns an LdoDataset
-   */
-  dataset(quads?: Dataset<Quad, Quad> | Quad[]): LdoDataset {
+export class LdoDatasetFactory
+  extends SubscribableDatasetFactory<Quad>
+  implements ISubscribableDatasetFactory<Quad>
+{
+  dataset(quads?: Dataset<Quad, Quad> | Quad[] | undefined): LdoDataset {
     return new LdoDataset(
-      this,
-      quads
-        ? Array.isArray(quads)
-          ? this.datasetFactory.dataset(quads)
-          : quads
-        : undefined,
+      this.datasetFactory,
+      this.transactionDatasetFactory,
+      this.datasetFactory.dataset(quads),
     );
   }
 }

packages/ldo/src/LdoTransactionDataset.ts

@@ -0,0 +1,19 @@
+import { TransactionDataset } from "@ldo/subscribable-dataset";
+import type { Quad } from "@rdfjs/types";
+import type { ILdoDataset } from "./types";
+import { LdoBuilder } from "./LdoBuilder";
+import type { ShapeType } from "./ShapeType";
+import type { LdoBase } from "./util";
+import jsonldDatasetProxy from "@ldo/jsonld-dataset-proxy";
+
+export class LdoTransactionDataset
+  extends TransactionDataset<Quad>
+  implements ILdoDataset
+{
+  usingType<Type extends LdoBase>(
+    shapeType: ShapeType<Type>,
+  ): LdoBuilder<Type> {
+    const proxyBuilder = jsonldDatasetProxy(this, shapeType.context);
+    return new LdoBuilder(proxyBuilder, shapeType);
+  }
+}

packages/ldo/src/LdoTransactionalDataset.ts

@@ -1,23 +0,0 @@
-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/ldo/src/createLdoDataset.ts

@@ -1,6 +1,7 @@
 import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
 import { createDataset } from "@ldo/dataset";
 import { LdoDatasetFactory } from "./LdoDatasetFactory";
+import { createTransactionDatasetFactory } from "@ldo/subscribable-dataset";
 import type { LdoDataset } from "./LdoDataset";
 
 /**
@@ -22,7 +23,10 @@ export function createLdoDatasetFactory() {
       return createDataset(quads);
     },
   };
-  return new LdoDatasetFactory(datasetFactory);
+  return new LdoDatasetFactory(
+    datasetFactory,
+    createTransactionDatasetFactory(),
+  );
 }
 
 /**

packages/ldo/src/types.ts

@@ -0,0 +1,9 @@
+import type { ISubscribableDataset } from "@ldo/subscribable-dataset";
+import type { LdoBuilder } from "./LdoBuilder";
+import type { ShapeType } from "./ShapeType";
+import type { LdoBase } from "./util";
+import type { Quad } from "@rdfjs/types";
+
+export interface ILdoDataset extends ISubscribableDataset<Quad> {
+  usingType<Type extends LdoBase>(shapeType: ShapeType<Type>): LdoBuilder<Type>;
+}

packages/ldo/src/util.ts

@@ -8,14 +8,15 @@ import {
 } from "@ldo/jsonld-dataset-proxy";
 import type { AnyNode } from "@ldo/rdf-utils";
 import type {
-  SubscribableDataset,
-  TransactionalDataset,
+  ISubscribableDataset,
+  ITransactionDataset,
 } from "@ldo/subscribable-dataset";
 
 /**
  * @category Types
  * `LdoBase` is an interface defining that a Linked Data Object is a JavaScript Object Literal.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type LdoBase = Record<string, any>;
 
 /**
@@ -42,21 +43,21 @@ export function normalizeNodeNames<NodeType extends AnyNode>(
 
 export function canDatasetStartTransaction(
   dataset: Dataset,
-): dataset is SubscribableDataset<Quad> {
+): dataset is ISubscribableDataset<Quad> {
   return (
-    typeof (dataset as SubscribableDataset).startTransaction === "function"
+    typeof (dataset as ISubscribableDataset).startTransaction === "function"
   );
 }
 
 export function isTransactionalDataset(
   dataset: Dataset,
-): dataset is TransactionalDataset<Quad> {
-  return typeof (dataset as TransactionalDataset).commit === "function";
+): dataset is ITransactionDataset<Quad> {
+  return typeof (dataset as ITransactionDataset).commit === "function";
 }
 
 export function getTransactionalDatasetFromLdo(
   ldo: LdoBase,
-): [TransactionalDataset<Quad>, SubjectProxy | ArrayProxy] {
+): [ITransactionDataset<Quad>, SubjectProxy | ArrayProxy] {
   const proxy = getProxyFromObject(ldo);
   const dataset = proxy[_getUnderlyingDataset];
   if (

packages/ldo/test/TransactionLdoDataset.test.ts

@@ -0,0 +1,21 @@
+import { createLdoDataset } from "../src/createLdoDataset";
+import { ProfileShapeType } from "./profileData";
+
+describe("TransactionLdoDataset", () => {
+  it("Uses transactions with an LdoBuilder", () => {
+    const ldoDataset = createLdoDataset();
+    const transaction = ldoDataset.startTransaction();
+    const profile = transaction
+      .usingType(ProfileShapeType)
+      .fromSubject("https://example.com/Person1");
+    profile.fn = "John Doe";
+    expect(transaction.getChanges().added?.toString()).toBe(
+      '<https://example.com/Person1> <http://www.w3.org/2006/vcard/ns#fn> "John Doe" .\n',
+    );
+    expect(ldoDataset.toString()).toBe("");
+    transaction.commit();
+    expect(ldoDataset.toString()).toBe(
+      '<https://example.com/Person1> <http://www.w3.org/2006/vcard/ns#fn> "John Doe" .\n',
+    );
+  });
+});

packages/ldo/test/methods.test.ts

@@ -9,7 +9,6 @@ import {
 import { createDataset } from "@ldo/dataset";
 import type { SolidProfileShape } from "./profileData";
 import { ProfileShapeType } from "./profileData";
-import type { LdoDataset } from "../src";
 import {
   commitTransaction,
   createLdoDataset,
@@ -25,9 +24,10 @@ import {
   setLanguagePreferences,
   languagesOf,
 } from "../src";
+import type { ILdoDataset } from "../src/types";
 
 describe("methods", () => {
-  let dataset: LdoDataset;
+  let dataset: ILdoDataset;
   let profile: SolidProfileShape;
   beforeEach(() => {
     dataset = createLdoDataset();

packages/subscribable-dataset/src/SubscribableDatasetFactory.ts

@@ -9,8 +9,8 @@ export class SubscribableDatasetFactory<
   InAndOutQuad extends BaseQuad = BaseQuad,
 > implements DatasetFactory<InAndOutQuad, InAndOutQuad>
 {
-  private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
-  private transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
+  protected datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
+  protected transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
   constructor(
     datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
     transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,