@zenfs/core 0.2.3 → 0.3.1

package/dist/FileIndex.d.ts

@@ -1,13 +1,29 @@
+import type { Cred } from './cred.js';
+import { NoSyncFile, type FileFlag } from './file.js';
+import { FileSystem } from './filesystem.js';
 import { Stats } from './stats.js';
-type ListingTree = {
+/**
+ * @internal
+ */
+export type ListingTree = {
     [key: string]: ListingTree | null;
 };
+/**
+ * @internal
+ */
+export interface ListingQueueNode<T> {
+    pwd: string;
+    tree: ListingTree;
+    parent: IndexDirInode<T>;
+}
 /**
  * A simple class for storing a filesystem index. Assumes that all paths passed
  * to it are *absolute* paths.
  *
  * Can be used as a partial or a full index, although care must be taken if used
  * for the former purpose, especially when directories are concerned.
+ *
+ * @internal
  */
 export declare class FileIndex<T> {
     /**
@@ -15,16 +31,13 @@ export declare class FileIndex<T> {
      * @param listing Directory listing generated by tools
      * @return A new FileIndex object.
      */
-    static fromListing<T>(listing: ListingTree): FileIndex<T>;
+    static FromListing<T>(listing: ListingTree): FileIndex<T>;
     protected _index: Map<string, IndexDirInode<T>>;
     /**
      * Constructs a new FileIndex.
      */
     constructor();
-    /**
-     * Runs the given function over all files in the index.
-     */
-    forEachFile(cb: (file?: T) => void): void;
+    files(): IndexFileInode<T>[];
     /**
      * Adds the given absolute path to the index if it is not already in the index.
      * Creates any needed parent directories.
@@ -37,27 +50,25 @@ export declare class FileIndex<T> {
      * @todo If adding fails and implicitly creates directories, we do not clean up
      *   the new empty directories.
      */
-    addPath(path: string, inode: IndexInode<T>): boolean;
+    add(path: string, inode: IndexInode<T>): boolean;
     /**
      * Adds the given absolute path to the index if it is not already in the index.
      * The path is added without special treatment (no joining of adjacent separators, etc).
      * Creates any needed parent directories.
      * @param path The path to add to the index.
-     * @param inode The inode for the
-     *   path to add.
+     * @param inode The inode for the path to add.
      * @return 'True' if it was added or already exists, 'false' if there
      *   was an issue adding it (e.g. item in path is a file, item exists but is
      *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up
-     *   the new empty directories.
+     * @todo If adding fails and implicitly creates directories, we do not clean up the new empty directories.
      */
-    addPathFast(path: string, inode: IndexInode<T>): boolean;
+    addFast(path: string, inode: IndexInode<T>): boolean;
     /**
      * Removes the given path. Can be a file or a directory.
      * @return The removed item,
      *   or null if it did not exist.
      */
-    removePath(path: string): IndexInode<T> | null;
+    remove(path: string): IndexInode<T> | null;
     /**
      * Retrieves the directory listing of the given path.
      * @return An array of files in the given path, or 'null' if it does not exist.
@@ -67,11 +78,7 @@ export declare class FileIndex<T> {
      * Returns the inode of the given item.
      * @return Returns null if the item does not exist.
      */
-    getInode(path: string): IndexInode<T> | null;
-    /**
-     * Split into a (directory path, item name) pair
-     */
-    protected splitPath(p: string): string[];
+    get(path: string): IndexInode<T> | null;
 }
 /**
  * Generic interface for file/directory inodes.
@@ -80,8 +87,14 @@ export declare class FileIndex<T> {
 export declare abstract class IndexInode<T> {
     data?: T;
     constructor(data?: T);
-    abstract isFile(): boolean;
-    abstract isDir(): boolean;
+    /**
+     * Whether this inode is for a file
+     */
+    abstract isFile(): this is IndexFileInode<T>;
+    /**
+     * Whether this inode is for a directory
+     */
+    abstract isDirectory(): this is IndexDirInode<T>;
     abstract toStats(): Stats;
 }
 /**
@@ -89,7 +102,7 @@ export declare abstract class IndexInode<T> {
  */
 export declare class IndexFileInode<T> extends IndexInode<T> {
     isFile(): boolean;
-    isDir(): boolean;
+    isDirectory(): boolean;
     toStats(): Stats;
 }
 /**
@@ -101,7 +114,7 @@ export declare class IndexDirInode<T> extends IndexInode<T> {
      */
     _listing: Map<string, IndexInode<T>>;
     isFile(): boolean;
