@zenfs/core 0.17.1 → 0.18.1

package/src/mixins/mutexed.ts

@@ -1,10 +1,9 @@
-import type { Cred } from '../cred.js';
 import { ErrnoError } from '../error.js';
 import type { File } from '../file.js';
-import type { FileSystem } from '../filesystem.js';
+import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
 import '../polyfills.js';
 import type { Stats } from '../stats.js';
-import type { Mixin } from './shared.js';
+import type { Concrete } from '../utils.js';
 
 export class MutexLock {
 	protected current = Promise.withResolvers<void>();
@@ -14,10 +13,7 @@ export class MutexLock {
 		return this._isLocked;
 	}
 
-	public constructor(
-		public readonly path: string,
-		protected readonly previous?: MutexLock
-	) {}
+	public constructor(protected readonly previous?: MutexLock) {}
 
 	public async done(): Promise<void> {
 		await this.previous?.done();
@@ -35,211 +31,227 @@ export class MutexLock {
 }
 
 /**
- * This serializes access to an underlying async filesystem.
- * For example, on an OverlayFS instance with an async lower
- * directory operations like rename and rmdir may involve multiple
- * requests involving both the upper and lower filesystems -- they
- * are not executed in a single atomic step. OverlayFS uses this
- * to avoid having to reason about the correctness of
- * multiple requests interleaving.
- *
- * Note: `@ts-expect-error 2513` is needed because `FS` is not properly detected as being concrete
- *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
- * @internal
+ * @hidden
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function Mutexed<T extends new (...args: any[]) => FileSystem>(
-	FS: T
-): Mixin<
-	T,
-	{
-		lock(path: string): Promise<MutexLock>;
-		lockSync(path: string): MutexLock;
-		isLocked(path: string): boolean;
-	}
-> {
-	class MutexedFS extends FS {
-		/**
-		 * The current locks
-		 */
-		private locks: Map<string, MutexLock> = new Map();
-
-		/**
-		 * Adds a lock for a path
-		 */
-		protected addLock(path: string): MutexLock {
-			const previous = this.locks.get(path);
-			const lock = new MutexLock(path, previous?.isLocked ? previous : undefined);
-			this.locks.set(path, lock);
-			return lock;
-		}
+export class __MutexedFS<T extends FileSystem> implements FileSystem {
+	/**
+	 * @internal
+	 */
+	public _fs!: T;
+
+	public async ready(): Promise<void> {
+		return await this._fs.ready();
+	}
 
-		/**
-		 * Locks `path` asynchronously.
-		 * If the path is currently locked, waits for it to be unlocked.
-		 * @internal
-		 */
-		public async lock(path: string): Promise<MutexLock> {
-			const previous = this.locks.get(path);
-			const lock = this.addLock(path);
-			await previous?.done();
-			return lock;
-		}
+	public metadata(): FileSystemMetadata {
+		return this._fs.metadata();
+	}
 
-		/**
-		 * Locks `path` asynchronously.
-		 * If the path is currently locked, an error will be thrown
-		 * @internal
-		 */
-		public lockSync(path: string): MutexLock {
-			if (this.locks.has(path)) {
-				// Non-null assertion: we already checked locks has path
-				throw ErrnoError.With('EBUSY', path, 'lockSync');
+	/**
+	 * The current locks
+	 */
+	private currentLock?: MutexLock;
+
+	/**
+	 * Adds a lock for a path
+	 */
+	protected addLock(): MutexLock {
+		const lock = new MutexLock(this.currentLock);
+		this.currentLock = lock;
+		return lock;
+	}
+
+	/**
+	 * Locks `path` asynchronously.
+	 * If the path is currently locked, waits for it to be unlocked.
+	 * @internal
+	 */
+	public async lock(path: string, syscall: string): Promise<MutexLock> {
+		const previous = this.currentLock;
+		const lock = this.addLock();
+		const stack = new Error().stack;
+		setTimeout(() => {
+			if (lock.isLocked) {
+				const error = ErrnoError.With('EDEADLK', path, syscall);
+				error.stack += stack?.slice('Error'.length);
+				throw error;
 			}
+		}, 5000);
+		await previous?.done();
+		return lock;
+	}
 
-			return this.addLock(path);
+	/**
+	 * Locks `path` asynchronously.
+	 * If the path is currently locked, an error will be thrown
+	 * @internal
+	 */
+	public lockSync(path: string, syscall: string): MutexLock {
+		if (this.currentLock) {
+			throw ErrnoError.With('EBUSY', path, syscall);
 		}
 
-		/**
-		 * Whether `path` is locked
-		 * @internal
-		 */
-		public isLocked(path: string): boolean {
-			return !!this.locks.get(path)?.isLocked;
-		}
+		return this.addLock();
+	}
 
-		/* eslint-disable @typescript-eslint/no-unused-vars */
-		public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
-			using _ = await this.lock(oldPath);
-			// @ts-expect-error 2513
-			await super.rename(oldPath, newPath, cred);
-		}
+	/**
+	 * Whether `path` is locked
+	 * @internal
+	 */
+	public get isLocked(): boolean {
+		return !!this.currentLock?.isLocked;
+	}
 
-		public renameSync(oldPath: string, newPath: string, cred: Cred): void {
-			using _ = this.lockSync(oldPath);
-			// @ts-expect-error 2513
-			return super.renameSync(oldPath, newPath, cred);
-		}
+	/* eslint-disable @typescript-eslint/no-unused-vars */
+	public async rename(oldPath: string, newPath: string): Promise<void> {
+		using _ = await this.lock(oldPath, 'rename');
+		await this._fs.rename(oldPath, newPath);
+	}
 
-		public async stat(path: string, cred: Cred): Promise<Stats> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			return await super.stat(path, cred);
-		}
+	public renameSync(oldPath: string, newPath: string): void {
+		using _ = this.lockSync(oldPath, 'rename');
+		return this._fs.renameSync(oldPath, newPath);
+	}
 
-		public statSync(path: string, cred: Cred): Stats {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.statSync(path, cred);
-		}
+	public async stat(path: string): Promise<Stats> {
+		using _ = await this.lock(path, 'stat');
+		return await this._fs.stat(path);
+	}
 
-		public async openFile(path: string, flag: string, cred: Cred): Promise<File> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			return await super.openFile(path, flag, cred);
-		}
+	public statSync(path: string): Stats {
+		using _ = this.lockSync(path, 'stat');
+		return this._fs.statSync(path);
+	}
 
-		public openFileSync(path: string, flag: string, cred: Cred): File {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.openFileSync(path, flag, cred);
-		}
+	public async openFile(path: string, flag: string): Promise<File> {
+		using _ = await this.lock(path, 'openFile');
+		const file = await this._fs.openFile(path, flag);
+		file.fs = this;
+		return file;
+	}
 
-		public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			return await super.createFile(path, flag, mode, cred);
-		}
+	public openFileSync(path: string, flag: string): File {
+		using _ = this.lockSync(path, 'openFile');
+		const file = this._fs.openFileSync(path, flag);
+		file.fs = this;
+		return file;
+	}
 
-		public createFileSync(path: string, flag: string, mode: number, cred: Cred): File {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.createFileSync(path, flag, mode, cred);
-		}
+	public async createFile(path: string, flag: string, mode: number): Promise<File> {
+		using _ = await this.lock(path, 'createFile');
+		const file = await this._fs.createFile(path, flag, mode);
+		file.fs = this;
+		return file;
+	}
 
-		public async unlink(path: string, cred: Cred): Promise<void> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			await super.unlink(path, cred);
-		}
+	public createFileSync(path: string, flag: string, mode: number): File {
+		using _ = this.lockSync(path, 'createFile');
+		const file = this._fs.createFileSync(path, flag, mode);
+		file.fs = this;
+		return file;
+	}
 
