@zenfs/core 0.13.0 → 0.14.1

package/dist/backends/locked.d.ts

@@ -1,7 +1,11 @@
 import type { Cred } from '../cred.js';
 import type { File } from '../file.js';
-import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import type { FileSystemMetadata } from '../filesystem.js';
+import { FileSystem } from '../filesystem.js';
 import type { Stats } from '../stats.js';
+export interface MutexLock extends PromiseWithResolvers<void> {
+    [Symbol.dispose](): void;
+}
 /**
  * This class serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
@@ -14,8 +18,37 @@ import type { Stats } from '../stats.js';
  */
 export declare class LockedFS<FS extends FileSystem> implements FileSystem {
     readonly fs: FS;
-    private mutex;
     constructor(fs: FS);
+    /**
+     * The current locks
+     */
+    private locks;
+    protected addLock(path: string): MutexLock;
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, waits for it to be unlocked.
+     * @internal
+     */
+    lock(path: string): Promise<MutexLock>;
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, an error will be thrown
+     * @internal
+     */
+    lockSync(path: string): MutexLock;
+    /**
+     * Unlocks a path
+     * @param path The path to lock
+     * @param noThrow If true, an error will not be thrown if the path is already unlocked
+     * @returns Whether the path was unlocked
+     * @internal
+     */
+    unlock(path: string, noThrow?: boolean): boolean;
+    /**
+     * Whether `path` is locked
+     * @internal
+     */
+    isLocked(path: string): boolean;
     ready(): Promise<void>;
     metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
@@ -41,3 +74,18 @@ export declare class LockedFS<FS extends FileSystem> implements FileSystem {
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
+export declare const Locked: {
+    name: string;
+    options: {
+        fs: {
+            type: "object";
+            required: true;
+            description: string;
+            validator(fs: FileSystem): void;
+        };
+    };
+    isAvailable(): true;
+    create({ fs }: {
+        fs: FileSystem;
+    } & Partial<import("./backend.js").SharedConfig>): LockedFS<FileSystem>;
+};

package/dist/backends/locked.js

@@ -1,5 +1,50 @@
-import { ErrnoError } from '../error.js';
-import { Mutex } from '../mutex.js';
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Errno, ErrnoError } from '../error.js';
+import { FileSystem } from '../filesystem.js';
 /**
  * This class serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
@@ -13,7 +58,70 @@ import { Mutex } from '../mutex.js';
 export class LockedFS {
     constructor(fs) {
         this.fs = fs;
-        this.mutex = new Mutex();
+        /**
+         * The current locks
+         */
+        this.locks = new Map();
+    }
+    addLock(path) {
+        const lock = {
+            ...Promise.withResolvers(),
+            [Symbol.dispose]: () => {
+                this.unlock(path);
+            },
+        };
+        this.locks.set(path, lock);
+        return lock;
+    }
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, waits for it to be unlocked.
+     * @internal
+     */
+    async lock(path) {
+        if (this.locks.has(path)) {
+            // Non-null assertion: we already checked locks has path
+            await this.locks.get(path).promise;
+        }
+        return this.addLock(path);
+    }
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, an error will be thrown
+     * @internal
+     */
+    lockSync(path) {
+        if (this.locks.has(path)) {
+            // Non-null assertion: we already checked locks has path
+            throw ErrnoError.With('EBUSY', path, 'lockSync');
+        }
+        return this.addLock(path);
+    }
+    /**
+     * Unlocks a path
+     * @param path The path to lock
+     * @param noThrow If true, an error will not be thrown if the path is already unlocked
+     * @returns Whether the path was unlocked
+     * @internal
+     */
+    unlock(path, noThrow = false) {
+        if (!this.locks.has(path)) {
+            if (noThrow) {
+                return false;
+            }
+            throw new ErrnoError(Errno.EPERM, 'Can not unlock an already unlocked path', path);
+        }
+        // Non-null assertion: we already checked locks has path
+        this.locks.get(path).resolve();
+        this.locks.delete(path);
+        return true;
+    }
+    /**
+     * Whether `path` is locked
+     * @internal
+     */
+    isLocked(path) {
+        return this.locks.has(path);
     }
     async ready() {
         await this.fs.ready();
@@ -25,129 +133,354 @@ export class LockedFS {
         };
     }
     async rename(oldPath, newPath, cred) {
-        await this.mutex.lock(oldPath);
-        await this.fs.rename(oldPath, newPath, cred);
-        this.mutex.unlock(oldPath);
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_1, await this.lock(oldPath), false);
+            await this.fs.rename(oldPath, newPath, cred);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
     }
     renameSync(oldPath, newPath, cred) {
-        if (this.mutex.isLocked(oldPath)) {
-            throw ErrnoError.With('EBUSY', oldPath, 'rename');
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_2, this.lockSync(oldPath), false);
+            return this.fs.renameSync(oldPath, newPath, cred);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
         }
