@rdfx/graph-store 0.0.45 → 0.0.46

package/dist/GraphIdentifier.d.ts

@@ -1,8 +1,9 @@
-import type { DefaultGraph, NamedNode, Quad_Graph } from "@rdfjs/types";
+import type { DataFactory, DefaultGraph, NamedNode, Quad_Graph } from "@rdfjs/types";
 import { Either } from "purify-ts";
 export type GraphIdentifier = DefaultGraph | NamedNode;
 export declare namespace GraphIdentifier {
     function fromQuadGraph(quadGraph: Quad_Graph): Either<Error, GraphIdentifier>;
+    function parse(dataFactory: DataFactory, graphIdentifier: string): GraphIdentifier;
     function stringify(graphIdentifier: GraphIdentifier): string;
 }
 //# sourceMappingURL=GraphIdentifier.d.ts.map

package/dist/GraphIdentifier.js

@@ -11,6 +11,13 @@ export var GraphIdentifier;
         }
     }
     GraphIdentifier.fromQuadGraph = fromQuadGraph;
+    function parse(dataFactory, graphIdentifier) {
+        if (graphIdentifier.length === 0) {
+            return dataFactory.defaultGraph();
+        }
+        return dataFactory.namedNode(graphIdentifier);
+    }
+    GraphIdentifier.parse = parse;
     function stringify(graphIdentifier) {
         return graphIdentifier.value;
     }

package/dist/RdfjsDatasetGraphStore.d.ts

@@ -6,14 +6,21 @@ import type { GraphStore } from "./GraphStore.js";
  * A GraphStore implementation backed by an RDF/JS Dataset.
  */
 export declare class RdfjsDatasetGraphStore implements GraphStore {
-    protected readonly dataset: DatasetCore;
+    readonly dataset: DatasetCore;
     constructor(dataset: DatasetCore);
     clear(): Promise<Either<Error, object>>;
+    clearSync(): Either<Error, object>;
     delete(identifier: GraphIdentifier): Promise<Either<Error, object>>;
+    deleteSync(identifier: GraphIdentifier): Either<Error, object>;
+    get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
+    getDatasetSync(identifier: GraphIdentifier): Either<Error, Maybe<DatasetCore>>;
+    getStreamSync(identifier: GraphIdentifier): Either<Error, Maybe<Stream>>;
     head(identifier: GraphIdentifier): Promise<Either<Error, boolean>>;
+    headSync(identifier: GraphIdentifier): Either<Error, boolean>;
     identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    identifiersSync(): Either<Error, readonly GraphIdentifier[]>;
     isEmpty(): Promise<Either<Error, boolean>>;
-    get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
+    isEmptySync(): Either<Error, boolean>;
     post(quads: Stream): Promise<Either<Error, object>>;
     put(quads: Stream): Promise<Either<Error, object>>;
 }

package/dist/RdfjsDatasetGraphStore.js

@@ -1,5 +1,5 @@
 import { iterableToStream } from "@rdfx/stream";
-import { Either, EitherAsync, Maybe } from "purify-ts";
+import { Either, Left, Maybe } from "purify-ts";
 import { GraphIdentifier } from "./GraphIdentifier.js";
 /**
  * A GraphStore implementation backed by an RDF/JS Dataset.
@@ -10,7 +10,10 @@ export class RdfjsDatasetGraphStore {
         this.dataset = dataset;
     }
     async clear() {
-        return EitherAsync(async () => {
+        return this.clearSync();
+    }
+    clearSync() {
+        return Either.encase(() => {
             for (const quad of this.dataset) {
                 this.dataset.delete(quad);
             }
@@ -18,15 +21,35 @@ export class RdfjsDatasetGraphStore {
         });
     }
     async delete(identifier) {
-        return EitherAsync(async () => {
+        return this.deleteSync(identifier);
+    }
+    deleteSync(identifier) {
+        return Either.encase(() => {
             for (const quad of this.dataset.match(null, null, null, identifier)) {
                 this.dataset.delete(quad);
             }
             return {};
         });
     }
+    async get(identifier) {
+        return this.getStreamSync(identifier);
+    }
+    getDatasetSync(identifier) {
+        return Either.encase(() => {
+            for (const _ of this.dataset.match(null, null, null, identifier)) {
+                return Maybe.of(this.dataset.match(null, null, null, identifier));
+            }
+            return Maybe.empty();
+        });
+    }
+    getStreamSync(identifier) {
+        return this.getDatasetSync(identifier).map((datasetMaybe) => datasetMaybe.map(iterableToStream));
+    }
     async head(identifier) {
-        return EitherAsync(async () => {
+        return this.headSync(identifier);
+    }
+    headSync(identifier) {
+        return Either.encase(() => {
             for (const _ of this.dataset.match(null, null, null, identifier)) {
                 return true;
             }
@@ -34,7 +57,10 @@ export class RdfjsDatasetGraphStore {
         });
     }
     async identifiers() {
-        return EitherAsync(async () => {
+        return this.identifiersSync();
+    }
+    identifiersSync() {
+        return Either.encase(() => {
             const identifiers = new Map();
             for (const quad of this.dataset.match()) {
                 switch (quad.graph.termType) {
@@ -50,23 +76,23 @@ export class RdfjsDatasetGraphStore {
         });
     }
     async isEmpty() {
-        return Either.of(this.dataset.size === 0);
+        return this.isEmptySync();
     }
-    async get(identifier) {
-        for (const _ of this.dataset.match(null, null, null, identifier)) {
-            return Either.of(Maybe.of(iterableToStream(this.dataset.match(null, null, null, identifier))));
-        }
-        return Either.of(Maybe.empty());
+    isEmptySync() {
+        return Either.of(this.dataset.size === 0);
     }
     async post(quads) {
         return new Promise((resolve) => {
-            quads.on("data", (quad) => {
+            quads
+                .on("data", (quad) => {
                 this.dataset.add(quad);
-            });
-            quads.on("end", () => {
+            })
+                .on("end", () => {
                 resolve(Either.of({}));
+            })
+                .on("error", (error) => {
+                resolve(Left(error));
             });
-            quads.on("error", (error) => resolve(Either.of(error)));
         });
     }
     async put(quads) {
@@ -85,7 +111,7 @@ export class RdfjsDatasetGraphStore {
             quads.on("end", () => {
                 resolve(Either.of({}));
             });
-            quads.on("error", (error) => resolve(Either.of(error)));
+            quads.on("error", (error) => resolve(Left(error)));
         });
     }
 }

package/package.json

@@ -1,14 +1,14 @@
 {
   "dependencies": {
-    "@rdfx/stream": "0.0.45",
+    "@rdfx/stream": "0.0.46",
     "@rdfjs/types": "~2.0.1",
     "purify-ts": "~2.1.4",
     "ts-log": "~3.0.2"
   },
   "devDependencies": {
-    "@rdfx/collection": "0.0.45",
-    "@rdfx/data-factory": "0.0.45",
-    "@rdfx/testing": "0.0.45"
+    "@rdfx/collection": "0.0.46",
+    "@rdfx/data-factory": "0.0.46",
+    "@rdfx/testing": "0.0.46"
   },
   "files": [
     "LICENSE",
@@ -33,5 +33,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.45"
+  "version": "0.0.46"
 }