-		public unlinkSync(path: string, cred: Cred): void {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.unlinkSync(path, cred);
-		}
+	public async unlink(path: string): Promise<void> {
+		using _ = await this.lock(path, 'unlink');
+		await this._fs.unlink(path);
+	}
 
-		public async rmdir(path: string, cred: Cred): Promise<void> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			await super.rmdir(path, cred);
-		}
+	public unlinkSync(path: string): void {
+		using _ = this.lockSync(path, 'unlink');
+		return this._fs.unlinkSync(path);
+	}
 
-		public rmdirSync(path: string, cred: Cred): void {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.rmdirSync(path, cred);
-		}
+	public async rmdir(path: string): Promise<void> {
+		using _ = await this.lock(path, 'rmdir');
+		await this._fs.rmdir(path);
+	}
 
-		public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			await super.mkdir(path, mode, cred);
-		}
+	public rmdirSync(path: string): void {
+		using _ = this.lockSync(path, 'rmdir');
+		return this._fs.rmdirSync(path);
+	}
 
-		public mkdirSync(path: string, mode: number, cred: Cred): void {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.mkdirSync(path, mode, cred);
-		}
+	public async mkdir(path: string, mode: number): Promise<void> {
+		using _ = await this.lock(path, 'mkdir');
+		await this._fs.mkdir(path, mode);
+	}
 
