@rdfx/graph-store 0.0.28

package/dist/GraphIdentifier.d.ts

@@ -0,0 +1,8 @@
+import type { 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 stringify(graphIdentifier: GraphIdentifier): string;
+}
+//# sourceMappingURL=GraphIdentifier.d.ts.map

package/dist/GraphIdentifier.js

@@ -0,0 +1,19 @@
+import { Either, Left } from "purify-ts";
+export var GraphIdentifier;
+(function (GraphIdentifier) {
+    function fromQuadGraph(quadGraph) {
+        switch (quadGraph.termType) {
+            case "DefaultGraph":
+            case "NamedNode":
+                return Either.of(quadGraph);
+            default:
+                return Left(new RangeError(quadGraph.termType));
+        }
+    }
+    GraphIdentifier.fromQuadGraph = fromQuadGraph;
+    function stringify(graphIdentifier) {
+        return graphIdentifier.value;
+    }
+    GraphIdentifier.stringify = stringify;
+})(GraphIdentifier || (GraphIdentifier = {}));
+//# sourceMappingURL=GraphIdentifier.js.map

package/dist/GraphStore.d.ts

@@ -0,0 +1,41 @@
+import type { Stream } from "@rdfjs/types";
+import type { Either, Maybe } from "purify-ts";
+import type { GraphIdentifier } from "./GraphIdentifier.js";
+/**
+ * Graph store abstraction, modeled on the SPARQL 1.1 Graph Store HTTP Protocol (https://www.w3.org/TR/sparql11-http-rdf-update/).
+ */
+export interface GraphStore<ClearOptionsT extends object = object, ClearReturnT extends object = object, DeleteOptionsT extends object = object, DeleteReturnT extends object = object, GetOptionsT extends object = object, HeadOptionsT extends object = object, PostOptionsT extends object = object, PostReturnT extends object = object, PutOptionsT extends object = object, PutReturnT extends object = object> {
+    /**
+     * Clear the store.
+     */
+    clear(options?: ClearOptionsT): Promise<Either<Error, ClearReturnT>>;
+    /**
+     * Delete a graph.
+     */
+    delete(identifier: GraphIdentifier, options?: DeleteOptionsT): Promise<Either<Error, DeleteReturnT>>;
+    /**
+     * Get the triples of the named graph.
+     */
+    get(identifier: GraphIdentifier, options?: GetOptionsT): Promise<Either<Error, Maybe<Stream>>>;
+    /**
+     * Does the store have the named graph?
+     */
+    head(identifier: GraphIdentifier, options?: HeadOptionsT): Promise<Either<Error, boolean>>;
+    /**
+     * Get a list of the store's graph identifiers.
+     */
+    identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    /**
+     * Test if the entire store is empty.
+     */
+    isEmpty(): Promise<Either<Error, boolean>>;
+    /**
+     * Add quads without clearing quads' graphs first.
+     */
+    post(quads: Stream, options?: PostOptionsT): Promise<Either<Error, PostReturnT>>;
+    /**
+     * Add quads, clearing the quads' graphs first.
+     */
+    put(quads: Stream, options?: PutOptionsT): Promise<Either<Error, PutReturnT>>;
+}
+//# sourceMappingURL=GraphStore.d.ts.map

package/dist/GraphStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=GraphStore.js.map

package/dist/LoggingGraphStore.d.ts

@@ -0,0 +1,22 @@
+import type { Stream } from "@rdfjs/types";
+import type { Either, Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { GraphIdentifier } from "./GraphIdentifier.js";
+import type { GraphStore } from "./GraphStore.js";
+/**
+ * Wrap a GraphStore implementation and log its operations.
+ */
+export declare class LoggingGraphStore<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<ClearOptionsT, ClearReturnT, DeleteOptionsT, DeleteReturnT, GetOptionsT, HeadOptionsT, PostOptionsT, PostReturnT, PutOptionsT, PutReturnT> {
+    private readonly delegate;
+    private readonly logger;
+    constructor(delegate: GraphStore<ClearOptionsT, ClearReturnT, DeleteOptionsT, DeleteReturnT, GetOptionsT, HeadOptionsT, PostOptionsT, PostReturnT, PutOptionsT, PutReturnT>, logger: Logger);
+    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=LoggingGraphStore.d.ts.map

package/dist/LoggingGraphStore.js

@@ -0,0 +1,92 @@
+/**
+ * Wrap a GraphStore implementation and log its operations.
+ */
+export class LoggingGraphStore {
+    delegate;
+    logger;
+    constructor(delegate, logger) {
+        this.delegate = delegate;
+        this.logger = logger;
+    }
+    async clear(options) {
+        this.logger.debug("clear(options=%s)", options);
+        return this.delegate.clear(options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("clear(options=%s) -> ERROR: %s", options, error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("clear(options=%s) -> SUCCESS: %s", options, return_);
+        }));
+    }
+    async delete(identifier, options) {
+        this.logger.debug("delete(identifier=%s, options=%s)", identifier, options);
+        return this.delegate.delete(identifier, options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("delete(identifier=%s, options=%s) -> ERROR: %s", identifier, options, error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("delete(identifier=%s, options=%s) -> SUCCESS: %s", identifier, options, return_);
+        }));
+    }
+    async get(identifier, options) {
+        this.logger.debug("get(identifier=%s, options=%s)", identifier, options);
+        return this.delegate.get(identifier, options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("get(identifier=%s, options=%s) -> ERROR: %s", identifier, options, error.message);
+        })
+            .ifRight((maybeStream) => {
+            this.logger.debug("get(identifier=%s, options=%s) -> SUCCESS: %s", identifier, options, maybeStream.isJust() ? "<stream>" : "<nothing>");
+        }));
+    }
+    async head(identifier, options) {
+        this.logger.debug("head(identifier=%s, options=%s)", identifier, options);
+        return this.delegate.head(identifier, options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("head(identifier=%s, options=%s) -> ERROR: %s", identifier, options, error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("head(identifier=%s, options=%s) -> SUCCESS: %s", identifier, options, return_);
+        }));
+    }
+    async identifiers() {
+        this.logger.debug("identifiers()");
+        return this.delegate.identifiers().then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("identifiers() -> ERROR: %s", error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("identifiers() -> SUCCESS: %s", return_);
+        }));
+    }
+    async isEmpty() {
+        this.logger.debug("isEmpty()");
+        return this.delegate.isEmpty().then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("isEmpty() -> ERROR: %s", error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("isEmpty() -> SUCCESS: %s", return_);
+        }));
+    }
+    async post(quads, options) {
+        this.logger.debug("post(quads, options=%s)", options);
+        return this.delegate.post(quads, options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("post(quads, options=%s) -> ERROR: %s", options, error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("post(quads, options=%s) -> SUCCESS: %s", options, return_);
+        }));
+    }
+    async put(quads, options) {
+        this.logger.debug("put(quads, options=%s)", options);
+        return this.delegate.put(quads, options).then((either) => either
+            .ifLeft((error) => {
+            this.logger.error("put(quads, options=%s) -> ERROR: %s", options, error.message);
+        })
+            .ifRight((return_) => {
+            this.logger.debug("put(quads, options=%s) -> SUCCESS: %s", options, return_);
+        }));
+    }
+}
+//# sourceMappingURL=LoggingGraphStore.js.map

package/dist/RdfjsDatasetGraphStore.d.ts

@@ -0,0 +1,20 @@
+import type { DatasetCore, Stream } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import { GraphIdentifier } from "./GraphIdentifier.js";
+import type { GraphStore } from "./GraphStore.js";
+/**
+ * A GraphStore implementation backed by an RDF/JS Dataset.
+ */
+export declare class RdfjsDatasetGraphStore implements GraphStore {
+    private readonly dataset;
+    constructor(dataset: DatasetCore);
+    clear(): Promise<Either<Error, object>>;
+    delete(identifier: GraphIdentifier): Promise<Either<Error, object>>;
+    head(identifier: GraphIdentifier): Promise<Either<Error, boolean>>;
+    identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    isEmpty(): Promise<Either<Error, boolean>>;
+    get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
+    post(quads: Stream): Promise<Either<Error, object>>;
+    put(quads: Stream): Promise<Either<Error, object>>;
+}
+//# sourceMappingURL=RdfjsDatasetGraphStore.d.ts.map

package/dist/RdfjsDatasetGraphStore.js

