@zenfs/core 0.18.0 → 1.0.0-rc.0

package/dist/emulation/promises.js

@@ -54,7 +54,6 @@ import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { credentials } from '../credentials.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -213,7 +212,7 @@ export class FileHandle {
     }
     async stat(opts) {
         const stats = await this.file.stat();
-        if (!stats.hasAccess(constants.R_OK, credentials)) {
+        if (!stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', this.file.path, 'stat');
         }
         return opts?.bigint ? new BigIntStats(stats) : stats;
@@ -357,7 +356,7 @@ export async function rename(oldPath, newPath) {
     newPath = normalizePath(newPath);
     const src = resolveMount(oldPath);
     const dst = resolveMount(newPath);
-    if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK, credentials)) {
+    if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -396,7 +395,7 @@ export async function stat(path, options) {
     const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
     try {
         const stats = await fs.stat(resolved);
-        if (!stats.hasAccess(constants.R_OK, credentials)) {
+        if (!stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', path, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -449,7 +448,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -476,7 +475,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+        if (!parentStats.hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', dirname(path), '_open');
         }
         if (!parentStats.isDirectory()) {
@@ -484,7 +483,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
         }
         return new FileHandle(await fs.createFile(resolved, flag, mode));
     }
-    if (!stats.hasAccess(flagToMode(flag), credentials)) {
+    if (!stats.hasAccess(flagToMode(flag))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
@@ -610,7 +609,7 @@ export async function rmdir(path) {
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK, credentials)) {
+        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         await fs.rmdir(resolved);
@@ -630,7 +629,7 @@ export async function mkdir(path, options) {
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, credentials)) {
+            if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
             }
             await fs.mkdir(resolved, mode);
@@ -643,7 +642,7 @@ export async function mkdir(path, options) {
             errorPaths[dir] = origDir;
         }
         for (const dir of dirs) {
-            if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, credentials)) {
+            if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
             }
             await fs.mkdir(dir, mode);
@@ -658,7 +657,7 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     path = normalizePath(path);
-    if (!(await stat(path)).hasAccess(constants.R_OK, credentials)) {
+    if (!(await stat(path)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
     path = (await exists(path)) ? await realpath(path) : path;
@@ -695,11 +694,11 @@ readdir;
  */
 export async function link(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK, credentials)) {
+    if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
     }
     linkPath = normalizePath(linkPath);
-    if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK, credentials)) {
+    if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK)) {
         throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
     }
     const { fs, path } = resolveMount(targetPath);
@@ -708,7 +707,7 @@ export async function link(targetPath, linkPath) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (!(await fs.stat(path)).hasAccess(constants.W_OK, credentials)) {
+        if (!(await fs.stat(path)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return await fs.link(path, link.path);
@@ -938,7 +937,7 @@ watch;
  */
 export async function access(path, mode = constants.F_OK) {
     const stats = await stat(path);
-    if (!stats.hasAccess(mode, credentials)) {
+    if (!stats.hasAccess(mode)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }

package/dist/emulation/sync.js

@@ -52,7 +52,6 @@ import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { credentials } from '../credentials.js';
 import { emitChange } from './watchers.js';
 /**
  * Synchronous rename.
@@ -64,7 +63,7 @@ export function renameSync(oldPath, newPath) {
     newPath = normalizePath(newPath);
     const oldMount = resolveMount(oldPath);
     const newMount = resolveMount(newPath);
-    if (!statSync(dirname(oldPath)).hasAccess(constants.W_OK, credentials)) {
+    if (!statSync(dirname(oldPath)).hasAccess(constants.W_OK)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -105,7 +104,7 @@ export function statSync(path, options) {
     const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
     try {
         const stats = fs.statSync(resolved);
-        if (!stats.hasAccess(constants.R_OK, credentials)) {
+        if (!stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', path, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -159,7 +158,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+        if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -181,7 +180,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         // Create the file
         const parentStats = fs.statSync(dirname(resolved));
-        if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+        if (!parentStats.hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', dirname(path), '_open');
         }
         if (!parentStats.isDirectory()) {
@@ -190,7 +189,7 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         return fs.createFileSync(resolved, flag, mode);
     }
     const stats = fs.statSync(resolved);
-    if (!stats.hasAccess(mode, credentials) || !stats.hasAccess(flagToMode(flag), credentials)) {
+    if (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
@@ -440,7 +439,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
     try {
-        if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+        if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         fs.rmdirSync(resolved);
@@ -460,7 +459,7 @@ export function mkdirSync(path, options) {
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            if (!fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, credentials)) {
+            if (!fs.statSync(dirname(resolved)).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
             }
             return fs.mkdirSync(resolved, mode);
@@ -471,7 +470,7 @@ export function mkdirSync(path, options) {
             errorPaths[dir] = original;
         }
         for (const dir of dirs) {
-            if (!fs.statSync(dirname(dir)).hasAccess(constants.W_OK, credentials)) {
+            if (!fs.statSync(dirname(dir)).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
             }
             fs.mkdirSync(dir, mode);
@@ -488,7 +487,7 @@ export function readdirSync(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
     let entries;
-    if (!statSync(path).hasAccess(constants.R_OK, credentials)) {
+    if (!statSync(path).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
     try {
@@ -527,11 +526,11 @@ readdirSync;
  */
 export function linkSync(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (!statSync(dirname(targetPath)).hasAccess(constants.R_OK, credentials)) {
+    if (!statSync(dirname(targetPath)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
     }
     linkPath = normalizePath(linkPath);
-    if (!statSync(dirname(linkPath)).hasAccess(constants.W_OK, credentials)) {
+    if (!statSync(dirname(linkPath)).hasAccess(constants.W_OK)) {
         throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
     }
     const { fs, path } = resolveMount(targetPath);
@@ -540,7 +539,7 @@ export function linkSync(targetPath, linkPath) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (!fs.statSync(path).hasAccess(constants.W_OK, credentials)) {
+        if (!fs.statSync(path).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return fs.linkSync(path, linkPath);
@@ -672,7 +671,7 @@ realpathSync;
  */
 export function accessSync(path, mode = 0o600) {
     const stats = statSync(path);
-    if (!stats.hasAccess(mode, credentials)) {
+    if (!stats.hasAccess(mode)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }

package/dist/file.d.ts

@@ -37,13 +37,28 @@ export declare function isSynchronous(flag: string): boolean;
 export declare function isExclusive(flag: string): boolean;
 export declare abstract class File {
     /**
-     * Get the current file position.
+     * @internal
+     * The file system that created the file
      */
-    abstract position: number;
+    fs: FileSystem;
+    /**
+     * The path to the file
+     */
+    readonly path: string;
+    constructor(
+    /**
+     * @internal
+     * The file system that created the file
+     */
+    fs: FileSystem, 
     /**
      * The path to the file
      */
-    abstract readonly path: string;
+    path: string);
+    /**
+     * Get the current file position.
+     */
+    abstract position: number;
     /**
      * Asynchronous `stat`.
      */
@@ -183,12 +198,9 @@ export declare abstract class File {
 export declare class PreloadFile<FS extends FileSystem> extends File {
     /**
      * The file system that created the file.
+     * @internal
      */
-    protected fs: FS;
-    /**
-     * Path to the file
-     */
-    readonly path: string;
+    fs: FS;
     readonly flag: string;
     readonly stats: Stats;
     protected _buffer: Uint8Array;
@@ -219,12 +231,9 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     constructor(
     /**
      * The file system that created the file.
+     * @internal
      */
-    fs: FS, 
-    /**
-     * Path to the file
-     */
-    path: string, flag: string, stats: Stats, _buffer?: Uint8Array);
+    fs: FS, path: string, flag: string, stats: Stats, _buffer?: Uint8Array);
     /**
      * Get the underlying buffer for this file. Mutating not recommended and will mess up dirty tracking.
      */

package/dist/file.js

@@ -105,6 +105,19 @@ export function isExclusive(flag) {
     return flag.indexOf('x') !== -1;
 }
 export class File {
+    constructor(
+    /**
+     * @internal
+     * The file system that created the file
+     */
+    fs, 
+    /**
+     * The path to the file
+     */
+    path) {
+        this.fs = fs;
+        this.path = path;
+    }
     [Symbol.asyncDispose]() {
         return this.close();
     }
@@ -149,15 +162,11 @@ export class PreloadFile extends File {
     constructor(
     /**
      * The file system that created the file.
+     * @internal
      */
-    fs, 
-    /**
-     * Path to the file
-     */
-    path, flag, stats, _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))) {
-        super();
+    fs, path, flag, stats, _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))) {
+        super(fs, path);
         this.fs = fs;
-        this.path = path;
         this.flag = flag;
         this.stats = stats;
         this._buffer = _buffer;

package/dist/mixins/mutexed.d.ts

@@ -1,17 +1,76 @@
-import type { FileSystem } from '../filesystem.js';
+import type { File } from '../file.js';
+import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
 import '../polyfills.js';
-import type { Mixin } from './shared.js';
+import type { Stats } from '../stats.js';
+import type { Concrete } from '../utils.js';
 export declare class MutexLock {
-    readonly path: string;
     protected readonly previous?: MutexLock | undefined;
     protected current: PromiseWithResolvers<void>;
     protected _isLocked: boolean;
     get isLocked(): boolean;
-    constructor(path: string, previous?: MutexLock | undefined);
+    constructor(previous?: MutexLock | undefined);
     done(): Promise<void>;
     unlock(): void;
     [Symbol.dispose](): void;
 }
+/**
+ * @hidden
+ */
+export declare class __MutexedFS<T extends FileSystem> implements FileSystem {
+    /**
+     * @internal
+     */
+    _fs: T;
+    ready(): Promise<void>;
+    metadata(): FileSystemMetadata;
+    /**
+     * The current locks
+     */
+    private currentLock?;
+    /**
+     * Adds a lock for a path
+     */
+    protected addLock(): MutexLock;
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, waits for it to be unlocked.
+     * @internal
+     */
+    lock(path: string, syscall: string): Promise<MutexLock>;
+    /**
+     * Locks `path` asynchronously.
+     * If the path is currently locked, an error will be thrown
+     * @internal
+     */
+    lockSync(path: string, syscall: string): MutexLock;
+    /**
+     * Whether `path` is locked
+     * @internal
+     */
+    get isLocked(): boolean;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    openFile(path: string, flag: string): Promise<File>;
+    openFileSync(path: string, flag: string): File;
+    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;
+    readdir(path: string): Promise<string[]>;
+    readdirSync(path: string): string[];
+    exists(path: string): Promise<boolean>;
+    existsSync(path: string): boolean;
+    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;
+}
 /**
  * This serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
@@ -21,13 +80,16 @@ export declare class MutexLock {
  * 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
+ * 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 declare function Mutexed<T extends new (...args: any[]) => FileSystem>(FS: T): Mixin<T, {
-    lock(path: string, syscall: string): Promise<MutexLock>;
-    lockSync(path: string): MutexLock;
-    isLocked(path: string): boolean;
-}>;
+export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof __MutexedFS<InstanceType<T>> & {
+    new (...args: ConstructorParameters<T>): __MutexedFS<InstanceType<T>>;
+};