@rdfx/git 0.0.34 → 0.0.36

package/dist/AbstractVersionedRdfFileGraphStore.d.ts

@@ -1,4 +1,4 @@
-import type { Stream } from "@rdfjs/types";
+import type { DatasetCore, 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";
@@ -21,7 +21,6 @@ export declare abstract class AbstractVersionedRdfFileGraphStore implements Vers
     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>>;
@@ -33,11 +32,13 @@ export declare abstract class AbstractVersionedRdfFileGraphStore implements Vers
     put(quads: Stream): Promise<Either<Error, {
         readonly version: string;
     }>>;
+    unionDataset(): Promise<Either<Error, DatasetCore>>;
     protected abstract delegate(options?: {
         fileSystem?: FileSystem;
     }): RdfDirectoryGraphStore | RdfFileGraphStore;
-    private mutate;
+    protected abstract getVersion(identifier: GraphIdentifier, version: string): Promise<Either<Error, Maybe<Stream>>>;
     protected gitRelativeFilePath(path: string): string;
+    private mutate;
 }
 type GitParameters = {
     readonly author?: Parameters<typeof git.commit>[0]["author"];

package/dist/AbstractVersionedRdfFileGraphStore.js

@@ -54,6 +54,12 @@ export class AbstractVersionedRdfFileGraphStore {
     async put(quads) {
         return this.mutate((delegate) => delegate.put(quads));
     }
+    async unionDataset() {
+        return this.delegate().unionDataset();
+    }
+    gitRelativeFilePath(path) {
+        return relative(this.gitParameters.dir, path);
+    }
     async mutate(mutator) {
         return EitherAsync(async ({ liftEither }) => {
             const addedFilePaths = [];
@@ -146,8 +152,5 @@ export class AbstractVersionedRdfFileGraphStore {
             return { version: objectId };
         });
     }
-    gitRelativeFilePath(path) {
-        return relative(this.gitParameters.dir, path);
-    }
 }
 //# sourceMappingURL=AbstractVersionedRdfFileGraphStore.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@rdfx/fs": "0.0.34",
-    "@rdfx/graph-store": "0.0.34",
+    "@rdfx/fs": "0.0.36",
+    "@rdfx/graph-store": "0.0.36",
     "isomorphic-git": "~1.38.3",
     "ts-log": "~3.0.2",
     "typescript-memoize": "~1.1.1"
@@ -30,5 +30,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.34"
+  "version": "0.0.36"
 }

package/dist/AbstractGitGraphStore.d.ts

@@ -1,28 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/GitDirectoryGraphStore.d.ts

@@ -1,7 +0,0 @@
-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

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

package/dist/GitFileSystem.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

package/dist/GitGraphStore.d.ts

@@ -1,7 +0,0 @@
-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

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

package/dist/GitVersionedGraphStore.d.ts

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

package/dist/GitVersionedGraphStore.js

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

package/dist/VersionedFileSystem.d.ts

@@ -1,35 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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