@rdfx/tinybase 0.0.45

package/dist/TinyBaseGraphStore.d.ts

@@ -0,0 +1,45 @@
+import type { DataFactory, DatasetCoreFactory, Quad, Stream } from "@rdfjs/types";
+import { GraphIdentifier, type GraphStore } from "@rdfx/graph-store";
+import { Either, Maybe } from "purify-ts";
+import { type NoValuesSchema, type Store } from "tinybase/with-schemas";
+import type { Logger } from "ts-log";
+export declare class TinyBaseGraphStore implements GraphStore {
+    private readonly dataFactory;
+    private readonly datasetFactory;
+    private readonly logger;
+    readonly tinyBaseStore: TinyBaseGraphStore.TinyBaseStore;
+    constructor({ dataFactory, datasetFactory, logger, parseGraph, tinyBaseStore, }: {
+        dataFactory: DataFactory;
+        datasetFactory: DatasetCoreFactory;
+        logger: Logger;
+        parseGraph?: (identifier: GraphIdentifier, ntriples: string) => Either<Error, Quad[]>;
+        tinyBaseStore?: TinyBaseGraphStore.TinyBaseStore;
+    });
+    clear(): Promise<Either<Error, object>>;
+    delete(identifier: GraphIdentifier): Promise<Either<Error, object>>;
+    deleteSync(identifier: GraphIdentifier): Either<Error, object>;
+    get(identifier: GraphIdentifier): Promise<Either<Error, Maybe<Stream>>>;
+    getQuadsSync(identifier?: GraphIdentifier): Either<Error, Maybe<readonly Quad[]>>;
+    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>>;
+    isEmptySync(): Either<Error, boolean>;
+    post(quads: Stream): Promise<Either<Error, object>>;
+    put(quads: Stream): Promise<Either<Error, object>>;
+    private clearSync;
+    private readonly parseGraph;
+}
+export declare namespace TinyBaseGraphStore {
+    type TinyBaseStore = Store<[typeof tablesSchema, NoValuesSchema]>;
+    const tablesSchema: {
+        readonly graph: {
+            readonly ntriples: {
+                readonly type: "string";
+            };
+        };
+    };
+}
+//# sourceMappingURL=TinyBaseGraphStore.d.ts.map

package/dist/TinyBaseGraphStore.js

