@zenfs/core 0.9.6 → 0.10.0

package/dist/emulation/sync.js

@@ -1,12 +1,12 @@
 import { Buffer } from 'buffer';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { COPYFILE_EXCL, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
+import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -52,7 +52,7 @@ export function existsSync(path) {
         return fs.existsSync(resolvedPath, cred);
     }
     catch (e) {
-        if (e.errno == ErrorCode.ENOENT) {
+        if (e.errno == Errno.ENOENT) {
             return false;
         }
         throw e;
@@ -60,12 +60,12 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = doOp('statSync', true, path, cred);
+    const stats = doOp('statSync', true, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = doOp('statSync', false, path, cred);
+    const stats = doOp('statSync', false, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 lstatSync;
@@ -89,10 +89,10 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return doOp('unlinkSync', false, path, cred);
+    return doOp('unlinkSync', false, path.toString(), cred);
 }
 unlinkSync;
-function _openSync(_path, _flag, _mode, resolveSymlinks) {
+function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
     const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     // Check if the path exists, and is a file.
     let stats;
@@ -106,22 +106,22 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
                 if (!parentStats.isDirectory()) {
-                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
+                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
                 }
                 return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.With('ENOENT', path, '_open');
+                throw ErrnoError.With('ENOENT', path, '_open');
             default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+                throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
         }
     }
     if (!stats.hasAccess(mode, cred)) {
-        throw ApiError.With('EACCES', path, '_open');
+        throw ErrnoError.With('EACCES', path, '_open');
     }
     // File exists.
     switch (pathExistsAction(flag)) {
         case ActionType.THROW:
-            throw ApiError.With('EEXIST', path, '_open');
+            throw ErrnoError.With('EEXIST', path, '_open');
         case ActionType.TRUNCATE:
             // Delete file.
             doOp('unlinkSync', resolveSymlinks, path, cred);
@@ -135,7 +135,7 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
         case ActionType.NOP:
             return doOp('openFileSync', resolveSymlinks, path, flag, cred);
         default:
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+            throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
     }
 }
 /**
@@ -146,8 +146,8 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
  * @param mode Mode to use to open the file. Can be ignored if the
  *   filesystem doesn't support permissions.
  */
-export function openSync(path, flag, mode) {
-    return getFdForFile(_openSync(path, flag, mode, true));
+export function openSync(path, flag, mode = F_OK) {
+    return file2fd(_openSync(path, flag, mode, true));
 }
 openSync;
 /**
@@ -155,7 +155,7 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return getFdForFile(_openSync(path, flag, mode, false));
+    return file2fd(_openSync(path, flag, mode, false));
 }
 /**
  * Synchronously reads the entire contents of a file.
@@ -175,13 +175,13 @@ function _readFileSync(fname, flag, resolveSymlinks) {
         file.closeSync();
     }
 }
-export function readFileSync(filename, arg2 = {}) {
-    const options = normalizeOptions(arg2, null, 'r', 0o644);
+export function readFileSync(path, _options = {}) {
+    const options = normalizeOptions(_options, null, 'r', 0o644);
     const flag = parseFlag(options.flag);
     if (!isReadable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = Buffer.from(_readFileSync(filename, options.flag, true));
+    const data = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -194,26 +194,26 @@ readFileSync;
 function _writeFileSync(fname, data, flag, mode, resolveSymlinks) {
     const file = _openSync(fname, flag, mode, resolveSymlinks);
     try {
-        file.writeSync(data, 0, data.length, 0);
+        file.writeSync(data, 0, data.byteLength, 0);
     }
     finally {
         file.closeSync();
     }
 }
-export function writeFileSync(filename, data, _options) {
+export function writeFileSync(path, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
     const flag = parseFlag(options.flag);
     if (!isWriteable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing.');
     }
     if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-    if (encodedData === undefined) {
-        throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (!encodedData) {
+        throw new ErrnoError(Errno.EINVAL, 'Data not specified');
     }
-    _writeFileSync(filename, encodedData, options.flag, options.mode, true);
+    _writeFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), encodedData, options.flag, options.mode, true);
 }
 writeFileSync;
 /**
@@ -223,7 +223,7 @@ writeFileSync;
 function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
     const file = _openSync(fname, flag, mode, resolveSymlinks);
     try {
-        file.writeSync(data, 0, data.length, null);
+        file.writeSync(data, 0, data.byteLength, null);
     }
     finally {
         file.closeSync();
@@ -240,17 +240,17 @@ function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export function appendFileSync(filename, data, _options) {
+export function appendFileSync(filename, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
     if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-    _appendFileSync(filename, encodedData, options.flag, options.mode, true);
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    _appendFileSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), encodedData, options.flag, options.mode, true);
 }
 appendFileSync;
 export function fstatSync(fd, options) {
@@ -273,8 +273,9 @@ closeSync;
  * @param len
  */
 export function ftruncateSync(fd, len = 0) {
+    len || (len = 0);
     if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+        throw new ErrnoError(Errno.EINVAL);
     }
     fd2file(fd).truncateSync(len);
 }
@@ -296,26 +297,24 @@ export function fdatasyncSync(fd) {
 }
 fdatasyncSync;
 export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
-    let buffer, offset = 0, length, position;
+    let buffer, offset, length, position;
     if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]])
         position = typeof posOrOff === 'number' ? posOrOff : null;
         const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
         offset = 0;
         buffer = Buffer.from(data, encoding);
