@rdfx/git 0.0.34

package/dist/AbstractGitGraphStore.d.ts

@@ -0,0 +1,28 @@
+import type { Stream } from "@rdfjs/types";
+import type { GraphIdentifier, GraphStore, VersionedGraphStore } from "@rdfx/graph-store";
+import type { Either, Maybe } from "purify-ts";
+export declare abstract class AbstractGitGraphStore implements VersionedGraphStore<string> {
+    constructor(path: string, {}: {});
+    clear(options?: object | undefined): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    delete(identifier: GraphIdentifier, options?: object | undefined): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    get(identifier: GraphIdentifier, options?: {
+        readonly version?: string | undefined;
+    } | undefined): Promise<Either<Error, Maybe<Stream>>>;
+    head(identifier: GraphIdentifier, options?: {
+        readonly version?: string | undefined;
+    } | undefined): Promise<Either<Error, boolean>>;
+    identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    isEmpty(): Promise<Either<Error, boolean>>;
+    post(quads: Stream, options?: object | undefined): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    put(quads: Stream, options?: object | undefined): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    protected abstract readonly delegate: GraphStore;
+}
+//# sourceMappingURL=AbstractGitGraphStore.d.ts.map

package/dist/AbstractGitGraphStore.js

@@ -0,0 +1,28 @@
+export class AbstractGitGraphStore {
+    constructor(path, {}) { }
+    clear(options) {
+        throw new Error("Method not implemented.");
+    }
+    delete(identifier, options) {
+        throw new Error("Method not implemented.");
+    }
+    get(identifier, options) {
+        throw new Error("Method not implemented.");
+    }
+    head(identifier, options) {
+        throw new Error("Method not implemented.");
+    }
+    identifiers() {
+        throw new Error("Method not implemented.");
+    }
+    isEmpty() {
+        throw new Error("Method not implemented.");
+    }
+    post(quads, options) {
+        throw new Error("Method not implemented.");
+    }
+    put(quads, options) {
+        throw new Error("Method not implemented.");
+    }
+}
+//# sourceMappingURL=AbstractGitGraphStore.js.map

package/dist/AbstractVersionedRdfFileGraphStore.d.ts

@@ -0,0 +1,49 @@
+import type { Stream } from "@rdfjs/types";
+import { type FileSystem, type RdfDirectoryGraphStore, type RdfFileGraphStore } from "@rdfx/fs";
+import type { GraphIdentifier, VersionedGraphStore } from "@rdfx/graph-store";
+import * as git from "isomorphic-git";
+import { type Either, type Maybe } from "purify-ts";
+import { type Logger } from "ts-log";
+export declare abstract class AbstractVersionedRdfFileGraphStore implements VersionedGraphStore<string> {
+    readonly path: string;
+    protected readonly gitParameters: GitParameters;
+    protected readonly logger: Logger;
+    constructor(path: string, { gitParameters, logger, }: {
+        gitParameters: Omit<GitParameters, "fs">;
+        logger?: Logger;
+    });
+    clear(): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    delete(identifier: GraphIdentifier): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    get(identifier: GraphIdentifier, options?: {
+        readonly version?: string;
+    }): Promise<Either<Error, Maybe<Stream>>>;
+    protected abstract getVersion(identifier: GraphIdentifier, version: string): Promise<Either<Error, Maybe<Stream>>>;
+    head(identifier: GraphIdentifier, options?: {
+        readonly version?: string;
+    }): Promise<Either<Error, boolean>>;
+    identifiers(): Promise<Either<Error, readonly GraphIdentifier[]>>;
+    isEmpty(): Promise<Either<Error, boolean>>;
+    post(quads: Stream): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    put(quads: Stream): Promise<Either<Error, {
+        readonly version: string;
+    }>>;
+    protected abstract delegate(options?: {
+        fileSystem?: FileSystem;
+    }): RdfDirectoryGraphStore | RdfFileGraphStore;
+    private mutate;
+    protected gitRelativeFilePath(path: string): string;
+}
+type GitParameters = {
+    readonly author?: Parameters<typeof git.commit>[0]["author"];
+    readonly dir: string;
+    readonly fs: git.PromiseFsClient;
+    readonly gitdir?: string;
+};
+export {};
+//# sourceMappingURL=AbstractVersionedRdfFileGraphStore.d.ts.map

package/dist/AbstractVersionedRdfFileGraphStore.js

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import { join, relative } from "node:path";
+import { NodeFileSystem, } from "@rdfx/fs";
+import * as git from "isomorphic-git";
+import { EitherAsync } from "purify-ts";
+import { dummyLogger } from "ts-log";
+export class AbstractVersionedRdfFileGraphStore {
+    path;
+    gitParameters;
+    logger;
+    constructor(path, { gitParameters, logger, }) {
+        this.path = path;
+        this.gitParameters = {
+            ...gitParameters,
+            fs,
+        };
+        this.logger = logger ?? dummyLogger;
+    }
+    async clear() {
+        return this.mutate((delegate) => delegate.clear());
+    }
+    async delete(identifier) {
+        return this.mutate((delegate) => delegate.delete(identifier));
+    }
+    get(identifier, options) {
+        const version = options?.version;
+        if (!version) {
+            return this.delegate().get(identifier);
+        }
+        return this.getVersion(identifier, version);
+    }
+    async head(identifier, options) {
+        const version = options?.version;
+        if (!version) {
+            return this.delegate().head(identifier);
+        }
+        return EitherAsync(async ({ liftEither }) => {
+            const stream = (await liftEither(await this.getVersion(identifier, version))).extract();
+            if (!stream) {
+                return false;
+            }
+            return await stream.some((quad) => quad.graph.equals(identifier));
+        });
+    }
+    identifiers() {
+        return this.delegate().identifiers();
+    }
+    isEmpty() {
+        return this.delegate().isEmpty();
+    }
+    async post(quads) {
+        return this.mutate((delegate) => delegate.post(quads));
+    }
+    async put(quads) {
+        return this.mutate((delegate) => delegate.put(quads));
+    }
+    async mutate(mutator) {
+        return EitherAsync(async ({ liftEither }) => {
+            const addedFilePaths = [];
+            const gitRelativeFilePath = (filePath) => this.gitRelativeFilePath(filePath);
+            const gitParameters = this.gitParameters;
+            const removedFilePaths = [];
+            const underlyingFileSystem = NodeFileSystem.instance;
+            const fileSystem = {
+                createDirectory(path, options) {
+                    return underlyingFileSystem.createDirectory(path, options);
+                },
+                createReadStream(path) {
+                    return underlyingFileSystem.createReadStream(path);
+                },
+                async deleteDirectory(path, options) {
+                    return EitherAsync(async ({ liftEither }) => {
+                        const filePaths = (await liftEither(await underlyingFileSystem.readDirectory(path, options)))
+                            .filter((dirent) => dirent.isFile())
+                            .map((dirent) => join(dirent.parentPath, dirent.name));
+                        await liftEither(await underlyingFileSystem.deleteDirectory(path, options));
+                        for (const filePath of filePaths) {
+                            await git.remove({
+                                ...gitParameters,
+                                filepath: gitRelativeFilePath(filePath),
+                            });
+                            removedFilePaths.push(filePath);
+                        }
+                    });
+                },
+                async deleteFile(path, options) {
+                    return EitherAsync(async ({ liftEither }) => {
+                        await liftEither(await underlyingFileSystem.deleteFile(path, options));
+                        await git.remove({
+                            ...gitParameters,
+                            filepath: gitRelativeFilePath(path),
+                        });
+                        removedFilePaths.push(path);
+                    });
+                },
+                readDirectory(path, options) {
+                    return underlyingFileSystem.readDirectory(path, options);
+                },
+                readFile(path) {
+                    return underlyingFileSystem.readFile(path);
+                },
+                realpath(path) {
+                    return underlyingFileSystem.realpath(path);
+                },
+                stat(path) {
+                    return underlyingFileSystem.stat(path);
+                },
+                async writeFile(path, data) {
+                    return EitherAsync(async ({ liftEither }) => {
+                        await liftEither(await underlyingFileSystem.writeFile(path, data));
+                        await git.add({
+                            ...gitParameters,
+                            filepath: gitRelativeFilePath(path),
+                        });
+                        addedFilePaths.push(path);
+                    });
+                },
+                async writeFileStream(path, write) {
+                    return EitherAsync(async ({ liftEither }) => {
+                        const result = await liftEither(await underlyingFileSystem.writeFileStream(path, write));
+                        await git.add({
+                            ...gitParameters,
+                            filepath: gitRelativeFilePath(path),
+                        });
+                        addedFilePaths.push(path);
+                        return result;
+                    });
+                },
+            };
+            const delegate = this.delegate({ fileSystem });
+            await liftEither(await mutator(delegate));
+            if (addedFilePaths.length === 0 && removedFilePaths.length === 0) {
+                throw new Error("didn't add or remove any file paths from git");
+            }
+            const objectId = await git.commit({
+                ...gitParameters,
+                author: gitParameters.author ?? {
+                    name: "John Doe",
+                    email: "author@example.com",
+                },
+                message: addedFilePaths
+                    .map((filePath) => `add: ${this.gitRelativeFilePath(filePath)}`)
+                    .concat(removedFilePaths.map((filePath) => `remove: ${this.gitRelativeFilePath(filePath)}`))
+                    .join("\n"),
+            });
+            return { version: objectId };
+        });
+    }
+    gitRelativeFilePath(path) {
+        return relative(this.gitParameters.dir, path);
+    }
+}
+//# sourceMappingURL=AbstractVersionedRdfFileGraphStore.js.map

