Refactored dependencies into context

package-lock.json

@@ -28721,6 +28721,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/typed-emitter": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/typed-emitter/-/typed-emitter-2.1.0.tgz",
+      "integrity": "sha512-g/KzbYKbH5C2vPkaXGu8DJlHrGKHLsM25Zg9WuC9pMGfuvT+X25tZQWo5fK1BjBm8+UrVE9LDCvaY0CQk+fXDA==",
+      "dev": true,
+      "optionalDependencies": {
+        "rxjs": "*"
+      }
+    },
     "node_modules/typedarray": {
       "version": "0.0.6",
       "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
@@ -31256,7 +31265,8 @@
         "@rdfjs/data-model": "^1.2.0",
         "@rdfjs/types": "^1.0.1",
         "@types/jest": "^29.0.3",
-        "ts-jest": "^29.0.2"
+        "ts-jest": "^29.0.2",
+        "typed-emitter": "^2.1.0"
       }
     },
     "packages/solid-react": {
@@ -39234,7 +39244,8 @@
         "@rdfjs/types": "^1.0.1",
         "@types/jest": "^29.0.3",
         "cross-fetch": "^3.1.6",
-        "ts-jest": "^29.0.2"
+        "ts-jest": "^29.0.2",
+        "typed-emitter": "*"
       },
       "dependencies": {
         "@jest/console": {
@@ -59644,6 +59655,15 @@
         "is-typed-array": "^1.1.9"
       }
     },
+    "typed-emitter": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/typed-emitter/-/typed-emitter-2.1.0.tgz",
+      "integrity": "sha512-g/KzbYKbH5C2vPkaXGu8DJlHrGKHLsM25Zg9WuC9pMGfuvT+X25tZQWo5fK1BjBm8+UrVE9LDCvaY0CQk+fXDA==",
+      "dev": true,
+      "requires": {
+        "rxjs": "*"
+      }
+    },
     "typedarray": {
       "version": "0.0.6",
       "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",

packages/solid/package.json

@@ -23,11 +23,12 @@
   },
   "homepage": "https://github.com/o-development/devtool-boilerplate#readme",
   "devDependencies": {
+    "@ldo/cli": "^0.0.0",
     "@rdfjs/data-model": "^1.2.0",
     "@rdfjs/types": "^1.0.1",
-    "@ldo/cli": "^0.0.0",
     "@types/jest": "^29.0.3",
-    "ts-jest": "^29.0.2"
+    "ts-jest": "^29.0.2",
+    "typed-emitter": "^2.1.0"
   },
   "dependencies": {
     "@ldo/dataset": "^0.0.0",
@@ -35,4 +36,4 @@
     "@ldo/rdf-utils": "^0.0.0",
     "cross-fetch": "^3.1.6"
   }
-}
+}

packages/solid/src/SolidLdoDataset.ts

@@ -4,46 +4,32 @@ import type { ContainerResource } from "./document/resource/dataResource/contain
 import type { AccessRules } from "./document/accessRules/AccessRules";
 import type { BinaryResource } from "./document/resource/binaryResource/BinaryResource";
 import type { DocumentGetterOptions } from "./document/DocumentStore";
-import type { DataResourceStore } from "./document/resource/dataResource/DataResourceStore";
-import type { ContainerResourceStore } from "./document/resource/dataResource/containerResource/ContainerResourceStore";
-import type { AccessRulesStore } from "./document/accessRules/AccessRulesStore";
-import type { BinaryResourceStore } from "./document/resource/binaryResource/BinaryResourceStore";
 import type { Dataset, DatasetFactory } from "@rdfjs/types";
 import type { Resource } from "./document/resource/Resource";
 import type { DocumentError } from "./document/errors/DocumentError";
