Clean up solid library

main
Ailin Luca 2 years ago
parent 7c514fdef3
commit 74880d09ff
  1. 63265
      package-lock.json
  2. 2
      packages/schema-converter-shex/src/context/ShexJContextVisitor.ts
  3. 2
      packages/schema-converter-shex/src/typing/ShexJTypingTransformer.ts
  4. 53
      packages/solid/src/ResourceStore.ts
  5. 13
      packages/solid/src/SolidLdoDataset.ts
  6. 3
      packages/solid/src/SolidLdoDatasetContext.ts
  7. 3
      packages/solid/src/createSolidLdoDataset.ts
  8. 6
      packages/solid/src/requester/ContainerRequester.ts
  9. 201
      packages/solid/src/requester/LeafRequester.ts
  10. 199
      packages/solid/src/requester/Requester.ts
  11. 19
      packages/solid/src/resource/Container.ts
  12. 56
      packages/solid/src/resource/Leaf.ts
  13. 107
      packages/solid/src/resource/Resource.ts

63265
package-lock.json generated

File diff suppressed because it is too large Load Diff

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

@ -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";

@ -1,29 +1,27 @@
import type { SolidLdoDatasetContext } from "../SolidLdoDatasetContext";
import type { FetchableDocument } from "./FetchableDocument";
import type { ResourceClass } from "./resource/abstract/AbstractResource";
import type { ContainerClass } from "./resource/abstract/container/Container";
import type { LeafClass } from "./resource/abstract/leaf/Leaf";
import { UnfetchedContainer } from "./resource/concrete/UnfetchedContainer";
import { UnfetchedLeaf } from "./resource/concrete/UnfetchedLeaf";
import { ContainerUri, LeafUri, isContainerUri } from "./uriTypes";
import { Container } from "./resource/Container";
import { Leaf } from "./resource/Leaf";
import type { Resource } from "./resource/Resource";
import type { SolidLdoDatasetContext } from "./SolidLdoDatasetContext";
import type { ContainerUri, LeafUri } from "./util/uriTypes";
import { isContainerUri } from "./util/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: LeafUri, options?: ResourceGetterOptions): LeafClass;
get(uri: string, options?: ResourceGetterOptions): ResourceClass;
get(uri: string, options?: ResourceGetterOptions): ResourceClass {
get(uri: ContainerUri, options?: ResourceGetterOptions): Container;
get(uri: LeafUri, options?: ResourceGetterOptions): Leaf;
get(uri: string, options?: ResourceGetterOptions): Resource;
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);

@ -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 {
// throw new Error("Not Implemented");
// }
get(uri: ContainerUri, options?: ResourceGetterOptions): Container;
get(uri: LeafUri, options?: ResourceGetterOptions): Leaf;
get(uri: string, options?: ResourceGetterOptions): Resource {
return this.context.resourceStore.get(uri, options);
}
}

@ -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;
}

@ -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;
}

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

@ -1,200 +1,3 @@
import type { LeafUri } from "../util/uriTypes";
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";
import { Requester } from "./Requester";
const READ_KEY = "read";
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;
}
}
export class LeafRequester extends Requester {}

@ -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;
}
}

@ -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;
}
}

@ -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");
}
}

@ -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 {
UploadResultError,
UploadResultWithoutOverwriteError,
} from "../requester/requests/uploadResource";
import type { LeafUri } from "../uriTypes";
export interface ConcreteInstance {
uri: LeafUri;
context: SolidLdoDatasetContext;
// methods: typeof AbstractLeaf;
}
import type { Container } from "./Container";
import type { Requester } from "../requester/Requester";
// REMEMBER: This file should be replaced with non abstract methods
export class Resource {
export abstract class Resource {
// All intance variables
private readonly context: SolidLdoDatasetContext;
protected readonly context: SolidLdoDatasetContext;
readonly uri: string;
private readonly requester: LeafRequester;
private didInitialFetch: boolean = false;
private absent: boolean | undefined;
private binaryData: { data: Blob; mimeType: string } | undefined;
protected abstract readonly requester: Requester;
protected didInitialFetch: boolean = false;
protected absent: boolean | 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 {
if (!this.didInitialFetch) {
return undefined;
}
return !!this.binaryData;
isAbsent(): boolean | undefined {
return this.absent;
}
isDataResource(): boolean | undefined {
if (!this.didInitialFetch) {
return undefined;
}
return !this.binaryData;
isPresent(): boolean | undefined {
return this.absent === undefined ? undefined : !this.absent;
}
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<
Resource | CreateResultWithoutOverwriteErrors
> {
async createIfAbsent(): Promise<this | 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(): Resource;
abstract getRootContainerFromCache():
| ContainerType
| undefined
| LdoSolidError;
abstract getRootContainer(): Promise<
FetchedContainerType | undefined | LdoSolidError
>;
abstract getRootContainerFromPod(): Promise<
FetchedContainerType | undefined | LdoSolidError
>;
abstract getParentContainer(): Promise<Container | undefined>;
abstract getRootContainer(): Promise<Container>;
// 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 reloadMimeType(): Promise<string | LeafMethodNotAllowedError>;
abstract getMimeType(): string;
}

Loading…
Cancel
Save