package/dist/GitDirectoryGraphStore.d.ts

@@ -0,0 +1,7 @@
+import type { RdfDirectoryGraphStore, RdfFileGraphStore } from "@rdfx/fs";
+import type { VersionedGraphStore } from "@rdfx/graph-store";
+export type GitGraphStore = VersionedGraphStore<string>;
+export declare namespace GitGraphStore {
+    function wrap(delegate: RdfDirectoryGraphStore | RdfFileGraphStore): void;
+}
+//# sourceMappingURL=GitDirectoryGraphStore.d.ts.map

package/dist/GitDirectoryGraphStore.js

@@ -0,0 +1,6 @@
+export var GitGraphStore;
+(function (GitGraphStore) {
+    function wrap(delegate) { }
+    GitGraphStore.wrap = wrap;
+})(GitGraphStore || (GitGraphStore = {}));
+//# sourceMappingURL=GitDirectoryGraphStore.js.map

package/dist/GitFileSystem.d.ts

@@ -0,0 +1,15 @@
+import type { Writable } from "node:stream";
+import { NodeFileSystem } from "@rdfx/fs";
+import { type Either } from "purify-ts";
+/**
+ * FileSystem implementation that git adds/removes files that are written or deleted successfully from the underlying node:fs.
+ */
+export declare class GitFileSystem extends NodeFileSystem {
+    private readonly gitParameters;
+    constructor({ dir, gitdir, }: {
+        dir: string;
+        gitdir?: string;
+    });
+    writeFileStream<ReturnT>(path: string, write: (stream: Writable) => Promise<Either<Error, ReturnT>>): Promise<Either<Error, ReturnT>>;
+}
+//# sourceMappingURL=GitFileSystem.d.ts.map

package/dist/GitFileSystem.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import { relative } from "node:path";
+import { NodeFileSystem } from "@rdfx/fs";
+import * as git from "isomorphic-git";
+import { EitherAsync } from "purify-ts";
+/**
+ * FileSystem implementation that git adds/removes files that are written or deleted successfully from the underlying node:fs.
+ */
+export class GitFileSystem extends NodeFileSystem {
+    gitParameters;
+    constructor({ dir, gitdir, }) {
+        super();
+        this.gitParameters = {
+            dir,
+            fs: fs.promises,
+            gitdir,
+        };
+    }
+    async writeFileStream(path, write) {
+        return EitherAsync(async ({ liftEither }) => {
+            const result = await liftEither(await super.writeFileStream(path, write));
+            await git.add({
+                ...this.gitParameters,
+                filepath: relative(this.gitParameters.dir, path),
+            });
+            return result;
+        });
+    }
+}
+//# sourceMappingURL=GitFileSystem.js.map

package/dist/GitGraphStore copy.d.ts

@@ -0,0 +1,7 @@
+import type { RdfDirectoryGraphStore, RdfFileGraphStore } from "@rdfx/fs";
+import type { VersionedGraphStore } from "@rdfx/graph-store";
+export type GitGraphStore = VersionedGraphStore<string>;
+export declare namespace GitGraphStore {
+    function wrap(delegate: RdfDirectoryGraphStore | RdfFileGraphStore): void;
+}
+//# sourceMappingURL=GitGraphStore%20copy.d.ts.map

