Clean up solid library

packages/schema-converter-shex/src/context/ShexJContextVisitor.ts

@@ -1,4 +1,4 @@
-import ShexJTraverser from "shexj-traverser";
+import ShexJTraverser from "@ldo/traverser-shexj";
 import type { JsonLdContextBuilder } from "./JsonLdContextBuilder";
 
 /**

packages/schema-converter-shex/src/typing/ShexJTypingTransformer.ts

@@ -1,4 +1,4 @@
-import ShexJTraverser from "shexj-traverser";
+import ShexJTraverser from "@ldo/traverser-shexj";
 import * as dom from "dts-dom";
 import type { Annotation } from "shexj";
 import { nameFromObject } from "../context/JsonLdContextBuilder";

packages/solid/src/ResourceStore.ts

@@ -1,29 +1,27 @@
-import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
+import { Container } from "./resource/Container";
-import type { FetchableDocument } from "./FetchableDocument";
+import { Leaf } from "./resource/Leaf";
-import type { ResourceClass } from "./resource/abstract/AbstractResource";
+import type { Resource } from "./resource/Resource";
-import type { ContainerClass } from "./resource/abstract/container/Container";
+import type { SolidLdoDatasetContext } from "./SolidLdoDatasetContext";
-import type { LeafClass } from "./resource/abstract/leaf/Leaf";
+import type { ContainerUri, LeafUri } from "./util/uriTypes";
-import { UnfetchedContainer } from "./resource/concrete/UnfetchedContainer";
+import { isContainerUri } from "./util/uriTypes";
-import { UnfetchedLeaf } from "./resource/concrete/UnfetchedLeaf";
-import { ContainerUri, LeafUri, isContainerUri } from "./uriTypes";
 
 export interface ResourceGetterOptions {
   autoLoad?: boolean;
 }
 
 export class ResourceStore {
-  protected resourceMap: Map<string, ResourceClass>;
+  protected resourceMap: Map<string, Resource>;
   protected context: SolidLdoDatasetContext;
 
   constructor(context: SolidLdoDatasetContext) {
-    this.documentMap = new Map();
+    this.resourceMap = new Map();
     this.context = context;
   }
 
-  get(uri: ContainerUri, options?: ResourceGetterOptions): ContainerClass;
+  get(uri: ContainerUri, options?: ResourceGetterOptions): Container;
-  get(uri: LeafUri, options?: ResourceGetterOptions): LeafClass;
+  get(uri: LeafUri, options?: ResourceGetterOptions): Leaf;
-  get(uri: string, options?: ResourceGetterOptions): ResourceClass;
+  get(uri: string, options?: ResourceGetterOptions): Resource;
-  get(uri: string, options?: ResourceGetterOptions): ResourceClass {
+  get(uri: string, options?: ResourceGetterOptions): Resource {
     // Normalize URI by removing hash
     const url = new URL(uri);
     url.hash = "";
@@ -33,9 +31,9 @@ export class ResourceStore {
     let resource = this.resourceMap.get(normalizedUri);
     if (!resource) {
       if (isContainerUri(normalizedUri)) {
-        resource = new UnfetchedContainer();
+        resource = new Container(normalizedUri, this.context);
       } else {
-        resource = new UnfetchedLeaf();
+        resource = new Leaf(normalizedUri, this.context);
       }
       this.resourceMap.set(normalizedUri, resource);
     }
@@ -45,28 +43,5 @@ export class ResourceStore {
     }
 
     return resource;
-
-
-    throw new Error("Not Implemented");
-    // const initializer = this.normalizeInitializer(initializerInput);
-    // const document = this.documentMap.get(initializer);
-    // if (document) {
-    //   if (options?.autoLoad) {
-    //     document.read();
-    //   }
-    //   return document;
-    // }
-    // const newDocument = this.create(initializer, options);
-    // this.documentMap.set(initializer, newDocument);
-    // return newDocument;
   }
 }
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const resourceStore = new ResourceStore();
-
-const container = resourceStore.get("https://jackson.com/");
-const leaf = resourceStore.get("https://jackson.com/item.ttl");
-const thing: string = "https://jackson.com/";
-const resource = resourceStore.get(thing);

packages/solid/src/SolidLdoDataset.ts

@@ -1,6 +1,11 @@
 import { LdoDataset } from "@ldo/ldo";
 import type { Dataset, DatasetFactory } from "@rdfjs/types";
+import type { Container } from "./resource/Container";
+import type { Leaf } from "./resource/Leaf";
+import type { Resource } from "./resource/Resource";
+import type { ResourceGetterOptions } from "./ResourceStore";
 import type { SolidLdoDatasetContext } from "./SolidLdoDatasetContext";
+import type { ContainerUri, LeafUri } from "./util/uriTypes";
 
 export class SolidLdoDataset extends LdoDataset {
   public context: SolidLdoDatasetContext;
@@ -14,7 +19,9 @@ export class SolidLdoDataset extends LdoDataset {
     this.context = context;
   }
 
-  // getResourceStatus(): ResourceStatus {
+  get(uri: ContainerUri, options?: ResourceGetterOptions): Container;
-  //   throw new Error("Not Implemented");
+  get(uri: LeafUri, options?: ResourceGetterOptions): Leaf;
-  // }
+  get(uri: string, options?: ResourceGetterOptions): Resource {
+    return this.context.resourceStore.get(uri, options);
+  }
 }

packages/solid/src/SolidLdoDatasetContext.ts

@@ -1,4 +1,5 @@
 // import type TypedEmitter from "typed-emitter";
+import type { ResourceStore } from "./ResourceStore";
 import type { SolidLdoDataset } from "./SolidLdoDataset";
 // import type { DocumentError } from "./document/errors/DocumentError";
 
@@ -10,6 +11,6 @@ import type { SolidLdoDataset } from "./SolidLdoDataset";
 
 export interface SolidLdoDatasetContext {
   solidLdoDataset: SolidLdoDataset;
-  // documentEventEmitter: DocumentEventEmitter;
+  resourceStore: ResourceStore;
   fetch: typeof fetch;
 }

packages/solid/src/createSolidLdoDataset.ts

@@ -4,6 +4,7 @@ import { SolidLdoDataset } from "./SolidLdoDataset";
 import type { SolidLdoDatasetContext } from "./SolidLdoDatasetContext";
 import crossFetch from "cross-fetch";
 import { createDataset, createDatasetFactory } from "@ldo/dataset";
+import { ResourceStore } from "./ResourceStore";
 
 export interface CreateSolidLdoDatasetOptions {
   fetch?: typeof fetch;
@@ -29,7 +30,9 @@ export function createSolidLdoDataset(
     finalDatasetFactory,
     finalDataset,
   );
+  const resourceStore = new ResourceStore(context);
   context.solidLdoDataset = solidLdoDataset;
+  context.resourceStore = resourceStore;
 
   return solidLdoDataset;
 }

packages/solid/src/requester/ContainerRequester.ts

@@ -1,3 +1,3 @@
-export class ContainerRequester {
+import { Requester } from "./Requester";
-  
+
-}
+export class ContainerRequester extends Requester {}

packages/solid/src/requester/LeafRequester.ts

@@ -1,200 +1,3 @@
-import type { LeafUri } from "../util/uriTypes";
+import { Requester } from "./Requester";
-import { ANY_KEY, RequestBatcher } from "../util/RequestBatcher";
-import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
-import type { DatasetChanges } from "@ldo/rdf-utils";
-import type {
-  CreateResult,
-  CreateResultWithoutOverwrite,
-} from "./requests/createDataResource";
-import { createDataResource } from "./requests/createDataResource";
-import type { ReadResult } from "./requests/readResource";
-import { readResource } from "./requests/readResource";
-import type {
-  UploadResult,
-  UploadResultWithoutOverwrite,
-} from "./requests/uploadResource";
-import { uploadResource } from "./requests/uploadResource";
-import type { DeleteResult } from "./requests/deleteResource";
-import { deleteResource } from "./requests/deleteResource";
-import type { UpdateResult } from "./requests/updateDataResource";
 
-const READ_KEY = "read";
+export class LeafRequester extends Requester {}
-const CREATE_KEY = "createDataResource";
-const UPLOAD_KEY = "upload";
-const UPDATE_KEY = "updateDataREsource";
-const DELETE_KEY = "delete";
-
-export class LeafRequester {
-  private readonly requestBatcher = new RequestBatcher();
-
-  // All intance variables
-  readonly uri: LeafUri;
-  private context: SolidLdoDatasetContext;
-
-  constructor(uri: LeafUri, context: SolidLdoDatasetContext) {
-    this.uri = uri;
-    this.context = context;
-  }
-
-  isLoading(): boolean {
-    return this.requestBatcher.isLoading(ANY_KEY);
-  }
-  isCreating(): boolean {
-    return this.requestBatcher.isLoading(CREATE_KEY);
-  }
-  isUploading(): boolean {
-    return this.requestBatcher.isLoading(UPLOAD_KEY);
-  }
-  isReading(): boolean {
-    return this.requestBatcher.isLoading(READ_KEY);
-  }
-  isUpdating(): boolean {
-    return this.requestBatcher.isLoading(UPDATE_KEY);
-  }
-  isDeletinng(): boolean {
-    return this.requestBatcher.isLoading(DELETE_KEY);
-  }
-
-  /**
-   * Read this resource.
-   */
-  async read(): Promise<ReadResult> {
-    const transaction = this.context.solidLdoDataset.startTransaction();
-    const result = await this.requestBatcher.queueProcess({
-      name: READ_KEY,
-      args: [{ uri: this.uri, transaction, fetch: this.context.fetch }],
-      perform: readResource,
-      modifyQueue: (queue, isLoading) => {
-        if (queue.length === 0) {
-          return isLoading[READ_KEY];
-        } else {
-          return queue[queue.length - 1].name === READ_KEY;
-        }
-      },
-    });
-    if (result.type !== "error") {
-      transaction.commit();
-    }
-    return result;
-  }
-
-  /**
-   * Creates a Resource
-   * @param overwrite: If true, this will orverwrite the resource if it already
-   * exists
-   */
-  async createDataResource(
-    overwrite?: false,
-  ): Promise<CreateResultWithoutOverwrite>;
-  async createDataResource(overwrite: true): Promise<CreateResult>;
-  async createDataResource(
-    overwrite?: boolean,
-  ): Promise<CreateResultWithoutOverwrite | CreateResult>;
-  async createDataResource(
-    overwrite?: boolean,
-  ): Promise<CreateResultWithoutOverwrite> {
-    const transaction = this.context.solidLdoDataset.startTransaction();
-    const result = await this.requestBatcher.queueProcess({
-      name: CREATE_KEY,
-      args: [
-        { uri: this.uri, transaction, fetch: this.context.fetch },
-        overwrite,
-      ],
-      perform: createDataResource,
-      modifyQueue: (queue, isLoading, args) => {
-        const lastElementInQueue = queue[queue.length - 1];
-        return (
-          lastElementInQueue &&
-          lastElementInQueue.name === CREATE_KEY &&
-          !!lastElementInQueue.args[1] === !!args[1]
-        );
-      },
-    });
-    if (result.type !== "error") {
-      transaction.commit();
-    }
-    return result;
-  }
-
-  /**
-   * Upload a binary
-   * @param blob
-   * @param mimeType
-   * @param overwrite: If true, will overwrite an existing file
-   */
-  async upload(
-    blob: Blob,
-    mimeType: string,
-    overwrite?: false,
-  ): Promise<UploadResultWithoutOverwrite>;
-  async upload(
-    blob: Blob,
-    mimeType: string,
-    overwrite: true,
-  ): Promise<UploadResult>;
-  async upload(
-    blob: Blob,
-    mimeType: string,
-    overwrite?: boolean,
-  ): Promise<UploadResultWithoutOverwrite | UploadResult>;
-  async upload(
-    blob: Blob,
-    mimeType: string,
-    overwrite?: boolean,
-  ): Promise<UploadResultWithoutOverwrite | UploadResult> {
-    const transaction = this.context.solidLdoDataset.startTransaction();
-    const result = await this.requestBatcher.queueProcess({
-      name: UPLOAD_KEY,
-      args: [
-        { uri: this.uri, transaction, fetch: this.context.fetch },
-        blob,
-        mimeType,
-        overwrite,
-      ],
-      perform: uploadResource,
-      modifyQueue: (queue, isLoading, args) => {
-        const lastElementInQueue = queue[queue.length - 1];
-        return (
-          lastElementInQueue &&
-          lastElementInQueue.name === UPLOAD_KEY &&
-          !!lastElementInQueue.args[3] === !!args[3]
-        );
-      },
-    });
-    if (result.type !== "error") {
-      transaction.commit();
-    }
-    return result;
-  }
-
-  /**
-   * Update the data on this resource
-   * @param changes
-   */
-  updateDataResource(_changes: DatasetChanges): Promise<UpdateResult> {
-    throw new Error("Not Implemented");
-  }
-
-  /**
-   * Delete this resource
-   */
-  async delete(): Promise<DeleteResult> {
-    const transaction = this.context.solidLdoDataset.startTransaction();
-    const result = await this.requestBatcher.queueProcess({
-      name: DELETE_KEY,
-      args: [{ uri: this.uri, transaction, fetch: this.context.fetch }],
-      perform: deleteResource,
-      modifyQueue: (queue, isLoading) => {
-        if (queue.length === 0) {
-          return isLoading[DELETE_KEY];
-        } else {
-          return queue[queue.length - 1].name === DELETE_KEY;
-        }
-      },
-    });
-    if (result.type !== "error") {
-      transaction.commit();
-    }
-    return result;
-  }
-}

