@zenfs/core 0.9.7 → 0.11.0

package/dist/backends/store/fs.js

@@ -0,0 +1,743 @@
+import { W_OK, R_OK } from '../../emulation/constants.js';
+import { dirname, basename, join, resolve } from '../../emulation/path.js';
+import { ErrnoError, Errno } from '../../error.js';
+import { PreloadFile, flagToMode } from '../../file.js';
+import { FileSystem } from '../../filesystem.js';
+import { Inode, rootIno, randomIno } from '../../inode.js';
+import { FileType } from '../../stats.js';
+import { encodeDirListing, encode, decodeDirListing } from '../../utils.js';
+const maxInodeAllocTries = 5;
+/**
+ * A synchronous key-value file system. Uses a SyncStore to store the data.
+ *
+ * We use a unique ID for each node in the file system. The root node has a fixed ID.
+ * @todo Introduce Node ID caching.
+ * @todo Check modes.
+ * @internal
+ */
+export class StoreFS extends FileSystem {
+    get store() {
+        if (!this._store) {
+            throw new ErrnoError(Errno.ENODATA, 'No store attached');
+        }
+        return this._store;
+    }
+    async ready() {
+        await super.ready();
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        this._store = await this.$store;
+    }
+    constructor($store) {
+        super();
+        this.$store = $store;
+        this._initialized = false;
+        if (!($store instanceof Promise)) {
+            this._store = $store;
+            this._initialized = true;
+            this.makeRootDirectorySync();
+        }
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            name: this.store.name,
+        };
+    }
+    /**
+     * Delete all contents stored in the file system.
+     */
+    async empty() {
+        await this.store.clear();
+        // Root always exists.
+        await this.makeRootDirectory();
+    }
+    /**
+     * Delete all contents stored in the file system.
+     */
+    emptySync() {
+        this.store.clearSync();
+        // Root always exists.
+        this.makeRootDirectorySync();
+    }
+    /**
+     * @todo Make rename compatible with the cache.
+     */
+    async rename(oldPath, newPath, cred) {
+        const tx = this.store.transaction(), 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, oldDirNode, oldParent);
+        if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', oldPath, 'rename');
+        }
+        if (!oldDirList[oldName]) {
+            throw ErrnoError.With('ENOENT', oldPath, 'rename');
+        }
+        const nodeId = oldDirList[oldName];
+        delete oldDirList[oldName];
+        // Invariant: Can't move a folder inside itself.
+        // This funny little hack ensures that the check passes only if oldPath
+        // is a subpath of newParent. We append '/' to avoid matching folders that
+        // are a substring of the bottom-most folder in the path.
+        if ((newParent + '/').indexOf(oldPath + '/') === 0) {
+            throw new ErrnoError(Errno.EBUSY, oldParent);
+        }
+        // Add newPath to parent's directory listing.
+        let newDirNode, newDirList;
+        if (newParent === oldParent) {
+            // Prevent us from re-grabbing the same directory listing, which still
+            // contains oldName.
+            newDirNode = oldDirNode;
+            newDirList = oldDirList;
+        }
+        else {
+            newDirNode = await this.findINode(tx, newParent);
+            newDirList = await this.getDirListing(tx, newDirNode, newParent);
+        }
+        if (newDirList[newName]) {
+            // If it's a file, delete it.
+            const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
+            if (newNameNode.toStats().isFile()) {
+                try {
+                    await tx.remove(newNameNode.ino);
+                    await tx.remove(newDirList[newName]);
+                }
+                catch (e) {
+                    await tx.abort();
+                    throw e;
+                }
+            }
+            else {
+                // If it's a directory, throw a permissions error.
+                throw ErrnoError.With('EPERM', newPath, 'rename');
+            }
+        }
+        newDirList[newName] = nodeId;
+        // Commit the two changed directory listings.
+        try {
+            await tx.set(oldDirNode.ino, encodeDirListing(oldDirList));
+            await tx.set(newDirNode.ino, encodeDirListing(newDirList));
+        }
+        catch (e) {
+            await tx.abort();
+            throw e;
+        }
+        await tx.commit();
+    }
+    renameSync(oldPath, newPath, cred) {
+        const tx = this.store.transaction(), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
+        // Remove oldPath from parent's directory listing.
+        oldDirNode = this.findINodeSync(tx, oldParent), oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
+        if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', oldPath, 'rename');
+        }
+        if (!oldDirList[oldName]) {
+            throw ErrnoError.With('ENOENT', oldPath, 'rename');
+        }
+        const ino = oldDirList[oldName];
+        delete oldDirList[oldName];
+        // Invariant: Can't move a folder inside itself.
+        // This funny little hack ensures that the check passes only if oldPath
+        // is a subpath of newParent. We append '/' to avoid matching folders that
+        // are a substring of the bottom-most folder in the path.
+        if ((newParent + '/').indexOf(oldPath + '/') == 0) {
+            throw new ErrnoError(Errno.EBUSY, oldParent);
+        }
+        // Add newPath to parent's directory listing.
+        let newDirNode, newDirList;
+        if (newParent === oldParent) {
+            // Prevent us from re-grabbing the same directory listing, which still
+            // contains oldName.
+            newDirNode = oldDirNode;
+            newDirList = oldDirList;
+        }
+        else {
+            newDirNode = this.findINodeSync(tx, newParent);
+            newDirList = this.getDirListingSync(tx, newDirNode, newParent);
+        }
+        if (newDirList[newName]) {
+            // If it's a file, delete it.
+            const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
+            if (newNameNode.toStats().isFile()) {
+                try {
+                    tx.removeSync(newNameNode.ino);
+                    tx.removeSync(newDirList[newName]);
+                }
+                catch (e) {
+                    tx.abortSync();
+                    throw e;
+                }
+            }
+            else {
+                // If it's a directory, throw a permissions error.
+                throw ErrnoError.With('EPERM', newPath, 'rename');
+            }
+        }
+        newDirList[newName] = ino;
+        // Commit the two changed directory listings.
+        try {
+            tx.setSync(oldDirNode.ino, encodeDirListing(oldDirList));
+            tx.setSync(newDirNode.ino, encodeDirListing(newDirList));
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        tx.commitSync();
+    }
+    async stat(path, cred) {
+        const tx = this.store.transaction();
+        const inode = await this.findINode(tx, path);
+        if (!inode) {
+            throw ErrnoError.With('ENOENT', path, 'stat');
+        }
+        const stats = inode.toStats();
+        if (!stats.hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'stat');
+        }
+        return stats;
+    }
+    statSync(path, cred) {
+        // Get the inode to the item, convert it into a Stats object.
+        const stats = this.findINodeSync(this.store.transaction(), path).toStats();
+        if (!stats.hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'stat');
+        }
+        return stats;
+    }
+    async createFile(path, flag, mode, cred) {
+        const data = new Uint8Array(0);
+        const file = await this.commitNew(this.store.transaction(), path, FileType.FILE, mode, cred, data);
+        return new PreloadFile(this, path, flag, file.toStats(), data);
+    }
+    createFileSync(path, flag, mode, cred) {
+        this.commitNewSync(path, FileType.FILE, mode, cred);
+        return this.openFileSync(path, flag, cred);
+    }
+    async openFile(path, flag, cred) {
+        const tx = this.store.transaction(), node = await this.findINode(tx, path), data = await tx.get(node.ino);
+        if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
+            throw ErrnoError.With('EACCES', path, 'openFile');
+        }
+        if (!data) {
+            throw ErrnoError.With('ENOENT', path, 'openFile');
+        }
+        return new PreloadFile(this, path, flag, node.toStats(), data);
+    }
+    openFileSync(path, flag, cred) {
+        const tx = this.store.transaction(), node = this.findINodeSync(tx, path), data = tx.getSync(node.ino);
+        if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
+            throw ErrnoError.With('EACCES', path, 'openFile');
+        }
+        if (!data) {
+            throw ErrnoError.With('ENOENT', path, 'openFile');
+        }
+        return new PreloadFile(this, path, flag, node.toStats(), data);
+    }
+    async unlink(path, cred) {
+        return this.remove(path, false, cred);
+    }
+    unlinkSync(path, cred) {
+        this.removeSync(path, false, cred);
+    }
+    async rmdir(path, cred) {
+        // Check first if directory is empty.
+        const list = await this.readdir(path, cred);
+        if (list.length > 0) {
+            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+        }
+        await this.remove(path, true, cred);
+    }
+    rmdirSync(path, cred) {
+        // Check first if directory is empty.
+        if (this.readdirSync(path, cred).length > 0) {
+            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+        }
+        else {
+            this.removeSync(path, true, cred);
+        }
+    }
+    async mkdir(path, mode, cred) {
+        const tx = this.store.transaction(), data = encode('{}');
+        await this.commitNew(tx, path, FileType.DIRECTORY, mode, cred, data);
+    }
+    mkdirSync(path, mode, cred) {
+        this.commitNewSync(path, FileType.DIRECTORY, mode, cred, encode('{}'));
+    }
+    async readdir(path, cred) {
+        const tx = this.store.transaction();
+        const node = await this.findINode(tx, path);
+        if (!node.toStats().hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'readdur');
+        }
+        return Object.keys(await this.getDirListing(tx, node, path));
+    }
+    readdirSync(path, cred) {
+        const tx = this.store.transaction();
+        const node = this.findINodeSync(tx, path);
+        if (!node.toStats().hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'readdir');
+        }
+        return Object.keys(this.getDirListingSync(tx, node, path));
+    }
+    /**
+     * 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(path, data, stats) {
+        const tx = this.store.transaction(), 
+        // We use _findInode because we actually need the INode id.
+        fileInodeId = await this._findINode(tx, dirname(path), basename(path)), fileInode = await this.getINode(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+        try {
+            // Sync data.
+            await tx.set(fileInode.ino, data);
+            // Sync metadata.
+            if (inodeChanged) {
+                await tx.set(fileInodeId, fileInode.data);
+            }
+        }
+        catch (e) {
+            await tx.abort();
+            throw e;
+        }
+        await tx.commit();
+    }
+    /**
+     * 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.
+     */
+    syncSync(path, data, stats) {
+        const tx = this.store.transaction(), 
+        // We use _findInode because we actually need the INode id.
+        fileInodeId = this._findINodeSync(tx, dirname(path), basename(path)), fileInode = this.getINodeSync(tx, fileInodeId, path), inodeChanged = fileInode.update(stats);
+        try {
+            // Sync data.
+            tx.setSync(fileInode.ino, data);
+            // Sync metadata.
+            if (inodeChanged) {
+                tx.setSync(fileInodeId, fileInode.data);
+            }
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        tx.commitSync();
+    }
+    async link(existing, newpath, cred) {
+        const tx = this.store.transaction(), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
+        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', existingDir, 'link');
+        }
+        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 ErrnoError.With('EACCES', newDir, 'link');
+        }
+        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 ErrnoError.With('EACCES', newpath, 'link');
+        }
+        node.nlink++;
+        newListing[basename(newpath)] = ino;
+        try {
+            tx.setSync(ino, node.data);
+            tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        tx.commitSync();
+    }
+    linkSync(existing, newpath, cred) {
+        const tx = this.store.transaction(), existingDir = dirname(existing), existingDirNode = this.findINodeSync(tx, existingDir);
+        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+            throw ErrnoError.With('EACCES', existingDir, 'link');
+        }
+        const newDir = dirname(newpath), newDirNode = this.findINodeSync(tx, newDir), newListing = this.getDirListingSync(tx, newDirNode, newDir);
+        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', newDir, 'link');
+        }
+        const ino = this._findINodeSync(tx, existingDir, basename(existing));
+        const node = this.getINodeSync(tx, ino, existing);
+        if (!node.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', newpath, 'link');
+        }
+        node.nlink++;
+        newListing[basename(newpath)] = ino;
+        try {
+            tx.setSync(ino, node.data);
+            tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        tx.commitSync();
+    }
+    /**
+     * Checks if the root directory exists. Creates it if it doesn't.
+     */
+    async makeRootDirectory() {
+        const tx = this.store.transaction();
+        if (await tx.get(rootIno)) {
+            return;
+        }
+        // Create new inode. o777, owned by root:root
+        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.set(inode.ino, encode('{}'));
+        await tx.set(rootIno, inode.data);
+        await tx.commit();
+    }
+    /**
+     * Checks if the root directory exists. Creates it if it doesn't.
+     */
+    makeRootDirectorySync() {
+        const tx = this.store.transaction();
+        if (tx.getSync(rootIno)) {
+            return;
+        }
+        // Create new inode, mode o777, owned by root:root
+        const inode = new Inode();
+        inode.mode = 0o777 | FileType.DIRECTORY;
+        // If the root doesn't exist, the first random ID shouldn't exist either.
+        tx.setSync(inode.ino, encode('{}'));
+        tx.setSync(rootIno, inode.data);
+        tx.commitSync();
+    }
+    /**
+     * 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.
+     */
+    async _findINode(tx, parent, filename, visited = new Set()) {
+        const currentPath = join(parent, filename);
+        if (visited.has(currentPath)) {
+            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+        }
+        visited.add(currentPath);
+        if (parent == '/' && filename === '') {
+            return rootIno;
+        }
+        const inode = parent == '/' ? await this.getINode(tx, rootIno, parent) : await this.findINode(tx, parent, visited);
+        const dirList = await this.getDirListing(tx, inode, parent);
+        if (!(filename in dirList)) {
+            throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
+        }
+        return dirList[filename];
+    }
+    /**
+     * 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.
+     */
+    _findINodeSync(tx, parent, filename, visited = new Set()) {
+        const currentPath = join(parent, filename);
+        if (visited.has(currentPath)) {
+            throw new ErrnoError(Errno.EIO, 'Infinite loop detected while finding inode', currentPath);
+        }
+        visited.add(currentPath);
+        if (parent == '/' && filename === '') {
+            return rootIno;
+        }
+        const inode = parent == '/' ? this.getINodeSync(tx, rootIno, parent) : this.findINodeSync(tx, parent, visited);
+        const dir = this.getDirListingSync(tx, inode, parent);
+        if (!(filename in dir)) {
+            throw ErrnoError.With('ENOENT', resolve(parent, filename), '_findINode');
+        }
+        return dir[filename];
+    }
+    /**
+     * Finds the Inode of the given path.
+     * @param path The path to look up.
+     * @todo memoize/cache
+     */
+    async findINode(tx, path, visited = new Set()) {
+        const id = await this._findINode(tx, dirname(path), basename(path), visited);
+        return this.getINode(tx, id, path);
+    }
+    /**
+     * Finds the Inode of the given path.
+     * @param path The path to look up.
+     * @return The Inode of the path p.
+     * @todo memoize/cache
+     */
+    findINodeSync(tx, path, visited = new Set()) {
+        const ino = this._findINodeSync(tx, dirname(path), basename(path), visited);
+        return this.getINodeSync(tx, ino, path);
+    }
+    /**
+     * Given the ID of a node, retrieves the corresponding Inode.
+     * @param tx The transaction to use.
+     * @param path The corresponding path to the file (used for error messages).
+     * @param id The ID to look up.
+     */
+    async getINode(tx, id, path) {
+        const data = await tx.get(id);
+        if (!data) {
+            throw ErrnoError.With('ENOENT', path, 'getINode');
+        }
+        return new Inode(data.buffer);
+    }
+    /**
+     * Given the ID of a node, retrieves the corresponding Inode.
+     * @param tx The transaction to use.
+     * @param path The corresponding path to the file (used for error messages).
+     * @param id The ID to look up.
+     */
+    getINodeSync(tx, id, path) {
+        const data = tx.getSync(id);
+        if (!data) {
+            throw ErrnoError.With('ENOENT', path, 'getINode');
+        }
+        const inode = new Inode(data.buffer);
+        return inode;
+    }
+    /**
+     * Given the Inode of a directory, retrieves the corresponding directory
+     * listing.
+     */
+    async getDirListing(tx, inode, path) {
+        if (!inode.toStats().isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', path, 'getDirListing');
+        }
+        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 ErrnoError.With('ENOENT', path, 'getDirListing');
+        }
+        return decodeDirListing(data);
+    }
+    /**
+     * Given the Inode of a directory, retrieves the corresponding directory listing.
+     */
+    getDirListingSync(tx, inode, p) {
+        if (!inode.toStats().isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', p, 'getDirListing');
+        }
+        const data = tx.getSync(inode.ino);
+        if (!data) {
+            throw ErrnoError.With('ENOENT', p, 'getDirListing');
+        }
+        return decodeDirListing(data);
+    }
+    /**
+     * Adds a new node under a random ID. Retries before giving up in
+     * the exceedingly unlikely chance that we try to reuse a random ino.
+     */
+    async addNew(tx, data, path) {
+        for (let i = 0; i < maxInodeAllocTries; i++) {
+            const ino = randomIno();
+            if (await tx.get(ino)) {
+                continue;
+            }
+            await tx.set(ino, data);
+            return ino;
+        }
+        throw new ErrnoError(Errno.ENOSPC, 'No inode IDs available', path, 'addNewNode');
+    }
+    /**
+     * Creates a new node under a random ID. Retries before giving up in
+     * the exceedingly unlikely chance that we try to reuse a random ino.
+     * @return The ino that the data was stored under.
+     */
+    addNewSync(tx, data, path) {
+        for (let i = 0; i < maxInodeAllocTries; i++) {
+            const ino = randomIno();
+            if (tx.getSync(ino)) {
+                continue;
+            }
+            tx.setSync(ino, data);
+            return ino;
+        }
+        throw new ErrnoError(Errno.ENOSPC, 'No inode IDs available', path, 'addNewNode');
+    }
+    /**
+     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with
+     * the given 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 cred The UID/GID to create the file with
+     * @param data The data to store at the file's data node.
+     */
+    async commitNew(tx, path, type, mode, cred, data) {
+        const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
+        //Check that the creater has correct access
+        if (!parent.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'commitNewFile');
+        }
+        const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
+        /*
+            The root always exists.
+            If we don't check this prior to taking steps below,
+            we will create a file with name '' in root should path == '/'.
+        */
+        if (path === '/') {
+            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+        }
+        // Check if file already exists.
+        if (listing[fname]) {
+            await tx.abort();
+            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+        }
+        try {
+            // Commit data.
+            const inode = new Inode();
+            inode.ino = await this.addNew(tx, data, path);
+            inode.mode = mode | type;
+            inode.uid = cred.uid;
+            inode.gid = cred.gid;
+            inode.size = data.length;
+            // Update and commit parent directory listing.
+            listing[fname] = await this.addNew(tx, inode.data, path);
+            await tx.set(parent.ino, encodeDirListing(listing));
+            await tx.commit();
+            return inode;
+        }
+        catch (e) {
+            tx.abort();
+            throw e;
+        }
+    }
+    /**
+     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with the given 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 data The data to store at the file's data node.
+     * @return The Inode for the new file.
+     */
+    commitNewSync(path, type, mode, cred, data = new Uint8Array()) {
+        const tx = this.store.transaction(), parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
+        //Check that the creater has correct access
+        if (!parent.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'commitNewFile');
+        }
+        const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
+        /*
+            The root always exists.
+            If we don't check this prior to taking steps below,
+            we will create a file with name '' in root should p == '/'.
+        */
+        if (path === '/') {
+            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+        }
+        // Check if file already exists.
+        if (listing[fname]) {
+            throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+        }
+        const node = new Inode();
+        try {
+            // Commit data.
+            node.ino = this.addNewSync(tx, data, path);
+            node.size = data.length;
+            node.mode = mode | type;
+            node.uid = cred.uid;
+            node.gid = cred.gid;
+            // Update and commit parent directory listing.
+            listing[fname] = this.addNewSync(tx, node.data, path);
+            tx.setSync(parent.ino, encodeDirListing(listing));
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        tx.commitSync();
+        return node;
+    }
+    /**
+     * Remove all traces of the given 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.
+     */
+    async remove(path, isDir, cred) {
+        const tx = this.store.transaction(), parent = dirname(path), parentNode = await this.findINode(tx, parent), listing = await this.getDirListing(tx, parentNode, parent), fileName = basename(path);
+        if (!listing[fileName]) {
+            throw ErrnoError.With('ENOENT', path, 'removeEntry');
+        }
+        const fileIno = listing[fileName];
+        // Get file inode.
+        const fileNode = await this.getINode(tx, fileIno, path);
+        if (!fileNode.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'removeEntry');
+        }
+        // Remove from directory listing of parent.
+        delete listing[fileName];
+        if (!isDir && fileNode.toStats().isDirectory()) {
+            throw ErrnoError.With('EISDIR', path, 'removeEntry');
+        }
+        if (isDir && !fileNode.toStats().isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+        }
+        try {
+            await tx.set(parentNode.ino, encodeDirListing(listing));
+            if (--fileNode.nlink < 1) {
+                // remove file
+                await tx.remove(fileNode.ino);
+                await tx.remove(fileIno);
+            }
+        }
+        catch (e) {
+            await tx.abort();
+            throw e;
+        }
+        // Success.
+        await tx.commit();
+    }
+    /**
+     * Remove all traces of the given 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.
+     */
+    removeSync(path, isDir, cred) {
+        const tx = this.store.transaction(), parent = dirname(path), parentNode = this.findINodeSync(tx, parent), listing = this.getDirListingSync(tx, parentNode, parent), fileName = basename(path), fileIno = listing[fileName];
+        if (!fileIno) {
+            throw ErrnoError.With('ENOENT', path, 'removeEntry');
+        }
+        // Get file inode.
+        const fileNode = this.getINodeSync(tx, fileIno, path);
+        if (!fileNode.toStats().hasAccess(W_OK, cred)) {
+            throw ErrnoError.With('EACCES', path, 'removeEntry');
+        }
+        // Remove from directory listing of parent.
+        delete listing[fileName];
+        if (!isDir && fileNode.toStats().isDirectory()) {
+            throw ErrnoError.With('EISDIR', path, 'removeEntry');
+        }
+        if (isDir && !fileNode.toStats().isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+        }
+        try {
+            // Update directory listing.
+            tx.setSync(parentNode.ino, encodeDirListing(listing));
+            if (--fileNode.nlink < 1) {
+                // remove file
+                tx.removeSync(fileNode.ino);
+                tx.removeSync(fileIno);
+            }
+        }
+        catch (e) {
+            tx.abortSync();
+            throw e;
+        }
+        // Success.
+        tx.commitSync();
+    }
+}