package/dist/GitGraphStore copy.js

@@ -0,0 +1,6 @@
+export var GitGraphStore;
+(function (GitGraphStore) {
+    function wrap(delegate) { }
+    GitGraphStore.wrap = wrap;
+})(GitGraphStore || (GitGraphStore = {}));
+//# sourceMappingURL=GitGraphStore%20copy.js.map

package/dist/GitGraphStore.d.ts

@@ -0,0 +1,7 @@
+import type { RdfDirectoryGraphStore, RdfFileGraphStore } from "@rdfx/fs";
+import type { VersionedGraphStore } from "@rdfx/graph-store";
+export type GitGraphStore = VersionedGraphStore<string>;
+export declare namespace GitGraphStore {
+    function wrap(delegate: RdfDirectoryGraphStore | RdfFileGraphStore): void;
+}
+//# sourceMappingURL=GitGraphStore.d.ts.map

package/dist/GitGraphStore.js

@@ -0,0 +1,6 @@
+export var GitGraphStore;
+(function (GitGraphStore) {
+    function wrap(delegate) { }
+    GitGraphStore.wrap = wrap;
+})(GitGraphStore || (GitGraphStore = {}));
+//# sourceMappingURL=GitGraphStore.js.map

package/dist/GitVersionedGraphStore.d.ts

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

package/dist/GitVersionedGraphStore.js

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

package/dist/VersionedFileSystem.d.ts

@@ -0,0 +1,35 @@
+import type { Readable, Writable } from "node:stream";
+import type { Dirent, ErrnoException, FileSystem, Stat } from "@rdfx/fs";
+import * as git from "isomorphic-git";
+import { type Either } from "purify-ts";
+/**
+ * FileSystem implementation that git adds/removes files that are written or deleted successfully from the underlying node:fs.
+ */
+export declare class VersionedFileSystem implements FileSystem {
+    private readonly delegate;
+    readonly gitParameters: VersionedFileSystem.GitParameters & {
+        readonly fs: git.PromiseFsClient;
+    };
+    constructor({ delegate, gitParameters, }: {
+        delegate: FileSystem;
+        gitParameters: VersionedFileSystem.GitParameters;
+    });
+    createDirectory(path: string, options?: FileSystem.CreateDirectoryOptions): Promise<Either<ErrnoException, void>>;
+    createReadStream(path: string): Readable;
+    deleteDirectory(path: string, options?: FileSystem.DeleteDirectoryOptions): Promise<Either<ErrnoException, void>>;
+    deleteFile(path: string, options?: FileSystem.DeleteFileOptions): Promise<Either<ErrnoException, void>>;
+    gitRelativeFilePath(path: string): string;
+    readDirectory(path: string, options?: FileSystem.ReadDirectoryOptions): Promise<Either<ErrnoException, readonly Dirent[]>>;
+    readFile(path: string): Promise<Either<ErrnoException, Uint8Array>>;
+    realpath(path: string): Promise<Either<ErrnoException, string>>;
+    stat(path: string): Promise<Either<ErrnoException, Stat>>;
+    writeFile(path: string, data: Uint8Array): Promise<Either<ErrnoException, void>>;
+    writeFileStream<ReturnT>(path: string, write: (stream: Writable) => Promise<Either<Error, ReturnT>>): Promise<Either<Error, ReturnT>>;
+}
+export declare namespace VersionedFileSystem {
+    interface GitParameters {
+        readonly dir: string;
+        readonly gitdir?: string;
+    }
+}
+//# sourceMappingURL=VersionedFileSystem.d.ts.map