-
-export interface SolidLdoDatasetArgs {
-  dataResourceStore: DataResourceStore;
-  containerResourceStore: ContainerResourceStore;
-  accessRulesStore: AccessRulesStore;
-  binaryResourceStore: BinaryResourceStore;
-  initialDataset?: Dataset;
-  datasetFactory: DatasetFactory;
-}
+import type { SolidLdoDatasetContext } from "./SolidLdoDatasetContext";
 
 export class SolidLdoDataset extends LdoDataset {
-  protected dataResourceStore: DataResourceStore;
-  protected containerResourceStore: ContainerResourceStore;
-  protected accessRulesStore: AccessRulesStore;
-  protected binaryResourceStore: BinaryResourceStore;
-
-  constructor(args: SolidLdoDatasetArgs) {
-    super(args.datasetFactory, args.initialDataset);
-    this.dataResourceStore = args.dataResourceStore;
-    this.containerResourceStore = args.containerResourceStore;
-    this.accessRulesStore = args.accessRulesStore;
-    this.binaryResourceStore = args.binaryResourceStore;
+  protected context: SolidLdoDatasetContext;
+
+  constructor(
+    context: SolidLdoDatasetContext,
+    datasetFactory: DatasetFactory,
+    initialDataset?: Dataset,
+  ) {
+    super(datasetFactory, initialDataset);
+    this.context = context;
   }
 
   getDataResource(uri: string, options?: DocumentGetterOptions): DataResource {
-    return this.dataResourceStore.get(uri, options);
+    return this.context.dataResourceStore.get(uri, options);
   }
 
   getContainerResource(
     uri: string,
     options?: DocumentGetterOptions,
   ): ContainerResource {
-    return this.containerResourceStore.get(uri, options);
+    return this.context.containerResourceStore.get(uri, options);
   }
 
   getAccessRules(
@@ -54,14 +40,14 @@ export class SolidLdoDataset extends LdoDataset {
       typeof forResource === "string"
         ? this.getDataResource(forResource)
         : forResource;
-    return this.accessRulesStore.get(resourceIdentifier, options);
+    return this.context.accessRulesStore.get(resourceIdentifier, options);
   }
 
   getBinaryResource(
     uri: string,
     options?: DocumentGetterOptions,
   ): BinaryResource {
-    return this.binaryResourceStore.get(uri, options);
+    return this.context.binaryResourceStore.get(uri, options);
   }
 
   onDocumentError(_callback: (error: DocumentError) => void): void {

packages/solid/src/SolidLdoDatasetContext.ts

@@ -0,0 +1,21 @@
+import type TypedEmitter from "typed-emitter";
+import type { SolidLdoDataset } from "./SolidLdoDataset";
+import type { ContainerResourceStore } from "./document/resource/dataResource/containerResource/ContainerResourceStore";
+import type { AccessRulesStore } from "./document/accessRules/AccessRulesStore";
+import type { DataResourceStore } from "./document/resource/dataResource/DataResourceStore";
+import type { BinaryResourceStore } from "./document/resource/binaryResource/BinaryResourceStore";
+import type { DocumentError } from "./document/errors/DocumentError";
+
+export type DocumentEventEmitter = TypedEmitter<{
+  documentError: (error: DocumentError) => void;
+}>;
+
+export interface SolidLdoDatasetContext {
+  solidLdoDataset: SolidLdoDataset;
+  documentEventEmitter: DocumentEventEmitter;
+  fetch: typeof fetch;
+  accessRulesStore: AccessRulesStore;
+  containerResourceStore: ContainerResourceStore;
+  dataResourceStore: DataResourceStore;
+  binaryResourceStore: BinaryResourceStore;
+}

packages/solid/src/createSolidLdoDataset.ts

@@ -1,31 +1,51 @@
-import type { Dataset } from "@rdfjs/types";
-import type { SolidLdoDataset } from "./SolidLdoDataset";
+import type { Dataset, DatasetFactory } from "@rdfjs/types";
+import { SolidLdoDataset } from "./SolidLdoDataset";
 import { AccessRulesStore } from "./document/accessRules/AccessRulesStore";
 import { BinaryResourceStore } from "./document/resource/binaryResource/BinaryResourceStore";
 import { DataResourceStore } from "./document/resource/dataResource/DataResourceStore";
 import { ContainerResourceStore } from "./document/resource/dataResource/containerResource/ContainerResourceStore";
+import type {
+  DocumentEventEmitter,
+  SolidLdoDatasetContext,
+} from "./SolidLdoDatasetContext";
+import crossFetch from "cross-fetch";
+import { EventEmitter } from "stream";
+import { createDataset, createDatasetFactory } from "@ldo/dataset";
 
 export interface CreateSolidLdoDatasetOptions {
   fetch?: typeof fetch;
   dataset?: Dataset;
+  datasetFactory?: DatasetFactory;
 }
 
 export function createSolidLdoDataset(
   options?: CreateSolidLdoDatasetOptions,
 ): SolidLdoDataset {
-  const finalFetch = fetch ||  vbhyg
+  const finalFetch = options?.fetch || crossFetch;
+  const finalDatasetFactory = options?.datasetFactory || createDatasetFactory();
+  const finalDataset = options?.dataset || createDataset();
 
-  // Ingnoring this because we're setting up circular dependencies
+  // Ignoring because of circular dependency
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
-  const dependencies: LdoContextData = {
-    onDocumentError,
+  const context: SolidLdoDatasetContext = {
+    documentEventEmitter: new EventEmitter() as DocumentEventEmitter,
     fetch: finalFetch,
-    dataset: ldoDataset,
-    updateManager: new UpdateManager(),
   };
-  const binaryResourceStore = new BinaryResourceStore(dependencies);
-  const dataResourceStore = new DataResourceStore(dependencies);
-  const containerResourceStore = new ContainerResourceStore(dependencies);
-  const accessRulesStore = new AccessRulesStore(dependencies);
+  const binaryResourceStore = new BinaryResourceStore(context);
+  const dataResourceStore = new DataResourceStore(context);
+  const containerResourceStore = new ContainerResourceStore(context);
+  const accessRulesStore = new AccessRulesStore(context);
+  const solidLdoDataset = new SolidLdoDataset(
+    context,
+    finalDatasetFactory,
+    finalDataset,
+  );
+  context.binaryResourceStore = binaryResourceStore;
+  context.dataResourceStore = dataResourceStore;
+  context.containerResourceStore = containerResourceStore;
+  context.accessRulesStore = accessRulesStore;
+  context.solidLdoDataset = solidLdoDataset;
+
+  return solidLdoDataset;
 }

packages/solid/src/document/DocumentStore.ts

@@ -1,9 +1,6 @@
+import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
 import type { FetchableDocument } from "./FetchableDocument";
 
-// This may eventually have fields
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface DocumentStoreDependencies {}
-
 export interface DocumentGetterOptions {
   autoLoad?: boolean;
 }
@@ -11,14 +8,13 @@ export interface DocumentGetterOptions {
 export abstract class DocumentStore<
   DocumentType extends FetchableDocument,
   Initializer,
-  Dependencies extends DocumentStoreDependencies,
 > {
   protected documentMap: Map<Initializer, DocumentType>;
-  protected dependencies: Dependencies;
+  protected context: SolidLdoDatasetContext;
 
-  constructor(dependencies: Dependencies) {
+  constructor(context: SolidLdoDatasetContext) {
     this.documentMap = new Map();
-    this.dependencies = dependencies;
+    this.context = context;
   }
 
   get(

packages/solid/src/document/FetchableDocument.ts

@@ -1,29 +1,31 @@
 import EventEmitter from "events";
 import type { DocumentError } from "./errors/DocumentError";
 import type { DocumentGetterOptions } from "./DocumentStore";
+import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
+import type TypedEventEmitter from "typed-emitter";
 
-export interface FetchableDocumentDependencies {
-  onDocumentError?: (error: DocumentError) => void;
-  documentGetterOptions?: DocumentGetterOptions;
-}
-
-const STATE_UPDATE = "stateUpdate";
+export type FetchableDocumentEventEmitter = TypedEventEmitter<{
+  stateUpdate: () => void;
+}>;
 
-export abstract class FetchableDocument extends EventEmitter {
+export abstract class FetchableDocument extends (EventEmitter as new () => FetchableDocumentEventEmitter) {
   protected _isLoading: boolean;
   protected _isWriting: boolean;
   protected _didInitialFetch: boolean;
   protected _error?: DocumentError;
-  private dependencies: FetchableDocumentDependencies;
+  protected context: SolidLdoDatasetContext;
 
-  constructor(dependencies: FetchableDocumentDependencies) {
+  constructor(
+    context: SolidLdoDatasetContext,
+    documentGetterOptions?: DocumentGetterOptions,
+  ) {
     super();
     this._isLoading = false;
     this._isWriting = false;
     this._didInitialFetch = false;
-    this.dependencies = dependencies;
+    this.context = context;
     // Trigger load if autoload is true
-    if (this.dependencies.documentGetterOptions?.autoLoad) {
+    if (documentGetterOptions?.autoLoad) {
       this._isLoading = true;
       this.read();
     }
@@ -57,10 +59,6 @@ export abstract class FetchableDocument extends EventEmitter {
     return this._isWriting;
   }
 
-  protected get onDocumentError() {
-    return this.dependencies.onDocumentError;
-  }
-
   /**
    * ===========================================================================
    * Methods
@@ -100,23 +98,21 @@ export abstract class FetchableDocument extends EventEmitter {
   setError(error: DocumentError) {
     this._error = error;
     this.emitStateUpdate();
-    if (this.onDocumentError) {
-      this.onDocumentError(error);
-    }
+    this.context.documentEventEmitter.emit("documentError", error);
   }
 
   /**
    * Emitter Information
    */
   protected emitStateUpdate() {
-    this.emit(STATE_UPDATE);
+    this.emit("stateUpdate");
   }
 
   onStateUpdate(callback: () => void) {
-    this.on(STATE_UPDATE, callback);
+    this.on("stateUpdate", callback);
   }
 
   offStateUpdate(callback: () => void) {
-    this.off(STATE_UPDATE, callback);
+    this.off("stateUpdate", callback);
   }
 }

packages/solid/src/document/accessRules/AccessRules.ts

@@ -1,27 +1,26 @@
 import type { AccessModes as IAccessModes } from "@inrupt/solid-client";
 import { universalAccess } from "@inrupt/solid-client";
-import type { FetchableDocumentDependencies } from "../FetchableDocument";
 import { FetchableDocument } from "../FetchableDocument";
 import type { Resource } from "../resource/Resource";
 import { DocumentError } from "../errors/DocumentError";
+import type { SolidLdoDatasetContext } from "../../SolidLdoDatasetContext";
+import type { DocumentGetterOptions } from "../DocumentStore";
 
 export type AccessModes = IAccessModes;
 
-export interface AccessRulesDependencies extends FetchableDocumentDependencies {
-  fetch: typeof fetch;
-}
-
 export class AccessRules extends FetchableDocument {
   readonly resource: Resource;
   private _publicAccess: IAccessModes | null;
   private _agentAccess: Record<string, IAccessModes> | null;
-  private dependencies0;
 
-  constructor(resource: Resource, dependencies: AccessRulesDependencies) {
-    super(dependencies);
+  constructor(
+    resource: Resource,
+    context: SolidLdoDatasetContext,
+    documentGetterOptions?: DocumentGetterOptions,
+  ) {
+    super(context, documentGetterOptions);
     this._publicAccess = null;
     this._agentAccess = null;
-    this.dependencies0 = dependencies;
     this.resource = resource;
   }
 
@@ -38,10 +37,6 @@ export class AccessRules extends FetchableDocument {
     return this._agentAccess;
   }
 
-  protected get fetch() {
-    return this.dependencies0.fetch;
-  }
-
   /**
    * ===========================================================================
    * Methods
@@ -51,10 +46,10 @@ export class AccessRules extends FetchableDocument {
     try {
       const [publicAccess, agentAccess] = await Promise.all([
         universalAccess.getPublicAccess(this.resource.uri, {
-          fetch: this.fetch,
+          fetch: this.context.fetch,
         }),
         universalAccess.getAgentAccessAll(this.resource.uri, {
-          fetch: this.fetch,
+          fetch: this.context.fetch,
         }),
       ]);
       this._publicAccess = publicAccess || {

packages/solid/src/document/accessRules/AccessRulesStore.ts

@@ -1,28 +1,13 @@
-import type {
-  DocumentGetterOptions,
-  DocumentStoreDependencies,
-} from "../DocumentStore";
+import type { DocumentGetterOptions } from "../DocumentStore";
 import { DocumentStore } from "../DocumentStore";
 import type { Resource } from "../resource/Resource";
-import type { AccessRulesDependencies } from "./AccessRules";
 import { AccessRules } from "./AccessRules";
 
-export interface AccessRulesStoreDependencies
-  extends DocumentStoreDependencies,
-    AccessRulesDependencies {}
-
-export class AccessRulesStore extends DocumentStore<
-  AccessRules,
-  Resource,
-  AccessRulesStoreDependencies
-> {
+export class AccessRulesStore extends DocumentStore<AccessRules, Resource> {
   protected create(
     initializer: Resource,
-    documentGetterOptions: DocumentGetterOptions,
+    documentGetterOptions?: DocumentGetterOptions,
   ) {
-    return new AccessRules(initializer, {
-      ...this.dependencies,
-      documentGetterOptions,
-    });
+    return new AccessRules(initializer, this.context, documentGetterOptions);
   }
 }

packages/solid/src/document/resource/Resource.ts

@@ -1,24 +1,19 @@
-import type { FetchableDocumentDependencies } from "../FetchableDocument";
+import type { SolidLdoDatasetContext } from "../../SolidLdoDatasetContext";
+import type { DocumentGetterOptions } from "../DocumentStore";
 import { FetchableDocument } from "../FetchableDocument";
-import type { AccessRulesStore } from "../accessRules/AccessRulesStore";
 import { DocumentFetchError } from "../errors/DocumentFetchError";
 import type { ContainerResource } from "./dataResource/containerResource/ContainerResource";
-import type { ContainerResourceStore } from "./dataResource/containerResource/ContainerResourceStore";
-
-export interface ResourceDependencies extends FetchableDocumentDependencies {
-  fetch: typeof fetch;
-  accessRulesStore: AccessRulesStore;
-  containerResourceStore: ContainerResourceStore;
-}
 
 export abstract class Resource extends FetchableDocument {
   public readonly uri: string;
-  private dependencies1;
 
-  constructor(uri: string, dependencies: ResourceDependencies) {
-    super(dependencies);
+  constructor(
+    uri: string,
+    context: SolidLdoDatasetContext,
+    documentGetterOptions?: DocumentGetterOptions,
+  ) {
+    super(context, documentGetterOptions);
     this.uri = uri;
-    this.dependencies1 = dependencies;
   }
 
   /**
@@ -27,29 +22,17 @@ export abstract class Resource extends FetchableDocument {
    * ===========================================================================
    */
   get accessRules() {
-    return this.accessRulesStore.get(this);
+    return this.context.accessRulesStore.get(this);
   }
 
   get parentContainer(): ContainerResource | undefined {
-    return this.containerResourceStore.getContainerForResouce(this);
+    return this.context.containerResourceStore.getContainerForResouce(this);
   }
 
   get ["@id"]() {
     return this.uri;
   }
 
-  protected get fetch() {
-    return this.dependencies1.fetch;
-  }
-
-  protected get accessRulesStore() {
-    return this.dependencies1.accessRulesStore;
-  }
-
-  protected get containerResourceStore() {
-    return this.dependencies1.containerResourceStore;
-  }
-
   /**
    * ===========================================================================
    * Methods
@@ -57,7 +40,7 @@ export abstract class Resource extends FetchableDocument {
    */
   async delete() {
     this.beginWrite();
-    const response = await this.fetch(this.uri, {
+    const response = await this.context.fetch(this.uri, {
       method: "DELETE",
     });
     if (response.status >= 200 && response.status < 300) {

packages/solid/src/document/resource/binaryResource/BinaryResource.ts

@@ -1,9 +1,6 @@
 import type { DocumentError } from "../../errors/DocumentError";
-import type { ResourceDependencies } from "../Resource";
 import { Resource } from "../Resource";
 
-export declare type BinaryResourceDependencies = ResourceDependencies;
-
 export class BinaryResource extends Resource {
   fetchDocument(): Promise<DocumentError | undefined> {
     throw new Error("Method not implemented.");

packages/solid/src/document/resource/binaryResource/BinaryResourceStore.ts

@@ -1,28 +1,13 @@
-import type {
-  DocumentGetterOptions,
-  DocumentStoreDependencies,
-} from "../../DocumentStore";
+import type { DocumentGetterOptions } from "../../DocumentStore";
 import { DocumentStore } from "../../DocumentStore";
-import type { BinaryResourceDependencies } from "./BinaryResource";
 import { BinaryResource } from "./BinaryResource";
 
-export interface BinaryResourceStoreDependencies
-  extends DocumentStoreDependencies,
-    BinaryResourceDependencies {}
-
-export class BinaryResourceStore extends DocumentStore<
-  BinaryResource,
-  string,
-  BinaryResourceStoreDependencies
-> {
+export class BinaryResourceStore extends DocumentStore<BinaryResource, string> {
   protected create(
     initializer: string,
-    documentGetterOptions: DocumentGetterOptions,
+    documentGetterOptions?: DocumentGetterOptions,
   ) {
-    return new BinaryResource(initializer, {
-      ...this.dependencies,
-      documentGetterOptions,
-    });
+    return new BinaryResource(initializer, this.context, documentGetterOptions);
   }
 
   protected normalizeInitializer(initializer: string): string {

packages/solid/src/document/resource/dataResource/DataResource.ts

@@ -1,5 +1,4 @@
 import { parseRdf } from "@ldo/ldo";
-import type { ResourceDependencies } from "../Resource";
 import { Resource } from "../Resource";
 import { DocumentFetchError } from "../../errors/DocumentFetchError";
 import { DocumentError } from "../../errors/DocumentError";
@@ -7,33 +6,8 @@ import { namedNode, quad as createQuad } from "@rdfjs/data-model";
 import type { DatasetChanges } from "@ldo/rdf-utils";
 import { changesToSparqlUpdate } from "@ldo/rdf-utils";
 import type { Quad } from "@rdfjs/types";
-import type { SolidLdoDataset } from "../../../SolidLdoDataset";
-
-export interface DataResourceDependencies extends ResourceDependencies {
-  dataset: SolidLdoDataset;
-}
 
 export class DataResource extends Resource {
-  private dependencies2;
-
-  constructor(uri: string, dependencies: DataResourceDependencies) {
-    super(uri, dependencies);
-    this.dependencies2 = dependencies;
-  }
-
-  /**
-   * ===========================================================================
-   * Getters
-   * ===========================================================================
-   */
-  protected get dataset() {
-    return this.dependencies2.dataset;
-  }
-
-  protected get updateManager() {
-    return this.dependencies2.updateManager;
-  }
-
   /**
    * ===========================================================================
    * Methods
@@ -45,7 +19,7 @@ export class DataResource extends Resource {
 
   protected async fetchDocument(): Promise<DocumentError | undefined> {
     // Fetch the document using auth fetch
-    const response = await this.fetch(this.uri, {
+    const response = await this.context.fetch(this.uri, {
       headers: {
         accept: "text/turtle",
       },
@@ -73,7 +47,8 @@ export class DataResource extends Resource {
       return new DocumentError(this, "Server returned poorly formatted Turtle");
     }
     // Start transaction
-    const transactionalDataset = this.dataset.startTransaction();
+    const transactionalDataset =
+      this.context.solidLdoDataset.startTransaction();
     const graphNode = namedNode(this.uri);
     // Destroy all triples that were once a part of this resouce
     loadedDataset.deleteMatches(undefined, undefined, undefined, graphNode);
@@ -83,8 +58,6 @@ export class DataResource extends Resource {
         createQuad(quad.subject, quad.predicate, quad.object, graphNode),
       );
     });
-    const changes = transactionalDataset.getChanges();
-    this.updateManager.notifyListenersOfChanges(changes);
     transactionalDataset.commit();
     return undefined;
   }
@@ -94,15 +67,15 @@ export class DataResource extends Resource {
   ): Promise<DocumentError | undefined> {
     this.beginWrite();
     // Convert changes to transactional Dataset
-    const transactionalDataset = this.dataset.startTransaction();
+    const transactionalDataset =
+      this.context.solidLdoDataset.startTransaction();
     changes.added?.forEach((quad) => transactionalDataset.add(quad));
     changes.removed?.forEach((quad) => transactionalDataset.delete(quad));
     // Commit data optimistically
     transactionalDataset.commit();
-    this.updateManager.notifyListenersOfChanges(changes);
     // Make request
     const sparqlUpdate = await changesToSparqlUpdate(changes);
-    const response = await this.fetch(this.uri, {
+    const response = await this.context.fetch(this.uri, {
       method: "PATCH",
       body: sparqlUpdate,
       headers: {
@@ -112,7 +85,6 @@ export class DataResource extends Resource {
     if (response.status < 200 || response.status > 299) {
       // Handle Error by rollback
       transactionalDataset.rollback();
-      this.updateManager.notifyListenersOfChanges(changes);
       this.endWrite(
         new DocumentFetchError(
           this,

packages/solid/src/document/resource/dataResource/DataResourceStore.ts

@@ -1,28 +1,13 @@
-import type {
-  DocumentGetterOptions,
-  DocumentStoreDependencies,
-} from "../../DocumentStore";
+import type { DocumentGetterOptions } from "../../DocumentStore";
 import { DocumentStore } from "../../DocumentStore";
-import type { DataResourceDependencies } from "./DataResource";
 import { DataResource } from "./DataResource";
 
-export interface DataResourceStoreDependencies
-  extends DocumentStoreDependencies,
-    DataResourceDependencies {}
-
-export class DataResourceStore extends DocumentStore<
-  DataResource,
-  string,
-  DataResourceStoreDependencies
-> {
+export class DataResourceStore extends DocumentStore<DataResource, string> {
   protected create(
     initializer: string,
-    documentGetterOptions: DocumentGetterOptions,
+    documentGetterOptions?: DocumentGetterOptions,
   ) {
-    return new DataResource(initializer, {
-      ...this.dependencies,
-      documentGetterOptions,
-    });
+    return new DataResource(initializer, this.context, documentGetterOptions);
   }
 
   protected normalizeInitializer(initializer: string): string {

packages/solid/src/document/resource/dataResource/containerResource/ContainerResource.ts

@@ -1,25 +1,9 @@
 import { ContainerShapeType } from "../../../../ldo/solid.shapeTypes";
 import type { Resource } from "../../Resource";
-import type { BinaryResourceStore } from "../../binaryResource/BinaryResourceStore";
-import type { DataResourceDependencies } from "../DataResource";
 import { DataResource } from "../DataResource";
-import type { DataResourceStore } from "../DataResourceStore";
-
-export interface ContainerResourceDependencies
-  extends DataResourceDependencies {
-  dataResourceStore: DataResourceStore;
-  binaryResourceStore: BinaryResourceStore;
-}
 
 export class ContainerResource extends DataResource {
-  private _contains: Set<Resource>;
-  private dependencies3: ContainerResourceDependencies;
-
-  constructor(uri: string, dependencies: ContainerResourceDependencies) {
-    super(uri, dependencies);
-    this._contains = new Set();
-    this.dependencies3 = dependencies;
-  }
+  private _contains: Set<Resource> = new Set();
 
   /**
    * ===========================================================================
@@ -30,13 +14,6 @@ export class ContainerResource extends DataResource {
     return Array.from(this._contains);
   }
 
-  protected get binaryResourceStore() {
-    return this.dependencies3.binaryResourceStore;
-  }
-
-  protected get dataResourceStore() {
-    return this.dependencies3.dataResourceStore;
-  }
   /**
    * ===========================================================================
    * Methods
@@ -48,7 +25,7 @@ export class ContainerResource extends DataResource {
       return error;
     }
     // Update the contains
-    const container = this.dataset
+    const container = this.context.solidLdoDataset
       .usingType(ContainerShapeType)
       .fromSubject(this.uri);
     const resourcesToAdd: Resource[] = [];
@@ -56,16 +33,16 @@ export class ContainerResource extends DataResource {
       if (resourceData["@id"]) {
         if (resourceData.type?.some((type) => type["@id"] === "Container")) {
           resourcesToAdd.push(
-            this.containerResourceStore.get(resourceData["@id"]),
+            this.context.containerResourceStore.get(resourceData["@id"]),
           );
         } else {
           if (resourceData["@id"].endsWith(".ttl")) {
             resourcesToAdd.push(
-              this.dataResourceStore.get(resourceData["@id"]),
+              this.context.dataResourceStore.get(resourceData["@id"]),
             );
           } else {
             resourcesToAdd.push(
-              this.binaryResourceStore.get(resourceData["@id"]),
+              this.context.binaryResourceStore.get(resourceData["@id"]),
             );
           }
         }

packages/solid/src/document/resource/dataResource/containerResource/ContainerResourceStore.ts

@@ -1,29 +1,21 @@
-import type {
-  DocumentGetterOptions,
-  DocumentStoreDependencies,
-} from "../../../DocumentStore";
+import type { DocumentGetterOptions } from "../../../DocumentStore";
 import { DocumentStore } from "../../../DocumentStore";
 import type { Resource } from "../../Resource";
-import type { ContainerResourceDependencies } from "./ContainerResource";
 import { ContainerResource } from "./ContainerResource";
 
-export interface ContainerResourceStoreDependencies
-  extends ContainerResourceDependencies,
-    DocumentStoreDependencies {}
-
 export class ContainerResourceStore extends DocumentStore<
   ContainerResource,
-  string,
-  ContainerResourceStoreDependencies
+  string
 > {
   protected create(
     initializer: string,
-    documentGetterOptions: DocumentGetterOptions,
+    documentGetterOptions?: DocumentGetterOptions,
   ) {
-    return new ContainerResource(initializer, {
-      ...this.dependencies,
+    return new ContainerResource(
+      initializer,
+      this.context,
       documentGetterOptions,
-    });
+    );
   }
 
   protected normalizeInitializer(initializer: string) {

packages/solid/src/ldo/solid.typings.ts

@@ -57,6 +57,9 @@ export interface Resource {
     | {
         "@id": "Resource2";
       }
+    | {
+        "@id": "Container";
+      }
   )[];
   /**
    * Date modified