@zenfs/core 2.0.0 → 2.1.1

package/dist/backends/backend.js

@@ -1,5 +1,6 @@
-import { Errno, ErrnoError } from '../internal/error.js';
-import { debug, err } from '../internal/log.js';
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-redundant-type-constituents */
+import { withErrno } from 'kerium';
+import { debug, err } from 'kerium/log';
 /**
  * @category Backends and Configuration
  * @internal
@@ -27,7 +28,7 @@ export function _fnOpt(name, fn) {
  */
 export function checkOptions(backend, options) {
     if (typeof options != 'object' || options === null) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options'));
+        throw err(withErrno('EINVAL', 'Invalid options'));
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
@@ -37,7 +38,7 @@ export function checkOptions(backend, options) {
                 debug('Using default for option: ' + optName);
                 continue;
             }
-            throw err(new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName));
+            throw err(withErrno('EINVAL', 'Missing required option: ' + optName));
         }
         const isType = (type, _ = value) => {
             var _a;
@@ -54,7 +55,7 @@ export function checkOptions(backend, options) {
         // The expected type (as a string)
         const name = (type) => (typeof type == 'function' ? (type.name != 'type' ? type.name : type.toString()) : type);
         const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
-        throw err(new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`));
+        throw err(withErrno('EINVAL', `Incorrect type for "${optName}": ${type} (expected ${expected})`));
     }
 }
 /**

package/dist/backends/cow.d.ts

@@ -73,8 +73,8 @@ export declare class CopyOnWriteFS extends FileSystem {
      * @todo Consider trying to track information on the writable as well
      */
     usage(): UsageInfo;
-    sync(path: string): Promise<void>;
-    syncSync(path: string): void;
+    sync(): Promise<void>;
+    syncSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;

package/dist/backends/cow.js

@@ -1,10 +1,10 @@
 import { EventEmitter } from 'eventemitter3';
+import { withErrno } from 'kerium';
+import { debug, err, warn } from 'kerium/log';
 import { canary } from 'utilium';
 import { resolveMountConfig } from '../config.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { isDirectory } from '../internal/inode.js';
-import { debug, err, warn } from '../internal/log.js';
 import { dirname, join } from '../path.js';
 const journalOperations = ['delete'];
 /** Because TS doesn't work right w/o it */
@@ -31,7 +31,7 @@ export class Journal extends EventEmitter {
      */
     fromString(value) {
         if (!value.startsWith(journalMagicString))
-            throw err(new ErrnoError(Errno.EINVAL, 'Invalid journal contents, refusing to parse'));
+            throw err(withErrno('EINVAL', 'Invalid journal contents, refusing to parse'));
         for (const line of value.split('\n')) {
             if (line.startsWith('#'))
                 continue; // ignore comments
@@ -91,7 +91,7 @@ export class CopyOnWriteFS extends FileSystem {
         this.writable = writable;
         this.journal = journal;
         if (writable.attributes.has('no_write')) {
-            throw err(new ErrnoError(Errno.EINVAL, 'Writable file system can not be written to'));
+            throw err(withErrno('EINVAL', 'Writable file system can not be written to'));
         }
         readable.attributes.set('no_write');
     }
@@ -104,13 +104,11 @@ export class CopyOnWriteFS extends FileSystem {
     usage() {
         return this.readable.usage();
     }
-    async sync(path) {
-        await this.copyForWrite(path);
-        await this.writable.sync(path);
+    async sync() {
+        await this.writable.sync();
     }
-    syncSync(path) {
-        this.copyForWriteSync(path);
-        this.writable.syncSync(path);
+    syncSync() {
+        this.writable.syncSync();
     }
     async read(path, buffer, offset, end) {
         return (await this.writable.exists(path))
@@ -134,9 +132,8 @@ export class CopyOnWriteFS extends FileSystem {
             await this.writable.rename(oldPath, newPath);
         }
         catch {
-            if (this.isDeleted(oldPath)) {
-                throw ErrnoError.With('ENOENT', oldPath, 'rename');
-            }
+            if (this.isDeleted(oldPath))
+                throw withErrno('ENOENT');
         }
     }
     renameSync(oldPath, newPath) {
@@ -145,9 +142,8 @@ export class CopyOnWriteFS extends FileSystem {
             this.writable.renameSync(oldPath, newPath);
         }
         catch {
-            if (this.isDeleted(oldPath)) {
-                throw ErrnoError.With('ENOENT', oldPath, 'rename');
-            }
+            if (this.isDeleted(oldPath))
+                throw withErrno('ENOENT');
         }
     }
     async stat(path) {
@@ -156,11 +152,8 @@ export class CopyOnWriteFS extends FileSystem {
         }
         catch {
             if (this.isDeleted(path))
-                throw ErrnoError.With('ENOENT', path, 'stat');
-            const oldStat = await this.readable.stat(path);
-            // Make the oldStat's mode writable.
-            oldStat.mode |= 0o222;
-            return oldStat;
+                throw withErrno('ENOENT');
+            return await this.readable.stat(path);
         }
     }
     statSync(path) {
@@ -169,11 +162,8 @@ export class CopyOnWriteFS extends FileSystem {
         }
         catch {
             if (this.isDeleted(path))
-                throw ErrnoError.With('ENOENT', path, 'stat');
-            const oldStat = this.readable.statSync(path);
-            // Make the oldStat's mode writable.
-            oldStat.mode |= 0o222;
-            return oldStat;
+                throw withErrno('ENOENT');
+            return this.readable.statSync(path);
         }
     }
     async touch(path, metadata) {
@@ -201,9 +191,8 @@ export class CopyOnWriteFS extends FileSystem {
         this.writable.linkSync(srcpath, dstpath);
     }
     async unlink(path) {
-        if (!(await this.exists(path))) {
-            throw ErrnoError.With('ENOENT', path, 'unlink');
-        }
+        if (!(await this.exists(path)))
+            throw withErrno('ENOENT');
         if (await this.writable.exists(path)) {
             await this.writable.unlink(path);
         }
@@ -214,7 +203,7 @@ export class CopyOnWriteFS extends FileSystem {
     }
     unlinkSync(path) {
         if (!this.existsSync(path))
-            throw ErrnoError.With('ENOENT', path, 'unlink');
+            throw withErrno('ENOENT');
         if (this.writable.existsSync(path)) {
             this.writable.unlinkSync(path);
         }
@@ -224,9 +213,8 @@ export class CopyOnWriteFS extends FileSystem {
         }
     }
     async rmdir(path) {
-        if (!(await this.exists(path))) {
-            throw ErrnoError.With('ENOENT', path, 'rmdir');
-        }
+        if (!(await this.exists(path)))
+            throw withErrno('ENOENT');
         if (await this.writable.exists(path)) {
             await this.writable.rmdir(path);
         }
@@ -234,15 +222,13 @@ export class CopyOnWriteFS extends FileSystem {
             return;
         }
         // Check if directory is empty.
-        if ((await this.readdir(path)).length) {
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        }
+        if ((await this.readdir(path)).length)
+            throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
     }
     rmdirSync(path) {
-        if (!this.existsSync(path)) {
-            throw ErrnoError.With('ENOENT', path, 'rmdir');
-        }
+        if (!this.existsSync(path))
+            throw withErrno('ENOENT');
         if (this.writable.existsSync(path)) {
             this.writable.rmdirSync(path);
         }
@@ -250,26 +236,25 @@ export class CopyOnWriteFS extends FileSystem {
             return;
         }
         // Check if directory is empty.
-        if (this.readdirSync(path).length) {
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        }
+        if (this.readdirSync(path).length)
+            throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
     }
     async mkdir(path, options) {
         if (await this.exists(path))
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
+            throw withErrno('EEXIST');
         await this.createParentDirectories(path);
         return await this.writable.mkdir(path, options);
     }
     mkdirSync(path, options) {
         if (this.existsSync(path))
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
+            throw withErrno('EEXIST');
         this.createParentDirectoriesSync(path);
         return this.writable.mkdirSync(path, options);
     }
     async readdir(path) {
         if (this.isDeleted(path) || !(await this.exists(path)))
-            throw ErrnoError.With('ENOENT', path, 'readdir');
+            throw withErrno('ENOENT');
         const entries = (await this.readable.exists(path)) ? await this.readable.readdir(path) : [];
         if (await this.writable.exists(path))
             for (const entry of await this.writable.readdir(path)) {
@@ -280,7 +265,7 @@ export class CopyOnWriteFS extends FileSystem {
     }
     readdirSync(path) {
         if (this.isDeleted(path) || !this.existsSync(path))
-            throw ErrnoError.With('ENOENT', path, 'readdir');
+            throw withErrno('ENOENT');
         const entries = this.readable.existsSync(path) ? this.readable.readdirSync(path) : [];
         if (this.writable.existsSync(path))
             for (const entry of this.writable.readdirSync(path)) {
@@ -302,7 +287,7 @@ export class CopyOnWriteFS extends FileSystem {
      */
     createParentDirectoriesSync(path) {
         const toCreate = [];
-        const silence = canary(ErrnoError.With('EDEADLK', path));
+        const silence = canary(withErrno('EDEADLK'));
         for (let parent = dirname(path); !this.writable.existsSync(parent); parent = dirname(parent)) {
             toCreate.push(parent);
         }
@@ -319,7 +304,7 @@ export class CopyOnWriteFS extends FileSystem {
      */
     async createParentDirectories(path) {
         const toCreate = [];
-        const silence = canary(ErrnoError.With('EDEADLK', path));
+        const silence = canary(withErrno('EDEADLK', path));
         for (let parent = dirname(path); !(await this.writable.exists(parent)); parent = dirname(parent)) {
             toCreate.push(parent);
         }
@@ -336,9 +321,8 @@ export class CopyOnWriteFS extends FileSystem {
      * - Calls f to perform operation on writable.
      */
     copyForWriteSync(path) {
-        if (!this.existsSync(path)) {
-            throw ErrnoError.With('ENOENT', path, '[copyForWrite]');
-        }
+        if (!this.existsSync(path))
+            throw withErrno('ENOENT');
         if (!this.writable.existsSync(dirname(path))) {
             this.createParentDirectoriesSync(path);
         }
@@ -347,9 +331,8 @@ export class CopyOnWriteFS extends FileSystem {
         }
     }
     async copyForWrite(path) {
-        if (!(await this.exists(path))) {
-            throw ErrnoError.With('ENOENT', path, '[copyForWrite]');
-        }
+        if (!(await this.exists(path)))
+            throw withErrno('ENOENT');
         if (!(await this.writable.exists(dirname(path)))) {
             await this.createParentDirectories(path);
         }
@@ -362,8 +345,7 @@ export class CopyOnWriteFS extends FileSystem {
      * PRECONDITION: File does not exist on writable storage.
      */
     copyToWritableSync(path) {
-        const stats = this.statSync(path);
-        stats.mode |= 0o222;
+        const stats = this.readable.statSync(path);
         if (isDirectory(stats)) {
             this.writable.mkdirSync(path, stats);
             for (const k of this.readable.readdirSync(path)) {
@@ -378,8 +360,7 @@ export class CopyOnWriteFS extends FileSystem {
         this.writable.writeSync(path, data, 0);
     }
     async copyToWritable(path) {
-        const stats = await this.stat(path);
-        stats.mode |= 0o222;
+        const stats = await this.readable.stat(path);
         if (isDirectory(stats)) {
             await this.writable.mkdir(path, stats);
             for (const k of await this.readable.readdir(path)) {

package/dist/backends/fetch.js

@@ -1,27 +1,25 @@
+import { withErrno } from 'kerium';
+import { err, warn } from 'kerium/log';
 import { decodeUTF8 } from 'utilium';
 import * as requests from 'utilium/requests.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
-import { err, warn } from '../internal/log.js';
 import { normalizePath } from '../utils.js';
 import { S_IFREG } from '../vfs/constants.js';
 /** Parse and throw */
-function parseError(path, fs) {
-    return (error) => {
-        if (!('tag' in error))
-            throw err(new ErrnoError(Errno.EIO, error.stack, path), { fs });
-        switch (error.tag) {
-            case 'fetch':
-                throw err(new ErrnoError(Errno.EREMOTEIO, error.message, path), { fs });
-            case 'status':
-                throw err(new ErrnoError(error.response.status > 500 ? Errno.EREMOTEIO : Errno.EIO, 'Response status code is ' + error.response.status, path), { fs });
-            case 'size':
-                throw err(new ErrnoError(Errno.EBADE, error.message, path), { fs });
-            case 'buffer':
-                throw err(new ErrnoError(Errno.EIO, 'Failed to decode buffer', path), { fs });
-        }
-    };
+function parseError(error) {
+    if (!('tag' in error))
+        throw err(withErrno('EIO', error.stack));
+    switch (error.tag) {
+        case 'fetch':
+            throw err(withErrno('EREMOTEIO', error.message));
+        case 'status':
+            throw err(withErrno(error.response.status > 500 ? 'EREMOTEIO' : 'EIO', 'Response status code is ' + error.response.status));
+        case 'size':
+            throw err(withErrno('EBADE', error.message));
+        case 'buffer':
+            throw err(withErrno('EIO', 'Failed to decode buffer'));
+    }
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
@@ -51,45 +49,45 @@ export class FetchFS extends IndexFS {
     async read(path, buffer, offset = 0, end) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'read');
+            throw withErrno('ENOENT');
         if (end - offset == 0)
             return;
         const data = await requests
             .get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit)
-            .catch(parseError(path, this))
+            .catch(parseError)
             .catch(() => undefined);
         if (!data)
-            throw ErrnoError.With('ENODATA', path, 'read');
+            throw withErrno('ENODATA');
         buffer.set(data);
     }
     readSync(path, buffer, offset = 0, end) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'read');
+            throw withErrno('ENOENT');
         if (end - offset == 0)
             return;
         const { data, missing } = requests.getCached(this.baseUrl + path, { start: offset, end, size: inode.size, warn });
         if (!data)
-            throw ErrnoError.With('ENODATA', path, 'read');
+            throw withErrno('ENODATA');
         if (missing.length) {
             this._async(requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }));
-            throw ErrnoError.With('EAGAIN', path, 'read');
+            throw withErrno('EAGAIN');
         }
         buffer.set(data);
     }
     async write(path, data, offset) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'write');
+            throw withErrno('ENOENT');
         inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
-        await requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this));
+        await requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError);
     }
     writeSync(path, data, offset) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'write');
+            throw withErrno('ENOENT');
         inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
-        this._async(requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this)));
+        this._async(requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError));
     }
 }
 const _Fetch = {
@@ -116,7 +114,7 @@ const _Fetch = {
             index.fromJSON(options.index);
         }
         else {
-            const data = await requests.get(options.index, { warn }, options.requestInit).catch(parseError());
+            const data = await requests.get(options.index, { warn }, options.requestInit).catch(parseError);
             index.fromJSON(JSON.parse(decodeUTF8(data)));
         }
         const fs = new FetchFS(index, baseUrl, options.requestInit, options.remoteWrite);
@@ -126,7 +124,7 @@ const _Fetch = {
         for (const [path, node] of index) {
             if (!(node.mode & S_IFREG))
                 continue;
-            await requests.get(baseUrl + path, { warn }, options.requestInit).catch(parseError(path, fs));
+            await requests.get(baseUrl + path, { warn }, options.requestInit).catch(parseError);
         }
         return fs;
     },

package/dist/backends/passthrough.d.ts

@@ -17,7 +17,6 @@ export declare class PassthroughFS extends FileSystem {
     constructor(nodeFS: NodeFS, prefix: string);
     usage(): UsageInfo;
     path(path: string): string;
-    error(err: unknown, path: string): never;
     /**
      * Rename a file or directory.
      */
@@ -79,11 +78,11 @@ export declare class PassthroughFS extends FileSystem {
     /**
      * Synchronize data to the file system.
      */
-    sync(path: string): Promise<void>;
+    sync(): Promise<void>;
     /**
      * Synchronize data to the file system synchronously.
      */
-    syncSync(path: string): void;
+    syncSync(): void;
     /**
      * Create a hard link.
      */