@zenfs/core 0.9.4 → 0.9.6

package/dist/backends/AsyncStore.d.ts

@@ -3,6 +3,18 @@ import { PreloadFile } from '../file.js';
 import { FileSystem, type FileSystemMetadata } from '../filesystem.js';
 import { type Ino } from '../inode.js';
 import { type Stats } from '../stats.js';
+/**
+ * Last Recently Used cache
+ */
+declare class LRUCache<K, V> {
+    readonly limit: number;
+    private cache;
+    constructor(limit: number);
+    set(key: K, value: V): void;
+    get(key: K): V | null;
+    remove(key: K): void;
+    reset(): void;
+}
 /**
  * Represents an asynchronous key-value store.
  */
@@ -68,6 +80,7 @@ export interface AsyncStoreOptions {
 }
 declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
     _sync: FileSystem;
+    queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
     ready(): Promise<any>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
@@ -101,7 +114,8 @@ declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
 export declare class AsyncStoreFS extends AsyncStoreFS_base {
     protected _options: AsyncStoreOptions;
     protected store: AsyncStore;
-    private _cache?;
+    protected _cache?: LRUCache<string, Ino>;
+    private _initialized;
     _sync: FileSystem;
     ready(): Promise<this>;
     metadata(): FileSystemMetadata;

package/dist/backends/AsyncStore.js

@@ -52,6 +52,10 @@ class LRUCache {
  */
 export class AsyncStoreFS extends Async(FileSystem) {
     async ready() {
+        if (this._initialized) {
+            return this;
+        }
+        this._initialized = true;
         if (this._options.lruCacheSize > 0) {
             this._cache = new LRUCache(this._options.lruCacheSize);
         }
@@ -70,6 +74,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
     constructor(_options) {
         super();
         this._options = _options;
+        this._initialized = false;
     }
     /**
      * Delete all contents stored in the file system.
@@ -79,13 +84,14 @@ export class AsyncStoreFS extends Async(FileSystem) {
             this._cache.reset();
         }
         await this.store.clear();
-        // INVARIANT: Root always exists.
+        // Root always exists.
         await this.makeRootDirectory();
     }
     /**
      * @todo Make rename compatible with the cache.
      */
     async rename(oldPath, newPath, cred) {
+        await this.queueDone();
         const c = this._cache;
         if (this._cache) {
             // Clear and disable cache during renaming process.
@@ -160,6 +166,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
         }
     }
     async stat(p, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction();
         const inode = await this.findINode(tx, p);
         if (!inode) {
@@ -172,11 +179,13 @@ export class AsyncStoreFS extends Async(FileSystem) {
         return stats;
     }
     async createFile(p, flag, mode, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction(), data = new Uint8Array(0), newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
         // Open the file.
         return new PreloadFile(this, p, flag, newFile.toStats(), data);
     }
     async openFile(p, flag, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction(), node = await this.findINode(tx, p), data = await tx.get(node.ino);
         if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
             throw ApiError.With('EACCES', p, 'openFile');
@@ -187,9 +196,11 @@ export class AsyncStoreFS extends Async(FileSystem) {
         return new PreloadFile(this, p, flag, node.toStats(), data);
     }
     async unlink(p, cred) {
+        await this.queueDone();
         return this.removeEntry(p, false, cred);
     }
     async rmdir(p, cred) {
+        await this.queueDone();
         // Check first if directory is empty.
         const list = await this.readdir(p, cred);
         if (list.length > 0) {
@@ -198,10 +209,12 @@ export class AsyncStoreFS extends Async(FileSystem) {
         await this.removeEntry(p, true, cred);
     }
     async mkdir(p, mode, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction(), data = encode('{}');
         await this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
     }
     async readdir(p, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction();
         const node = await this.findINode(tx, p);
         if (!node.toStats().hasAccess(R_OK, cred)) {
@@ -214,6 +227,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
      * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
      */
     async sync(p, data, stats) {
+        await this.queueDone();
         const tx = this.store.beginTransaction(), 
         // We use the _findInode helper because we actually need the INode id.
         fileInodeId = await this._findINode(tx, dirname(p), basename(p)), fileInode = await this.getINode(tx, fileInodeId, p), inodeChanged = fileInode.update(stats);
@@ -232,6 +246,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
         await tx.commit();
     }
     async link(existing, newpath, cred) {
+        await this.queueDone();
         const tx = this.store.beginTransaction(), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
         if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
             throw ApiError.With('EACCES', existingDir, 'link');
@@ -262,14 +277,13 @@ export class AsyncStoreFS extends Async(FileSystem) {
      */
     async makeRootDirectory() {
         const tx = this.store.beginTransaction();
-        if ((await tx.get(rootIno)) === undefined) {
+        if (!(await tx.get(rootIno))) {
             // Create new inode. o777, owned by root:root
-            const dirInode = new Inode();
-            dirInode.mode = 0o777 | FileType.DIRECTORY;
-            // If the root doesn't exist, the first random ID shouldn't exist,
-            // either.
-            await tx.put(dirInode.ino, encode('{}'), false);
-            await tx.put(rootIno, dirInode.data, false);
+            const inode = new Inode();
+            inode.mode = 0o777 | FileType.DIRECTORY;
+            // If the root doesn't exist, the first random ID shouldn't exist either.
+            await tx.put(inode.ino, encode('{}'), false);
+            await tx.put(rootIno, inode.data, false);
             await tx.commit();
         }
     }