-		public async readdir(path: string, cred: Cred): Promise<string[]> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			return await super.readdir(path, cred);
-		}
+	public mkdirSync(path: string, mode: number): void {
+		using _ = this.lockSync(path, 'mkdir');
+		return this._fs.mkdirSync(path, mode);
+	}
 
-		public readdirSync(path: string, cred: Cred): string[] {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.readdirSync(path, cred);
-		}
+	public async readdir(path: string): Promise<string[]> {
+		using _ = await this.lock(path, 'readdir');
+		return await this._fs.readdir(path);
+	}
 
-		public async exists(path: string, cred: Cred): Promise<boolean> {
-			using _ = await this.lock(path);
-			return await super.exists(path, cred);
-		}
+	public readdirSync(path: string): string[] {
+		using _ = this.lockSync(path, 'readdir');
+		return this._fs.readdirSync(path);
+	}
 
-		public existsSync(path: string, cred: Cred): boolean {
-			using _ = this.lockSync(path);
-			return super.existsSync(path, cred);
-		}
+	public async exists(path: string): Promise<boolean> {
+		using _ = await this.lock(path, 'exists');
+		return await this._fs.exists(path);
+	}
 
-		public async link(srcpath: string, dstpath: string, cred: Cred): Promise<void> {
-			using _ = await this.lock(srcpath);
-			// @ts-expect-error 2513
-			await super.link(srcpath, dstpath, cred);
-		}
+	public existsSync(path: string): boolean {
+		using _ = this.lockSync(path, 'exists');
+		return this._fs.existsSync(path);
+	}
 
-		public linkSync(srcpath: string, dstpath: string, cred: Cred): void {
-			using _ = this.lockSync(srcpath);
-			// @ts-expect-error 2513
-			return super.linkSync(srcpath, dstpath, cred);
-		}
+	public async link(srcpath: string, dstpath: string): Promise<void> {
+		using _ = await this.lock(srcpath, 'link');
+		await this._fs.link(srcpath, dstpath);
+	}
 
-		public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-			using _ = await this.lock(path);
-			// @ts-expect-error 2513
-			await super.sync(path, data, stats);
-		}
+	public linkSync(srcpath: string, dstpath: string): void {
+		using _ = this.lockSync(srcpath, 'link');
+		return this._fs.linkSync(srcpath, dstpath);
+	}
+
+	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
+		using _ = await this.lock(path, 'sync');
+		await this._fs.sync(path, data, stats);
+	}
+
+	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
+		using _ = this.lockSync(path, 'sync');
+		return this._fs.syncSync(path, data, stats);
+	}
+	/* eslint-enable @typescript-eslint/no-unused-vars */
+}
 
