@rdfx/graph-store 0.0.31 → 0.0.32

package/dist/MultiplexingGraphStore.d.ts

@@ -0,0 +1,21 @@
+import type { Stream } from "@rdfjs/types";
+import { type Either, Maybe } from "purify-ts";
+import type { GraphIdentifier } from "./GraphIdentifier.js";
+import type { GraphStore } from "./GraphStore.js";
+/**
+ * A GraphStore implementation that multiplexes over multiple other GraphStore implementations.
+ */
+export declare class MultiplexingGraphStore<ClearOptionsT extends object, ClearReturnT extends object, DeleteOptionsT extends object, DeleteReturnT extends object, GetOptionsT extends object, HeadOptionsT extends object, PostOptionsT extends object, PostReturnT extends object, PutOptionsT extends object, PutReturnT extends object> implements GraphStore {
+    private readonly readWriteGraphStore;
+    private readonly graphStores;
+    constructor(readWriteGraphStore: GraphStore<ClearOptionsT, ClearReturnT, DeleteOptionsT, DeleteReturnT, GetOptionsT, HeadOptionsT, PostOptionsT, PostReturnT, PutOptionsT, PutReturnT>, ...readOnlyGraphStores: readonly GraphStore<ClearOptionsT, ClearReturnT, DeleteOptionsT, DeleteReturnT, GetOptionsT, HeadOptionsT, PostOptionsT, PostReturnT, PutOptionsT, PutReturnT>[]);
+    clear(options?: ClearOptionsT): Promise<Either<Error, ClearReturnT>>;
+    delete(identifier: GraphIdentifier, options?: DeleteOptionsT): Promise<Either<Error, DeleteReturnT>>;
+    get(identifier: GraphIdentifier, options?: GetOptionsT): Promise<Either<Error, Maybe<Stream>>>;
+    head(identifier: GraphIdentifier, options?: HeadOptionsT): Promise<Either<Error, boolean>>;
+    identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    isEmpty(): Promise<Either<Error, boolean>>;
+    post(quads: Stream, options?: PostOptionsT): Promise<Either<Error, PostReturnT>>;
+    put(quads: Stream, options?: PutOptionsT): Promise<Either<Error, PutReturnT>>;
+}
+//# sourceMappingURL=MultiplexingGraphStore.d.ts.map

package/dist/MultiplexingGraphStore.js

@@ -0,0 +1,68 @@
+import { EitherAsync, Maybe } from "purify-ts";
+/**
+ * A GraphStore implementation that multiplexes over multiple other GraphStore implementations.
+ */
+export class MultiplexingGraphStore {
+    readWriteGraphStore;
+    graphStores;
+    constructor(readWriteGraphStore, ...readOnlyGraphStores) {
+        this.readWriteGraphStore = readWriteGraphStore;
+        this.graphStores = [readWriteGraphStore, ...readOnlyGraphStores];
+    }
+    clear(options) {
+        return this.readWriteGraphStore.clear(options);
+    }
+    delete(identifier, options) {
+        return this.readWriteGraphStore.delete(identifier, options);
+    }
+    async get(identifier, options) {
+        return EitherAsync(async ({ liftEither }) => {
+            for (const graphStore of this.graphStores) {
+                const quads = await liftEither(await graphStore.get(identifier, options));
+                if (quads.isJust()) {
+                    return quads;
+                }
+            }
+            return Maybe.empty();
+        });
+    }
+    async head(identifier, options) {
+        return EitherAsync(async ({ liftEither }) => {
+            for (const graphStore of this.graphStores) {
+                const result = await liftEither(await graphStore.head(identifier, options));
+                if (result) {
+                    return result;
+                }
+            }
+            return false;
+        });
+    }
+    async identifiers() {
+        return EitherAsync(async ({ liftEither }) => {
+            const identifiers = new Map();
+            for (const graphStore of this.graphStores) {
+                for (const identifier of await liftEither(await graphStore.identifiers())) {
+                    identifiers.set(identifier.value, identifier);
+                }
+            }
+            return [...identifiers.values()];
+        });
+    }
+    async isEmpty() {
+        return EitherAsync(async ({ liftEither }) => {
+            for (const graphStore of this.graphStores) {
+                if (!(await liftEither(await graphStore.isEmpty()))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    post(quads, options) {
+        return this.readWriteGraphStore.post(quads, options);
+    }
+    put(quads, options) {
+        return this.readWriteGraphStore.put(quads, options);
+    }
+}
+//# sourceMappingURL=MultiplexingGraphStore.js.map

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from "./ForwardingGraphStore.js";
 export * from "./GraphIdentifier.js";
 export * from "./GraphStore.js";
 export * from "./LoggingGraphStore.js";
+export * from "./MultiplexingGraphStore.js";
 export * from "./RdfjsDatasetGraphStore.js";
 export * from "./VersionedGraphStore.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,6 +2,7 @@ export * from "./ForwardingGraphStore.js";
 export * from "./GraphIdentifier.js";
 export * from "./GraphStore.js";
 export * from "./LoggingGraphStore.js";
+export * from "./MultiplexingGraphStore.js";
 export * from "./RdfjsDatasetGraphStore.js";
 export * from "./VersionedGraphStore.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -7,7 +7,7 @@
     "ts-log": "~3.0.2"
   },
   "devDependencies": {
-    "@rdfx/data-factory": "0.0.31",
+    "@rdfx/data-factory": "0.0.32",
     "@rdfjs/dataset": "~2.0.2",
     "get-stream": "~9.0.1",
     "into-stream": "~9.1.0"
@@ -35,5 +35,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.31"
+  "version": "0.0.32"
 }