@@ -0,0 +1,92 @@
+import { Either, EitherAsync, Maybe } from "purify-ts";
+import { Readable } from "readable-stream";
+import { GraphIdentifier } from "./GraphIdentifier.js";
+/**
+ * A GraphStore implementation backed by an RDF/JS Dataset.
+ */
+export class RdfjsDatasetGraphStore {
+    dataset;
+    constructor(dataset) {
+        this.dataset = dataset;
+    }
+    async clear() {
+        return EitherAsync(async () => {
+            for (const quad of this.dataset) {
+                this.dataset.delete(quad);
+            }
+            return {};
+        });
+    }
+    async delete(identifier) {
+        return EitherAsync(async () => {
+            for (const quad of this.dataset.match(null, null, null, identifier)) {
+                this.dataset.delete(quad);
+            }
+            return {};
+        });
+    }
+    async head(identifier) {
+        return EitherAsync(async () => {
+            for (const _ of this.dataset.match(null, null, null, identifier)) {
+                return true;
+            }
+            return false;
+        });
+    }
+    async identifiers() {
+        return EitherAsync(async () => {
+            const identifiers = new Map();
+            for (const quad of this.dataset.match()) {
+                switch (quad.graph.termType) {
+                    case "DefaultGraph":
+                        identifiers.set("", quad.graph);
+                        break;
+                    case "NamedNode":
+                        identifiers.set(quad.graph.value, quad.graph);
+                        break;
+                }
+            }
+            return [...identifiers.values()];
+        });
+    }
+    async isEmpty() {
+        return Either.of(this.dataset.size === 0);
+    }
+    async get(identifier) {
+        for (const _ of this.dataset.match(null, null, null, identifier)) {
+            return Either.of(Maybe.of(Readable.from(this.dataset.match(null, null, null, identifier))));
+        }
+        return Either.of(Maybe.empty());
+    }
+    async post(quads) {
+        return new Promise((resolve) => {
+            quads.on("data", (quad) => {
+                this.dataset.add(quad);
+            });
+            quads.on("end", () => {
+                resolve(Either.of({}));
+            });
+            quads.on("error", (error) => resolve(Either.of(error)));
+        });
+    }
+    async put(quads) {
+        const clearedGraphIdentifiers = new Set();
+        return new Promise((resolve) => {
+            quads.on("data", (quad) => {
+                const graphIdentifierString = GraphIdentifier.stringify(GraphIdentifier.fromQuadGraph(quad.graph).unsafeCoerce());
+                if (!clearedGraphIdentifiers.has(graphIdentifierString)) {
+                    for (const deleteQuad of this.dataset.match(null, null, null, quad.graph)) {
+                        this.dataset.delete(deleteQuad);
+                    }
+                    clearedGraphIdentifiers.add(graphIdentifierString);
+                }
+                this.dataset.add(quad);
+            });
+            quads.on("end", () => {
+                resolve(Either.of({}));
+            });
+            quads.on("error", (error) => resolve(Either.of(error)));
+        });
+    }
+}
+//# sourceMappingURL=RdfjsDatasetGraphStore.js.map

package/dist/VersionedGraphStore.d.ts

@@ -0,0 +1,32 @@
+import type { GraphStore } from "./GraphStore.js";
+/**
+ * GraphStore specialization that supports retrieving versions of named graphs.
+ *
+ * Writes to the store return the new version of the store. Versions are intentionally opaque.
+ */
+export type VersionedGraphStore<VersionT, ClearOptionsT extends object = object, ClearReturnT extends {
+    readonly version: VersionT;
+} = {
+    readonly version: VersionT;
+}, DeleteOptionsT extends object = object, DeleteReturnT extends {
+    readonly version: VersionT;
+} = {
+    readonly version: VersionT;
+}, GetOptionsT extends {
+    readonly version?: VersionT;
+} = {
+    readonly version?: VersionT;
+}, HeadOptionsT extends {
+    readonly version?: VersionT;
+} = {
+    readonly version?: VersionT;
+}, PostOptionsT extends object = object, PostReturnT extends {
+    readonly version: VersionT;
+} = {
+    readonly version: VersionT;
+}, PutOptionsT extends object = object, PutReturnT extends {
+    readonly version: VersionT;
+} = {
+    readonly version: VersionT;
+}> = GraphStore<ClearOptionsT, ClearReturnT, DeleteOptionsT, DeleteReturnT, GetOptionsT, HeadOptionsT, PostOptionsT, PostReturnT, PutOptionsT, PutReturnT>;
+//# sourceMappingURL=VersionedGraphStore.d.ts.map

package/dist/VersionedGraphStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VersionedGraphStore.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./GraphIdentifier.js";
+export * from "./GraphStore.js";
+export * from "./LoggingGraphStore.js";
+export * from "./RdfjsDatasetGraphStore.js";
+export * from "./VersionedGraphStore.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "dependencies": {
+    "@rdfjs/types": "~2.0.1",
+    "@types/readable-stream": "~4.0.23",
+    "purify-ts": "~2.1.4",
+    "readable-stream": "^4.7.0",
+    "ts-log": "~3.0.2"
+  },
+  "devDependencies": {
+    "@rdfx/data-factory": "0.0.28",
+    "@rdfjs/dataset": "~2.0.2",
+    "get-stream": "~9.0.1",
+    "into-stream": "~9.1.0"
+  },
+  "files": [
+    "LICENSE",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/graph-store",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run /Users/minor/projects/rdfx/packages/graph-store/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.28"
+}