@zenfs/core 0.1.0 → 0.2.1

package/dist/backends/AsyncStore.js

@@ -1,104 +1,50 @@
 import { dirname, basename, join, resolve } from '../emulation/path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { W_OK, R_OK } from '../emulation/constants.js';
-import { PreloadFile, FileFlag } from '../file.js';
-import { BaseFileSystem } from '../filesystem.js';
-import Inode from '../inode.js';
+import { PreloadFile } from '../file.js';
+import { AsyncFileSystem } from '../filesystem.js';
+import { randomIno, Inode } from '../inode.js';
 import { FileType } from '../stats.js';
-import { ROOT_NODE_ID, randomUUID, encode, decode } from '../utils.js';
-class LRUNode {
-    constructor(key, value) {
-        this.key = key;
-        this.value = value;
-        this.prev = null;
-        this.next = null;
-    }
-}
-// Adapted from https://chrisrng.svbtle.com/lru-cache-in-javascript
+import { encode, decodeDirListing, encodeDirListing } from '../utils.js';
+import { rootIno } from '../inode.js';
+/**
+ * Last Recently Used cache
+ */
 class LRUCache {
     constructor(limit) {
         this.limit = limit;
-        this.size = 0;
-        this.map = {};
-        this.head = null;
-        this.tail = null;
+        this.cache = [];
     }
-    /**
-     * Change or add a new value in the cache
-     * We overwrite the entry if it already exists
-     */
     set(key, value) {
-        const node = new LRUNode(key, value);
-        if (this.map[key]) {
-            this.map[key].value = node.value;
-            this.remove(node.key);
+        const existingIndex = this.cache.findIndex(node => node.key === key);
+        if (existingIndex != -1) {
+            this.cache.splice(existingIndex, 1);
         }
-        else {
-            if (this.size >= this.limit) {
-                delete this.map[this.tail.key];
-                this.size--;
-                this.tail = this.tail.prev;
-                this.tail.next = null;
-            }
+        else if (this.cache.length >= this.limit) {
+            this.cache.shift();
         }
-        this.setHead(node);
+        this.cache.push({ key, value });
     }
-    /* Retrieve a single entry from the cache */
     get(key) {
-        if (this.map[key]) {
-            const value = this.map[key].value;
-            const node = new LRUNode(key, value);
-            this.remove(key);
-            this.setHead(node);
-            return value;
-        }
-        else {
-            return null;
-        }
-    }
-    /* Remove a single entry from the cache */
-    remove(key) {
-        const node = this.map[key];
+        const node = this.cache.find(n => n.key === key);
         if (!node) {
             return;
         }
-        if (node.prev !== null) {
-            node.prev.next = node.next;
-        }
-        else {
-            this.head = node.next;
-        }
-        if (node.next !== null) {
-            node.next.prev = node.prev;
-        }
-        else {
-            this.tail = node.prev;
-        }
-        delete this.map[key];
-        this.size--;
-    }
-    /* Resets the entire cache - Argument limit is optional to be reset */
-    removeAll() {
-        this.size = 0;
-        this.map = {};
-        this.head = null;
-        this.tail = null;
+        // Move the accessed item to the end of the cache (most recently used)
+        this.set(key, node.value);
+        return node.value;
     }
-    setHead(node) {
-        node.next = this.head;
-        node.prev = null;
-        if (this.head !== null) {
-            this.head.prev = node;
-        }
-        this.head = node;
-        if (this.tail === null) {
-            this.tail = node;
+    remove(key) {
+        const index = this.cache.findIndex(node => node.key === key);
+        if (index !== -1) {
+            this.cache.splice(index, 1);
         }
-        this.size++;
-        this.map[node.key] = node;
+    }
+    reset() {
+        this.cache = [];
     }
 }
-export class AsyncKeyValueFile extends PreloadFile {
+export class AsyncFile extends PreloadFile {
     constructor(_fs, _path, _flag, _stat, contents) {
         super(_fs, _path, _flag, _stat, contents);
     }
@@ -106,73 +52,55 @@ export class AsyncKeyValueFile extends PreloadFile {
         if (!this.isDirty()) {
             return;
         }
-        await this._fs._sync(this.getPath(), this.getBuffer(), this.getStats());
+        await this.fs.sync(this.path, this._buffer, this.stats);
         this.resetDirty();
     }
+    syncSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
     async close() {
         this.sync();
     }
+    closeSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
 }
 /**
  * An "Asynchronous key-value file system". Stores data to/retrieves data from
  * an underlying asynchronous key-value store.
  */
-export class AsyncKeyValueFileSystem extends BaseFileSystem {
-    static isAvailable() {
-        return true;
+export class AsyncStoreFileSystem extends AsyncFileSystem {
+    ready() {
+        return this._ready;
     }
-    constructor(cacheSize) {
+    constructor({ store, cacheSize }) {
         super();
-        this._cache = null;
         if (cacheSize > 0) {
             this._cache = new LRUCache(cacheSize);
         }
+        this._ready = this._initialize(store);
     }
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    async init(store) {
-        this.store = store;
+    async _initialize(store) {
+        this.store = await store;
         // INVARIANT: Ensure that the root exists.
         await this.makeRootDirectory();
-    }
-    getName() {
-        return this.store.name();
-    }
-    isReadOnly() {
-        return false;
-    }
-    supportsSymlinks() {
-        return false;
-    }
-    supportsProps() {
-        return true;
-    }
-    supportsSynch() {
-        return false;
+        return this;
     }
     /**
      * Delete all contents stored in the file system.
      */
     async empty() {
         if (this._cache) {
-            this._cache.removeAll();
+            this._cache.reset();
         }
         await this.store.clear();
         // INVARIANT: Root always exists.
         await this.makeRootDirectory();
     }
-    async access(p, mode, cred) {
-        const tx = this.store.beginTransaction('readonly');
-        const inode = await this.findINode(tx, p);
-        if (!inode) {
-            throw ApiError.ENOENT(p);
-        }
-        if (!inode.toStats().hasAccess(mode, cred)) {
-            throw ApiError.EACCES(p);
-        }
-    }
     /**
      * @todo Make rename compatible with the cache.
      */
@@ -181,12 +109,12 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
         if (this._cache) {
             // Clear and disable cache during renaming process.
             this._cache = null;
-            c.removeAll();
+            c.reset();
         }
         try {
             const tx = this.store.beginTransaction('readwrite'), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
             // Remove oldPath from parent's directory listing.
-            oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldParent, oldDirNode);
+            oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
             if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
                 throw ApiError.EACCES(oldPath);
             }
@@ -212,15 +140,15 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
             }
             else {
                 newDirNode = await this.findINode(tx, newParent);
-                newDirList = await this.getDirListing(tx, newParent, newDirNode);
+                newDirList = await this.getDirListing(tx, newDirNode, newParent);
             }
             if (newDirList[newName]) {
                 // If it's a file, delete it.
-                const newNameNode = await this.getINode(tx, newPath, newDirList[newName]);
-                if (newNameNode.isFile()) {
+                const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
+                if (newNameNode.toStats().isFile()) {
                     try {
-                        await tx.del(newNameNode.id);
-                        await tx.del(newDirList[newName]);
+                        await tx.remove(newNameNode.ino);
+                        await tx.remove(newDirList[newName]);
                     }
                     catch (e) {
                         await tx.abort();
@@ -235,8 +163,8 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
             newDirList[newName] = nodeId;
             // Commit the two changed directory listings.
             try {
-                await tx.put(oldDirNode.id, encode(JSON.stringify(oldDirList)), true);
-                await tx.put(newDirNode.id, encode(JSON.stringify(newDirList)), true);
+                await tx.put(oldDirNode.ino, encodeDirListing(oldDirList), true);
+                await tx.put(newDirNode.ino, encodeDirListing(newDirList), true);
             }
             catch (e) {
                 await tx.abort();
@@ -253,6 +181,9 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
     async stat(p, cred) {
         const tx = this.store.beginTransaction('readonly');
         const inode = await this.findINode(tx, p);
+        if (!inode) {
+            throw ApiError.ENOENT(p);
+        }
         const stats = inode.toStats();
         if (!stats.hasAccess(R_OK, cred)) {
             throw ApiError.EACCES(p);
@@ -262,17 +193,17 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
     async createFile(p, flag, mode, cred) {
         const tx = this.store.beginTransaction('readwrite'), data = new Uint8Array(0), newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
         // Open the file.
-        return new AsyncKeyValueFile(this, p, flag, newFile.toStats(), data);
+        return new AsyncFile(this, p, flag, newFile.toStats(), data);
     }
     async openFile(p, flag, cred) {
-        const tx = this.store.beginTransaction('readonly'), node = await this.findINode(tx, p), data = await tx.get(node.id);
-        if (!node.toStats().hasAccess(flag.getMode(), cred)) {
+        const tx = this.store.beginTransaction('readonly'), node = await this.findINode(tx, p), data = await tx.get(node.ino);
+        if (!node.toStats().hasAccess(flag.mode, cred)) {
             throw ApiError.EACCES(p);
         }
-        if (data === undefined) {
+        if (!data) {
             throw ApiError.ENOENT(p);
         }
-        return new AsyncKeyValueFile(this, p, flag, node.toStats(), data);
+        return new AsyncFile(this, p, flag, node.toStats(), data);
     }
     async unlink(p, cred) {
         return this.removeEntry(p, false, cred);
@@ -295,28 +226,22 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
         if (!node.toStats().hasAccess(R_OK, cred)) {
             throw ApiError.EACCES(p);
         }
-        return Object.keys(await this.getDirListing(tx, p, node));
-    }
-    async chmod(p, mode, cred) {
-        const fd = await this.openFile(p, FileFlag.getFileFlag('r+'), cred);
-        await fd.chmod(mode);
+        return Object.keys(await this.getDirListing(tx, node, p));
     }
-    async chown(p, new_uid, new_gid, cred) {
-        const fd = await this.openFile(p, FileFlag.getFileFlag('r+'), cred);
-        await fd.chown(new_uid, new_gid);
-    }
-    async _sync(p, data, stats) {
-        // @todo Ensure mtime updates properly, and use that to determine if a data
-        //       update is required.
+    /**
+     * 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.
+     */
+    async sync(p, data, stats) {
         const tx = this.store.beginTransaction('readwrite'), 
         // 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, p, fileInodeId), inodeChanged = fileInode.update(stats);
+        fileInodeId = await this._findINode(tx, dirname(p), basename(p)), fileInode = await this.getINode(tx, fileInodeId, p), inodeChanged = fileInode.update(stats);
         try {
             // Sync data.
-            await tx.put(fileInode.id, data, true);
+            await tx.put(fileInode.ino, data, true);
             // Sync metadata.
             if (inodeChanged) {
-                await tx.put(fileInodeId, fileInode.serialize(), true);
+                await tx.put(fileInodeId, fileInode.data, true);
             }
         }
         catch (e) {
@@ -325,20 +250,45 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
         }
         await tx.commit();
     }
+    async link(existing, newpath, cred) {
+        const tx = this.store.beginTransaction('readwrite'), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
+        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(existingDir);
+        }
+        const newDir = dirname(newpath), newDirNode = await this.findINode(tx, newDir), newListing = await this.getDirListing(tx, newDirNode, newDir);
+        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
+            throw ApiError.EACCES(newDir);
+        }
+        const ino = await this._findINode(tx, existingDir, basename(existing));
+        const node = await this.getINode(tx, ino, existing);
+        if (!node.toStats().hasAccess(W_OK, cred)) {
+            throw ApiError.EACCES(newpath);
+        }
+        node.nlink++;
+        newListing[basename(newpath)] = ino;
+        try {
+            tx.put(ino, node.data, true);
+            tx.put(newDirNode.ino, encodeDirListing(newListing), true);
+        }
+        catch (e) {
+            tx.abort();
+            throw e;
+        }
+        tx.commit();
+    }
     /**
      * Checks if the root directory exists. Creates it if it doesn't.
      */
     async makeRootDirectory() {
         const tx = this.store.beginTransaction('readwrite');
-        if ((await tx.get(ROOT_NODE_ID)) === undefined) {
-            // Create new inode.
-            const currTime = new Date().getTime(), 
-            // Mode 0666, owned by root:root
-            dirInode = new Inode(randomUUID(), 4096, 511 | FileType.DIRECTORY, currTime, currTime, currTime, 0, 0);
+        if ((await tx.get(rootIno)) === undefined) {
+            // 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.id, encode('{}'), false);
-            await tx.put(ROOT_NODE_ID, dirInode.serialize(), false);
+            await tx.put(dirInode.ino, encode('{}'), false);
+            await tx.put(rootIno, dirInode.data, false);
             await tx.commit();
         }
     }
@@ -364,14 +314,14 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
             if (filename === '') {
                 // BASE CASE #1: Return the root's ID.
                 if (this._cache) {
-                    this._cache.set(currentPath, ROOT_NODE_ID);
+                    this._cache.set(currentPath, rootIno);
                 }
-                return ROOT_NODE_ID;
+                return rootIno;
             }
             else {
                 // BASE CASE #2: Find the item in the root node.
-                const inode = await this.getINode(tx, parent, ROOT_NODE_ID);
-                const dirList = await this.getDirListing(tx, parent, inode);
+                const inode = await this.getINode(tx, rootIno, parent);
+                const dirList = await this.getDirListing(tx, inode, parent);
                 if (dirList[filename]) {
                     const id = dirList[filename];
                     if (this._cache) {
@@ -388,7 +338,7 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
             // Get the parent directory's INode, and find the file in its directory
             // listing.
             const inode = await this.findINode(tx, parent, visited);
-            const dirList = await this.getDirListing(tx, parent, inode);
+            const dirList = await this.getDirListing(tx, inode, parent);
             if (dirList[filename]) {
                 const id = dirList[filename];
                 if (this._cache) {
@@ -408,7 +358,7 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      */
     async findINode(tx, p, visited = new Set()) {
         const id = await this._findINode(tx, dirname(p), basename(p), visited);
-        return this.getINode(tx, p, id);
+        return this.getINode(tx, id, p);
     }
     /**
      * Given the ID of a node, retrieves the corresponding Inode.
@@ -416,35 +366,35 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param p The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    async getINode(tx, p, id) {
+    async getINode(tx, id, p) {
         const data = await tx.get(id);
         if (!data) {
             throw ApiError.ENOENT(p);
         }
-        return Inode.Deserialize(data);
+        return new Inode(data.buffer);
     }
     /**
      * Given the Inode of a directory, retrieves the corresponding directory
      * listing.
      */
-    async getDirListing(tx, p, inode) {
-        if (!inode.isDirectory()) {
+    async getDirListing(tx, inode, p) {
+        if (!inode.toStats().isDirectory()) {
             throw ApiError.ENOTDIR(p);
         }
-        const data = await tx.get(inode.id);
-        try {
-            return JSON.parse(decode(data));
-        }
-        catch (e) {
-            // Occurs when data is undefined, or corresponds to something other
-            // than a directory listing. The latter should never occur unless
-            // the file system is corrupted.
+        const data = await tx.get(inode.ino);
+        if (!data) {
+            /*
+                Occurs when data is undefined, or corresponds to something other
+                than a directory listing. The latter should never occur unless
+                the file system is corrupted.
+             */
             throw ApiError.ENOENT(p);
         }
+        return decodeDirListing(data);
     }
     /**
      * 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.
      */
     async addNewNode(tx, data) {
         let retries = 0;
@@ -455,13 +405,13 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
             }
             else {
                 // Try again.
-                const currId = randomUUID();
-                const committed = await tx.put(currId, data, false);
+                const ino = randomIno();
+                const committed = await tx.put(ino, data, false);
                 if (!committed) {
                     return reroll();
                 }
                 else {
-                    return currId;
+                    return ino;
                 }
             }
         };
@@ -478,7 +428,7 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param data The data to store at the file's data node.
      */
     async commitNewFile(tx, p, type, mode, cred, data) {
-        const parentDir = dirname(p), fname = basename(p), parentNode = await this.findINode(tx, parentDir), dirListing = await this.getDirListing(tx, parentDir, parentNode), currTime = new Date().getTime();
+        const parentDir = dirname(p), fname = basename(p), parentNode = await this.findINode(tx, parentDir), dirListing = await this.getDirListing(tx, parentNode, parentDir);
         //Check that the creater has correct access
         if (!parentNode.toStats().hasAccess(W_OK, cred)) {
             throw ApiError.EACCES(p);
@@ -496,15 +446,17 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
         }
         try {
             // Commit data.
-            const dataId = await this.addNewNode(tx, data);
-            const fileNode = new Inode(dataId, data.length, mode | type, currTime, currTime, currTime, cred.uid, cred.gid);
-            // Commit file node.
-            const fileNodeId = await this.addNewNode(tx, fileNode.serialize());
+            const inode = new Inode();
+            inode.ino = await this.addNewNode(tx, data);
+            inode.mode = mode | type;
+            inode.uid = cred.uid;
+            inode.gid = cred.gid;
+            inode.size = data.length;
             // Update and commit parent directory listing.
-            dirListing[fname] = fileNodeId;
-            await tx.put(parentNode.id, encode(JSON.stringify(dirListing)), true);
+            dirListing[fname] = await this.addNewNode(tx, inode.data);
+            await tx.put(parentNode.ino, encodeDirListing(dirListing), true);
             await tx.commit();
-            return fileNode;
+            return inode;
         }
         catch (e) {
             tx.abort();
@@ -527,31 +479,31 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
         if (this._cache) {
             this._cache.remove(p);
         }
-        const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = await this.findINode(tx, parent), parentListing = await this.getDirListing(tx, parent, parentNode), fileName = basename(p);
+        const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = await this.findINode(tx, parent), parentListing = await this.getDirListing(tx, parentNode, parent), fileName = basename(p);
         if (!parentListing[fileName]) {
             throw ApiError.ENOENT(p);
         }
-        const fileNodeId = parentListing[fileName];
+        const fileIno = parentListing[fileName];
         // Get file inode.
-        const fileNode = await this.getINode(tx, p, fileNodeId);
+        const fileNode = await this.getINode(tx, fileIno, p);
         if (!fileNode.toStats().hasAccess(W_OK, cred)) {
             throw ApiError.EACCES(p);
         }
         // Remove from directory listing of parent.
         delete parentListing[fileName];
-        if (!isDir && fileNode.isDirectory()) {
+        if (!isDir && fileNode.toStats().isDirectory()) {
             throw ApiError.EISDIR(p);
         }
-        else if (isDir && !fileNode.isDirectory()) {
+        if (isDir && !fileNode.toStats().isDirectory()) {
             throw ApiError.ENOTDIR(p);
         }
         try {
-            // Delete data.
-            await tx.del(fileNode.id);
-            // Delete node.
-            await tx.del(fileNodeId);
-            // Update directory listing.
-            await tx.put(parentNode.id, encode(JSON.stringify(parentListing)), true);
+            await tx.put(parentNode.ino, encodeDirListing(parentListing), true);
+            if (--fileNode.nlink < 1) {
+                // remove file
+                await tx.remove(fileNode.ino);
+                await tx.remove(fileIno);
+            }
         }
         catch (e) {
             await tx.abort();

package/dist/backends/InMemory.d.ts

@@ -1,24 +1,27 @@
-import { SyncKeyValueStore, SimpleSyncStore, SyncKeyValueRWTransaction, SyncKeyValueFileSystem } from './SyncStore.js';
-import { type BackendOptions } from './backend.js';
+import type { Ino } from '../inode.js';
+import { SyncStore, SimpleSyncStore, SyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
+import { type Backend } from './backend.js';
 /**
- * A simple in-memory key-value store backed by a JavaScript object.
+ * A simple in-memory store
  */
-export declare class InMemoryStore implements SyncKeyValueStore, SimpleSyncStore {
+export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
+    name: string;
     private store;
-    name(): string;
+    constructor(name?: string);
     clear(): void;
-    beginTransaction(type: string): SyncKeyValueRWTransaction;
-    get(key: string): Uint8Array;
-    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
-    del(key: string): void;
+    beginTransaction(): SyncRWTransaction;
+    get(key: Ino): Uint8Array;
+    put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
+    remove(key: Ino): void;
 }
+export declare const InMemory: Backend;
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export declare class InMemoryFileSystem extends SyncKeyValueFileSystem {
-    static readonly Name = "InMemory";
-    static Create: any;
-    static readonly Options: BackendOptions;
+export declare class _InMemory extends SyncStoreFileSystem {
+    static isAvailable(): boolean;
+    static create: any;
+    static readonly options: {};
     constructor();
 }