package/dist/VersionedFileSystem.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import { join, relative } from "node:path";
+import * as git from "isomorphic-git";
+import { EitherAsync } from "purify-ts";
+/**
+ * FileSystem implementation that git adds/removes files that are written or deleted successfully from the underlying node:fs.
+ */
+export class VersionedFileSystem {
+    delegate;
+    gitParameters;
+    constructor({ delegate, gitParameters, }) {
+        this.delegate = delegate;
+        this.gitParameters = { ...gitParameters, fs: fs.promises };
+    }
+    createDirectory(path, options) {
+        return this.delegate.createDirectory(path, options);
+    }
+    createReadStream(path) {
+        return this.delegate.createReadStream(path);
+    }
+    async deleteDirectory(path, options) {
+        return EitherAsync(async ({ liftEither }) => {
+            const filePaths = (await liftEither(await this.delegate.readDirectory(path, options)))
+                .filter((dirent) => dirent.isFile())
+                .map((dirent) => join(dirent.parentPath, dirent.name));
+            await liftEither(await this.delegate.deleteDirectory(path, options));
+            for (const filePath of filePaths) {
+                await git.remove({
+                    ...this.gitParameters,
+                    filepath: this.gitRelativeFilePath(filePath),
+                });
+            }
+        });
+    }
+    async deleteFile(path, options) {
+        return EitherAsync(async ({ liftEither }) => {
+            await liftEither(await this.delegate.deleteFile(path, options));
+            await git.remove({
+                ...this.gitParameters,
+                filepath: this.gitRelativeFilePath(path),
+            });
+        });
+    }
+    gitRelativeFilePath(path) {
+        return relative(this.gitParameters.dir, path);
+    }
+    readDirectory(path, options) {
+        return this.delegate.readDirectory(path, options);
+    }
+    readFile(path) {
+        return this.delegate.readFile(path);
+    }
+    realpath(path) {
+        return this.delegate.realpath(path);
+    }
+    stat(path) {
+        return this.delegate.stat(path);
+    }
+    async writeFile(path, data) {
+        return EitherAsync(async ({ liftEither }) => {
+            await liftEither(await this.delegate.writeFile(path, data));
+            await git.add({
+                ...this.gitParameters,
+                filepath: this.gitRelativeFilePath(path),
+            });
+        });
+    }
+    async writeFileStream(path, write) {
+        return EitherAsync(async ({ liftEither }) => {
+            const result = await liftEither(await this.delegate.writeFileStream(path, write));
+            await git.add({
+                ...this.gitParameters,
+                filepath: this.gitRelativeFilePath(path),
+            });
+            return result;
+        });
+    }
+}
+//# sourceMappingURL=VersionedFileSystem.js.map

package/dist/VersionedRdfDirectoryGraphStore.d.ts

@@ -0,0 +1,13 @@
+import type { Stream } from "@rdfjs/types";
+import { type FileSystem, RdfDirectoryGraphStore } from "@rdfx/fs";
+import type { GraphIdentifier } from "@rdfx/graph-store";
+import { type Either, Maybe } from "purify-ts";
+import { AbstractVersionedRdfFileGraphStore } from "./AbstractVersionedRdfFileGraphStore.js";
+export declare class VersionedRdfDirectoryGraphStore extends AbstractVersionedRdfFileGraphStore {
+    constructor(path: string, options?: Partial<ConstructorParameters<typeof AbstractVersionedRdfFileGraphStore>[1]>);
+    protected getVersion(identifier: GraphIdentifier, version: string): Promise<Either<Error, Maybe<Stream>>>;
+    protected delegate(options?: {
+        fileSystem?: FileSystem;
+    }): RdfDirectoryGraphStore;
+}
+//# sourceMappingURL=VersionedRdfDirectoryGraphStore.d.ts.map

package/dist/VersionedRdfDirectoryGraphStore.js

@@ -0,0 +1,47 @@
+import { Readable } from "node:stream";
+import dataFactory from "@rdfx/data-factory";
+import { CompressedRdfStream, RdfDirectoryGraphStore, } from "@rdfx/fs";
+import * as git from "isomorphic-git";
+import { EitherAsync, Maybe } from "purify-ts";
+import { AbstractVersionedRdfFileGraphStore } from "./AbstractVersionedRdfFileGraphStore.js";
+export class VersionedRdfDirectoryGraphStore extends AbstractVersionedRdfFileGraphStore {
+    constructor(path, options) {
+        super(path, {
+            gitParameters: options?.gitParameters ?? {
+                dir: path,
+            },
+            logger: options?.logger,
+        });
+    }
+    async getVersion(identifier, version) {
+        return EitherAsync(async () => {
+            let blob;
+            try {
+                blob = (await git.readBlob({
+                    ...this.gitParameters,
+                    oid: version,
+                    filepath: this.gitRelativeFilePath(this.delegate().graphFilePath(identifier)),
+                })).blob;
+            }
+            catch (error) {
+                if (error instanceof git.Errors.NotFoundError) {
+                    return Maybe.empty();
+                }
+                else {
+                    throw error;
+                }
+            }
+            const stream = CompressedRdfStream.parse(RdfDirectoryGraphStore.fileFormat, Readable.from(Buffer.from(blob)));
+            return Maybe.of(identifier.termType === "DefaultGraph"
+                ? stream
+                : stream.map((quad) => dataFactory.quad(quad.subject, quad.predicate, quad.object, identifier)));
+        });
+    }
+    delegate(options) {
+        return new RdfDirectoryGraphStore(this.path, {
+            ...options,
+            logger: this.logger,
+        });
+    }
+}
+//# sourceMappingURL=VersionedRdfDirectoryGraphStore.js.map