-    isDir(): boolean;
+    isDirectory(): boolean;
     /**
      * Return a Stats object for this inode.
      * @todo Should probably remove this at some point. This isn't the responsibility of the FileIndex.
@@ -120,18 +133,18 @@ export declare class IndexDirInode<T> extends IndexInode<T> {
     get listing(): string[];
     /**
      * Returns the inode for the indicated item, or null if it does not exist.
-     * @param p Name of item in this directory.
+     * @param path Name of item in this directory.
      */
-    get(p: string): IndexInode<T> | null;
+    get(path: string): IndexInode<T> | null;
     /**
      * Add the given item to the directory listing. Note that the given inode is
      * not copied, and will be mutated by the DirInode if it is a DirInode.
-     * @param p Item name to add to the directory listing.
+     * @param path Item name to add to the directory listing.
      * @param inode The inode for the
      *   item to add to the directory inode.
      * @return True if it was added, false if it already existed.
      */
-    add(p: string, inode: IndexInode<T>): boolean;
+    add(path: string, inode: IndexInode<T>): boolean;
     /**
      * Removes the given item from the directory listing.
      * @param p Name of item to remove from the directory listing.
@@ -140,12 +153,82 @@ export declare class IndexDirInode<T> extends IndexInode<T> {
      */
     remove(p: string): IndexInode<T> | null;
 }
-/**
- * @hidden
- */
-export declare function isIndexFileInode<T>(inode?: IndexInode<T>): inode is IndexFileInode<T>;
-/**
- * @hidden
- */
-export declare function isIndexDirInode<T>(inode?: IndexInode<T>): inode is IndexDirInode<T>;
+declare const FileIndexFS_base: (abstract new (...args: any[]) => {
+    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<import("./file.js").File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): import("./file.js").File;
+    unlink(path: string, cred: Cred): Promise<void>;
+    unlinkSync(path: string, cred: Cred): void;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    rmdirSync(path: string, cred: Cred): void;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}) & typeof FileSystem;
+export declare abstract class FileIndexFS<TIndex> extends FileIndexFS_base {
+    protected _index: FileIndex<TIndex>;
+    constructor(index: ListingTree);
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<NoSyncFile<this>>;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): NoSyncFile<this>;
+    readdir(path: string): Promise<string[]>;
+    readdirSync(path: string): string[];
+    protected abstract statFileInode(inode: IndexFileInode<TIndex>): Promise<Stats>;
+    protected abstract fileForFileInode(inode: IndexFileInode<TIndex>): Promise<NoSyncFile<this>>;
+    protected abstract statFileInodeSync(inode: IndexFileInode<TIndex>): Stats;
+    protected abstract fileForFileInodeSync(inode: IndexFileInode<TIndex>): NoSyncFile<this>;
+}
+declare const SyncFileIndexFS_base: (abstract new (...args: any[]) => {
+    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    ready(): Promise<any>;
+    exists(path: string, cred: Cred): Promise<boolean>;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<import("./file.js").File>;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<import("./file.js").File>;
+    unlink(path: string, cred: Cred): Promise<void>;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    statSync(path: string, cred: Cred): Stats;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): import("./file.js").File;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): import("./file.js").File;
+    unlinkSync(path: string, cred: Cred): void;
+    rmdirSync(path: string, cred: Cred): void;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
+    readdirSync(path: string, cred: Cred): string[];
+    existsSync(path: string, cred: Cred): boolean;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}) & (abstract new (index: ListingTree) => FileIndexFS<unknown>);
+export declare abstract class SyncFileIndexFS<TIndex> extends SyncFileIndexFS_base {
+    protected statFileInode(inode: IndexFileInode<TIndex>): Promise<Stats>;
+    protected fileForFileInode(inode: IndexFileInode<TIndex>): Promise<NoSyncFile<this>>;
+}
+declare const AsyncFileIndexFS_base: (abstract new (...args: any[]) => {
+    readonly metadata: import("./filesystem.js").FileSystemMetadata;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    statSync(path: string, cred: Cred): Stats;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): import("./file.js").File;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): import("./file.js").File;
+    unlinkSync(path: string, cred: Cred): void;
+    rmdirSync(path: string, cred: Cred): void;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
+    readdirSync(path: string, cred: Cred): string[];
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}) & (abstract new (index: ListingTree) => FileIndexFS<unknown>);
+export declare abstract class AsyncFileIndexFS<TIndex> extends AsyncFileIndexFS_base {
+    protected statFileInodeSync(): Stats;
+    protected fileForFileInodeSync(): NoSyncFile<this>;
+}
 export {};

