@zenfs/core 0.0.12 → 0.2.0

package/dist/backends/AsyncMirror.js

@@ -1,19 +1,8 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var _a;
-import { SynchronousFileSystem } from '../filesystem.js';
+import { SyncFileSystem } from '../filesystem.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { FileFlag, PreloadFile } from '../file.js';
 import { join } from '../emulation/path.js';
 import { Cred } from '../cred.js';
-import { CreateBackend } from './backend.js';
 /**
  * We define our own file to interpose on syncSync() for mirroring purposes.
  */
@@ -21,12 +10,18 @@ class MirrorFile extends PreloadFile {
     constructor(fs, path, flag, stat, data) {
         super(fs, path, flag, stat, data);
     }
+    async sync() {
+        this.syncSync();
+    }
     syncSync() {
         if (this.isDirty()) {
-            this._fs._syncSync(this);
+            this.fs.syncSync(this.path, this._buffer, this.stats);
             this.resetDirty();
         }
     }
+    async close() {
+        this.closeSync();
+    }
     closeSync() {
         this.syncSync();
     }
@@ -43,38 +38,11 @@ class MirrorFile extends PreloadFile {
  * The two stores will be kept in sync. The most common use-case is to pair a synchronous
  * in-memory filesystem with an asynchronous backing store.
  *
- * Example: Mirroring an IndexedDB file system to an in memory file system. Now, you can use
- * IndexedDB synchronously.
- *
- * ```javascript
- * ZenFS.configure({
- *   fs: "AsyncMirror",
- *   options: {
- *     sync: { fs: "InMemory" },
- *     async: { fs: "IndexedDB" }
- *   }
- * }, function(e) {
- *   // ZenFS is initialized and ready-to-use!
- * });
- * ```
- *
- * Or, alternatively:
- *
- * ```javascript
- * ZenFS.Backend.IndexedDB.Create(function(e, idbfs) {
- *   ZenFS.Backend.InMemory.Create(function(e, inMemory) {
- *     ZenFS.Backend.AsyncMirror({
- *       sync: inMemory, async: idbfs
- *     }, function(e, mirrored) {
- *       ZenFS.initialize(mirrored);
- *     });
- *   });
- * });
- * ```
  */
-export class AsyncMirror extends SynchronousFileSystem {
-    static isAvailable() {
-        return true;
+export class AsyncMirrorFS extends SyncFileSystem {
+    async ready() {
+        await this._ready;
+        return this;
     }
     /**
      *
@@ -91,25 +59,58 @@ export class AsyncMirror extends SynchronousFileSystem {
         this._queue = [];
         this._queueRunning = false;
         this._isInitialized = false;
-        this._initializeCallbacks = [];
         this._sync = sync;
         this._async = async;
         this._ready = this._initialize();
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: AsyncMirror.Name, synchronous: true, supportsProperties: this._sync.metadata.supportsProperties && this._async.metadata.supportsProperties });
+        return {
+            ...super.metadata,
+            name: AsyncMirrorFS.name,
+            synchronous: true,
+            supportsProperties: this._sync.metadata.supportsProperties && this._async.metadata.supportsProperties,
+        };
     }
-    _syncSync(fd) {
-        const stats = fd.getStats();
-        this._sync.writeFileSync(fd.getPath(), fd.getBuffer(), FileFlag.getFileFlag('w'), stats.mode, stats.getCred(0, 0));
-        this.enqueueOp({
+    /*public _syncSync(file: PreloadFile<AsyncMirror>, cred: Cred) {
+        const sync = this._sync.openFileSync(file.path, FileFlag.FromString('w'), cred);
+        sync.writeSync(file.buffer);
+
+        this.enqueue({
             apiMethod: 'writeFile',
-            arguments: [fd.getPath(), fd.getBuffer(), fd.getFlag(), stats.mode, stats.getCred(0, 0)],
+            arguments: [file.path, file.buffer, file.flag, file.stats.mode, cred],
+        });
+    }*/
+    syncSync(path, data, stats) {
+        this._sync.syncSync(path, data, stats);
+        this.enqueue({
+            apiMethod: 'sync',
+            arguments: [path, data, stats],
+        });
+    }
+    openFileSync(path, flag, cred) {
+        return this._sync.openFileSync(path, flag, cred);
+    }
+    createFileSync(path, flag, mode, cred) {
+        const file = this._sync.createFileSync(path, flag, mode, cred);
+        this.enqueue({
+            apiMethod: 'createFile',
+            arguments: [path, flag, mode, cred],
+        });
+        const stats = file.statSync();
+        const buffer = new Uint8Array(stats.size);
+        file.readSync(buffer);
+        return new MirrorFile(this, path, flag, stats, buffer);
+    }
+    linkSync(srcpath, dstpath, cred) {
+        this._sync.linkSync(srcpath, dstpath, cred);
+        this.enqueue({
+            apiMethod: 'link',
+            arguments: [srcpath, dstpath, cred],
         });
     }
     renameSync(oldPath, newPath, cred) {
         this._sync.renameSync(oldPath, newPath, cred);
-        this.enqueueOp({
+        this.enqueue({
             apiMethod: 'rename',
             arguments: [oldPath, newPath, cred],
         });
@@ -117,29 +118,23 @@ export class AsyncMirror extends SynchronousFileSystem {
     statSync(p, cred) {
         return this._sync.statSync(p, cred);
     }
-    openSync(p, flag, mode, cred) {
-        // Sanity check: Is this open/close permitted?
-        const fd = this._sync.openSync(p, flag, mode, cred);
-        fd.closeSync();
-        return new MirrorFile(this, p, flag, this._sync.statSync(p, cred), this._sync.readFileSync(p, FileFlag.getFileFlag('r'), cred));
-    }
     unlinkSync(p, cred) {
         this._sync.unlinkSync(p, cred);
-        this.enqueueOp({
+        this.enqueue({
             apiMethod: 'unlink',
             arguments: [p, cred],
         });
     }
     rmdirSync(p, cred) {
         this._sync.rmdirSync(p, cred);
-        this.enqueueOp({
+        this.enqueue({
             apiMethod: 'rmdir',
             arguments: [p, cred],
         });
     }
     mkdirSync(p, mode, cred) {
         this._sync.mkdirSync(p, mode, cred);
-        this.enqueueOp({
+        this.enqueue({
             apiMethod: 'mkdir',
             arguments: [p, mode, cred],
         });
@@ -150,103 +145,115 @@ export class AsyncMirror extends SynchronousFileSystem {
     existsSync(p, cred) {
         return this._sync.existsSync(p, cred);
     }
-    chmodSync(p, mode, cred) {
-        this._sync.chmodSync(p, mode, cred);
-        this.enqueueOp({
-            apiMethod: 'chmod',
-            arguments: [p, mode, cred],
-        });
+    /**
+     * @internal
+     */
+    async crossCopyDirectory(p, mode) {
+        if (p !== '/') {
+            const stats = await this._async.stat(p, Cred.Root);
+            this._sync.mkdirSync(p, mode, stats.getCred());
+        }
+        const files = await this._async.readdir(p, Cred.Root);
+        for (const file of files) {
+            await this.crossCopy(join(p, file));
+        }
     }
-    chownSync(p, new_uid, new_gid, cred) {
-        this._sync.chownSync(p, new_uid, new_gid, cred);
-        this.enqueueOp({
-            apiMethod: 'chown',
-            arguments: [p, new_uid, new_gid, cred],
-        });
+    /**
+     * @internal
+     */
+    async crossCopyFile(p, mode) {
+        const asyncFile = await this._async.openFile(p, FileFlag.FromString('r'), Cred.Root);
+        const syncFile = this._sync.createFileSync(p, FileFlag.FromString('w'), mode, Cred.Root);
+        try {
+            const { size } = await asyncFile.stat();
+            const buffer = new Uint8Array(size);
+            await asyncFile.read(buffer);
+            syncFile.writeSync(buffer);
+        }
+        finally {
+            await asyncFile.close();
+            syncFile.closeSync();
+        }
     }
-    utimesSync(p, atime, mtime, cred) {
-        this._sync.utimesSync(p, atime, mtime, cred);
-        this.enqueueOp({
-            apiMethod: 'utimes',
-            arguments: [p, atime, mtime, cred],
-        });
+    /**
+     * @internal
+     */
+    async crossCopy(p) {
+        const stats = await this._async.stat(p, Cred.Root);
+        if (stats.isDirectory()) {
+            await this.crossCopyDirectory(p, stats.mode);
+        }
+        else {
+            await this.crossCopyFile(p, stats.mode);
+        }
     }
     /**
      * Called once to load up files from async storage into sync storage.
      */
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._isInitialized) {
-                // First call triggers initialization, the rest wait.
-                const copyDirectory = (p, mode) => __awaiter(this, void 0, void 0, function* () {
-                    if (p !== '/') {
-                        const stats = yield this._async.stat(p, Cred.Root);
-                        this._sync.mkdirSync(p, mode, stats.getCred());
-                    }
-                    const files = yield this._async.readdir(p, Cred.Root);
-                    for (const file of files) {
-                        yield copyItem(join(p, file));
-                    }
-                }), copyFile = (p, mode) => __awaiter(this, void 0, void 0, function* () {
-                    const data = yield this._async.readFile(p, FileFlag.getFileFlag('r'), Cred.Root);
-                    this._sync.writeFileSync(p, data, FileFlag.getFileFlag('w'), mode, Cred.Root);
-                }), copyItem = (p) => __awaiter(this, void 0, void 0, function* () {
-                    const stats = yield this._async.stat(p, Cred.Root);
-                    if (stats.isDirectory()) {
-                        yield copyDirectory(p, stats.mode);
-                    }
-                    else {
-                        yield copyFile(p, stats.mode);
-                    }
-                });
-                try {
-                    yield copyDirectory('/', 0);
-                    this._isInitialized = true;
-                }
-                catch (e) {
-                    this._isInitialized = false;
-                    throw e;
-                }
-            }
-            return this;
-        });
+    async _initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        try {
+            await this.crossCopy('/');
+            this._isInitialized = true;
+        }
+        catch (e) {
+            this._isInitialized = false;
+            throw e;
+        }
     }
-    enqueueOp(op) {
+    /**
+     * @internal
+     */
+    async _next() {
+        if (this._queue.length == 0) {
+            this._queueRunning = false;
+            return;
+        }
+        const op = this._queue.shift();
+        try {
+            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
+            await this._async[op.apiMethod](...op.arguments);
+        }
+        catch (e) {
+            throw new ApiError(ErrorCode.EIO, 'AsyncMirror desync: ' + e);
+        }
+        await this._next();
+    }
+    /**
+     * @internal
+     */
+    enqueue(op) {
         this._queue.push(op);
-        if (!this._queueRunning) {
-            this._queueRunning = true;
-            const doNextOp = (err) => {
-                if (err) {
-                    throw new Error(`WARNING: File system has desynchronized. Received following error: ${err}\n$`);
-                }
-                if (this._queue.length > 0) {
-                    const op = this._queue.shift();
-                    op.arguments.push(doNextOp);
-                    this._async[op.apiMethod].apply(this._async, op.arguments);
-                }
-                else {
-                    this._queueRunning = false;
-                }
-            };
-            doNextOp();
+        if (this._queueRunning) {
+            return;
         }
+        this._queueRunning = true;
+        this._next();
     }
 }
-_a = AsyncMirror;
-AsyncMirror.Name = 'AsyncMirror';
-AsyncMirror.Create = CreateBackend.bind(_a);
-AsyncMirror.Options = {
-    sync: {
-        type: 'object',
-        description: 'The synchronous file system to mirror the asynchronous file system to.',
-        validator: (v) => __awaiter(void 0, void 0, void 0, function* () {
-            if (!(v === null || v === void 0 ? void 0 : v.metadata.synchronous)) {
-                throw new ApiError(ErrorCode.EINVAL, `'sync' option must be a file system that supports synchronous operations`);
-            }
-        }),
+export const AsyncMirror = {
+    name: 'AsyncMirror',
+    options: {
+        sync: {
+            type: 'object',
+            description: 'The synchronous file system to mirror the asynchronous file system to.',
+            validator: async (v) => {
+                if (!v?.metadata.synchronous) {
+                    throw new ApiError(ErrorCode.EINVAL, `'sync' option must be a file system that supports synchronous operations`);
+                }
+            },
+        },
+        async: {
+            type: 'object',
+            description: 'The asynchronous file system to mirror.',
+        },
+    },
+    isAvailable() {
+        return true;
     },
-    async: {
-        type: 'object',
-        description: 'The asynchronous file system to mirror.',
+    create(options) {
+        return new AsyncMirrorFS(options);
     },
 };

package/dist/backends/AsyncStore.d.ts

@@ -1,15 +1,16 @@
 import { Cred } from '../cred.js';
 import { PreloadFile, File, FileFlag } from '../file.js';
-import { BaseFileSystem } from '../filesystem.js';
+import { AsyncFileSystem } from '../filesystem.js';
+import { type Ino } from '../inode.js';
 import { Stats } from '../stats.js';
 /**
  * Represents an *asynchronous* key-value store.
  */
-export interface AsyncKeyValueStore {
+export interface AsyncStore {
     /**
      * The name of the key-value store.
      */
-    name(): string;
+    name: string;
     /**
      * Empties the key-value store completely.
      */
@@ -17,27 +18,27 @@ export interface AsyncKeyValueStore {
     /**
      * Begins a read-write transaction.
      */
-    beginTransaction(type: 'readwrite'): AsyncKeyValueRWTransaction;
+    beginTransaction(type: 'readwrite'): AsyncRWTransaction;
     /**
      * Begins a read-only transaction.
      */
-    beginTransaction(type: 'readonly'): AsyncKeyValueROTransaction;
-    beginTransaction(type: string): AsyncKeyValueROTransaction;
+    beginTransaction(type: 'readonly'): AsyncROTransaction;
+    beginTransaction(type: string): AsyncROTransaction;
 }
 /**
  * Represents an asynchronous read-only transaction.
  */
-export interface AsyncKeyValueROTransaction {
+export interface AsyncROTransaction {
     /**
      * Retrieves the data at the given key.
      * @param key The key to look under for data.
      */
-    get(key: string): Promise<Uint8Array>;
+    get(key: Ino): Promise<Uint8Array>;
 }
 /**
  * Represents an asynchronous read-write transaction.
  */
-export interface AsyncKeyValueRWTransaction extends AsyncKeyValueROTransaction {
+export interface AsyncRWTransaction extends AsyncROTransaction {
     /**
      * Adds the data to the store under the given key. Overwrites any existing
      * data.
@@ -46,12 +47,12 @@ export interface AsyncKeyValueRWTransaction extends AsyncKeyValueROTransaction {
      * @param overwrite If 'true', overwrite any existing data. If 'false',
      *   avoids writing the data if the key exists.
      */
-    put(key: string, data: Uint8Array, overwrite: boolean): Promise<boolean>;
+    put(key: Ino, data: Uint8Array, overwrite: boolean): Promise<boolean>;
     /**
      * Deletes the data at the given key.
      * @param key The key to delete from the store.
      */
-    del(key: string): Promise<void>;
+    remove(key: Ino): Promise<void>;
     /**
      * Commits the transaction.
      */
@@ -61,35 +62,32 @@ export interface AsyncKeyValueRWTransaction extends AsyncKeyValueROTransaction {
      */
     abort(): Promise<void>;
 }
-export declare class AsyncKeyValueFile extends PreloadFile<AsyncKeyValueFileSystem> implements File {
-    constructor(_fs: AsyncKeyValueFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+export declare class AsyncFile extends PreloadFile<AsyncStoreFileSystem> {
+    constructor(_fs: AsyncStoreFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
+    syncSync(): void;
     close(): Promise<void>;
+    closeSync(): void;
 }
 /**
  * An "Asynchronous key-value file system". Stores data to/retrieves data from
  * an underlying asynchronous key-value store.
  */
-export declare class AsyncKeyValueFileSystem extends BaseFileSystem {
-    static isAvailable(): boolean;
-    protected store: AsyncKeyValueStore;
-    private _cache;
+export declare class AsyncStoreFileSystem extends AsyncFileSystem {
+    protected store: AsyncStore;
+    private _cache?;
+    protected _ready: Promise<this>;
+    ready(): Promise<this>;
     constructor(cacheSize: number);
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    init(store: AsyncKeyValueStore): Promise<void>;
-    getName(): string;
-    isReadOnly(): boolean;
-    supportsSymlinks(): boolean;
-    supportsProps(): boolean;
-    supportsSynch(): boolean;
+    init(store: AsyncStore): Promise<void>;
     /**
      * Delete all contents stored in the file system.
      */
     empty(): Promise<void>;
-    access(p: string, mode: number, cred: Cred): Promise<void>;
     /**
      * @todo Make rename compatible with the cache.
      */
@@ -101,9 +99,12 @@ export declare class AsyncKeyValueFileSystem extends BaseFileSystem {
     rmdir(p: string, cred: Cred): Promise<void>;
     mkdir(p: string, mode: number, cred: Cred): Promise<void>;
     readdir(p: string, cred: Cred): Promise<string[]>;
-    chmod(p: string, mode: number, cred: Cred): Promise<void>;
-    chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
-    _sync(p: string, data: Uint8Array, stats: Stats): Promise<void>;
+    /**
+     * Updated the inode and data node at the given path
+     * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
+     */
+    sync(p: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    link(existing: string, newpath: string, cred: Cred): Promise<void>;
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
@@ -135,7 +136,7 @@ export declare class AsyncKeyValueFileSystem extends BaseFileSystem {
     private getDirListing;
     /**
      * Adds a new node under a random ID. Retries 5 times before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random GUID.
+     * the exceedingly unlikely chance that we try to reuse a random ino.
      */
     private addNewNode;
     /**