-        return this.fs.renameSync(oldPath, newPath, cred);
     }
     async stat(path, cred) {
-        await this.mutex.lock(path);
-        const stats = await this.fs.stat(path, cred);
-        this.mutex.unlock(path);
-        return stats;
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_3, await this.lock(path), false);
+            return await this.fs.stat(path, cred);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
     }
     statSync(path, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'stat');
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_4, this.lockSync(path), false);
+            return this.fs.statSync(path, cred);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
         }
-        return this.fs.statSync(path, cred);
     }
     async openFile(path, flag, cred) {
-        await this.mutex.lock(path);
-        const fd = await this.fs.openFile(path, flag, cred);
-        this.mutex.unlock(path);
-        return fd;
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_5, await this.lock(path), false);
+            return await this.fs.openFile(path, flag, cred);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
     }
     openFileSync(path, flag, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'openFile');
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_6, this.lockSync(path), false);
+            return this.fs.openFileSync(path, flag, cred);
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
         }
-        return this.fs.openFileSync(path, flag, cred);
     }
     async createFile(path, flag, mode, cred) {
-        await this.mutex.lock(path);
-        const fd = await this.fs.createFile(path, flag, mode, cred);
-        this.mutex.unlock(path);
-        return fd;
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_7, await this.lock(path), false);
+            return await this.fs.createFile(path, flag, mode, cred);
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
     }
     createFileSync(path, flag, mode, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'createFile');
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_8, this.lockSync(path), false);
+            return this.fs.createFileSync(path, flag, mode, cred);
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
+        }
+        finally {
+            __disposeResources(env_8);
         }
-        return this.fs.createFileSync(path, flag, mode, cred);
     }
     async unlink(path, cred) {
-        await this.mutex.lock(path);
-        await this.fs.unlink(path, cred);
-        this.mutex.unlock(path);
+        const env_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_9, await this.lock(path), false);
+            await this.fs.unlink(path, cred);
+        }
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            __disposeResources(env_9);
+        }
     }
     unlinkSync(path, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'unlink');
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_10, this.lockSync(path), false);
+            return this.fs.unlinkSync(path, cred);
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            __disposeResources(env_10);
         }
-        return this.fs.unlinkSync(path, cred);
     }
     async rmdir(path, cred) {
-        await this.mutex.lock(path);
-        await this.fs.rmdir(path, cred);
-        this.mutex.unlock(path);
+        const env_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_11, await this.lock(path), false);
+            await this.fs.rmdir(path, cred);
+        }
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            __disposeResources(env_11);
+        }
     }
     rmdirSync(path, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'rmdir');
+        const env_12 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_12, this.lockSync(path), false);
+            return this.fs.rmdirSync(path, cred);
+        }
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
+        }
+        finally {
+            __disposeResources(env_12);
         }
-        return this.fs.rmdirSync(path, cred);
     }
     async mkdir(path, mode, cred) {
-        await this.mutex.lock(path);
-        await this.fs.mkdir(path, mode, cred);
-        this.mutex.unlock(path);
+        const env_13 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_13, await this.lock(path), false);
+            await this.fs.mkdir(path, mode, cred);
+        }
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            __disposeResources(env_13);
+        }
     }
     mkdirSync(path, mode, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'mkdir');
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_14, this.lockSync(path), false);
+            return this.fs.mkdirSync(path, mode, cred);
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
+        }
+        finally {
+            __disposeResources(env_14);
         }
-        return this.fs.mkdirSync(path, mode, cred);
     }
     async readdir(path, cred) {
-        await this.mutex.lock(path);
-        const files = await this.fs.readdir(path, cred);
-        this.mutex.unlock(path);
-        return files;
+        const env_15 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_15, await this.lock(path), false);
+            return await this.fs.readdir(path, cred);
+        }
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
+        }
+        finally {
+            __disposeResources(env_15);
+        }
     }
     readdirSync(path, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'readdir');
+        const env_16 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_16, this.lockSync(path), false);
+            return this.fs.readdirSync(path, cred);
+        }
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
+        }
+        finally {
+            __disposeResources(env_16);
         }
