@gjsify/fs 0.1.13 → 0.2.0

package/lib/esm/file-handle.js

@@ -1,63 +1,150 @@
-import { warnNotImplemented, notImplemented } from "@gjsify/utils";
+import { createGLibFileError } from "@gjsify/utils";
 import { ReadStream } from "./read-stream.js";
 import { WriteStream } from "./write-stream.js";
-import { Stats } from "./stats.js";
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
 import { getEncodingFromOptions, encodeUint8Array } from "./encoding.js";
+import { normalizePath } from "./utils.js";
+import { chmodSync, chownSync } from "./sync.js";
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
+import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
-const GLIB_FILE_ERROR_TO_NODE = {
-  0: "EEXIST",
-  1: "EISDIR",
-  2: "EACCES",
-  3: "ENAMETOOLONG",
-  4: "ENOENT",
-  5: "ENOTDIR",
-  6: "ENXIO",
-  7: "ENODEV",
-  8: "EROFS",
-  11: "ELOOP",
-  12: "ENOSPC",
-  13: "ENOMEM",
-  14: "EMFILE",
-  15: "ENFILE",
-  16: "EBADF",
-  17: "EINVAL",
-  18: "EPIPE",
-  21: "EIO",
-  22: "EPERM",
-  24: "EIO"
-};
+const O_WRONLY = 1;
+const O_RDWR = 2;
+const O_CREAT = 64;
+const O_TRUNC = 512;
+const O_APPEND = 1024;
+function resolveIOMode(flags) {
+  if (flags === void 0 || flags === null) return "r";
+  if (typeof flags === "number") {
+    const rdwr = (flags & O_RDWR) !== 0;
+    const wronly = (flags & O_WRONLY) !== 0;
+    const append = (flags & O_APPEND) !== 0;
+    const trunc = (flags & O_TRUNC) !== 0;
+    if (rdwr) return trunc ? "w+" : "r+";
+    if (wronly) return append ? "a" : "w";
+    return "r";
+  }
+  switch (flags) {
+    case "ax":
+    case "wx":
+      return "w";
+    case "ax+":
+    case "wx+":
+      return "w+";
+    case "as":
+    case "rs+":
+      return "r+";
+    case "as+":
+      return "a+";
+    default:
+      return flags;
+  }
+}
+function openIOChannel(path, mode, creat) {
+  try {
+    return GLib.IOChannel.new_file(path, mode);
+  } catch (err) {
+    const gErr = err;
+    if (creat && mode === "r+" && gErr?.code === GLib.FileError.NOENT) {
+      GLib.file_set_contents(path, new Uint8Array(0));
+      return GLib.IOChannel.new_file(path, mode);
+    }
+    throw err;
+  }
+}
 function mapOpenError(err, path) {
-  const gErr = err;
-  const msg = gErr?.message ?? "";
-  const code = GLIB_FILE_ERROR_TO_NODE[gErr?.code ?? -1] ?? "EIO";
-  const error = new Error(`${code}: ${msg || "unknown error"}, open '${path}'`);
-  error.code = code;
-  error.syscall = "open";
-  error.path = path;
-  return error;
+  return createGLibFileError(err, "open", { path });
 }
 class FileHandle {
   constructor(options) {
     this.options = options;
     this.options.flags ||= "r";
     this.options.mode ||= 438;
+    const pathStr = normalizePath(options.path);
+    const creat = typeof options.flags === "number" && (options.flags & O_CREAT) !== 0;
+    const ioMode = resolveIOMode(options.flags);
     try {
-      this._file = GLib.IOChannel.new_file(options.path.toString(), this.options.flags);
+      this._file = openIOChannel(pathStr, ioMode, creat);
     } catch (err) {
-      throw mapOpenError(err, options.path.toString());
+      throw mapOpenError(err, pathStr);
     }
     this._file.set_encoding(null);
     this.fd = this._file.unix_get_fd();
+    this._gFile = Gio.File.new_for_path(pathStr);
+    this._ioMode = ioMode;
     FileHandle.instances[this.fd] = this;
     return FileHandle.getInstance(this.fd);
   }
   options;
   /** Not part of the default implementation, used internal by gjsify */
   _file;
+  /**
+   * Lazily-opened Gio streams for positional read() / write() so each call does
+   * not re-load the entire file via Gio.File.load_contents(). The IOStream is
+   * used when the handle was opened with write capability (r+, w, w+, a, a+) —
+   * it shares seek state between input and output so writes are visible to
+   * subsequent reads without a flush. For read-only handles we only open a
+   * FileInputStream; trying to open_readwrite on a read-only file can fall
+   * back to create_readwrite(REPLACE_DESTINATION) which would truncate it.
+   */
+  _ioStream = null;
+  _readStream = null;
+  _gFile;
+  _ioMode;
+  // Serialize async I/O on the shared FileIOStream. Concurrent write_bytes_async
+  // calls hit Gio.IOErrorEnum.PENDING ("Datenstrom hat noch einen ausstehenden
+  // Vorgang"); overlapping seek()s on the shared cursor also corrupt positions.
+  // random-access-file (used by fs-chunk-store / webtorrent) issues many
+  // concurrent positional writes, so every async op on this handle chains
+  // through _ioLock.
+  _ioLock = Promise.resolve();
   /** Not part of the default implementation, used internal by gjsify */
   static instances = {};
+  /**
+   * Lazy-open the read-capable stream and return both the input stream and
+   * its seekable view. Both FileInputStream (read-only handle) and
+   * FileIOStream (read/write handle) implement Gio.Seekable, but we return
+   * both to avoid callers needing to know which concrete type they got.
+   */
+  _getReadStream() {
+    if (this._ioStream) {
+      return {
+        input: this._ioStream.get_input_stream(),
+        seekable: this._ioStream
+      };
+    }
+    if (this._ioMode === "r") {
+      if (!this._readStream) this._readStream = this._gFile.read(null);
+      return {
+        input: this._readStream,
+        seekable: this._readStream
+      };
+    }
+    this._ioStream = this._gFile.open_readwrite(null);
+    return {
+      input: this._ioStream.get_input_stream(),
+      seekable: this._ioStream
+    };
+  }
+  /** Lazy-open the write-capable stream (IOStream) for this handle. Only valid
+   *  when the handle was opened with a write-capable mode. */
+  _getWriteStream() {
+    if (this._ioStream) return this._ioStream;
+    if (this._ioMode === "r") {
+      throw new Error("FileHandle opened read-only; cannot write");
+    }
+    this._ioStream = this._gFile.open_readwrite(null);
+    return this._ioStream;
+  }
+  /** Serialize an async operation on the shared FileIOStream. */
+  _serialize(op) {
+    const prev = this._ioLock;
+    const next = prev.catch(() => {
+    }).then(op);
+    this._ioLock = next;
+    return next;
+  }
   /**
    * The numeric file descriptor managed by the {FileHandle} object.
    * @since v10.0.0
@@ -98,7 +185,7 @@ class FileHandle {
    * @return Fulfills with `undefined` upon success.
    */
   async chown(uid, gid) {
-    warnNotImplemented("fs.FileHandle.chown");
+    chownSync(normalizePath(this.options.path), uid, gid);
   }
   /**
    * Modifies the permissions on the file. See [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html).
@@ -107,7 +194,7 @@ class FileHandle {
    * @return Fulfills with `undefined` upon success.
    */
   async chmod(mode) {
-    warnNotImplemented("fs.FileHandle.chmod");
+    chmodSync(normalizePath(this.options.path), mode);
   }
   /**
    * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream
@@ -193,7 +280,7 @@ class FileHandle {
    * @return Fulfills with `undefined` upon success.
    */
   async datasync() {
-    warnNotImplemented("fs.FileHandle.datasync");
+    this._file.flush();
   }
   /**
    * Request that all data for the open file descriptor is flushed to the storage
@@ -203,7 +290,7 @@ class FileHandle {
    * @return Fufills with `undefined` upon success.
    */
   async sync() {
-    warnNotImplemented("fs.FileHandle.sync");
+    this._file.flush();
   }
   async read(...args) {
     let buffer;
@@ -225,19 +312,18 @@ class FileHandle {
     const bufView = buffer;
     const bufOffset = offset ?? 0;
     const readLength = length ?? bufView?.byteLength ?? 65536;
-    const gFile = Gio.File.new_for_path(this.options.path.toString());
-    const [, fileContents] = gFile.load_contents(null);
-    const fileData = fileContents;
     const startPos = position ?? 0;
-    const readData = fileData.slice(startPos, startPos + readLength);
-    const bytesRead = readData.length;
-    if (bufView && bytesRead > 0) {
-      bufView.set(readData, bufOffset);
-    }
-    return {
-      bytesRead,
-      buffer
-    };
+    return this._serialize(async () => {
+      const { input, seekable } = this._getReadStream();
+      seekable.seek(BigInt(startPos), GLib.SeekType.SET, null);
+      const bytes = input.read_bytes(readLength, null);
+      const data = bytes.get_data();
+      const bytesRead = data?.length ?? 0;
+      if (bufView && data && bytesRead > 0) {
+        bufView.set(data, bufOffset);
+      }
+      return { bytesRead, buffer };
+    });
   }
   /**
    * Returns a `ReadableStream` that may be used to read the files data.
@@ -303,11 +389,20 @@ class FileHandle {
    * @param options See `filehandle.createReadStream()` for the options.
    */
   readLines(options) {
-    notImplemented("fs.FileHandle.readLines");
+    return createInterface({ input: this.createReadStream(options), crlfDelay: Infinity });
   }
   async stat(opts) {
-    warnNotImplemented("fs.FileHandle.stat");
-    return new Stats(this.options.path.toString());
+    const info = await new Promise((resolve, reject) => {
+      this._gFile.query_info_async(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+        try {
+          resolve(this._gFile.query_info_finish(res));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+    const pathStr = normalizePath(this.options.path);
+    return opts?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
   }
   /**
    * Truncates the file.
@@ -340,18 +435,16 @@ class FileHandle {
   async truncate(len = 0) {
     const effectiveLen = Math.max(0, len);
     this._file.flush();
-    const gFile = Gio.File.new_for_path(this.options.path.toString());
-    const [, currentContent] = gFile.load_contents(null);
-    const newContent = new Uint8Array(effectiveLen);
-    newContent.set(currentContent.slice(0, Math.min(effectiveLen, currentContent.length)));
-    gFile.replace_contents(newContent, null, false, Gio.FileCreateFlags.NONE, null);
+    const out = this._getWriteStream().get_output_stream();
+    out.truncate(effectiveLen, null);
   }
   /**
    * Change the file system timestamps of the object referenced by the `FileHandle` then resolves the promise with no arguments upon success.
    * @since v10.0.0
    */
   async utimes(atime, mtime) {
-    warnNotImplemented("fs.FileHandle.utimes");
+    const { utimesSync } = await import("./utimes.js");
+    utimesSync(normalizePath(this.options.path), atime, mtime);
   }
   /**
    * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
@@ -410,21 +503,33 @@ class FileHandle {
     const writeLength = length ?? writeBuf.byteLength - bufOffset;
     const writeSlice = writeBuf.slice(bufOffset, bufOffset + writeLength);
     const writePos = position ?? 0;
-    const gFile = Gio.File.new_for_path(this.options.path.toString());
-    let existingData;
-    try {
-      const [, existing] = gFile.load_contents(null);
-      existingData = existing;
-    } catch {
-      existingData = new Uint8Array(0);
-    }
-    const newSize = Math.max(existingData.length, writePos + writeSlice.length);
-    const newContent = new Uint8Array(newSize);
-    newContent.set(existingData);
-    newContent.set(writeSlice, writePos);
-    gFile.replace_contents(newContent, null, false, Gio.FileCreateFlags.NONE, null);
+    const bytesWritten = await this._serialize(async () => {
+      const stream = this._getWriteStream();
+      stream.seek(BigInt(writePos), GLib.SeekType.SET, null);
+      const output = stream.get_output_stream();
+      const written = await new Promise((resolve, reject) => {
+        output.write_bytes_async(new GLib.Bytes(writeSlice), GLib.PRIORITY_DEFAULT, null, (_source, asyncResult) => {
+          try {
+            resolve(output.write_bytes_finish(asyncResult));
+          } catch (err) {
+            reject(err);
+          }
+        });
+      });
+      await new Promise((resolve, reject) => {
+        output.flush_async(GLib.PRIORITY_DEFAULT, null, (_source, asyncResult) => {
+          try {
+            output.flush_finish(asyncResult);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      });
+      return written;
+    });
     return {
-      bytesWritten: writeSlice.length,
+      bytesWritten,
       buffer: data
     };
   }
@@ -444,11 +549,18 @@ class FileHandle {
    * position.
    */
   async writev(buffers, position) {
-    warnNotImplemented("fs.FileHandle.writev");
-    return {
-      bytesWritten: 0,
-      buffers
-    };
+    let bytesWritten = 0;
+    for (const buf of buffers) {
+      const b = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+      const res = await this.write(
+        b,
+        0,
+        b.byteLength,
+        position != null ? position + bytesWritten : null
+      );
+      bytesWritten += res.bytesWritten;
+    }
+    return { bytesWritten, buffers };
   }
   /**
    * Read from a file and write to an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s
@@ -457,11 +569,65 @@ class FileHandle {
    * @return Fulfills upon success an object containing two properties:
    */
   async readv(buffers, position) {
-    warnNotImplemented("fs.FileHandle.readv");
-    return {
-      bytesRead: 0,
-      buffers
-    };
+    let bytesRead = 0;
+    for (const buf of buffers) {
+      const res = await this.read({
+        buffer: Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength),
+        position: position != null ? position + bytesRead : null
+      });
+      bytesRead += res.bytesRead;
+      if (res.bytesRead < buf.byteLength) break;
+    }
+    return { bytesRead, buffers };
+  }
+  /** @internal */
+  _flushSync() {
+    this._file.flush();
+  }
+  /** @internal */
+  _closeSync() {
+    try {
+      this._ioStream?.close(null);
+    } catch {
+    }
+    try {
+      this._readStream?.close(null);
+    } catch {
+    }
+    this._ioStream = null;
+    this._readStream = null;
+    try {
+      this._file.shutdown(true);
+    } catch {
+    }
+    delete FileHandle.instances[this.fd];
+  }
+  /** @internal */
+  _readSync(buffer, offset, length, position) {
+    const stream = this._gFile.read(null);
+    try {
+      if (position !== null && position >= 0) {
+        stream.seek(position, GLib.SeekType.SET, null);
+      }
+      const bytes = stream.read_bytes(length, null);
+      const arr = bytes.get_data();
+      new Uint8Array(buffer.buffer, buffer.byteOffset + offset).set(arr.subarray(0, arr.length));
+      return arr.length;
+    } finally {
+      stream.close(null);
+    }
+  }
+  /** @internal */
+  _writeSync(data, position) {
+    const stream = this._gFile.open_readwrite(null);
+    try {
+      if (position !== null && position >= 0) {
+        stream.seek(position, GLib.SeekType.SET, null);
+      }
+      return stream.get_output_stream().write_bytes(GLib.Bytes.new(data), null);
+    } finally {
+      stream.close(null);
+    }
   }
   /**
    * Closes the file handle after waiting for any pending operation on the handle to
@@ -481,7 +647,20 @@ class FileHandle {
    * @return Fulfills with `undefined` upon success.
    */
   async close() {
-    this._file.shutdown(true);
+    try {
+      this._ioStream?.close(null);
+    } catch {
+    }
+    try {
+      this._readStream?.close(null);
+    } catch {
+    }
+    this._ioStream = null;
+    this._readStream = null;
+    try {
+      this._file.shutdown(true);
+    } catch {
+    }
   }
   async [Symbol.asyncDispose]() {
     await this.close();

package/lib/esm/fs-watcher.js

@@ -1,6 +1,7 @@
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
 import { EventEmitter } from "node:events";
+import { normalizePath } from "./utils.js";
 const privates = /* @__PURE__ */ new WeakMap();
 class FSWatcher extends EventEmitter {
   constructor(filename, options, listener) {
@@ -9,12 +10,17 @@ class FSWatcher extends EventEmitter {
       options = { persistent: true };
     const persistent = options.persistent !== false;
     const cancellable = Gio.Cancellable.new();
-    const file = Gio.File.new_for_path(filename);
+    const pathStr = normalizePath(filename);
+    const file = Gio.File.new_for_path(pathStr);
     const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
     watcher.connect("changed", changed.bind(this));
     let sourceId = null;
     if (persistent) {
-      sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+      sourceId = GLib.timeout_add(
+        GLib.PRIORITY_LOW,
+        2147483647,
+        () => GLib.SOURCE_CONTINUE
+      );
     }
     privates.set(this, {
       persistent,
@@ -45,7 +51,11 @@ class FSWatcher extends EventEmitter {
     const priv = privates.get(this);
     if (!priv.persistent && !priv.cancellable.is_cancelled()) {
       priv.persistent = true;
-      priv.sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+      priv.sourceId = GLib.timeout_add(
+        GLib.PRIORITY_LOW,
+        2147483647,
+        () => GLib.SOURCE_CONTINUE
+      );
     }
     return this;
   }
@@ -81,7 +91,81 @@ function changed(watcher, file, otherFile, eventType) {
   }
 }
 var fs_watcher_default = FSWatcher;
+function gioEventToNodeType(eventType) {
+  switch (eventType) {
+    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
+      return "change";
+    case Gio.FileMonitorEvent.DELETED:
+    case Gio.FileMonitorEvent.CREATED:
+    case Gio.FileMonitorEvent.RENAMED:
+    case Gio.FileMonitorEvent.MOVED_IN:
+    case Gio.FileMonitorEvent.MOVED_OUT:
+      return "rename";
+    default:
+      return null;
+  }
+}
+async function* watchAsync(filename, options) {
+  const signal = options?.signal;
+  if (signal?.aborted) return;
+  const pathStr = normalizePath(filename);
+  const file = Gio.File.new_for_path(pathStr);
+  const cancellable = Gio.Cancellable.new();
+  let watcher;
+  try {
+    watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
+  } catch {
+    return;
+  }
+  const eventQueue = [];
+  const waiterQueue = [];
+  let finished = false;
+  function enqueue(event) {
+    if (finished) return;
+    if (waiterQueue.length > 0) {
+      waiterQueue.shift().resolve({ value: event, done: false });
+    } else {
+      eventQueue.push(event);
+    }
+  }
+  function terminate() {
+    if (finished) return;
+    finished = true;
+    if (!cancellable.is_cancelled()) cancellable.cancel();
+    while (waiterQueue.length > 0) {
+      waiterQueue.shift().resolve({ value: void 0, done: true });
+    }
+  }
+  const signalId = watcher.connect("changed", (_mon, changedFile, _otherFile, eventType) => {
+    const type = gioEventToNodeType(eventType);
+    if (type === null) return;
+    enqueue({ eventType: type, filename: changedFile?.get_basename() ?? null });
+  });
+  const abortHandler = () => terminate();
+  signal?.addEventListener("abort", abortHandler);
+  try {
+    while (!finished) {
+      if (eventQueue.length > 0) {
+        yield eventQueue.shift();
+        continue;
+      }
+      const result = await new Promise((resolve) => {
+        waiterQueue.push({ resolve });
+      });
+      if (result.done) break;
+      yield result.value;
+    }
+  } finally {
+    signal?.removeEventListener("abort", abortHandler);
+    try {
+      watcher.disconnect(signalId);
+    } catch {
+    }
+    if (!cancellable.is_cancelled()) cancellable.cancel();
+  }
+}
 export {
   FSWatcher,
-  fs_watcher_default as default
+  fs_watcher_default as default,
+  watchAsync
 };