-        length = buffer.length;
+        length = buffer.byteLength;
     }
     else {
         // Signature 2: (fd, buffer, offset, length, position?)
-        buffer = data;
+        buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
         offset = posOrOff;
         length = lenOrEnc;
         position = typeof pos === 'number' ? pos : null;
     }
     const file = fd2file(fd);
-    if (position === undefined || position === null) {
-        position = file.position;
-    }
+    position ?? (position = file.position);
     return file.writeSync(buffer, offset, length, position);
 }
 writeSync;
@@ -351,7 +350,7 @@ fchownSync;
 export function fchmodSync(fd, mode) {
     const numMode = normalizeMode(mode, -1);
     if (numMode < 0) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+        throw new ErrnoError(Errno.EINVAL, `Invalid mode.`);
     }
     fd2file(fd).chmodSync(numMode);
 }
@@ -372,13 +371,13 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return doOp('rmdirSync', true, path, cred);
+    return doOp('rmdirSync', true, path.toString(), cred);
 }
 rmdirSync;
 export function mkdirSync(path, options) {
     const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
     const recursive = typeof options == 'object' && options?.recursive;
-    doOp('mkdirSync', true, path, normalizeMode(mode, 0o777), cred);
+    doOp('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
 }
 mkdirSync;
 export function readdirSync(path, options) {
@@ -397,9 +396,9 @@ export function readdirSync(path, options) {
     }
     return entries.map((entry) => {
         if (typeof options == 'object' && options?.withFileTypes) {
-            return new Dirent(entry, statSync(join(path, entry)));
+            return new Dirent(entry, statSync(join(path.toString(), entry)));
         }
-        if (options == 'buffer' || (typeof options == 'object' && options.encoding == 'buffer')) {
+        if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
             return Buffer.from(entry);
         }
         return entry;
@@ -414,7 +413,7 @@ readdirSync;
  */
 export function linkSync(existing, newpath) {
     newpath = normalizePath(newpath);
-    return doOp('linkSync', false, existing, newpath, cred);
+    return doOp('linkSync', false, existing.toString(), newpath.toString(), cred);
 }
 linkSync;
 /**
@@ -425,19 +424,19 @@ linkSync;
  */
 export function symlinkSync(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
+        throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
     }
     if (existsSync(path)) {
-        throw ApiError.With('EEXIST', path, 'symlink');
+        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
-    writeFileSync(path, target);
+    writeFileSync(path, target.toString());
     const file = _openSync(path, 'r+', 0o644, false);
     file._setTypeSync(FileType.SYMLINK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync(path, 'r', false));
-    const encoding = typeof options == 'object' ? options.encoding : options;
+    const value = Buffer.from(_readFileSync(path.toString(), 'r', false));
+    const encoding = typeof options == 'object' ? options?.encoding : options;
     if (encoding == 'buffer') {
         return value;
     }
@@ -540,7 +539,7 @@ realpathSync;
 export function accessSync(path, mode = 0o600) {
     const stats = statSync(path);
     if (!stats.hasAccess(mode, cred)) {
-        throw new ApiError(ErrorCode.EACCES);
+        throw new ErrnoError(Errno.EACCES);
     }
 }
 accessSync;
@@ -569,12 +568,12 @@ export function rmSync(path, options) {
         case S_IFIFO:
         case S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
 }
 rmSync;
 export function mkdtempSync(prefix, options) {
-    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
     mkdirSync(resolvedPath);
@@ -592,7 +591,7 @@ export function copyFileSync(src, dest, flags) {
     src = normalizePath(src);
     dest = normalizePath(dest);
     if (flags && flags & COPYFILE_EXCL && existsSync(dest)) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
     writeFileSync(dest, readFileSync(src));
 }
@@ -608,7 +607,7 @@ export function readvSync(fd, buffers, position) {
     const file = fd2file(fd);
     let bytesRead = 0;
     for (const buffer of buffers) {
-        bytesRead += file.readSync(buffer, 0, buffer.length, position + bytesRead);
+        bytesRead += file.readSync(buffer, 0, buffer.byteLength, position + bytesRead);
     }
     return bytesRead;
 }
@@ -624,7 +623,7 @@ export function writevSync(fd, buffers, position) {
     const file = fd2file(fd);
     let bytesWritten = 0;
     for (const buffer of buffers) {
-        bytesWritten += file.writeSync(buffer, 0, buffer.length, position + bytesWritten);
+        bytesWritten += file.writeSync(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
     }
     return bytesWritten;
 }
@@ -657,12 +656,12 @@ export function cpSync(source, destination, opts) {
     destination = normalizePath(destination);
     const srcStats = lstatSync(source); // Use lstat to follow symlinks if not dereferencing
     if (opts?.errorOnExist && existsSync(destination)) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & S_IFMT) {
         case S_IFDIR:
             if (!opts?.recursive) {
-                throw new ApiError(ErrorCode.EISDIR, source + ' is a directory (not copied)', source, 'cp');
+                throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
             mkdirSync(destination, { recursive: true }); // Ensure the destination directory exists
             for (const dirent of readdirSync(source, { withFileTypes: true })) {
@@ -681,7 +680,7 @@ export function cpSync(source, destination, opts) {
         case S_IFIFO:
         case S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', source, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', source, 'rm');
     }
     // Optionally preserve timestamps
     if (opts?.preserveTimestamps) {
@@ -690,5 +689,5 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ApiError.With('ENOSYS', path, 'statfs');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }

package/dist/{ApiError.d.ts → error.d.ts}

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /**
- * Standard libc error codes. More will be added to this enum and ErrorStrings as they are
+ * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
  * @url https://en.wikipedia.org/wiki/Errno.h
  */
-export declare enum ErrorCode {
+export declare enum Errno {
     /** Operation not permitted */
     EPERM = 1,
     /** No such file or directory */
@@ -159,13 +159,13 @@ export declare enum ErrorCode {
  * @internal
  */
 export declare const errorMessages: {
-    [K in ErrorCode]: string;
+    [K in Errno]: string;
 };
-interface ApiErrorJSON {
-    errno: ErrorCode;
+export interface ErrnoErrorJSON {
+    errno: Errno;
     message: string;
     path?: string;
-    code: keyof typeof ErrorCode;
+    code: keyof typeof Errno;
     stack: string;
     syscall: string;
 }
@@ -173,13 +173,14 @@ interface ApiErrorJSON {
  * Represents a ZenFS error. Passed back to applications after a failed
  * call to the ZenFS API.
  */
-export declare class ApiError extends Error implements NodeJS.ErrnoException {
-    errno: ErrorCode;
-    path?: string;
+export declare class ErrnoError extends Error implements NodeJS.ErrnoException {
+    errno: Errno;
+    path?: string | undefined;
     syscall: string;
-    static fromJSON(json: ApiErrorJSON): ApiError;
-    static With(code: keyof typeof ErrorCode, path: string, syscall?: string): ApiError;
-    code: keyof typeof ErrorCode;
+    static fromJSON(json: ErrnoErrorJSON): ErrnoError;
+    static With(code: keyof typeof Errno, path?: string, syscall?: string): ErrnoError;
+    code: keyof typeof Errno;
+    stack: string;
     /**
      * Represents a ZenFS error. Passed back to applications after a failed
      * call to the ZenFS API.
@@ -190,15 +191,14 @@ export declare class ApiError extends Error implements NodeJS.ErrnoException {
      * @param type The type of the error.
      * @param message A descriptive error message.
      */
-    constructor(errno: ErrorCode, message?: string, path?: string, syscall?: string);
+    constructor(errno: Errno, message?: string, path?: string | undefined, syscall?: string);
     /**
      * @return A friendly error message.
      */
     toString(): string;
-    toJSON(): ApiErrorJSON;
+    toJSON(): ErrnoErrorJSON;
     /**
      * The size of the API error in buffer-form in bytes.
      */
     bufferSize(): number;
 }
-export {};