-        return this.fs.readdirSync(path, cred);
     }
     async exists(path, cred) {
-        await this.mutex.lock(path);
-        const exists = await this.fs.exists(path, cred);
-        this.mutex.unlock(path);
-        return exists;
+        const env_17 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_17, await this.lock(path), false);
+            return await this.fs.exists(path, cred);
+        }
+        catch (e_17) {
+            env_17.error = e_17;
+            env_17.hasError = true;
+        }
+        finally {
+            __disposeResources(env_17);
+        }
     }
     existsSync(path, cred) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'exists');
+        const env_18 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_18, this.lockSync(path), false);
+            return this.fs.existsSync(path, cred);
+        }
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
+        }
+        finally {
+            __disposeResources(env_18);
         }
-        return this.fs.existsSync(path, cred);
     }
     async link(srcpath, dstpath, cred) {
-        await this.mutex.lock(srcpath);
-        await this.fs.link(srcpath, dstpath, cred);
-        this.mutex.unlock(srcpath);
+        const env_19 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_19, await this.lock(srcpath), false);
+            await this.fs.link(srcpath, dstpath, cred);
+        }
+        catch (e_19) {
+            env_19.error = e_19;
+            env_19.hasError = true;
+        }
+        finally {
+            __disposeResources(env_19);
+        }
     }
     linkSync(srcpath, dstpath, cred) {
-        if (this.mutex.isLocked(srcpath)) {
-            throw ErrnoError.With('EBUSY', srcpath, 'link');
+        const env_20 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_20, this.lockSync(srcpath), false);
+            return this.fs.linkSync(srcpath, dstpath, cred);
+        }
+        catch (e_20) {
+            env_20.error = e_20;
+            env_20.hasError = true;
+        }
+        finally {
+            __disposeResources(env_20);
         }
-        return this.fs.linkSync(srcpath, dstpath, cred);
     }
     async sync(path, data, stats) {
-        await this.mutex.lock(path);
-        await this.fs.sync(path, data, stats);
-        this.mutex.unlock(path);
+        const env_21 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_21, await this.lock(path), false);
+            await this.fs.sync(path, data, stats);
+        }
+        catch (e_21) {
+            env_21.error = e_21;
+            env_21.hasError = true;
+        }
+        finally {
+            __disposeResources(env_21);
+        }
     }
     syncSync(path, data, stats) {
-        if (this.mutex.isLocked(path)) {
-            throw ErrnoError.With('EBUSY', path, 'sync');
+        const env_22 = { stack: [], error: void 0, hasError: false };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _ = __addDisposableResource(env_22, this.lockSync(path), false);
+            return this.fs.syncSync(path, data, stats);
+        }
+        catch (e_22) {
+            env_22.error = e_22;
+            env_22.hasError = true;
+        }
+        finally {
+            __disposeResources(env_22);
         }
-        return this.fs.syncSync(path, data, stats);
     }
 }
+export const Locked = {
+    name: 'Locked',
+    options: {
+        fs: {
+            type: 'object',
+            required: true,
+            description: '',
+            validator(fs) {
+                if (!(fs instanceof FileSystem)) {
+                    throw new ErrnoError(Errno.EINVAL, 'fs passed to LockedFS must be a FileSystem');
+                }
+            },
+        },
+    },
+    isAvailable() {
+        return true;
+    },
+    create({ fs }) {
+        return new LockedFS(fs);
+    },
+};

package/dist/backends/overlay.js

@@ -56,6 +56,9 @@ export class UnlockedOverlayFS extends FileSystem {
     async sync(path, data, stats) {
         const cred = stats.cred(0, 0);
         await this.createParentDirectories(path, cred);
+        if (!(await this._writable.exists(path, cred))) {
+            await this._writable.createFile(path, 'w', 0o644, cred);
+        }
         await this._writable.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
@@ -123,7 +126,7 @@ export class UnlockedOverlayFS extends FileSystem {
     async stat(path, cred) {
         this.checkInitialized();
         try {
-            return this._writable.stat(path, cred);
+            return await this._writable.stat(path, cred);
         }
         catch (e) {
             if (this._deletedFiles.has(path)) {

package/dist/backends/store/store.d.ts

@@ -1,4 +1,5 @@
 import type { Ino } from '../../inode.js';
+import '../../symbol-dispose.js';
 /**
  * Represents a key-value store.
  */

package/dist/backends/store/store.js

@@ -1,4 +1,5 @@
 import { ErrnoError } from '../../error.js';
+import '../../symbol-dispose.js';
 /**
  * A transaction for a store.
  */