@zenfs/core 0.12.1 → 0.12.2

package/src/emulation/shared.ts

@@ -1,10 +1,13 @@
 // Utilities and shared data
 
-import { ErrnoError, Errno } from '../error.js';
+import type { BigIntStatsFs, StatsFs } from 'node:fs';
 import { InMemory } from '../backends/memory.js';
 import { Cred, rootCred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
+import { size_max } from '../inode.js';
+import { ZenFsType } from '../stats.js';
 import { normalizePath } from '../utils.js';
 import { resolve, type AbsolutePath } from './path.js';
 
@@ -117,3 +120,21 @@ export function mountObject(mounts: MountObject): void {
 		mount(point, fs);
 	}
 }
+
+/**
+ * @hidden
+ */
+export function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs {
+	const md = fs.metadata();
+	const bs = md.blockSize || 4096;
+
+	return {
+		type: (bigint ? BigInt : Number)(md.type || ZenFsType),
+		bsize: (bigint ? BigInt : Number)(bs),
+		ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
+		files: (bigint ? BigInt : Number)(md.totalNodes || size_max),
+		bavail: (bigint ? BigInt : Number)(md.freeSpace / bs),
+		bfree: (bigint ? BigInt : Number)(md.freeSpace / bs),
+		blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
+	} as T extends true ? BigIntStatsFs : StatsFs;
+}

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,45 +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 (_) {
-		const original = _ as ErrnoError;
-		if (original.code != 'ENOENT') {
-			throw original;
-		}
-		try {
-			// File does not exist.
-			switch (pathNotExistsAction(flag)) {
-				case ActionType.CREATE:
-					// Ensure parent exists.
-					const parentStats: Stats = wrap('statSync', resolveSymlinks, dirname(path), cred);
-					if (!parentStats.isDirectory()) {
-						throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-					}
-					return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
-				case ActionType.THROW:
-					throw ErrnoError.With('ENOENT', path, '_open');
-				default:
-					throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
-			}
-		} catch (_) {
-			const ex = _ as ErrnoError;
-			ex.stack += '\n<original>\n';
-			ex.stack += (original as Error).stack;
-			throw ex;
+
+	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 = fs.statSync(dirname(resolved), cred);
+				if (!parentStats.isDirectory()) {
+					throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+				}
+				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');
 	}
@@ -166,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.');
 	}
@@ -474,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;
 
@@ -488,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;
 
@@ -507,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;
@@ -541,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;
 
@@ -883,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/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!
@@ -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,7 +535,7 @@ 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.');
@@ -566,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;
 	}
 
@@ -609,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) {
@@ -617,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;
@@ -638,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();
 	}
@@ -658,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();
 	}
@@ -668,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();
 	}

package/src/filesystem.ts

@@ -44,6 +44,27 @@ export interface FileSystemMetadata {
 	 * @default false
 	 */
 	noAsyncCache: boolean;
+
+	/**
+	 * The optimal block size to use with the file system
+	 * @default 4096
+	 */
+	blockSize?: number;
+
+	/**
+	 * Total number of (file) nodes available
+	 */
+	totalNodes?: number;
+
+	/**
+	 * Number of free (file) nodes available
+	 */
+	freeNodes?: number;
+
+	/**
+	 * The type of the FS
+	 */
+	type?: number;
 }
 
 /**
@@ -57,6 +78,12 @@ export interface FileSystemMetadata {
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export abstract class FileSystem {
+	/**
+	 * Numeric type, used for statfs
+	 * @internal @protected
+	 */
+	_type?: number;
+
 	/**
 	 * Get metadata about the current file system
 	 */
@@ -68,11 +95,11 @@ export abstract class FileSystem {
 			freeSpace: 0,
 			noResizableBuffers: false,
 			noAsyncCache: false,
+			type: this._type,
 		};
 	}
 
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	public constructor(options?: object) {}
+	public constructor() {}
 
 	public async ready(): Promise<void> {}