packages/solid/src/requester/Requester.ts

@@ -0,0 +1,199 @@
+import { ANY_KEY, RequestBatcher } from "../util/RequestBatcher";
+import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
+import type { DatasetChanges } from "@ldo/rdf-utils";
+import type {
+  CreateResult,
+  CreateResultWithoutOverwrite,
+} from "./requests/createDataResource";
+import { createDataResource } from "./requests/createDataResource";
+import type { ReadResult } from "./requests/readResource";
+import { readResource } from "./requests/readResource";
+import type {
+  UploadResult,
+  UploadResultWithoutOverwrite,
+} from "./requests/uploadResource";
+import { uploadResource } from "./requests/uploadResource";
+import type { DeleteResult } from "./requests/deleteResource";
+import { deleteResource } from "./requests/deleteResource";
+import type { UpdateResult } from "./requests/updateDataResource";
+
+const READ_KEY = "read";
+const CREATE_KEY = "createDataResource";
+const UPLOAD_KEY = "upload";
+const UPDATE_KEY = "updateDataREsource";
+const DELETE_KEY = "delete";
+
+export abstract class Requester {
+  protected readonly requestBatcher = new RequestBatcher();
+
+  // All intance variables
+  readonly uri: string;
+  protected context: SolidLdoDatasetContext;
+
+  constructor(uri: string, context: SolidLdoDatasetContext) {
+    this.uri = uri;
+    this.context = context;
+  }
+
+  isLoading(): boolean {
+    return this.requestBatcher.isLoading(ANY_KEY);
+  }
+  isCreating(): boolean {
+    return this.requestBatcher.isLoading(CREATE_KEY);
+  }
+  isUploading(): boolean {
+    return this.requestBatcher.isLoading(UPLOAD_KEY);
+  }
+  isReading(): boolean {
+    return this.requestBatcher.isLoading(READ_KEY);
+  }
+  isUpdating(): boolean {
+    return this.requestBatcher.isLoading(UPDATE_KEY);
+  }
+  isDeletinng(): boolean {
+    return this.requestBatcher.isLoading(DELETE_KEY);
+  }
+
+  /**
+   * Read this resource.
+   */
+  async read(): Promise<ReadResult> {
+    const transaction = this.context.solidLdoDataset.startTransaction();
+    const result = await this.requestBatcher.queueProcess({
+      name: READ_KEY,
+      args: [{ uri: this.uri, transaction, fetch: this.context.fetch }],
+      perform: readResource,
+      modifyQueue: (queue, isLoading) => {
+        if (queue.length === 0) {
+          return isLoading[READ_KEY];
+        } else {
+          return queue[queue.length - 1].name === READ_KEY;
+        }
+      },
+    });
+    if (result.type !== "error") {
+      transaction.commit();
+    }
+    return result;
+  }
+
+  /**
+   * Creates a Resource
+   * @param overwrite: If true, this will orverwrite the resource if it already
+   * exists
+   */
+  async createDataResource(
+    overwrite?: false,
+  ): Promise<CreateResultWithoutOverwrite>;
+  async createDataResource(overwrite: true): Promise<CreateResult>;
+  async createDataResource(
+    overwrite?: boolean,
+  ): Promise<CreateResultWithoutOverwrite | CreateResult>;
+  async createDataResource(
+    overwrite?: boolean,
+  ): Promise<CreateResultWithoutOverwrite> {
+    const transaction = this.context.solidLdoDataset.startTransaction();
+    const result = await this.requestBatcher.queueProcess({
+      name: CREATE_KEY,
+      args: [
+        { uri: this.uri, transaction, fetch: this.context.fetch },
+        overwrite,
+      ],
+      perform: createDataResource,
+      modifyQueue: (queue, isLoading, args) => {
+        const lastElementInQueue = queue[queue.length - 1];
+        return (
+          lastElementInQueue &&
+          lastElementInQueue.name === CREATE_KEY &&
+          !!lastElementInQueue.args[1] === !!args[1]
+        );
+      },
+    });
+    if (result.type !== "error") {
+      transaction.commit();
+    }
+    return result;
+  }
+
+  /**
+   * Upload a binary
+   * @param blob
+   * @param mimeType
+   * @param overwrite: If true, will overwrite an existing file
+   */
+  async upload(
+    blob: Blob,
+    mimeType: string,
+    overwrite?: false,
+  ): Promise<UploadResultWithoutOverwrite>;
+  async upload(
+    blob: Blob,
+    mimeType: string,
+    overwrite: true,
+  ): Promise<UploadResult>;
+  async upload(
+    blob: Blob,
+    mimeType: string,
+    overwrite?: boolean,
+  ): Promise<UploadResultWithoutOverwrite | UploadResult>;
+  async upload(
+    blob: Blob,
+    mimeType: string,
+    overwrite?: boolean,
+  ): Promise<UploadResultWithoutOverwrite | UploadResult> {
+    const transaction = this.context.solidLdoDataset.startTransaction();
+    const result = await this.requestBatcher.queueProcess({
+      name: UPLOAD_KEY,
+      args: [
+        { uri: this.uri, transaction, fetch: this.context.fetch },
+        blob,
+        mimeType,
+        overwrite,
+      ],
+      perform: uploadResource,
+      modifyQueue: (queue, isLoading, args) => {
+        const lastElementInQueue = queue[queue.length - 1];
+        return (
+          lastElementInQueue &&
+          lastElementInQueue.name === UPLOAD_KEY &&
+          !!lastElementInQueue.args[3] === !!args[3]
+        );
+      },
+    });
+    if (result.type !== "error") {
+      transaction.commit();
+    }
+    return result;
+  }
+
+  /**
+   * Update the data on this resource
+   * @param changes
+   */
+  updateDataResource(_changes: DatasetChanges): Promise<UpdateResult> {
+    throw new Error("Not Implemented");
+  }
+
+  /**
+   * Delete this resource
+   */
+  async delete(): Promise<DeleteResult> {
+    const transaction = this.context.solidLdoDataset.startTransaction();
+    const result = await this.requestBatcher.queueProcess({
+      name: DELETE_KEY,
+      args: [{ uri: this.uri, transaction, fetch: this.context.fetch }],
+      perform: deleteResource,
+      modifyQueue: (queue, isLoading) => {
+        if (queue.length === 0) {
+          return isLoading[DELETE_KEY];
+        } else {
+          return queue[queue.length - 1].name === DELETE_KEY;
+        }
+      },
+    });
+    if (result.type !== "error") {
+      transaction.commit();
+    }
+    return result;
+  }
+}

