@zenfs/core 0.12.0 → 0.12.2

package/src/emulation/sync.ts

@@ -1,31 +1,14 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 import { ActionType, File, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
-import { FileContents, FileSystem } from '../filesystem.js';
-import { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { FileContents } from '../filesystem.js';
+import { BigIntStats, FileType, type Stats } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
-
-type FileSystemMethod = {
-	[K in keyof FileSystem]: FileSystem[K] extends (...args: any[]) => unknown
-		? (name: K, resolveSymlinks: boolean, ...args: Parameters<FileSystem[K]>) => ReturnType<FileSystem[K]>
-		: never;
-}[keyof FileSystem]; // https://stackoverflow.com/a/76335220/17637456
-
-function wrap<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, resolveSymlinks, path, ...args]: Parameters<M>): RT {
-	path = normalizePath(path!);
-	const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
-	try {
-		// @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-		return fs[name](resolvedPath, ...args) as RT;
-	} catch (e) {
-		throw fixError(e as Error, { [resolvedPath]: path });
-	}
-}
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 
 /**
  * Synchronous rename.
@@ -78,8 +61,14 @@ existsSync satisfies typeof fs.existsSync;
 export function statSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
 export function statSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
 export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
-	const stats: Stats = wrap('statSync', true, path.toString(), cred);
-	return options?.bigint ? new BigIntStats(stats) : stats;
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	try {
+		const stats = fs.statSync(resolved, cred);
+		return options?.bigint ? new BigIntStats(stats) : stats;
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 statSync satisfies typeof fs.statSync;
 
@@ -92,8 +81,14 @@ statSync satisfies typeof fs.statSync;
 export function lstatSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
 export function lstatSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
 export function lstatSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
-	const stats: Stats = wrap('statSync', false, path.toString(), cred);
-	return options?.bigint ? new BigIntStats(stats) : stats;
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(path);
+	try {
+		const stats = fs.statSync(resolved, cred);
+		return options?.bigint ? new BigIntStats(stats) : stats;
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 lstatSync satisfies typeof fs.lstatSync;
 
@@ -117,34 +112,42 @@ truncateSync satisfies typeof fs.truncateSync;
  * @param path
  */
 export function unlinkSync(path: fs.PathLike): void {
-	return wrap('unlinkSync', false, path.toString(), cred);
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(path);
+	try {
+		return fs.unlinkSync(resolved, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 unlinkSync satisfies typeof fs.unlinkSync;
 
-function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null, resolveSymlinks: boolean = true): File {
-	const path = normalizePath(_path),
-		mode = normalizeMode(_mode, 0o644),
+function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null, resolveSymlinks: boolean = true): File {
+	path = normalizePath(path);
+	const mode = normalizeMode(_mode, 0o644),
 		flag = parseFlag(_flag);
-	// Check if the path exists, and is a file.
-	let stats: Stats;
-	try {
-		stats = wrap('statSync', resolveSymlinks, path, cred);
-	} catch (e) {
-		// File does not exist.
+
+	path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+	const { fs, path: resolved } = resolveMount(path);
+
+	if (!fs.existsSync(resolved, cred)) {
 		switch (pathNotExistsAction(flag)) {
 			case ActionType.CREATE:
 				// Ensure parent exists.
-				const parentStats: Stats = wrap('statSync', resolveSymlinks, dirname(path), cred);
+				const parentStats: Stats = fs.statSync(dirname(resolved), cred);
 				if (!parentStats.isDirectory()) {
 					throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
 				}
-				return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
+				return fs.createFileSync(resolved, flag, mode, cred);
 			case ActionType.THROW:
 				throw ErrnoError.With('ENOENT', path, '_open');
 			default:
 				throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
 		}
 	}
+
+	const stats: Stats = fs.statSync(resolved, cred);
+
 	if (!stats.hasAccess(mode, cred)) {
 		throw ErrnoError.With('EACCES', path, '_open');
 	}
@@ -155,16 +158,16 @@ function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | nul
 			throw ErrnoError.With('EEXIST', path, '_open');
 		case ActionType.TRUNCATE:
 			// Delete file.
-			wrap('unlinkSync', resolveSymlinks, path, cred);
+			fs.unlinkSync(resolved, cred);
 			/*
 				Create file. Use the same mode as the old file.
 				Node itself modifies the ctime when this occurs, so this action
 				will preserve that behavior if the underlying file system
 				supports those properties.
 			*/
-			return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+			return fs.createFileSync(resolved, flag, stats.mode, cred);
 		case ActionType.NOP:
-			return wrap('openFileSync', resolveSymlinks, path, flag, cred);
+			return fs.openFileSync(resolved, flag, cred);
 		default:
 			throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
 	}
@@ -372,7 +375,7 @@ export function writeSync(fd: number, data: FileContents, posOrOff?: number | nu
 	if (typeof data === 'string') {
 		// Signature 1: (fd, string, [position?, [encoding?]])
 		position = typeof posOrOff === 'number' ? posOrOff : null;
-		const encoding = <BufferEncoding>(typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
+		const encoding = typeof lenOrEnc === 'string' ? lenOrEnc : ('utf8' as BufferEncoding);
 		offset = 0;
 		buffer = Buffer.from(data, encoding);
 		length = buffer.byteLength;
@@ -380,7 +383,7 @@ export function writeSync(fd: number, data: FileContents, posOrOff?: number | nu
 		// Signature 2: (fd, buffer, offset, length, position?)
 		buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 		offset = posOrOff!;
-		length = <number>lenOrEnc;
+		length = lenOrEnc as number;
 		position = typeof pos === 'number' ? pos : null;
 	}
 
@@ -463,7 +466,13 @@ futimesSync satisfies typeof fs.futimesSync;
  * @param path
  */
 export function rmdirSync(path: fs.PathLike): void {
-	return wrap('rmdirSync', true, path.toString(), cred);
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	try {
+		fs.rmdirSync(resolved, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 rmdirSync satisfies typeof fs.rmdirSync;
 
@@ -477,9 +486,15 @@ export function mkdirSync(path: fs.PathLike, options: fs.MakeDirectoryOptions &
 export function mkdirSync(path: fs.PathLike, options?: fs.Mode | (fs.MakeDirectoryOptions & { recursive?: false }) | null): void;
 export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined;
 export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined | void {
-	const mode: fs.Mode | undefined = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+	const mode: fs.Mode = normalizeMode(typeof options == 'number' || typeof options == 'string' ? options : options?.mode, 0o777);
 	const recursive = typeof options == 'object' && options?.recursive;
-	wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+	path = normalizePath(path);
+	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	try {
+		return fs.mkdirSync(resolved, mode, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 }
 mkdirSync satisfies typeof fs.mkdirSync;
 
@@ -496,7 +511,13 @@ export function readdirSync(
 	options?: { recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null; withFileTypes?: boolean } | BufferEncoding | 'buffer' | null
 ): string[] | Dirent[] | Buffer[] {
 	path = normalizePath(path);
-	const entries: string[] = wrap('readdirSync', true, path, cred);
+	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(resolved, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: path });
+	}
 	for (const mount of mounts.keys()) {
 		if (!mount.startsWith(path)) {
 			continue;
@@ -508,7 +529,7 @@ export function readdirSync(
 		}
 		entries.push(entry);
 	}
-	return <string[] | Dirent[] | Buffer[]>entries.map((entry: string) => {
+	return entries.map((entry: string) => {
 		if (typeof options == 'object' && options?.withFileTypes) {
 			return new Dirent(entry, statSync(join(path.toString(), entry)));
 		}
@@ -518,7 +539,7 @@ export function readdirSync(
 		}
 
 		return entry;
-	});
+	}) as string[] | Dirent[] | Buffer[];
 }
 readdirSync satisfies typeof fs.readdirSync;
 
@@ -530,8 +551,14 @@ readdirSync satisfies typeof fs.readdirSync;
  * @param newpath
  */
 export function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void {
+	existing = normalizePath(existing);
 	newpath = normalizePath(newpath);
-	return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
+	const { fs, path: resolved } = resolveMount(existing);
+	try {
+		return fs.linkSync(resolved, newpath, cred);
+	} catch (e) {
+		throw fixError(e as Error, { [resolved]: existing });
+	}
 }
 linkSync satisfies typeof fs.linkSync;
 
@@ -872,9 +899,11 @@ cpSync satisfies typeof fs.cpSync;
  * @param path A path to an existing file or directory on the file system to be queried.
  * @param callback
  */
-export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & { bigint?: false }): StatsFs;
-export function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }): BigIntStatsFs;
-export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
-export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & { bigint?: false }): fs.StatsFs;
+export function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }): fs.BigIntStatsFs;
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): fs.StatsFs | fs.BigIntStatsFs;
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): fs.StatsFs | fs.BigIntStatsFs {
+	path = normalizePath(path);
+	const { fs } = resolveMount(path);
+	return _statfs(fs, options?.bigint);
 }

package/src/error.ts

@@ -279,7 +279,7 @@ export class ErrnoError extends Error implements NodeJS.ErrnoException {
 		public syscall: string = ''
 	) {
 		super(message);
-		this.code = <keyof typeof Errno>Errno[errno];
+		this.code = Errno[errno] as keyof typeof Errno;
 		this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
 	}
 

package/src/file.ts

@@ -359,7 +359,7 @@ export abstract class File {
  */
 export class PreloadFile<FS extends FileSystem> extends File {
 	protected _position: number = 0;
-	protected _dirty: boolean = false;
+	protected dirty: boolean = false;
 	/**
 	 * Creates a file with the given path and, optionally, the given contents. Note
 	 * that, if contents is specified, it will be mutated by the file!
@@ -383,7 +383,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		public readonly path: string,
 		public readonly flag: string,
 		public readonly stats: Stats,
-		protected _buffer: Uint8Array = new Uint8Array(new ArrayBuffer(0, { maxByteLength: size_max }))
+		protected _buffer: Uint8Array = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))
 	) {
 		super();
 
@@ -400,7 +400,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 			throw new Error(`Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`);
 		}
 
-		this._dirty = true;
+		this.dirty = true;
 	}
 
 	/**
@@ -435,19 +435,19 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public async sync(): Promise<void> {
-		if (!this.isDirty()) {
+		if (!this.dirty) {
 			return;
 		}
 		await this.fs.sync(this.path, this._buffer, this.stats);
-		this._dirty = false;
+		this.dirty = false;
 	}
 
 	public syncSync(): void {
-		if (!this.isDirty()) {
+		if (!this.dirty) {
 			return;
 		}
 		this.fs.syncSync(this.path, this._buffer, this.stats);
-		this._dirty = false;
+		this.dirty = false;
 	}
 
 	public async close(): Promise<void> {
@@ -474,40 +474,33 @@ export class PreloadFile<FS extends FileSystem> extends File {
 
 	/**
 	 * Asynchronous truncate.
-	 * @param len
+	 * @param length
 	 */
-	public async truncate(len: number): Promise<void> {
-		this.truncateSync(len);
-		if (isSynchronous(this.flag)) {
-			return this.sync();
-		}
+	public async truncate(length: number): Promise<void> {
+		this.truncateSync(length);
+		return this.sync();
 	}
 
 	/**
 	 * Synchronous truncate.
-	 * @param len
+	 * @param length
 	 */
-	public truncateSync(len: number): void {
-		this._dirty = true;
+	public truncateSync(length: number): void {
+		this.dirty = true;
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
 		this.stats.mtimeMs = Date.now();
-		if (len > this._buffer.length) {
-			const buf = new Uint8Array(len - this._buffer.length);
-			// Write will set stats.size for us.
-			this.writeSync(buf, 0, buf.length, this._buffer.length);
-			if (isSynchronous(this.flag)) {
-				this.syncSync();
-			}
+		if (length > this._buffer.length) {
+			const data = new Uint8Array(length - this._buffer.length);
+			// Write will set stats.size and handle syncing.
+			this.writeSync(data, 0, data.length, this._buffer.length);
 			return;
 		}
-		this.stats.size = len;
-		// Truncate buffer to 'len'.
-		this._buffer = this._buffer.subarray(0, len);
-		if (isSynchronous(this.flag)) {
-			this.syncSync();
-		}
+		this.stats.size = length;
+		// Truncate.
+		this._buffer = this._buffer.slice(0, length);
+		this.syncSync();
 	}
 
 	/**
@@ -542,20 +535,21 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @returns bytes written
 	 */
 	public writeSync(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = 0): number {
-		this._dirty = true;
+		this.dirty = true;
 		position ??= this.position;
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
-		const endFp = position + length;
-		if (endFp > this.stats.size) {
-			this.stats.size = endFp;
-			if (endFp > this._buffer.byteLength) {
-				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= endFp) {
-					this._buffer.buffer.resize(endFp);
+		const end = position + length;
+
+		if (end > this.stats.size) {
+			this.stats.size = end;
+			if (end > this._buffer.byteLength) {
+				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= end) {
+					this._buffer.buffer.resize(end);
 				} else {
 					// Extend the buffer!
-					const newBuffer = new Uint8Array(new ArrayBuffer(endFp, { maxByteLength: size_max }));
+					const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
 					newBuffer.set(this._buffer);
 					this._buffer = newBuffer;
 				}
@@ -565,11 +559,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this._buffer.set(slice, position);
 		const bytesWritten = slice.byteLength;
 		this.stats.mtimeMs = Date.now();
-		if (isSynchronous(this.flag)) {
-			this.syncSync();
-			return bytesWritten;
-		}
 		this.position = position + bytesWritten;
+		this.syncSync();
 		return bytesWritten;
 	}
 
@@ -608,6 +599,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		if (!isReadable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
 		}
+		this.dirty = true;
 		position ??= this.position;
 		let end = position + length;
 		if (end > this.stats.size) {
@@ -616,6 +608,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this.stats.atimeMs = Date.now();
 		this._position = end;
 		const bytesRead = end - position;
+		this.syncSync();
 		if (bytesRead == 0) {
 			// No copy/read. Return immediatly for better performance
 			return bytesRead;
@@ -637,7 +630,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param mode
 	 */
 	public chmodSync(mode: number): void {
-		this._dirty = true;
+		this.dirty = true;
 		this.stats.chmod(mode);
 		this.syncSync();
 	}
@@ -657,7 +650,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * @param gid
 	 */
 	public chownSync(uid: number, gid: number): void {
-		this._dirty = true;
+		this.dirty = true;
 		this.stats.chown(uid, gid);
 		this.syncSync();
 	}
@@ -667,31 +660,20 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	}
 
 	public utimesSync(atime: Date, mtime: Date): void {
-		this._dirty = true;
+		this.dirty = true;
 		this.stats.atime = atime;
 		this.stats.mtime = mtime;
 		this.syncSync();
 	}
 
-	protected isDirty(): boolean {
-		return this._dirty;
-	}
-
-	/**
-	 * Resets the dirty bit. Should only be called after a sync has completed successfully.
-	 */
-	protected resetDirty() {
-		this._dirty = false;
-	}
-
 	public _setType(type: FileType): Promise<void> {
-		this._dirty = true;
+		this.dirty = true;
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
 		return this.sync();
 	}
 
 	public _setTypeSync(type: FileType): void {
-		this._dirty = true;
+		this.dirty = true;
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
 		this.syncSync();
 	}