@@ -0,0 +1,181 @@
+import { GraphIdentifier } from "@rdfx/graph-store";
+import { iterableToStream } from "@rdfx/stream";
+import { NTriplesTerm } from "@rdfx/string";
+import { Parser } from "n3";
+import { Either, Left, Maybe } from "purify-ts";
+import { createMergeableStore, } from "tinybase/with-schemas";
+export class TinyBaseGraphStore {
+    dataFactory;
+    datasetFactory;
+    logger;
+    tinyBaseStore;
+    constructor({ dataFactory, datasetFactory, logger, parseGraph, tinyBaseStore, }) {
+        this.dataFactory = dataFactory;
+        this.datasetFactory = datasetFactory;
+        this.logger = logger;
+        this.parseGraph =
+            parseGraph ??
+                ((identifier, ntriples) => Either.encase(() => {
+                    const parser = new Parser({ format: "application/n-triples" });
+                    // Hack to put the quads in this named graph rather than rewriting them all after parsing.
+                    parser.DEFAULTGRAPH = identifier;
+                    return parser.parse(ntriples);
+                }));
+        this.tinyBaseStore =
+            tinyBaseStore ??
+                createMergeableStore().setTablesSchema(TinyBaseGraphStore.tablesSchema);
+    }
+    async clear() {
+        return this.clearSync();
+    }
+    async delete(identifier) {
+        return this.deleteSync(identifier);
+    }
+    deleteSync(identifier) {
+        return Either.encase(() => {
+            this.tinyBaseStore.delRow("graph", GraphIdentifier.stringify(identifier));
+            return {};
+        });
+    }
+    async get(identifier) {
+        return this.getStreamSync(identifier);
+    }
+    getQuadsSync(identifier) {
+        return Either.encase(() => {
+            if (identifier) {
+                const row = this.tinyBaseStore.getRow("graph", GraphIdentifier.stringify(identifier));
+                if (Object.values(row).length === 0) {
+                    return Maybe.empty();
+                }
+                const parsedQuadsEither = this.parseGraph(identifier, row.ntriples);
+                if (parsedQuadsEither.isLeft()) {
+                    this.logger.warn("error parsing row %s: %s", GraphIdentifier.stringify(identifier), parsedQuadsEither.extract().message);
+                    return Maybe.empty();
+                }
+                return Maybe.of(parsedQuadsEither.extract());
+            }
+            else {
+                const startTimestampMs = performance.now();
+                let quads = [];
+                const rows = Object.entries(this.tinyBaseStore.getTable("graph"));
+                // this.logger.debug("parsing %d rows", rows.length);
+                for (const [rowId, row] of rows) {
+                    // this.logger.debug("parsing row %s", rowId);
+                    const identifier = GraphIdentifier.parse(this.dataFactory, rowId);
+                    this.parseGraph(identifier, row.ntriples)
+                        .ifLeft((error) => {
+                        this.logger.warn("error parsing row %s: %s", rowId, error.message);
+                    })
+                        .ifRight((newQuads) => {
+                        quads = quads.concat(newQuads);
+                    });
+                }
+                const elapsedTimeMs = performance.now() - startTimestampMs;
+                this.logger.debug("parsed %d quads from %d rows in %.2fms", quads, rows.length, elapsedTimeMs);
+                return Maybe.of(quads);
+            }
+        });
+    }
+    getStreamSync(identifier) {
+        return this.getQuadsSync(identifier).map((quadsMaybe) => quadsMaybe.map((quads) => iterableToStream(quads)));
+    }
+    async head(identifier) {
+        return this.headSync(identifier);
+    }
+    headSync(identifier) {
+        return Either.encase(() => this.tinyBaseStore.hasRow("graph", GraphIdentifier.stringify(identifier)));
+    }
+    async identifiers() {
+        return this.identifiersSync();
+    }
+    identifiersSync() {
+        return Either.encase(() => this.tinyBaseStore
+            .getRowIds("graph")
+            .map((rowId) => GraphIdentifier.parse(this.dataFactory, rowId)));
+    }
+    async isEmpty() {
+        return this.isEmptySync();
+    }
+    isEmptySync() {
+        return Either.encase(() => this.tinyBaseStore.getRowCount("graph") === 0);
+    }
+    async post(quads) {
+        return new Promise((resolve) => {
+            const datasetsByGraphIdentifier = new Map();
+            quads
+                .on("data", (quad) => {
+                const identifier = GraphIdentifier.fromQuadGraph(quad.graph).unsafeCoerce();
+                const graphIdentifierString_ = GraphIdentifier.stringify(identifier);
+                let dataset = datasetsByGraphIdentifier.get(graphIdentifierString_);
+                if (!dataset) {
+                    dataset = this.datasetFactory.dataset();
+                    datasetsByGraphIdentifier.set(graphIdentifierString_, dataset);
+                    this.getQuadsSync(identifier)
+                        .unsafeCoerce()
+                        .ifJust((existingDataset) => {
+                        for (const quad of existingDataset) {
+                            dataset.add(this.dataFactory.quad(quad.subject, quad.predicate, quad.object));
+                        }
+                    });
+                }
+                dataset.add(this.dataFactory.quad(quad.subject, quad.predicate, quad.object));
+            })
+                .on("end", () => {
+                for (const [identifier, dataset,] of datasetsByGraphIdentifier.entries()) {
+                    const ntriples = [];
+                    for (const quad of dataset) {
+                        ntriples.push(NTriplesTerm.stringify(quad));
+                    }
+                    this.tinyBaseStore.setRow("graph", identifier, {
+                        ntriples: ntriples.join("\n"),
+                    });
+                }
+                resolve(Either.of({}));
+            })
+                .on("error", (error) => {
+                resolve(Left(error));
+            });
+        });
+    }
+    async put(quads) {
+        return new Promise((resolve) => {
+            const ntriplesByGraphIdentifier = new Map();
+            quads
+                .on("data", (quad) => {
+                const graphIdentifierString_ = GraphIdentifier.stringify(GraphIdentifier.fromQuadGraph(quad.graph).unsafeCoerce());
+                let ntriples = ntriplesByGraphIdentifier.get(graphIdentifierString_);
+                if (!ntriples) {
+                    ntriples = [];
+                    ntriplesByGraphIdentifier.set(graphIdentifierString_, ntriples);
+                }
+                ntriples.push(NTriplesTerm.stringify(this.dataFactory.quad(quad.subject, quad.predicate, quad.object)));
+            })
+                .on("end", () => {
+                for (const [identifier, ntriples,] of ntriplesByGraphIdentifier.entries()) {
+                    this.tinyBaseStore.setRow("graph", identifier, {
+                        ntriples: ntriples.join("\n"),
+                    });
+                }
+                resolve(Either.of({}));
+            })
+                .on("error", (error) => {
+                resolve(Left(error));
+            });
+        });
+    }
+    clearSync() {
+        return Either.encase(() => {
+            this.tinyBaseStore.delTable("graph");
+            return {};
+        });
+    }
+    parseGraph;
+}
+(function (TinyBaseGraphStore) {
+    TinyBaseGraphStore.tablesSchema = {
+        graph: {
+            ntriples: { type: "string" },
+        },
+    };
+})(TinyBaseGraphStore || (TinyBaseGraphStore = {}));
+//# sourceMappingURL=TinyBaseGraphStore.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

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

package/package.json

@@ -0,0 +1,41 @@
+{
+  "dependencies": {
+    "@rdfx/graph-store": "0.0.45",
+    "@rdfx/stream": "0.0.45",
+    "@rdfx/string": "0.0.45",
+    "@rdfjs/types": "~2.0.1",
+    "@types/n3": "~1.26.0",
+    "n3": "~1.26.0",
+    "purify-ts": "~2.1.4",
+    "tinybase": "~9.4.0",
+    "ts-log": "~3.0.2"
+  },
+  "devDependencies": {
+    "@rdfx/collection": "0.0.45",
+    "@rdfx/data-factory": "0.0.45"
+  },
+  "files": [
+    "LICENSE",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/tinybase",
+  "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 --ignores=\"@tsconfig/*,vitest,vitest-fetch-mock\" .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run packages/tinybase/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.45"
+}