@zenfs/core 1.3.3 → 1.3.5

package/src/emulation/sync.ts

@@ -10,7 +10,7 @@ import * as cache from './cache.js';
 import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse } from './path.js';
+import { dirname, join, parse, resolve } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
 import { emitChange } from './watchers.js';
 
@@ -26,6 +26,7 @@ export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 		if (oldMount === newMount) {
 			oldMount.fs.renameSync(oldMount.path, newMount.path);
 			emitChange('rename', oldPath.toString());
+			emitChange('change', newPath.toString());
 			return;
 		}
 
@@ -106,7 +107,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.stats.get(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -386,7 +387,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+		const stats = cache.stats.get(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -459,8 +460,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
-		cache.stats.setSync(path, stats);
+		const stats = cache.stats.get(path) || fs.statSync(resolved);
+		cache.stats.set(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -475,8 +476,8 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.stats.setSync(join(path, entry), entryStat);
+		const entryStat = cache.stats.get(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.stats.set(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -500,7 +501,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.stats.clearSync();
+		cache.stats.clear();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -550,7 +551,7 @@ export function symlinkSync(target: fs.PathLike, path: fs.PathLike, type: fs.sym
 
 	writeFileSync(path, target.toString());
 	const file = _openSync(path, 'r+', 0o644, false);
-	file._setTypeSync(constants.S_IFLNK);
+	file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync satisfies typeof fs.symlinkSync;
 
@@ -621,18 +622,24 @@ export function realpathSync(path: fs.PathLike, options: fs.BufferEncodingOption
 export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption): string;
 export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): string | Buffer {
 	path = normalizePath(path);
+	if (cache.paths.has(path)) return cache.paths.get(path)!;
 	const { base, dir } = parse(path);
-	const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
-	const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
+	const realDir = dir == '/' ? '/' : cache.paths.get(dir) || realpathSync(dir);
+	const lpath = join(realDir, base);
+	const { fs, path: resolvedPath } = resolveMount(lpath);
 
 	try {
-		const stats = fs.statSync(resolvedPath);
+		const stats = cache.stats.get(lpath) || fs.statSync(resolvedPath);
+		cache.stats.set(lpath, stats);
 		if (!stats.isSymbolicLink()) {
+			cache.paths.set(path, lpath);
 			return lpath;
 		}
 
-		const target = mountPoint + readlinkSync(lpath, options).toString();
-		return cache.paths.getSync(target) || realpathSync(target);
+		const target = resolve(realDir, readlinkSync(lpath, options).toString());
+		const real = cache.paths.get(target) || realpathSync(target);
+		cache.paths.set(path, real);
+		return real;
 	} catch (e) {
 		if ((e as ErrnoError).code == 'ENOENT') {
 			return path;
@@ -659,7 +666,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.stats.getSync(path) || statSync(path);
+		stats = cache.stats.get(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -668,7 +675,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.stats.setSync(path, stats);
+	cache.stats.set(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -682,19 +689,19 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 			break;
 		case constants.S_IFREG:
 		case constants.S_IFLNK:
-			unlinkSync(path);
-			break;
 		case constants.S_IFBLK:
 		case constants.S_IFCHR:
+			unlinkSync(path);
+			break;
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.stats.clearSync();
+			cache.stats.clear();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.stats.clearSync();
+		cache.stats.clear();
 	}
 }
 rmSync satisfies typeof fs.rmSync;

package/src/emulation/watchers.ts

@@ -4,7 +4,7 @@ import type * as fs from 'node:fs';
 import { ErrnoError } from '../error.js';
 import { isStatsEqual, type Stats } from '../stats.js';
 import { normalizePath } from '../utils.js';
-import { dirname, basename } from './path.js';
+import { basename, dirname } from './path.js';
 import { statSync } from './sync.js';
 
 /**
@@ -171,23 +171,24 @@ export function removeWatcher(path: string, watcher: FSWatcher) {
 }
 
 export function emitChange(eventType: fs.WatchEventType, filename: string) {
-	let normalizedFilename: string = normalizePath(filename);
+	filename = normalizePath(filename);
 	// Notify watchers on the specific file
-	if (watchers.has(normalizedFilename)) {
-		for (const watcher of watchers.get(normalizedFilename)!) {
+	if (watchers.has(filename)) {
+		for (const watcher of watchers.get(filename)!) {
 			watcher.emit('change', eventType, basename(filename));
 		}
 	}
 
 	// Notify watchers on parent directories if they are watching recursively
-	let parent = dirname(normalizedFilename);
-	while (parent !== normalizedFilename && parent !== '/') {
+	let parent = filename,
+		normalizedFilename;
+	while (parent !== normalizedFilename) {
+		normalizedFilename = parent;
+		parent = dirname(parent);
 		if (watchers.has(parent)) {
 			for (const watcher of watchers.get(parent)!) {
-				watcher.emit('change', eventType, basename(filename));
+				watcher.emit('change', eventType, filename.slice(parent.length + (parent == '/' ? 0 : 1)));
 			}
 		}
-		normalizedFilename = parent;
-		parent = dirname(parent);
 	}
 }

package/src/file.ts

@@ -4,7 +4,7 @@ import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY,
 import { Errno, ErrnoError } from './error.js';
 import type { FileSystem } from './filesystem.js';
 import './polyfills.js';
-import { Stats, type FileType } from './stats.js';
+import { _chown, Stats } from './stats.js';
 
 /**
 	Typescript does not include a type declaration for resizable array buffers. 
@@ -251,18 +251,6 @@ export abstract class File<FS extends FileSystem = FileSystem> {
 	 * Change the file timestamps of the file.
 	 */
 	public abstract utimesSync(atime: Date, mtime: Date): void;
-
-	/**
-	 * Set the file type
-	 * @internal
-	 */
-	public abstract _setType(type: FileType): Promise<void>;
-
-	/**
-	 * Set the file type
-	 * @internal
-	 */
-	public abstract _setTypeSync(type: FileType): void;
 }
 
 /**
@@ -573,8 +561,8 @@ export class PreloadFile<FS extends FileSystem> extends File<FS> {
 			throw ErrnoError.With('EBADF', this.path, 'File.chmod');
 		}
 		this.dirty = true;
-		this.stats.chmod(mode);
-		if (config.syncImmediately) await this.sync();
+		this.stats.mode = (this.stats.mode & (mode > S_IFMT ? ~S_IFMT : S_IFMT)) | mode;
+		if (config.syncImmediately || mode > S_IFMT) await this.sync();
 	}
 
 	public chmodSync(mode: number): void {
@@ -582,8 +570,8 @@ export class PreloadFile<FS extends FileSystem> extends File<FS> {
 			throw ErrnoError.With('EBADF', this.path, 'File.chmod');
 		}
 		this.dirty = true;
-		this.stats.chmod(mode);
-		if (config.syncImmediately) this.syncSync();
+		this.stats.mode = (this.stats.mode & (mode > S_IFMT ? ~S_IFMT : S_IFMT)) | mode;
+		if (config.syncImmediately || mode > S_IFMT) this.syncSync();
 	}
 
 	public async chown(uid: number, gid: number): Promise<void> {
@@ -591,7 +579,7 @@ export class PreloadFile<FS extends FileSystem> extends File<FS> {
 			throw ErrnoError.With('EBADF', this.path, 'File.chown');
 		}
 		this.dirty = true;
-		this.stats.chown(uid, gid);
+		_chown(this.stats, uid, gid);
 		if (config.syncImmediately) await this.sync();
 	}
 
@@ -600,7 +588,7 @@ export class PreloadFile<FS extends FileSystem> extends File<FS> {
 			throw ErrnoError.With('EBADF', this.path, 'File.chown');
 		}
 		this.dirty = true;
-		this.stats.chown(uid, gid);
+		_chown(this.stats, uid, gid);
 		if (config.syncImmediately) this.syncSync();
 	}
 
@@ -623,24 +611,6 @@ export class PreloadFile<FS extends FileSystem> extends File<FS> {
 		this.stats.mtime = mtime;
 		if (config.syncImmediately) this.syncSync();
 	}
-
-	public async _setType(type: FileType): Promise<void> {
-		if (this.closed) {
-			throw ErrnoError.With('EBADF', this.path, 'File._setType');
-		}
-		this.dirty = true;
-		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-		await this.sync();
-	}
-
-	public _setTypeSync(type: FileType): void {
-		if (this.closed) {
-			throw ErrnoError.With('EBADF', this.path, 'File._setType');
-		}
-		this.dirty = true;
-		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
-		this.syncSync();
-	}
 }
 
 /**

package/src/stats.ts

@@ -1,5 +1,5 @@
 import type * as Node from 'node:fs';
-import { credentials, type Credentials } from './credentials.js';
+import { credentials } from './credentials.js';
 import {
 	R_OK,
 	S_IFBLK,
@@ -67,6 +67,10 @@ export interface StatsLike<T extends number | bigint = number | bigint> {
 	 * Inode number
 	 */
 	ino: T;
+	/**
+	 * Number of hard links
+	 */
+	nlink: T;
 }
 
 /**
@@ -258,7 +262,7 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 		}
 
 		// Group permissions
-		if (credentials.gid === this.gid) {
+		if (credentials.gid === this.gid || credentials.groups.includes(Number(this.gid))) {
 			if (this.mode & S_IRGRP) perm |= R_OK;
 			if (this.mode & S_IWGRP) perm |= W_OK;
 			if (this.mode & S_IXGRP) perm |= X_OK;
@@ -273,25 +277,11 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 		return (perm & mode) === mode;
 	}
 
-	/**
-	 * Convert the current stats object into a credentials object
-	 * @internal
-	 */
-	public cred(uid: number = Number(this.uid), gid: number = Number(this.gid)): Credentials {
-		return {
-			uid,
-			gid,
-			suid: Number(this.uid),
-			sgid: Number(this.gid),
-			euid: uid,
-			egid: gid,
-		};
-	}
-
 	/**
 	 * Change the mode of the file.
 	 * We use this helper function to prevent messing up the type of the file.
 	 * @internal
+	 * @deprecated This will be removed in the next minor release since it is internal
 	 */
 	public chmod(mode: number): void {
 		this.mode = this._convert((this.mode & S_IFMT) | mode);
@@ -301,8 +291,9 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 	 * Change the owner user/group of the file.
 	 * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
 	 * @internal
+	 * @deprecated This will be removed in the next minor release since it is internal
 	 */
-	public chown(uid: number | bigint, gid: number | bigint): void {
+	public chown(uid: number, gid: number): void {
 		uid = Number(uid);
 		gid = Number(gid);
 		if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {
@@ -330,6 +321,18 @@ export abstract class StatsCommon<T extends number | bigint> implements Node.Sta
 	}
 }
 
+/**
+ * @hidden @internal
+ */
+export function _chown(stats: Partial<StatsLike<number>>, uid: number, gid: number) {
+	if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {
+		stats.uid = uid;
+	}
+	if (!isNaN(gid) && 0 <= gid && gid < 2 ** 32) {
+		stats.gid = gid;
+	}
+}
+
 /**
  * Implementation of Node's `Stats`.
  *

package/tests/fs/links.test.ts

@@ -23,6 +23,10 @@ suite('Links', () => {
 		assert.strictEqual(destination, target);
 	});
 
+	test('read target contents', async () => {
+		assert.equal(await fs.promises.readFile(target, 'utf-8'), await fs.promises.readFile(symlink, 'utf-8'));
+	});
+
 	test('unlink', async () => {
 		await fs.promises.unlink(symlink);
 		assert(!(await fs.promises.exists(symlink)));

package/tests/fs/watch.test.ts

@@ -71,18 +71,29 @@ suite('Watch Features', () => {
 	});
 
 	test('fs.watch should detect file renames', async () => {
-		const oldFile = `${testDir}/oldFile.txt`;
-		const newFile = `${testDir}/newFile.txt`;
+		const oldFileName = `oldFile.txt`;
+		const newFileName = `newFile.txt`;
+		const oldFile = `${testDir}/${oldFileName}`;
+		const newFile = `${testDir}/${newFileName}`;
 
 		await fs.promises.writeFile(oldFile, 'Some content');
+		const oldFileResolver = Promise.withResolvers<void>();
+		const newFileResolver = Promise.withResolvers<void>();
 
+		const fileResolvers: Record<string, { resolver: PromiseWithResolvers<void>; eventType: string }> = {
+			[oldFileName]: { resolver: oldFileResolver, eventType: 'rename' },
+			[newFileName]: { resolver: newFileResolver, eventType: 'change' },
+		};
 		using watcher = fs.watch(testDir, (eventType, filename) => {
-			assert.strictEqual(eventType, 'rename');
-			assert.strictEqual(filename, 'oldFile.txt');
+			const resolver = fileResolvers[filename];
+			assert.notEqual(resolver, undefined); // should have a resolver so file is expected
+			assert.strictEqual(eventType, resolver.eventType);
+			resolver.resolver.resolve();
 		});
 
 		// Rename the file to trigger the event
 		await fs.promises.rename(oldFile, newFile);
+		await Promise.all([newFileResolver.promise, oldFileResolver.promise]);
 	});
 
 	test('fs.watch should detect file deletions', async () => {
@@ -115,6 +126,27 @@ suite('Watch Features', () => {
 			resolve();
 		})();
 
+		await fs.promises.unlink(tempFile);
+		await promise;
+	});
+	test('fs.promises.watch should detect file creations recursively', async () => {
+		const rootDir = '/';
+		const subDir = `${testDir}sub-dir`;
+		const tempFile = `${subDir}/tempFile.txt`;
+		await fs.promises.mkdir(subDir);
+		const watcher = fs.promises.watch(rootDir);
+
+		await fs.promises.writeFile(tempFile, 'Temporary content');
+		const { promise, resolve } = Promise.withResolvers<void>();
+		(async () => {
+			for await (const event of watcher) {
+				assert.equal(event.eventType, 'rename');
+				assert.equal(event.filename, tempFile.substring(rootDir.length));
+				break;
+			}
+			resolve();
+		})();
+
 		await fs.promises.unlink(tempFile);
 		await promise;
 	});