-		public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-			using _ = this.lockSync(path);
-			// @ts-expect-error 2513
-			return super.syncSync(path, data, stats);
+/**
+ * This serializes access to an underlying async filesystem.
+ * For example, on an OverlayFS instance with an async lower
+ * directory operations like rename and rmdir may involve multiple
+ * requests involving both the upper and lower filesystems -- they
+ * are not executed in a single atomic step. OverlayFS uses this
+ * to avoid having to reason about the correctness of
+ * multiple requests interleaving.
+ *
+ * Note:
+ * Instead of extending the passed class, `MutexedFS` stores it internally.
+ * This is to avoid a deadlock caused when a mathod calls another one
+ * The problem is discussed extensivly in [#78](https://github.com/zen-fs/core/issues/78)
+ * Instead of extending `FileSystem`,
+ * `MutexedFS` implements it in order to make sure all of the methods are passed through
+ *
+ * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
+ * @internal
+ */
+export function Mutexed<const T extends Concrete<typeof FileSystem>>(
+	FS: T
+): typeof __MutexedFS<InstanceType<T>> & {
+	new (...args: ConstructorParameters<T>): __MutexedFS<InstanceType<T>>;
+} {
+	class MutexedFS extends __MutexedFS<InstanceType<T>> {
+		public constructor(...args: ConstructorParameters<T>) {
+			super();
+			this._fs = new FS(...args) as InstanceType<T>;
 		}
-		/* eslint-enable @typescript-eslint/no-unused-vars */
 	}
 	return MutexedFS;
 }

package/src/mixins/readonly.ts

@@ -1,4 +1,3 @@
-import type { Cred } from '../cred.js';
 import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
@@ -15,18 +14,18 @@ export function Readonly<T extends typeof FileSystem>(
 	T,
 	{
 		metadata(): FileSystemMetadata;
-		rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-		renameSync(oldPath: string, newPath: string, cred: Cred): void;
-		createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
-		createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
-		unlink(path: string, cred: Cred): Promise<void>;
-		unlinkSync(path: string, cred: Cred): void;
-		rmdir(path: string, cred: Cred): Promise<void>;
-		rmdirSync(path: string, cred: Cred): void;
-		mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-		mkdirSync(path: string, mode: number, cred: Cred): void;
-		link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-		linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+		rename(oldPath: string, newPath: string): Promise<void>;
+		renameSync(oldPath: string, newPath: string): void;
+		createFile(path: string, flag: string, mode: number): Promise<File>;
+		createFileSync(path: string, flag: string, mode: number): File;
+		unlink(path: string): Promise<void>;
+		unlinkSync(path: string): void;
+		rmdir(path: string): Promise<void>;
+		rmdirSync(path: string): void;
+		mkdir(path: string, mode: number): Promise<void>;
+		mkdirSync(path: string, mode: number): void;
+		link(srcpath: string, dstpath: string): Promise<void>;
+		linkSync(srcpath: string, dstpath: string): void;
 		sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
 		syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 	}
@@ -36,51 +35,51 @@ export function Readonly<T extends typeof FileSystem>(
 			return { ...super.metadata(), readonly: true };
 		}
 		/* eslint-disable @typescript-eslint/no-unused-vars */
-		public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
+		public async rename(oldPath: string, newPath: string): Promise<void> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public renameSync(oldPath: string, newPath: string, cred: Cred): void {
+		public renameSync(oldPath: string, newPath: string): void {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File> {
+		public async createFile(path: string, flag: string, mode: number): Promise<File> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public createFileSync(path: string, flag: string, mode: number, cred: Cred): File {
+		public createFileSync(path: string, flag: string, mode: number): File {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public async unlink(path: string, cred: Cred): Promise<void> {
+		public async unlink(path: string): Promise<void> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public unlinkSync(path: string, cred: Cred): void {
+		public unlinkSync(path: string): void {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public async rmdir(path: string, cred: Cred): Promise<void> {
+		public async rmdir(path: string): Promise<void> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public rmdirSync(path: string, cred: Cred): void {
+		public rmdirSync(path: string): void {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
+		public async mkdir(path: string, mode: number): Promise<void> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public mkdirSync(path: string, mode: number, cred: Cred): void {
+		public mkdirSync(path: string, mode: number): void {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public async link(srcpath: string, dstpath: string, cred: Cred): Promise<void> {
+		public async link(srcpath: string, dstpath: string): Promise<void> {
 			throw new ErrnoError(Errno.EROFS);
 		}
 
-		public linkSync(srcpath: string, dstpath: string, cred: Cred): void {
+		public linkSync(srcpath: string, dstpath: string): void {
 			throw new ErrnoError(Errno.EROFS);
 		}
 

package/src/mixins/shared.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /*
 	Code shared by various mixins
 */
@@ -9,12 +10,12 @@ import type { FileSystem } from '../filesystem.js';
  * `TBase` with `TMixin` mixed-in.
  * @internal @experimental
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
 
 /**
  * Asynchronous `FileSystem` methods. This is a convience type.
  * @internal
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type _AsyncFSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>;
+
+export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/src/mixins/sync.ts

@@ -1,7 +1,6 @@
-import type { Cred } from '../cred.js';
 import type { File } from '../file.js';
-import type { Stats } from '../stats.js';
 import type { FileSystem } from '../filesystem.js';
+import type { Stats } from '../stats.js';
 import type { Mixin, _AsyncFSMethods } from './shared.js';
 
 /**
@@ -10,44 +9,44 @@ import type { Mixin, _AsyncFSMethods } from './shared.js';
 /* eslint-disable @typescript-eslint/require-await */
 export function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, _AsyncFSMethods> {
 	abstract class SyncFS extends FS implements _AsyncFSMethods {
-		public async exists(path: string, cred: Cred): Promise<boolean> {
-			return this.existsSync(path, cred);
+		public async exists(path: string): Promise<boolean> {
+			return this.existsSync(path);
 		}
 
-		public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
-			return this.renameSync(oldPath, newPath, cred);
+		public async rename(oldPath: string, newPath: string): Promise<void> {
+			return this.renameSync(oldPath, newPath);
 		}
 
-		public async stat(path: string, cred: Cred): Promise<Stats> {
-			return this.statSync(path, cred);
+		public async stat(path: string): Promise<Stats> {
+			return this.statSync(path);
 		}
 
-		public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File> {
-			return this.createFileSync(path, flag, mode, cred);
+		public async createFile(path: string, flag: string, mode: number): Promise<File> {
+			return this.createFileSync(path, flag, mode);
 		}
 
-		public async openFile(path: string, flag: string, cred: Cred): Promise<File> {
-			return this.openFileSync(path, flag, cred);
+		public async openFile(path: string, flag: string): Promise<File> {
+			return this.openFileSync(path, flag);
 		}
 
-		public async unlink(path: string, cred: Cred): Promise<void> {
-			return this.unlinkSync(path, cred);
+		public async unlink(path: string): Promise<void> {
+			return this.unlinkSync(path);
 		}
 
-		public async rmdir(path: string, cred: Cred): Promise<void> {
-			return this.rmdirSync(path, cred);
+		public async rmdir(path: string): Promise<void> {
+			return this.rmdirSync(path);
 		}
 
-		public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-			return this.mkdirSync(path, mode, cred);
+		public async mkdir(path: string, mode: number): Promise<void> {
+			return this.mkdirSync(path, mode);
 		}
 
-		public async readdir(path: string, cred: Cred): Promise<string[]> {
-			return this.readdirSync(path, cred);
+		public async readdir(path: string): Promise<string[]> {
+			return this.readdirSync(path);
 		}
 
-		public async link(srcpath: string, dstpath: string, cred: Cred): Promise<void> {
-			return this.linkSync(srcpath, dstpath, cred);
+		public async link(srcpath: string, dstpath: string): Promise<void> {
+			return this.linkSync(srcpath, dstpath);
 		}
 
 		public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {