@zenfs/core 0.1.0 → 0.2.0

package/dist/backends/Locked.d.ts

@@ -13,21 +13,19 @@ import { Cred } from '../cred.js';
  * multiple requests interleaving.
  */
 export default class LockedFS<T extends FileSystem> implements FileSystem {
-    private _fs;
+    readonly fs: T;
     private _mu;
-    protected _ready: Promise<this>;
     constructor(fs: T);
-    whenReady(): Promise<this>;
+    ready(): Promise<this>;
     get metadata(): FileSystemMetadata;
-    get fs(): T;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     stat(p: string, cred: Cred): Promise<Stats>;
     statSync(p: string, cred: Cred): Stats;
-    access(p: string, mode: number, cred: Cred): Promise<void>;
-    accessSync(p: string, mode: number, cred: Cred): void;
-    open(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
-    openSync(p: string, flag: FileFlag, mode: number, cred: Cred): File;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
     unlink(p: string, cred: Cred): Promise<void>;
     unlinkSync(p: string, cred: Cred): void;
     rmdir(p: string, cred: Cred): Promise<void>;
@@ -38,26 +36,8 @@ export default class LockedFS<T extends FileSystem> implements FileSystem {
     readdirSync(p: string, cred: Cred): string[];
     exists(p: string, cred: Cred): Promise<boolean>;
     existsSync(p: string, cred: Cred): boolean;
-    realpath(p: string, cred: Cred): Promise<string>;
-    realpathSync(p: string, cred: Cred): string;
-    truncate(p: string, len: number, cred: Cred): Promise<void>;
-    truncateSync(p: string, len: number, cred: Cred): void;
-    readFile(fname: string, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
-    readFileSync(fname: string, flag: FileFlag, cred: Cred): Uint8Array;
-    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    writeFileSync(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): void;
-    appendFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    appendFileSync(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): void;
-    chmod(p: string, mode: number, cred: Cred): Promise<void>;
-    chmodSync(p: string, mode: number, cred: Cred): void;
-    chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
-    chownSync(p: string, new_uid: number, new_gid: number, cred: Cred): void;
-    utimes(p: string, atime: Date, mtime: Date, cred: Cred): Promise<void>;
-    utimesSync(p: string, atime: Date, mtime: Date, cred: Cred): void;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    symlink(srcpath: string, dstpath: string, type: string, cred: Cred): Promise<void>;
-    symlinkSync(srcpath: string, dstpath: string, type: string, cred: Cred): void;
-    readlink(p: string, cred: Cred): Promise<string>;
-    readlinkSync(p: string, cred: Cred): string;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }

package/dist/backends/Locked.js

@@ -10,36 +10,33 @@ import Mutex from '../mutex.js';
  */
 export default class LockedFS {
     constructor(fs) {
-        this._ready = Promise.resolve(this);
-        this._fs = fs;
+        this.fs = fs;
         this._mu = new Mutex();
     }
-    whenReady() {
-        return this._ready;
+    async ready() {
+        await this.fs.ready();
+        return this;
     }
     get metadata() {
         return {
-            ...this._fs.metadata,
-            name: 'LockedFS<' + this._fs.metadata.name + '>',
+            ...this.fs.metadata,
+            name: 'Locked<' + this.fs.metadata.name + '>',
         };
     }
-    get fs() {
-        return this._fs;
-    }
     async rename(oldPath, newPath, cred) {
         await this._mu.lock(oldPath);
-        await this._fs.rename(oldPath, newPath, cred);
+        await this.fs.rename(oldPath, newPath, cred);
         this._mu.unlock(oldPath);
     }
     renameSync(oldPath, newPath, cred) {
         if (this._mu.isLocked(oldPath)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.renameSync(oldPath, newPath, cred);
+        return this.fs.renameSync(oldPath, newPath, cred);
     }
     async stat(p, cred) {
         await this._mu.lock(p);
-        const stats = await this._fs.stat(p, cred);
+        const stats = await this.fs.stat(p, cred);
         this._mu.unlock(p);
         return stats;
     }
@@ -47,67 +44,68 @@ export default class LockedFS {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.statSync(p, cred);
+        return this.fs.statSync(p, cred);
     }
-    async access(p, mode, cred) {
-        await this._mu.lock(p);
-        await this._fs.access(p, mode, cred);
-        this._mu.unlock(p);
+    async openFile(path, flag, cred) {
+        await this._mu.lock(path);
+        const fd = await this.fs.openFile(path, flag, cred);
+        this._mu.unlock(path);
+        return fd;
     }
-    accessSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
+    openFileSync(path, flag, cred) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.accessSync(p, mode, cred);
+        return this.fs.openFileSync(path, flag, cred);
     }
-    async open(p, flag, mode, cred) {
-        await this._mu.lock(p);
-        const fd = await this._fs.open(p, flag, mode, cred);
-        this._mu.unlock(p);
+    async createFile(path, flag, mode, cred) {
+        await this._mu.lock(path);
+        const fd = await this.fs.createFile(path, flag, mode, cred);
+        this._mu.unlock(path);
         return fd;
     }
-    openSync(p, flag, mode, cred) {
-        if (this._mu.isLocked(p)) {
+    createFileSync(path, flag, mode, cred) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.openSync(p, flag, mode, cred);
+        return this.fs.createFileSync(path, flag, mode, cred);
     }
     async unlink(p, cred) {
         await this._mu.lock(p);
-        await this._fs.unlink(p, cred);
+        await this.fs.unlink(p, cred);
         this._mu.unlock(p);
     }
     unlinkSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.unlinkSync(p, cred);
+        return this.fs.unlinkSync(p, cred);
     }
     async rmdir(p, cred) {
         await this._mu.lock(p);
-        await this._fs.rmdir(p, cred);
+        await this.fs.rmdir(p, cred);
         this._mu.unlock(p);
     }
     rmdirSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.rmdirSync(p, cred);
+        return this.fs.rmdirSync(p, cred);
     }
     async mkdir(p, mode, cred) {
         await this._mu.lock(p);
-        await this._fs.mkdir(p, mode, cred);
+        await this.fs.mkdir(p, mode, cred);
         this._mu.unlock(p);
     }
     mkdirSync(p, mode, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.mkdirSync(p, mode, cred);
+        return this.fs.mkdirSync(p, mode, cred);
     }
     async readdir(p, cred) {
         await this._mu.lock(p);
-        const files = await this._fs.readdir(p, cred);
+        const files = await this.fs.readdir(p, cred);
         this._mu.unlock(p);
         return files;
     }
@@ -115,11 +113,11 @@ export default class LockedFS {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.readdirSync(p, cred);
+        return this.fs.readdirSync(p, cred);
     }
     async exists(p, cred) {
         await this._mu.lock(p);
-        const exists = await this._fs.exists(p, cred);
+        const exists = await this.fs.exists(p, cred);
         this._mu.unlock(p);
         return exists;
     }
@@ -127,130 +125,28 @@ export default class LockedFS {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.existsSync(p, cred);
-    }
-    async realpath(p, cred) {
-        await this._mu.lock(p);
-        const resolvedPath = await this._fs.realpath(p, cred);
-        this._mu.unlock(p);
-        return resolvedPath;
-    }
-    realpathSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.realpathSync(p, cred);
-    }
-    async truncate(p, len, cred) {
-        await this._mu.lock(p);
-        await this._fs.truncate(p, len, cred);
-        this._mu.unlock(p);
-    }
-    truncateSync(p, len, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.truncateSync(p, len, cred);
-    }
-    async readFile(fname, flag, cred) {
-        await this._mu.lock(fname);
-        const data = await this._fs.readFile(fname, flag, cred);
-        this._mu.unlock(fname);
-        return data;
-    }
-    readFileSync(fname, flag, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.readFileSync(fname, flag, cred);
-    }
-    async writeFile(fname, data, flag, mode, cred) {
-        await this._mu.lock(fname);
-        await this._fs.writeFile(fname, data, flag, mode, cred);
-        this._mu.unlock(fname);
-    }
-    writeFileSync(fname, data, flag, mode, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.writeFileSync(fname, data, flag, mode, cred);
-    }
-    async appendFile(fname, data, flag, mode, cred) {
-        await this._mu.lock(fname);
-        await this._fs.appendFile(fname, data, flag, mode, cred);
-        this._mu.unlock(fname);
-    }
-    appendFileSync(fname, data, flag, mode, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.appendFileSync(fname, data, flag, mode, cred);
-    }
-    async chmod(p, mode, cred) {
-        await this._mu.lock(p);
-        await this._fs.chmod(p, mode, cred);
-        this._mu.unlock(p);
-    }
-    chmodSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.chmodSync(p, mode, cred);
-    }
-    async chown(p, new_uid, new_gid, cred) {
-        await this._mu.lock(p);
-        await this._fs.chown(p, new_uid, new_gid, cred);
-        this._mu.unlock(p);
-    }
-    chownSync(p, new_uid, new_gid, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.chownSync(p, new_uid, new_gid, cred);
-    }
-    async utimes(p, atime, mtime, cred) {
-        await this._mu.lock(p);
-        await this._fs.utimes(p, atime, mtime, cred);
-        this._mu.unlock(p);
-    }
-    utimesSync(p, atime, mtime, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.utimesSync(p, atime, mtime, cred);
+        return this.fs.existsSync(p, cred);
     }
     async link(srcpath, dstpath, cred) {
         await this._mu.lock(srcpath);
-        await this._fs.link(srcpath, dstpath, cred);
+        await this.fs.link(srcpath, dstpath, cred);
         this._mu.unlock(srcpath);
     }
     linkSync(srcpath, dstpath, cred) {
         if (this._mu.isLocked(srcpath)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.linkSync(srcpath, dstpath, cred);
-    }
-    async symlink(srcpath, dstpath, type, cred) {
-        await this._mu.lock(srcpath);
-        await this._fs.symlink(srcpath, dstpath, type, cred);
-        this._mu.unlock(srcpath);
-    }
-    symlinkSync(srcpath, dstpath, type, cred) {
-        if (this._mu.isLocked(srcpath)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.symlinkSync(srcpath, dstpath, type, cred);
+        return this.fs.linkSync(srcpath, dstpath, cred);
     }
-    async readlink(p, cred) {
-        await this._mu.lock(p);
-        const linkString = await this._fs.readlink(p, cred);
-        this._mu.unlock(p);
-        return linkString;
+    async sync(path, data, stats) {
+        await this._mu.lock(path);
+        await this.fs.sync(path, data, stats);
+        this._mu.unlock(path);
     }
-    readlinkSync(p, cred) {
-        if (this._mu.isLocked(p)) {
+    syncSync(path, data, stats) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.readlinkSync(p, cred);
+        return this.fs.syncSync(path, data, stats);
     }
 }

package/dist/backends/OverlayFS.d.ts

@@ -1,9 +1,9 @@
-import { type FileSystem, BaseFileSystem, FileSystemMetadata } from '../filesystem.js';
-import { File, FileFlag, PreloadFile } from '../file.js';
+import { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import { File, FileFlag } from '../file.js';
 import { Stats } from '../stats.js';
 import LockedFS from './Locked.js';
 import { Cred } from '../cred.js';
-import { type BackendOptions } from './backend.js';
+import type { Backend } from './backend.js';
 export declare namespace OverlayFS {
     /**
      * Configuration options for OverlayFS instances.
@@ -20,13 +20,15 @@ export declare namespace OverlayFS {
     }
 }
 /**
- * *INTERNAL, DO NOT USE DIRECTLY!*
+ * OverlayFS makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
  *
- * Core OverlayFS class that contains no locking whatsoever. We wrap these objects
- * in a LockedFS to prevent races.
+ * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
+ *
+ * @internal
  */
-export declare class UnlockedOverlayFS extends BaseFileSystem {
-    static isAvailable(): boolean;
+export declare class UnlockedOverlayFS extends FileSystem {
+    ready(): Promise<this>;
     private _writable;
     private _readable;
     private _isInitialized;
@@ -34,19 +36,16 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
     private _deleteLog;
     private _deleteLogUpdatePending;
     private _deleteLogUpdateNeeded;
-    private _deleteLogError;
+    private _deleteLogError?;
+    private _ready;
     constructor({ writable, readable }: OverlayFS.Options);
     get metadata(): FileSystemMetadata;
-    getOverlayedFileSystems(): {
-        readable: FileSystem;
-        writable: FileSystem;
-    };
-    _syncAsync(file: PreloadFile<UnlockedOverlayFS>): Promise<void>;
-    _syncSync(file: PreloadFile<UnlockedOverlayFS>): void;
+    getOverlayedFileSystems(): OverlayFS.Options;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
     /**
-     * **INTERNAL METHOD**
-     *
      * Called once to load up metadata stored on the writable file system.
+     * @internal
      */
     _initialize(): Promise<void>;
     getDeletionLog(): string;
@@ -55,8 +54,12 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     stat(p: string, cred: Cred): Promise<Stats>;
     statSync(p: string, cred: Cred): Stats;
-    open(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
-    openSync(p: string, flag: FileFlag, mode: number, cred: Cred): File;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     unlink(p: string, cred: Cred): Promise<void>;
     unlinkSync(p: string, cred: Cred): void;
     rmdir(p: string, cred: Cred): Promise<void>;
@@ -65,14 +68,6 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
     mkdirSync(p: string, mode: number, cred: Cred): void;
     readdir(p: string, cred: Cred): Promise<string[]>;
     readdirSync(p: string, cred: Cred): string[];
-    exists(p: string, cred: Cred): Promise<boolean>;
-    existsSync(p: string, cred: Cred): boolean;
-    chmod(p: string, mode: number, cred: Cred): Promise<void>;
-    chmodSync(p: string, mode: number, cred: Cred): void;
-    chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
-    chownSync(p: string, new_uid: number, new_gid: number, cred: Cred): void;
-    utimes(p: string, atime: Date, mtime: Date, cred: Cred): Promise<void>;
-    utimesSync(p: string, atime: Date, mtime: Date, cred: Cred): void;
     private deletePath;
     private updateLog;
     private _reparseDeletionLog;
@@ -82,8 +77,8 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
      * With the given path, create the needed parent directories on the writable storage
      * should they not exist. Use modes from the read-only storage.
      */
+    private createParentDirectoriesSync;
     private createParentDirectories;
-    private createParentDirectoriesAsync;
     /**
      * Helper function:
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
@@ -95,8 +90,8 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
      * Copy from readable to writable storage.
      * PRECONDITION: File does not exist on writable storage.
      */
+    private copyToWritableSync;
     private copyToWritable;
-    private copyToWritableAsync;
 }
 /**
  * OverlayFS makes a read-only filesystem writable by storing writes on a second,
@@ -104,10 +99,7 @@ export declare class UnlockedOverlayFS extends BaseFileSystem {
  * file system.
  */
 export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
-    static readonly Name = "OverlayFS";
-    static Create: any;
-    static readonly Options: BackendOptions;
-    static isAvailable(): boolean;
+    ready(): Promise<this>;
     /**
      * @param options The options to initialize the OverlayFS with
      */
@@ -116,5 +108,5 @@ export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
     getDeletionLog(): string;
     resDeletionLog(): string;
     unwrap(): UnlockedOverlayFS;
-    private _initialize;
 }
+export declare const Overlay: Backend;