package/dist/FileIndex.js

@@ -1,11 +1,16 @@
-import { Stats, FileType } from './stats.js';
-import * as path from './emulation/path.js';
+import { ApiError, ErrorCode } from './ApiError.js';
+import { basename, dirname, join } from './emulation/path.js';
+import { NoSyncFile } from './file.js';
+import { FileSystem, Sync, Async, Readonly } from './filesystem.js';
+import { FileType, Stats } from './stats.js';
 /**
  * A simple class for storing a filesystem index. Assumes that all paths passed
  * to it are *absolute* paths.
  *
  * Can be used as a partial or a full index, although care must be taken if used
  * for the former purpose, especially when directories are concerned.
+ *
+ * @internal
  */
 export class FileIndex {
     /**
@@ -13,7 +18,7 @@ export class FileIndex {
      * @param listing Directory listing generated by tools
      * @return A new FileIndex object.
      */
-    static fromListing(listing) {
+    static FromListing(listing) {
         const index = new FileIndex();
         // Add a root DirNode.
         const rootInode = new IndexDirInode();
@@ -28,7 +33,7 @@ export class FileIndex {
                 }
                 const children = tree[node];
                 if (children) {
-                    const path = `${pwd}/${node}`;
+                    const path = pwd + '/' + node;
                     inode = new IndexDirInode();
                     index._index.set(path, inode);
                     queue.push({ pwd: path, tree: children, parent: inode });
@@ -54,21 +59,20 @@ export class FileIndex {
         // _index is a single-level key,value store that maps *directory* paths to
         // DirInodes. File information is only contained in DirInodes themselves.
         // Create the root directory.
-        this.addPath('/', new IndexDirInode());
+        this.add('/', new IndexDirInode());
     }
-    /**
-     * Runs the given function over all files in the index.
-     */
-    forEachFile(cb) {
+    files() {
+        const files = [];
         for (const dir of this._index.values()) {
             for (const file of dir.listing) {
                 const item = dir.get(file);
                 if (!item?.isFile()) {
                     continue;
                 }
-                cb(item.data);
+                files.push(item);
             }
         }
+        return files;
     }
     /**
      * Adds the given absolute path to the index if it is not already in the index.
@@ -82,38 +86,34 @@ export class FileIndex {
      * @todo If adding fails and implicitly creates directories, we do not clean up
      *   the new empty directories.
      */
-    addPath(path, inode) {
+    add(path, inode) {
         if (!inode) {
             throw new Error('Inode must be specified');
         }
-        if (path[0] !== '/') {
+        if (!path.startsWith('/')) {
             throw new Error('Path must be absolute, got: ' + path);
         }
         // Check if it already exists.
         if (this._index.has(path)) {
             return this._index.get(path) === inode;
         }
-        const splitPath = this.splitPath(path);
-        const dirpath = splitPath[0];
-        const itemname = splitPath[1];
+        const dirpath = dirname(path);
         // Try to add to its parent directory first.
         let parent = this._index.get(dirpath);
-        if (!parent && path !== '/') {
+        if (!parent && path != '/') {
             // Create parent.
             parent = new IndexDirInode();
-            if (!this.addPath(dirpath, parent)) {
+            if (!this.add(dirpath, parent)) {
                 return false;
             }
         }
-        // Add myself to my parent.
-        if (path !== '/') {
-            if (!parent.add(itemname, inode)) {
-                return false;
-            }
+        // Add to parent.
+        if (path != '/' && !parent.add(basename(path), inode)) {
+            return false;
         }
-        // If I'm a directory, add myself to the index.
-        if (isIndexDirInode(inode)) {
-            this._index[path] = inode;
+        // If a directory, add to the index.
+        if (inode.isDirectory()) {
+            this._index.set(path, inode);
         }
         return true;
     }
@@ -122,31 +122,28 @@ export class FileIndex {
      * The path is added without special treatment (no joining of adjacent separators, etc).
      * Creates any needed parent directories.
      * @param path The path to add to the index.
-     * @param inode The inode for the
-     *   path to add.
+     * @param inode The inode for the path to add.
      * @return 'True' if it was added or already exists, 'false' if there
      *   was an issue adding it (e.g. item in path is a file, item exists but is
      *   different).
-     * @todo If adding fails and implicitly creates directories, we do not clean up
-     *   the new empty directories.
+     * @todo If adding fails and implicitly creates directories, we do not clean up the new empty directories.
      */
-    addPathFast(path, inode) {
-        const itemNameMark = path.lastIndexOf('/');
-        const parentPath = itemNameMark === 0 ? '/' : path.substring(0, itemNameMark);
-        const itemName = path.substring(itemNameMark + 1);
+    addFast(path, inode) {
+        const parentPath = dirname(path);
+        const itemName = basename(path);
         // Try to add to its parent directory first.
         let parent = this._index.get(parentPath);
         if (!parent) {
             // Create parent.
             parent = new IndexDirInode();
-            this.addPathFast(parentPath, parent);
+            this.addFast(parentPath, parent);
         }
         if (!parent.add(itemName, inode)) {
             return false;
         }
         // If adding a directory, add to the index as well.
-        if (inode.isDir()) {
-            this._index[path] = inode;
+        if (inode.isDirectory()) {
+            this._index.set(path, inode);
         }
         return true;
     }
@@ -155,30 +152,28 @@ export class FileIndex {
      * @return The removed item,
      *   or null if it did not exist.
      */
-    removePath(path) {
-        const splitPath = this.splitPath(path);
-        const dirpath = splitPath[0];
-        const itemname = splitPath[1];
+    remove(path) {
+        const dirpath = dirname(path);
         // Try to remove it from its parent directory first.
-        const parent = this._index[dirpath];
+        const parent = this._index.get(dirpath);
         if (!parent) {
             return;
         }
-        // Remove myself from my parent.
-        const inode = parent.remove(itemname);
+        // Remove from parent.
+        const inode = parent.remove(basename(path));
         if (!inode) {
             return;
         }
-        // If I'm a directory, remove myself from the index, and remove my children.
-        if (!isIndexDirInode(inode)) {
+        if (!inode.isDirectory()) {
             return inode;
         }
+        // If a directory, remove from the index, and remove children.
         const children = inode.listing;
         for (const child of children) {
-            this.removePath(path + '/' + child);
+            this.remove(join(path, child));
         }
         // Remove the directory from the index, unless it's the root.
-        if (path !== '/') {
+        if (path != '/') {
             this._index.delete(path);
         }
     }
@@ -193,23 +188,15 @@ export class FileIndex {
      * Returns the inode of the given item.
      * @return Returns null if the item does not exist.
      */
-    getInode(path) {
-        const [dirpath, itemname] = this.splitPath(path);
+    get(path) {
+        const dirpath = dirname(path);
         // Retrieve from its parent directory.
         const parent = this._index.get(dirpath);
         // Root case
-        if (dirpath === path) {
+        if (dirpath == path) {
             return parent;
         }
-        return parent?.get(itemname);
-    }
-    /**
-     * Split into a (directory path, item name) pair
-     */
-    splitPath(p) {
-        const dirpath = path.dirname(p);
-        const itemname = p.slice(dirpath.length + (dirpath === '/' ? 0 : 1));
-        return [dirpath, itemname];
+        return parent?.get(basename(path));
     }
 }
 /**
@@ -228,7 +215,7 @@ export class IndexFileInode extends IndexInode {
     isFile() {
         return true;
     }
-    isDir() {
+    isDirectory() {
         return false;
     }
     toStats() {
@@ -249,7 +236,7 @@ export class IndexDirInode extends IndexInode {
     isFile() {
         return false;
     }
-    isDir() {
+    isDirectory() {
         return true;
     }
     /**
@@ -272,29 +259,28 @@ export class IndexDirInode extends IndexInode {
      * @return The directory listing for this directory.
      */
     get listing() {
-        return Object.keys(this._listing);
+        return [...this._listing.keys()];
     }
     /**
      * Returns the inode for the indicated item, or null if it does not exist.
-     * @param p Name of item in this directory.
+     * @param path Name of item in this directory.
      */
-    get(p) {
-        const item = this._listing[p];
-        return item ? item : null;
+    get(path) {
+        return this._listing.get(path);
     }
     /**
      * Add the given item to the directory listing. Note that the given inode is
      * not copied, and will be mutated by the DirInode if it is a DirInode.
-     * @param p Item name to add to the directory listing.
+     * @param path Item name to add to the directory listing.
      * @param inode The inode for the
      *   item to add to the directory inode.
      * @return True if it was added, false if it already existed.
      */
-    add(p, inode) {
-        if (p in this._listing) {
+    add(path, inode) {
+        if (this._listing.has(path)) {
             return false;
         }
-        this._listing[p] = inode;
+        this._listing.set(path, inode);
         return true;
     }
     /**
@@ -304,23 +290,119 @@ export class IndexDirInode extends IndexInode {
      *   removed, or null if the item did not exist.
      */
     remove(p) {
-        const item = this._listing[p];
-        if (item === undefined) {
-            return null;
+        const item = this._listing.get(p);
+        if (!item) {
+            return;
         }
-        delete this._listing[p];
+        this._listing.delete(p);
         return item;
     }
 }
-/**
- * @hidden
- */
-export function isIndexFileInode(inode) {
-    return inode?.isFile();
+export class FileIndexFS extends Readonly(FileSystem) {
+    constructor(index) {
+        super();
+        this._index = FileIndex.FromListing(index);
+    }
+    async stat(path) {
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (inode.isDirectory()) {
+            return inode.stats;
+        }
+        if (inode.isFile()) {
+            return this.statFileInode(inode);
+        }
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid inode.');
+    }
+    statSync(path) {
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (inode.isDirectory()) {
+            return inode.stats;
+        }
+        if (inode.isFile()) {
+            return this.statFileInodeSync(inode);
+        }
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid inode.');
+    }
+    async openFile(path, flag, cred) {
+        if (flag.isWriteable()) {
+            // You can't write to files on this file system.
+            throw new ApiError(ErrorCode.EPERM, path);
+        }
+        // Check if the path exists, and is a file.
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(flag.mode, cred)) {
+            throw ApiError.EACCES(path);
+        }
+        if (inode.isDirectory()) {
+            const stats = inode.stats;
+            return new NoSyncFile(this, path, flag, stats, stats.fileData);
+        }
+        return this.fileForFileInode(inode);
+    }
+    openFileSync(path, flag, cred) {
+        if (flag.isWriteable()) {
+            // You can't write to files on this file system.
+            throw new ApiError(ErrorCode.EPERM, path);
+        }
+        // Check if the path exists, and is a file.
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(flag.mode, cred)) {
+            throw ApiError.EACCES(path);
+        }
+        if (inode.isDirectory()) {
+            const stats = inode.stats;
+            return new NoSyncFile(this, path, flag, stats, stats.fileData);
+        }
+        return this.fileForFileInodeSync(inode);
+    }
+    async readdir(path) {
+        // Check if it exists.
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (inode.isDirectory()) {
+            return inode.listing;
+        }
+        throw ApiError.ENOTDIR(path);
+    }
+    readdirSync(path) {
+        // Check if it exists.
+        const inode = this._index.get(path);
+        if (!inode) {
+            throw ApiError.ENOENT(path);
+        }
+        if (inode.isDirectory()) {
+            return inode.listing;
+        }
+        throw ApiError.ENOTDIR(path);
+    }
 }
-/**
- * @hidden
- */
-export function isIndexDirInode(inode) {
-    return inode?.isDir();
+export class SyncFileIndexFS extends Sync((FileIndexFS)) {
+    async statFileInode(inode) {
+        return this.statFileInodeSync(inode);
+    }
+    async fileForFileInode(inode) {
+        return this.fileForFileInodeSync(inode);
+    }
+}
+export class AsyncFileIndexFS extends Async((FileIndexFS)) {
+    statFileInodeSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    fileForFileInodeSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
 }