packages/solid/src/resource/Container.ts

@@ -1,9 +1,22 @@
+import type { Requester } from "../requester/Requester";
 import type { ContainerUri } from "../util/uriTypes";
 import { Resource } from "./Resource";
 
-export class Container {
+export class Container extends Resource {
+  protected requester: Requester;
+  getParentContainer(): Promise<Container | undefined> {
+    throw new Error("Method not implemented.");
+  }
+  getRootContainer(): Promise<Container> {
+    throw new Error("Method not implemented.");
+  }
+  getMimeType(): string {
+    throw new Error("Method not implemented.");
+  }
   readonly uri: ContainerUri;
-  private 
+  private rootContainer: boolean | undefined;
 
-  isFetched(): 
+  isRootContainer(): boolean | undefined {
+    return this.rootContainer;
+  }
 }

packages/solid/src/resource/Leaf.ts

@@ -0,0 +1,56 @@
+import type { DatasetChanges } from "@ldo/rdf-utils";
+import type { Requester } from "../requester/Requester";
+import type { UpdateResultError } from "../requester/requests/updateDataResource";
+import type {
+  UploadResultError,
+  UploadResultWithoutOverwriteError,
+} from "../requester/requests/uploadResource";
+import type { Container } from "./Container";
+import { Resource } from "./Resource";
+
+export class Leaf extends Resource {
+  protected requester: Requester;
+  getParentContainer(): Promise<Container | undefined> {
+    throw new Error("Method not implemented.");
+  }
+  getRootContainer(): Promise<Container> {
+    throw new Error("Method not implemented.");
+  }
+  getMimeType(): string {
+    throw new Error("Method not implemented.");
+  }
+  isBinary(): boolean | undefined {
+    if (!this.didInitialFetch) {
+      return undefined;
+    }
+    return !!this.binaryData;
+  }
+  isDataResource(): boolean | undefined {
+    if (!this.didInitialFetch) {
+      return undefined;
+    }
+    return !this.binaryData;
+  }
+
+  async uploadAndOverwrite(
+    blob: Blob,
+    mimeType: string,
+  ): Promise<this | UploadResultError> {
+    return this.parseResult(await this.requester.upload(blob, mimeType)) as
+      | this
+      | UploadResultError;
+  }
+
+  async uploadIfAbsent(
+    blob: Blob,
+    mimeType: string,
+  ): Promise<this | UploadResultWithoutOverwriteError> {
+    return this.parseResult(
+      await this.requester.upload(blob, mimeType, true),
+    ) as this | UploadResultWithoutOverwriteError;
+  }
+
+  update(_changes: DatasetChanges): Promise<this | UpdateResultError> {
+    throw new Error("Method not implemented");
+  }
+}

packages/solid/src/resource/Resource.ts

@@ -1,9 +1,4 @@
-// import type { LdoDataset } from "@ldo/ldo";
-// import type { LeafMethodNotAllowedError } from "./error/MethodNotAllowedError";
-// import type { DatasetChanges } from "@ldo/rdf-utils";
-// import type { PresentContainer } from "./abstract/container/PresentContainer";
 import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
-import { LeafRequester } from "../requester/LeafRequester";
 import type { AbsentResult } from "../requester/requestResults/AbsentResult";
 import type { BinaryResult } from "../requester/requestResults/BinaryResult";
 import type { DataResult } from "../requester/requestResults/DataResult";
@@ -17,32 +12,21 @@ import type {
 } from "../requester/requests/createDataResource";
 import type { DeleteResultError } from "../requester/requests/deleteResource";
 import type { ReadResultError } from "../requester/requests/readResource";
-import type {
+import type { Container } from "./Container";
-  UploadResultError,
+import type { Requester } from "../requester/Requester";
-  UploadResultWithoutOverwriteError,
-} from "../requester/requests/uploadResource";
-import type { LeafUri } from "../uriTypes";
-
-export interface ConcreteInstance {
-  uri: LeafUri;
-  context: SolidLdoDatasetContext;
-  // methods: typeof AbstractLeaf;
-}
 
-// REMEMBER: This file should be replaced with non abstract methods
+export abstract class Resource {
-export class Resource {
   // All intance variables
-  private readonly context: SolidLdoDatasetContext;
+  protected readonly context: SolidLdoDatasetContext;
   readonly uri: string;
-  private readonly requester: LeafRequester;
+  protected abstract readonly requester: Requester;
-  private didInitialFetch: boolean = false;
+  protected didInitialFetch: boolean = false;
-  private absent: boolean | undefined;
+  protected absent: boolean | undefined;
-  private binaryData: { data: Blob; mimeType: string } | undefined;
+  protected binaryData: { data: Blob; mimeType: string } | undefined;
 
   constructor(uri: string, context: SolidLdoDatasetContext) {
     this.uri = uri;
     this.context = context;
-    this.requester = new LeafRequester(uri as LeafUri, context);
   }
 
   // Loading Methods
@@ -75,20 +59,14 @@ export class Resource {
   isUnfetched(): boolean {
     return !this.didInitialFetch;
   }
-  isBinary(): boolean | undefined {
+  isAbsent(): boolean | undefined {
-    if (!this.didInitialFetch) {
+    return this.absent;
-      return undefined;
-    }
-    return !!this.binaryData;
   }
-  isDataResource(): boolean | undefined {
+  isPresent(): boolean | undefined {
-    if (!this.didInitialFetch) {
+    return this.absent === undefined ? undefined : !this.absent;
-      return undefined;
-    }
-    return !this.binaryData;
   }
 
-  private parseResult(
+  protected parseResult(
     result: AbsentResult | BinaryResult | DataResult | ErrorResult,
   ) {
     switch (result.type) {
@@ -120,12 +98,12 @@ export class Resource {
   }
 
   // Read Methods
-  async read(): Promise<Resource | ReadResultError> {
+  async read(): Promise<this | ReadResultError> {
     return this.parseResult(await this.requester.read()) as
-      | Resource
+      | this
       | ReadResultError;
   }
-  async readIfUnfetched(): Promise<Resource | ReadResultError> {
+  async readIfUnfetched(): Promise<this | ReadResultError> {
     if (this.didInitialFetch) {
       return this;
     }
@@ -133,38 +111,18 @@ export class Resource {
   }
 
   // Create Methods
-  async createAndOverwrite(): Promise<Resource | CreateResultErrors> {
+  async createAndOverwrite(): Promise<this | CreateResultErrors> {
     return this.parseResult(await this.requester.createDataResource(true)) as
-      | Resource
+      | this
       | CreateResultErrors;
   }
 
-  async createIfAbsent(): Promise<
+  async createIfAbsent(): Promise<this | CreateResultWithoutOverwriteErrors> {
-    Resource | CreateResultWithoutOverwriteErrors
-  > {
     return this.parseResult(await this.requester.createDataResource()) as
-      | Resource
+      | this
       | CreateResultWithoutOverwriteErrors;
   }
 
-  async uploadAndOverwrite(
-    blob: Blob,
-    mimeType: string,
-  ): Promise<Resource | UploadResultError> {
-    return this.parseResult(await this.requester.upload(blob, mimeType)) as
-      | Resource
-      | UploadResultError;
-  }
-
-  async uploadIfAbsent(
-    blob: Blob,
-    mimeType: string,
-  ): Promise<Resource | UploadResultWithoutOverwriteError> {
-    return this.parseResult(
-      await this.requester.upload(blob, mimeType, true),
-    ) as Resource | UploadResultWithoutOverwriteError;
-  }
-
   // Delete Method
   async delete(): Promise<Resource | DeleteResultError> {
     return this.parseResult(await this.requester.delete()) as
@@ -173,28 +131,11 @@ export class Resource {
   }
 
   // Parent Container Methods -- Remember to change for Container
-  abstract getCachedParentContainer(): ContainerType | LdoSolidError;
+  abstract getParentContainer(): Promise<Container | undefined>;
-  abstract getParentContainer(): Resource;
+  abstract getRootContainer(): Promise<Container>;
-  abstract getRootContainerFromCache():
-    | ContainerType
-    | undefined
-    | LdoSolidError;
-  abstract getRootContainer(): Promise<
-    FetchedContainerType | undefined | LdoSolidError
-  >;
-  abstract getRootContainerFromPod(): Promise<
-    FetchedContainerType | undefined | LdoSolidError
-  >;
   // Exclusing Methods =========================================================
   // Data Methods (Data Leaf Only)
-  abstract getLdoDataset(): LdoDataset | LeafMethodNotAllowedError;
+
-  abstract reloadLdoDataset(): Promise<LdoDataset | LeafMethodNotAllowedError>;
-  abstract hasData(): boolean | LeafMethodNotAllowedError;
-  abstract reloadHasData(): Promise<boolean | LeafMethodNotAllowedError>;
-  abstract update(
-    changes: DatasetChanges,
-  ): Promise<DataLeaf | LdoSolidError | LeafMethodNotAllowedError>;
   // Binary Methods (Binary Only)
-  abstract getMimeType(): string | LeafMethodNotAllowedError;
+  abstract getMimeType(): string;
-  abstract reloadMimeType(): Promise<string | LeafMethodNotAllowedError>;
 }