@zenfs/core 0.1.0 → 0.2.0

package/dist/emulation/sync.js

@@ -1,10 +1,10 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
-import { FileFlag } from '../file.js';
-import { BigIntStats } from '../stats.js';
+import { ActionType, FileFlag } from '../file.js';
+import { BigIntStats, FileType } from '../stats.js';
 import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts, } from './shared.js';
 import { decode, encode } from '../utils.js';
 import { Dirent } from './dir.js';
-import { join } from './path.js';
+import { dirname, join } from './path.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -74,10 +74,13 @@ lstatSync;
  * @param len
  */
 export function truncateSync(path, len = 0) {
-    if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+    const fd = openSync(path, 'r+');
+    try {
+        ftruncateSync(fd, len);
+    }
+    finally {
+        closeSync(fd);
     }
-    return doOp('truncateSync', true, path, len, cred);
 }
 truncateSync;
 /**
@@ -88,51 +91,146 @@ export function unlinkSync(path) {
     return doOp('unlinkSync', false, path, cred);
 }
 unlinkSync;
+function _openSync(_path, _flag, _mode, resolveSymlinks) {
+    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = FileFlag.FromString(_flag);
+    // Check if the path exists, and is a file.
+    let stats;
+    try {
+        stats = doOp('statSync', resolveSymlinks, path, cred);
+    }
+    catch (e) {
+        // File does not exist.
+        switch (flag.pathNotExistsAction()) {
+            case ActionType.CREATE:
+                // Ensure parent exists.
+                const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
+                if (!parentStats.isDirectory()) {
+                    throw ApiError.ENOTDIR(dirname(path));
+                }
+                return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
+            case ActionType.THROW:
+                throw ApiError.ENOENT(path);
+            default:
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+        }
+    }
+    if (!stats.hasAccess(mode, cred)) {
+        throw ApiError.EACCES(path);
+    }
+    // File exists.
+    switch (flag.pathExistsAction()) {
+        case ActionType.THROW:
+            throw ApiError.EEXIST(path);
+        case ActionType.TRUNCATE:
+            // Delete file.
+            doOp('unlinkSync', resolveSymlinks, path, cred);
+            /*
+                Create file. Use the same mode as the old file.
+                Node itself modifies the ctime when this occurs, so this action
+                will preserve that behavior if the underlying file system
+                supports those properties.
+            */
+            return doOp('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+        case ActionType.NOP:
+            return doOp('openFileSync', resolveSymlinks, path, flag, cred);
+        default:
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+    }
+}
 /**
  * Synchronous file open.
  * @see http://www.manpagez.com/man/2/open/
- * @param path
- * @param flags
- * @param mode defaults to `0644`
- * @returns file descriptor
+ * @param flags Handles the complexity of the various file
+ *   modes. See its API for more details.
+ * @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 = 0o644) {
-    const file = doOp('openSync', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
-    return getFdForFile(file);
+export function openSync(path, flag, mode) {
+    return getFdForFile(_openSync(path, flag, mode, true));
 }
 openSync;
+/**
+ * Opens a file or symlink
+ * @internal
+ */
+export function lopenSync(path, flag, mode) {
+    return getFdForFile(_openSync(path, flag, mode, false));
+}
+/**
+ * Synchronously reads the entire contents of a file.
+ */
+function _readFileSync(fname, flag, resolveSymlinks) {
+    // Get file.
+    const file = _openSync(fname, flag, 0o644, resolveSymlinks);
+    try {
+        const stat = file.statSync();
+        // Allocate buffer.
+        const data = new Uint8Array(stat.size);
+        file.readSync(data, 0, stat.size, 0);
+        file.closeSync();
+        return data;
+    }
+    finally {
+        file.closeSync();
+    }
+}
 export function readFileSync(filename, arg2 = {}) {
-    const options = normalizeOptions(arg2, null, 'r', null);
-    const flag = FileFlag.getFileFlag(options.flag);
+    const options = normalizeOptions(arg2, null, 'r', 0o644);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isReadable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = doOp('readFileSync', true, filename, flag, cred);
-    switch (options.encoding) {
-        case 'utf8':
-        case 'utf-8':
-            return decode(data);
-        default:
-            return data;
-    }
+    const data = _readFileSync(filename, options.flag, true);
+    return options.encoding ? decode(data, options.encoding) : data;
 }
 readFileSync;
-export function writeFileSync(filename, data, arg3) {
-    const options = normalizeOptions(arg3, 'utf8', 'w', 0o644);
-    const flag = FileFlag.getFileFlag(options.flag);
+/**
+ * Synchronously writes data to a file, replacing the file
+ * if it already exists.
+ *
+ * The encoding option is ignored if data is a buffer.
+ */
+function _writeFileSync(fname, data, flag, mode, resolveSymlinks) {
+    const file = _openSync(fname, flag, mode, resolveSymlinks);
+    try {
+        file.writeSync(data, 0, data.length, 0);
+    }
+    finally {
+        file.closeSync();
+    }
+}
+export function writeFileSync(filename, data, _options) {
+    const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isWriteable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
     }
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('writeFileSync', true, filename, encodedData, flag, options.mode, cred);
+    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
+    if (encodedData === undefined) {
+        throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
+    }
+    _writeFileSync(filename, encodedData, options.flag, options.mode, true);
 }
 writeFileSync;
+/**
+ * Synchronously append data to a file, creating the file if
+ * it not yet exists.
+ */
+function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
+    const file = _openSync(fname, flag, mode, resolveSymlinks);
+    try {
+        file.writeSync(data, 0, data.length, null);
+    }
+    finally {
+        file.closeSync();
+    }
+}
 export function appendFileSync(filename, data, arg3) {
     const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
-    const flag = FileFlag.getFileFlag(options.flag);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isAppendable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
@@ -140,7 +238,7 @@ export function appendFileSync(filename, data, arg3) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
     const encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('appendFileSync', true, filename, encodedData, flag, options.mode, cred);
+    _appendFileSync(filename, encodedData, options.flag, options.mode, true);
 }
 appendFileSync;
 export function fstatSync(fd, options) {
@@ -163,11 +261,10 @@ closeSync;
  * @param len
  */
 export function ftruncateSync(fd, len = 0) {
-    const file = fd2file(fd);
     if (len < 0) {
         throw new ApiError(ErrorCode.EINVAL);
     }
-    file.truncateSync(len);
+    fd2file(fd).truncateSync(len);
 }
 ftruncateSync;
 /**
@@ -186,26 +283,26 @@ export function fdatasyncSync(fd) {
     fd2file(fd).datasyncSync();
 }
 fdatasyncSync;
-export function writeSync(fd, arg2, arg3, arg4, arg5) {
+export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
     let buffer, offset = 0, length, position;
-    if (typeof arg2 === 'string') {
+    if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]])
-        position = typeof arg3 === 'number' ? arg3 : null;
-        const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
+        position = typeof posOrOff === 'number' ? posOrOff : null;
+        const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
         offset = 0;
-        buffer = encode(arg2);
+        buffer = encode(data, encoding);
         length = buffer.length;
     }
     else {
         // Signature 2: (fd, buffer, offset, length, position?)
-        buffer = arg2;
-        offset = arg3;
-        length = arg4;
-        position = typeof arg5 === 'number' ? arg5 : null;
+        buffer = data;
+        offset = posOrOff;
+        length = lenOrEnc;
+        position = typeof pos === 'number' ? pos : null;
     }
     const file = fd2file(fd);
     if (position === undefined || position === null) {
-        position = file.getPos();
+        position = file.position;
     }
     return file.writeSync(buffer, offset, length, position);
 }
@@ -217,7 +314,7 @@ export function readSync(fd, buffer, opts, length, position) {
         ({ offset, length, position } = opts);
     }
     if (isNaN(+position)) {
-        position = file.getPos();
+        position = file.position;
     }
     return file.readSync(buffer, offset, length, position);
 }
@@ -238,7 +335,10 @@ fchownSync;
  * @param mode
  */
 export function fchmodSync(fd, mode) {
-    const numMode = typeof mode === 'string' ? parseInt(mode, 8) : mode;
+    const numMode = normalizeMode(mode, -1);
+    if (numMode < 0) {
+        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+    }
     fd2file(fd).chmodSync(numMode);
 }
 fchmodSync;
@@ -253,7 +353,6 @@ export function futimesSync(fd, atime, mtime) {
     fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
 }
 futimesSync;
-// DIRECTORY-ONLY METHODS
 /**
  * Synchronous `rmdir`.
  * @param path
@@ -296,31 +395,39 @@ readdirSync;
 // SYMLINK METHODS
 /**
  * Synchronous `link`.
- * @param srcpath
- * @param dstpath
+ * @param existing
+ * @param newpath
  */
-export function linkSync(srcpath, dstpath) {
-    dstpath = normalizePath(dstpath);
-    return doOp('linkSync', false, srcpath, dstpath, cred);
+export function linkSync(existing, newpath) {
+    newpath = normalizePath(newpath);
+    return doOp('linkSync', false, existing, newpath, cred);
 }
 linkSync;
 /**
  * Synchronous `symlink`.
- * @param srcpath
- * @param dstpath
+ * @param target target path
+ * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export function symlinkSync(srcpath, dstpath, type) {
+export function symlinkSync(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
     }
-    dstpath = normalizePath(dstpath);
-    return doOp('symlinkSync', false, srcpath, dstpath, type, cred);
+    if (existsSync(path)) {
+        throw ApiError.EEXIST(path);
+    }
+    writeFileSync(path, target);
+    const file = _openSync(path, 'r+', 0o644, false);
+    file._setTypeSync(FileType.SYMLINK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = doOp('readlinkSync', false, path, cred);
-    return encode(value, typeof options == 'object' ? options.encoding : options);
+    const value = _readFileSync(path, 'r', false);
+    const encoding = typeof options == 'object' ? options.encoding : options;
+    if (encoding == 'buffer') {
+        return value;
+    }
+    return decode(value, encoding);
 }
 readlinkSync;
 // PROPERTY OPERATIONS
@@ -331,7 +438,9 @@ readlinkSync;
  * @param gid
  */
 export function chownSync(path, uid, gid) {
-    doOp('chownSync', true, path, uid, gid, cred);
+    const fd = openSync(path, 'r+');
+    fchownSync(fd, uid, gid);
+    closeSync(fd);
 }
 chownSync;
 /**
@@ -341,7 +450,9 @@ chownSync;
  * @param gid
  */
 export function lchownSync(path, uid, gid) {
-    doOp('chownSync', false, path, uid, gid, cred);
+    const fd = lopenSync(path, 'r+');
+    fchownSync(fd, uid, gid);
+    closeSync(fd);
 }
 lchownSync;
 /**
@@ -350,11 +461,9 @@ lchownSync;
  * @param mode
  */
 export function chmodSync(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 0) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-    }
-    doOp('chmodSync', true, path, numMode, cred);
+    const fd = openSync(path, 'r+');
+    fchmodSync(fd, mode);
+    closeSync(fd);
 }
 chmodSync;
 /**
@@ -363,11 +472,9 @@ chmodSync;
  * @param mode
  */
 export function lchmodSync(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 1) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-    }
-    doOp('chmodSync', false, path, numMode, cred);
+    const fd = lopenSync(path, 'r+');
+    fchmodSync(fd, mode);
+    closeSync(fd);
 }
 lchmodSync;
 /**
@@ -377,7 +484,9 @@ lchmodSync;
  * @param mtime
  */
 export function utimesSync(path, atime, mtime) {
-    doOp('utimesSync', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    const fd = openSync(path, 'r+');
+    futimesSync(fd, atime, mtime);
+    closeSync(fd);
 }
 utimesSync;
 /**
@@ -387,7 +496,9 @@ utimesSync;
  * @param mtime
  */
 export function lutimesSync(path, atime, mtime) {
-    doOp('utimesSync', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    const fd = lopenSync(path, 'r+');
+    futimesSync(fd, atime, mtime);
+    closeSync(fd);
 }
 lutimesSync;
 export function realpathSync(path, options) {
@@ -398,7 +509,7 @@ export function realpathSync(path, options) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = normalizePath(mountPoint + fs.readlinkSync(resolvedPath, cred));
+        const dst = normalizePath(mountPoint + decode(_readFileSync(resolvedPath, 'r+', false)));
         return realpathSync(dst);
     }
     catch (e) {
@@ -412,7 +523,10 @@ realpathSync;
  * @param mode
  */
 export function accessSync(path, mode = 0o600) {
-    return doOp('accessSync', true, path, mode, cred);
+    const stats = statSync(path);
+    if (!stats.hasAccess(mode, cred)) {
+        throw new ApiError(ErrorCode.EACCES);
+    }
 }
 accessSync;
 export function rmSync(path) {