package/dist/VersionedRdfFileGraphStore.d.ts

@@ -0,0 +1,16 @@
+import type { Stream } from "@rdfjs/types";
+import { type FileSystem, RdfFileGraphStore, RdfFormat } from "@rdfx/fs";
+import type { GraphIdentifier } from "@rdfx/graph-store";
+import { type Either, Maybe } from "purify-ts";
+import { AbstractVersionedRdfFileGraphStore } from "./AbstractVersionedRdfFileGraphStore.js";
+export declare class VersionedRdfFileGraphStore extends AbstractVersionedRdfFileGraphStore {
+    private readonly format;
+    constructor(path: string, options?: Partial<ConstructorParameters<typeof AbstractVersionedRdfFileGraphStore>[1]> & {
+        format?: RdfFormat;
+    });
+    protected delegate(options?: {
+        fileSystem?: FileSystem;
+    }): RdfFileGraphStore;
+    protected getVersion(identifier: GraphIdentifier, version: string): Promise<Either<Error, Maybe<Stream>>>;
+}
+//# sourceMappingURL=VersionedRdfFileGraphStore.d.ts.map

package/dist/VersionedRdfFileGraphStore.js

@@ -0,0 +1,57 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { dirname } from "node:path";
+import { Readable } from "node:stream";
+import { CompressedRdfStream, RdfFileGraphStore, RdfFormat, } from "@rdfx/fs";
+import * as git from "isomorphic-git";
+import { EitherAsync, Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractVersionedRdfFileGraphStore } from "./AbstractVersionedRdfFileGraphStore.js";
+export class VersionedRdfFileGraphStore extends AbstractVersionedRdfFileGraphStore {
+    format;
+    constructor(path, options) {
+        super(path, {
+            gitParameters: options?.gitParameters ?? {
+                dir: dirname(path),
+            },
+            logger: options?.logger,
+        });
+        this.format = options?.format ?? RdfFormat.fromPath(path).unsafeCoerce();
+    }
+    delegate(options) {
+        return new RdfFileGraphStore(this.path, {
+            ...options,
+            format: this.format,
+            logger: this.logger,
+        });
+    }
+    async getVersion(identifier, version) {
+        return EitherAsync(async () => {
+            let blob;
+            try {
+                blob = (await git.readBlob({
+                    ...this.gitParameters,
+                    oid: version,
+                    filepath: this.gitRelativeFilePath(this.path),
+                })).blob;
+            }
+            catch (error) {
+                if (error instanceof git.Errors.NotFoundError) {
+                    return Maybe.empty();
+                }
+                else {
+                    throw error;
+                }
+            }
+            return Maybe.of(CompressedRdfStream.parse(this.format, Readable.from(Buffer.from(blob))).filter((quad) => quad.graph.equals(identifier)));
+        });
+    }
+}
+__decorate([
+    Memoize()
+], VersionedRdfFileGraphStore.prototype, "delegate", null);
+//# sourceMappingURL=VersionedRdfFileGraphStore.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./VersionedRdfDirectoryGraphStore.js";
+export * from "./VersionedRdfFileGraphStore.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./VersionedRdfDirectoryGraphStore.js";
+export * from "./VersionedRdfFileGraphStore.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "dependencies": {
+    "@rdfx/fs": "0.0.34",
+    "@rdfx/graph-store": "0.0.34",
+    "isomorphic-git": "~1.38.3",
+    "ts-log": "~3.0.2",
+    "typescript-memoize": "~1.1.1"
+  },
+  "devDependencies": {},
+  "files": [
+    "LICENSE",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/git",
+  "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/git/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.34"
+}