@zenfs/core 0.16.0 → 0.16.2

package/dist/backends/fetch.js

@@ -1,20 +1,21 @@
 import { Errno, ErrnoError } from '../error.js';
 import { IndexFS } from './index/fs.js';
 async function fetchFile(path, type) {
-    const response = await fetch(path).catch(e => {
+    const response = await fetch(path).catch((e) => {
         throw new ErrnoError(Errno.EIO, e.message);
     });
     if (!response.ok) {
         throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status);
     }
     switch (type) {
-        case 'buffer':
-            const arrayBuffer = await response.arrayBuffer().catch(e => {
+        case 'buffer': {
+            const arrayBuffer = await response.arrayBuffer().catch((e) => {
                 throw new ErrnoError(Errno.EIO, e.message);
             });
             return new Uint8Array(arrayBuffer);
+        }
         case 'json':
-            return response.json().catch(e => {
+            return response.json().catch((e) => {
                 throw new ErrnoError(Errno.EIO, e.message);
             });
         default:

package/dist/backends/index/fs.js

@@ -30,8 +30,8 @@ export class IndexFS extends Readonly(FileSystem) {
             stats.fileData = this.getDataSync(path, stats);
         }
     }
-    async stat(path) {
-        return this.statSync(path);
+    stat(path) {
+        return Promise.resolve(this.statSync(path));
     }
     statSync(path) {
         if (!this.index.has(path)) {
@@ -69,8 +69,8 @@ export class IndexFS extends Readonly(FileSystem) {
         }
         return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : this.getDataSync(path, stats));
     }
-    async readdir(path) {
-        return this.readdirSync(path);
+    readdir(path) {
+        return Promise.resolve(this.readdirSync(path));
     }
     readdirSync(path) {
         // Check if it exists.
@@ -81,6 +81,13 @@ export class IndexFS extends Readonly(FileSystem) {
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', path, 'readdir');
         }
-        return JSON.parse(decode(stats.fileData));
+        const content = JSON.parse(decode(stats.fileData));
+        if (!Array.isArray(content)) {
+            throw ErrnoError.With('ENODATA', path, 'readdir');
+        }
+        if (!content.every(item => typeof item == 'string')) {
+            throw ErrnoError.With('ENODATA', path, 'readdir');
+        }
+        return content;
     }
 }

package/dist/backends/overlay.d.ts

@@ -47,7 +47,7 @@ export declare class UnlockedOverlayFS extends FileSystem {
      */
     _initialize(): Promise<void>;
     getDeletionLog(): string;
-    restoreDeletionLog(log: string, cred: Cred): void;
+    restoreDeletionLog(log: string, cred: Cred): Promise<void>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     stat(path: string, cred: Cred): Promise<Stats>;

package/dist/backends/overlay.js

@@ -92,10 +92,10 @@ export class UnlockedOverlayFS extends FileSystem {
     getDeletionLog() {
         return this._deleteLog;
     }
-    restoreDeletionLog(log, cred) {
+    async restoreDeletionLog(log, cred) {
         this._deleteLog = log;
         this._reparseDeletionLog();
-        this.updateLog('', cred);
+        await this.updateLog('', cred);
     }
     async rename(oldPath, newPath, cred) {
         this.checkInitialized();
@@ -203,7 +203,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         // if it still exists add to the delete log
         if (await this.exists(path, cred)) {
-            this.deletePath(path, cred);
+            await this.deletePath(path, cred);
         }
     }
     unlinkSync(path, cred) {
@@ -217,7 +217,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         // if it still exists add to the delete log
         if (this.existsSync(path, cred)) {
-            this.deletePath(path, cred);
+            void this.deletePath(path, cred);
         }
     }
     async rmdir(path, cred) {
@@ -234,7 +234,7 @@ export class UnlockedOverlayFS extends FileSystem {
                 throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                this.deletePath(path, cred);
+                await this.deletePath(path, cred);
             }
         }
     }
@@ -252,7 +252,7 @@ export class UnlockedOverlayFS extends FileSystem {
                 throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
             }
             else {
-                this.deletePath(path, cred);
+                void this.deletePath(path, cred);
             }
         }
     }
@@ -328,9 +328,9 @@ export class UnlockedOverlayFS extends FileSystem {
             return result;
         });
     }
-    deletePath(path, cred) {
+    async deletePath(path, cred) {
         this._deletedFiles.add(path);
-        this.updateLog(`d${path}\n`, cred);
+        await this.updateLog(`d${path}\n`, cred);
     }
     async updateLog(addition, cred) {
         this._deleteLog += addition;
@@ -344,7 +344,7 @@ export class UnlockedOverlayFS extends FileSystem {
             await log.write(encode(this._deleteLog));
             if (this._deleteLogUpdateNeeded) {
                 this._deleteLogUpdateNeeded = false;
-                this.updateLog('', cred);
+                await this.updateLog('', cred);
             }
         }
         catch (e) {

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

@@ -6,9 +6,17 @@ import type { Cred } from '../../cred.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
+import { type MountConfiguration } from '../../config.js';
 type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
 type FileMethod = keyof FileMethods;
+interface FileRequest<TMethod extends FileMethod = FileMethod> extends RPC.Request {
+    fd: number;
+    scope: 'file';
+    method: TMethod;
+    args: Parameters<FileMethods[TMethod]>;
+}
 export declare class PortFile extends File {
     readonly fs: PortFS;
     readonly fd: number;
@@ -40,6 +48,11 @@ export declare class PortFile extends File {
 }
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
+interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
+    scope: 'fs';
+    method: TMethod;
+    args: Parameters<FSMethods[TMethod]>;
+}
 declare const PortFS_base: import("../../filesystem.js").Mixin<typeof FileSystem, {
     _sync?: FileSystem | undefined;
     queueDone(): Promise<void>;
@@ -88,6 +101,14 @@ export declare class PortFS extends PortFS_base {
     exists(path: string, cred: Cred): Promise<boolean>;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
 }
+/**
+ * @internal
+ */
+export type FileOrFSRequest = FSRequest | FileRequest;
+/**
+ * @internal
+ */
+export declare function handleRequest(port: RPC.Port, fs: FileSystem, request: FileOrFSRequest): Promise<void>;
 export declare function attachFS(port: RPC.Port, fs: FileSystem): void;
 export declare function detachFS(port: RPC.Port, fs: FileSystem): void;
 export declare const Port: {
@@ -108,4 +129,5 @@ export declare const Port: {
     isAvailable(): Promise<boolean>;
     create(options: RPC.Options): PortFS;
 };
+export declare function resolveRemoteMount<T extends Backend>(port: RPC.Port, config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 export {};

package/dist/backends/port/fs.js

@@ -4,6 +4,7 @@ import { Async, FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
 import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
+import { resolveMountConfig } from '../../config.js';
 export class PortFile extends File {
     constructor(fs, fd, path, position) {
         super();
@@ -159,7 +160,10 @@ export class PortFS extends Async(FileSystem) {
 }
 let nextFd = 0;
 const descriptors = new Map();
-async function handleRequest(port, fs, request) {
+/**
+ * @internal
+ */
+export async function handleRequest(port, fs, request) {
     if (!RPC.isMessage(request)) {
         return;
     }
@@ -233,3 +237,10 @@ export const Port = {
         return new PortFS(options);
     },
 };
+export async function resolveRemoteMount(port, config, _depth = 0) {
+    const stopAndReplay = RPC.catchMessages(port);
+    const fs = await resolveMountConfig(config, _depth);
+    attachFS(port, fs);
+    stopAndReplay(fs);
+    return fs;
+}

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

@@ -1,5 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { type ErrnoErrorJSON } from '../../error.js';
+import type { Backend, FilesystemOf } from '../backend.js';
 import { type PortFS } from './fs.js';
 type _MessageEvent<T = any> = T | {
     data: T;
@@ -62,3 +63,4 @@ export declare function request<const TRequest extends Request, TValue>(request:
 export declare function handleResponse<const TResponse extends Response>(response: TResponse): void;
 export declare function attach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
 export declare function detach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
+export declare function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => void;

package/dist/backends/port/rpc.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Errno, ErrnoError } from '../../error.js';
-import { PortFile } from './fs.js';
+import { handleRequest, PortFile } from './fs.js';
 function isFileData(value) {
     return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
 }
@@ -72,3 +72,15 @@ export function detach(port, handler) {
         handler('data' in message ? message.data : message);
     });
 }
+export function catchMessages(port) {
+    const events = [];
+    const handler = events.push.bind(events);
+    attach(port, handler);
+    return function (fs) {
+        detach(port, handler);
+        for (const event of events) {
+            const request = 'data' in event ? event.data : event;
+            void handleRequest(port, fs, request);
+        }
+    };
+}

package/dist/backends/store/fs.js

@@ -598,7 +598,7 @@ export class StoreFS extends FileSystem {
             return inode;
         }
         catch (e) {
-            tx.abort();
+            await tx.abort();
             throw e;
         }
     }