@zenfs/core 1.8.7 → 1.9.0

package/dist/backends/port/fs.js

@@ -1,10 +1,10 @@
 import { pick } from 'utilium';
 import { resolveMountConfig } from '../../config.js';
-import { Errno, ErrnoError } from '../../error.js';
-import { FileSystem } from '../../filesystem.js';
+import { Errno, ErrnoError } from '../../internal/error.js';
+import { FileSystem } from '../../internal/filesystem.js';
+import { err, info } from '../../internal/log.js';
 import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
-import { decodeUTF8 } from '../../utils.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
 /**
@@ -18,21 +18,15 @@ export class PortFS extends Async(FileSystem) {
      * Constructs a new PortFS instance that connects with the FS running on `options.port`.
      */
     constructor(options) {
-        super();
+        super(0x706f7274, 'portfs');
         this.options = options;
         /**`
          * @hidden
          */
-        this._sync = InMemory.create({ name: 'port-tmpfs' });
+        this._sync = InMemory.create({ name: 'tmpfs:port' });
         this.port = options.port;
         RPC.attach(this.port, RPC.handleResponse);
     }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: 'PortFS',
-        };
-    }
     rpc(method, ...args) {
         return RPC.request({ method, args }, {
             ...this.options,
@@ -130,7 +124,7 @@ const _Port = {
             validator(port) {
                 // Check for a `postMessage` function.
                 if (typeof (port === null || port === void 0 ? void 0 : port.postMessage) != 'function') {
-                    throw new ErrnoError(Errno.EINVAL, 'option must be a port.');
+                    throw err(new ErrnoError(Errno.EINVAL, 'option must be a port.'));
                 }
             },
         },
@@ -146,5 +140,6 @@ export async function resolveRemoteMount(port, config, _depth = 0) {
     const fs = await resolveMountConfig(config, _depth);
     attachFS(port, fs);
     stopAndReplay(fs);
+    info('Resolved remote mount: ' + fs.toString());
     return fs;
 }

package/dist/backends/port/rpc.d.ts

@@ -1,6 +1,6 @@
 import type { TransferListItem } from 'node:worker_threads';
 import type { WithOptional } from 'utilium';
-import type { ErrnoErrorJSON } from '../../error.js';
+import type { ErrnoErrorJSON } from '../../internal/error.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import type { PortFS } from './fs.js';
 import { type StatsLike } from '../../stats.js';

package/dist/backends/port/rpc.js

@@ -1,5 +1,6 @@
-import { Errno, ErrnoError } from '../../error.js';
-import { LazyFile } from '../../file.js';
+import { Errno, ErrnoError } from '../../internal/error.js';
+import { LazyFile } from '../../internal/file.js';
+import { err, info } from '../../internal/log.js';
 import { Stats } from '../../stats.js';
 import { handleRequest } from './fs.js';
 function isFileData(value) {
@@ -12,15 +13,16 @@ export function isMessage(arg) {
 const executors = new Map();
 export function request(request, { port, timeout = 1000, fs } = {}) {
     const stack = '\n' + new Error().stack.slice('Error:'.length);
-    if (!port) {
-        throw ErrnoError.With('EINVAL');
-    }
+    if (!port)
+        throw err(new ErrnoError(Errno.EINVAL, 'Can not make an RPC request without a port'));
     return new Promise((resolve, reject) => {
         const id = Math.random().toString(16).slice(10);
         executors.set(id, { resolve, reject, fs });
         port.postMessage({ ...request, _zenfs: true, id, stack });
         const _ = setTimeout(() => {
-            const error = new ErrnoError(Errno.EIO, 'RPC Failed', typeof request.args[0] == 'string' ? request.args[0] : '', request.method);
+            const error = err(new ErrnoError(Errno.EIO, 'RPC Failed', typeof request.args[0] == 'string' ? request.args[0] : '', request.method), {
+                fs,
+            });
             error.stack += stack;
             reject(error);
             if (typeof _ == 'object')
@@ -34,7 +36,7 @@ export function handleResponse(response) {
     }
     const { id, value, error, stack } = response;
     if (!executors.has(id)) {
-        const error = new ErrnoError(Errno.EIO, 'Invalid RPC id:' + id);
+        const error = err(new ErrnoError(Errno.EIO, 'Invalid RPC id:' + id));
         error.stack += stack;
         throw error;
     }
@@ -58,17 +60,17 @@ export function handleResponse(response) {
     return;
 }
 export function attach(port, handler) {
-    if (!port) {
-        throw ErrnoError.With('EINVAL');
-    }
+    if (!port)
+        throw err(new ErrnoError(Errno.EINVAL, 'Cannot attach to non-existent port'));
+    info('Attached handler to port: ' + handler.name);
     port['on' in port ? 'on' : 'addEventListener']('message', (message) => {
         handler('data' in message ? message.data : message);
     });
 }
 export function detach(port, handler) {
-    if (!port) {
-        throw ErrnoError.With('EINVAL');
-    }
+    if (!port)
+        throw err(new ErrnoError(Errno.EINVAL, 'Cannot detach from non-existent port'));
+    info('Detached handler from port: ' + handler.name);
     port['off' in port ? 'off' : 'removeEventListener']('message', (message) => {
         handler('data' in message ? message.data : message);
     });

package/dist/backends/store/fs.d.ts

@@ -1,10 +1,10 @@
-import type { File } from '../../file.js';
-import type { CreationOptions, FileSystemMetadata, PureCreationOptions } from '../../filesystem.js';
-import { FileSystem } from '../../filesystem.js';
-import type { FileType, Stats } from '../../stats.js';
-import { Index } from './file_index.js';
-import { Inode, type InodeLike } from './inode.js';
-import type { Store, Transaction } from './store.js';
+import type { File } from '../../internal/file.js';
+import { Index } from '../../internal/file_index.js';
+import type { CreationOptions, PureCreationOptions } from '../../internal/filesystem.js';
+import { FileSystem } from '../../internal/filesystem.js';
+import { Inode, type InodeLike } from '../../internal/inode.js';
+import type { Stats } from '../../stats.js';
+import { WrappedTransaction, type Store } from './store.js';
 /**
  * A file system which uses a key-value store.
  *
@@ -16,10 +16,35 @@ import type { Store, Transaction } from './store.js';
  */
 export declare class StoreFS<T extends Store = Store> extends FileSystem {
     protected readonly store: T;
+    /**
+     * A map of paths to inode IDs
+     * @internal @hidden
+     */
+    readonly _ids: Map<string, number>;
+    /**
+     * A map of inode IDs to paths
+     * @internal @hidden
+     */
+    readonly _paths: Map<number, Set<string>>;
+    /**
+     * Gets the first path associated with an inode
+     */
+    _path(id: number): string | undefined;
+    /**
+     * Add a inode/path pair
+     */
+    _add(ino: number, path: string): void;
+    /**
+     * Remove a inode/path pair
+     */
+    _remove(ino: number): void;
+    /**
+     * Move paths in the tables
+     */
+    _move(from: string, to: string): void;
     protected _initialized: boolean;
     ready(): Promise<void>;
     constructor(store: T);
-    metadata(): FileSystemMetadata;
     /**
      * Delete all contents stored in the file system.
      * @deprecated
@@ -77,6 +102,11 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, data: Uint8Array, offset: number): Promise<void>;
     writeSync(path: string, data: Uint8Array, offset: number): void;
+    /**
+     * Wraps a transaction
+     * @internal @hidden
+     */
+    transaction(): WrappedTransaction;
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
@@ -86,75 +116,56 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
      */
     checkRootSync(): void;
     /**
-     * Helper function for findINode.
-     * @param parent The parent directory of the file we are attempting to find.
-     * @param filename The filename of the inode we are attempting to find, minus
-     *   the parent.
+     * Populates the `_ids` and `_paths` maps with all existing files stored in the underlying `Store`.
      */
-    private _findInode;
-    /**
-     * Helper function for findINode.
-     * @param parent The parent directory of the file we are attempting to find.
-     * @param filename The filename of the inode we are attempting to find, minus
-     *   the parent.
-     * @return string The ID of the file's inode in the file system.
-     */
-    private _findInodeSync;
+    private _populate;
     /**
      * Finds the Inode of `path`.
      * @param path The path to look up.
      * @todo memoize/cache
      */
-    private findInode;
+    protected findInode(tx: WrappedTransaction, path: string, syscall: string): Promise<Inode>;
     /**
      * Finds the Inode of `path`.
      * @param path The path to look up.
      * @return The Inode of the path p.
      * @todo memoize/cache
      */
-    protected findInodeSync(tx: Transaction, path: string, syscall: string, visited?: Set<string>): Inode;
-    /**
-     * Adds a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random id.
-     */
-    protected allocNew(tx: Transaction, path: string, syscall: string): Promise<number>;
+    protected findInodeSync(tx: WrappedTransaction, path: string, syscall: string): Inode;
+    private _lastID?;
     /**
-     * Creates a new node under a random ID. Retries before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random id.
-     * @return The ino that the data was stored under.
+     * Allocates a new ID and adds the ID/path
      */
-    protected allocNewSync(tx: Transaction, path: string, syscall: string): number;
+    protected allocNew(path: string, syscall: string): number;
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.
      * @param path The path to the new file.
-     * @param type The type of the new file.
-     * @param mode The mode to create the new file with.
+     * @param options The options to create the new file with.
      * @param data The data to store at the file's data node.
      */
-    protected commitNew(path: string, type: FileType, options: PureCreationOptions, data: Uint8Array, syscall: string): Promise<Inode>;
+    protected commitNew(path: string, options: PureCreationOptions, data: Uint8Array, syscall: string): Promise<Inode>;
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.
      * @param path The path to the new file.
-     * @param type The type of the new file.
-     * @param mode The mode to create the new file with.
+     * @param options The options to create the new file with.
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    protected commitNewSync(path: string, type: FileType, options: PureCreationOptions, data: Uint8Array, syscall: string): Inode;
+    protected commitNewSync(path: string, options: PureCreationOptions, data: Uint8Array, syscall: string): Inode;
     /**
      * Remove all traces of `path` from the file system.
      * @param path The path to remove from the file system.
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    protected remove(path: string, isDir: boolean, syscall: string): Promise<void>;
+    protected remove(path: string, isDir: boolean): Promise<void>;
     /**
      * Remove all traces of `path` from the file system.
      * @param path The path to remove from the file system.
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    protected removeSync(path: string, isDir: boolean, syscall: string): void;
+    protected removeSync(path: string, isDir: boolean): void;
 }