@zenfs/core 2.5.7 → 2.6.0

package/dist/node/sync.js

@@ -56,13 +56,14 @@ import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory } from '../internal/inode.js';
-import { join, matchesGlob } from '../path.js';
+import { dirname, join, matchesGlob } from '../path.js';
 import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
 import { _statfs, resolveMount } from '../vfs/shared.js';
 import * as _sync from '../vfs/sync.js';
+import { cacheOf, lockPathSync } from '../vfs/vcache.js';
 import { emitChange } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { BigIntStats, Stats } from './stats.js';
@@ -118,13 +119,25 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
-            throw UV('EACCES', 'unlink');
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
+                throw UV('EACCES', 'unlink');
+            }
+            const _ = __addDisposableResource(env_2, lockPathSync(fs, dirname(resolved), 'rw'), false);
+            fs.unlinkSync(resolved);
+            cacheOf(fs).remove(resolved);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
         }
-        fs.unlinkSync(resolved);
     }
     catch (e) {
-        throw setUVMessage(Object.assign(e, { path }));
+        throw setUVMessage(Object.assign(e, { syscall: 'unlink', path }));
     }
     emitChange(this, 'rename', path.toString());
 }
@@ -146,13 +159,13 @@ export function lopenSync(path, flag, mode) {
     return toFD(_sync.open.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
 export function readFileSync(path, _options = {}) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, null, 'r', 0o644);
         const flag = flags.parse(options.flag);
         if (flag & constants.O_WRONLY)
             throw UV('EBADF', 'read', path.toString());
-        const file = __addDisposableResource(env_2, typeof path == 'number'
+        const file = __addDisposableResource(env_3, typeof path == 'number'
             ? fromFD(this, path)
             : _sync.open.call(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
         const { size } = file.stat();
@@ -160,17 +173,17 @@ export function readFileSync(path, _options = {}) {
         file.readSync(data, 0, size, 0);
         return options.encoding ? data.toString(options.encoding) : data;
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
     }
     finally {
-        __disposeResources(env_2);
+        __disposeResources(env_3);
     }
 }
 readFileSync;
 export function writeFileSync(path, data, _options = {}) {
-    const env_3 = { stack: [], error: void 0, hasError: false };
+    const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
         const flag = flags.parse(options.flag);
@@ -184,7 +197,7 @@ export function writeFileSync(path, data, _options = {}) {
         if (!encodedData) {
             throw new Exception(Errno.EINVAL, 'Data not specified');
         }
-        const file = __addDisposableResource(env_3, typeof path == 'number'
+        const file = __addDisposableResource(env_4, typeof path == 'number'
             ? fromFD(this, path)
             : _sync.open.call(this, path.toString(), {
                 flag,
@@ -194,12 +207,12 @@ export function writeFileSync(path, data, _options = {}) {
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
         emitChange(this, 'change', path.toString());
     }
-    catch (e_3) {
-        env_3.error = e_3;
-        env_3.hasError = true;
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
     }
     finally {
-        __disposeResources(env_3);
+        __disposeResources(env_4);
     }
 }
 writeFileSync;
@@ -324,15 +337,27 @@ export function futimesSync(fd, atime, mtime) {
 }
 futimesSync;
 export function rmdirSync(path) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = _sync.resolve(this, path);
-    const stats = wrap(fs, 'statSync', path)(resolved);
-    if (!isDirectory(stats))
-        throw UV('ENOTDIR', 'rmdir', path);
-    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-        throw UV('EACCES', 'rmdir', path);
-    wrap(fs, 'rmdirSync', path)(resolved);
-    emitChange(this, 'rename', path.toString());
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath(path);
+        const { fs, path: resolved } = _sync.resolve(this, path);
+        const stats = wrap(fs, 'statSync', { path, syscall: 'rmdir' })(resolved);
+        if (!isDirectory(stats))
+            throw UV('ENOTDIR', 'rmdir', path);
+        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+            throw UV('EACCES', 'rmdir', path);
+        const _ = __addDisposableResource(env_5, lockPathSync(fs, dirname(resolved), 'rw'), false);
+        wrap(fs, 'rmdirSync', path)(resolved);
+        cacheOf(fs).remove(resolved);
+        emitChange(this, 'rename', path.toString());
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
+    }
 }
 rmdirSync;
 export function mkdirSync(path, options) {
@@ -348,7 +373,7 @@ export function readdirSync(path, options) {
     const rawEntries = _sync.readdir.call(this, path, options ?? undefined);
     for (const raw of rawEntries) {
         if (options?.withFileTypes) {
-            entries.push(Dirent.from(raw, options.encoding));
+            entries.push(Dirent.from(raw, options.encoding, path));
         }
         else if (options?.encoding == 'buffer') {
             entries.push(Buffer.from(raw.path));
@@ -371,21 +396,21 @@ linkSync;
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export function symlinkSync(target, path, type = 'file') {
-    const env_4 = { stack: [], error: void 0, hasError: false };
+    const env_6 = { stack: [], error: void 0, hasError: false };
     try {
         if (!['file', 'dir', 'junction'].includes(type))
             throw new TypeError('Invalid symlink type: ' + type);
         path = normalizePath(path);
-        const file = __addDisposableResource(env_4, _sync.open.call(this, path, { flag: 'wx', mode: 0o644 }), false);
+        const file = __addDisposableResource(env_6, _sync.open.call(this, path, { flag: 'wx', mode: 0o644 }), false);
         file.writeSync(encodeUTF8(normalizePath(target, true)));
         file.chmodSync(constants.S_IFLNK);
     }
-    catch (e_4) {
-        env_4.error = e_4;
-        env_4.hasError = true;
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
     }
     finally {
-        __disposeResources(env_4);
+        __disposeResources(env_6);
     }
 }
 symlinkSync;
@@ -400,17 +425,17 @@ export function readlinkSync(path, options) {
 }
 readlinkSync;
 export function chownSync(path, uid, gid) {
-    const env_5 = { stack: [], error: void 0, hasError: false };
+    const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_5, _sync.open.call(this, path, { flag: 'r+', mode: constants.F_OK }), false);
+        const handle = __addDisposableResource(env_7, _sync.open.call(this, path, { flag: 'r+', mode: constants.F_OK }), false);
         handle.chownSync(uid, gid);
     }
-    catch (e_5) {
-        env_5.error = e_5;
-        env_5.hasError = true;
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
     }
     finally {
-        __disposeResources(env_5);
+        __disposeResources(env_7);
     }
 }
 chownSync;
@@ -421,7 +446,13 @@ export function lchownSync(path, uid, gid) {
 }
 lchownSync;
 export function chmodSync(path, mode) {
-    const fd = openSync.call(this, path, 'r+');
+    let fd;
+    try {
+        fd = openSync.call(this, path, 'r+');
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { syscall: 'chmod', path: normalizePath(path) }));
+    }
     fchmodSync.call(this, fd, mode);
     closeSync.call(this, fd);
 }

package/dist/utils.d.ts

@@ -25,7 +25,14 @@ export type Callback<Args extends unknown[] = [], NoError = null> = (e: Exceptio
  */
 export declare function normalizeMode(mode: unknown, def?: number): number;
 /**
- * Normalizes a time
+ * Checks that `fd` is in the range Node accepts for a file descriptor.
+ * Note this throws a `RangeError` rather than an `Exception`, since that is what Node does.
+ * @internal
+ */
+export declare function validateFD(fd: number): void;
+/**
+ * Normalizes a time to milliseconds since the epoch.
+ * Note numbers and numeric strings are seconds, like Node's `toUnixTimestamp`.
  * @internal
  */
 export declare function normalizeTime(time: fs.TimeLike): number;

package/dist/utils.js

@@ -35,18 +35,36 @@ export function normalizeMode(mode, def) {
     throw withErrno('EINVAL', 'Invalid mode: ' + mode?.toString());
 }
 /**
- * Normalizes a time
+ * The largest valid file descriptor, since Node validates them as 32-bit signed integers
+ * @internal @hidden
+ */
+const fd_max = 0x7fffffff;
+/**
+ * Checks that `fd` is in the range Node accepts for a file descriptor.
+ * Note this throws a `RangeError` rather than an `Exception`, since that is what Node does.
+ * @internal
+ */
+export function validateFD(fd) {
+    if (Number.isInteger(fd) && fd >= 0 && fd <= fd_max)
+        return;
+    throw Object.assign(new RangeError(`The value of "fd" is out of range. It must be >= 0 && <= ${fd_max}. Received ${fd}`), {
+        code: 'ERR_OUT_OF_RANGE',
+    });
+}
+/**
+ * Normalizes a time to milliseconds since the epoch.
+ * Note numbers and numeric strings are seconds, like Node's `toUnixTimestamp`.
  * @internal
  */
 export function normalizeTime(time) {
+    // Dates are already in milliseconds
     if (time instanceof Date)
         return time.getTime();
-    try {
-        return Number(time);
-    }
-    catch {
+    const seconds = Number(time);
+    if (!Number.isFinite(seconds))
         throw withErrno('EINVAL', 'Invalid time.');
-    }
+    // Negative times mean "now"
+    return seconds < 0 ? Date.now() : seconds * 1000;
 }
 /**
  * Normalizes a path
@@ -119,5 +137,6 @@ export async function waitOnline(worker) {
  * @internal @hidden
  */
 export function _tempDirName(prefix) {
-    return `/tmp/${normalizePath(prefix, true)}${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    // Like Node, the prefix is a path. A relative one is resolved against the working directory, not `/tmp`.
+    return `${normalizePath(prefix, true)}${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }