@gjsify/fs 0.0.4 → 0.1.0

package/src/promises.ts

@@ -1,18 +1,16 @@
+// Reference: Node.js lib/internal/fs/promises.js
+// Reimplemented for GJS using Gio.File
+
 import Gio from '@girs/gio-2.0';
 import GLib from '@girs/glib-2.0';
-import { warnNotImplemented } from '@gjsify/utils';
-import { join } from 'path';
+import { join, dirname } from 'node:path';
 import { getEncodingFromOptions, encodeUint8Array, decode } from './encoding.js';
-import { writeFileSync, mkdirSync, rmdirSync, unlinkSync } from './sync.js';
+import { realpathSync, readdirSync as readdirSyncFn, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, linkSync } from './sync.js';
 import { FileHandle } from './file-handle.js';
 import { tempDirPath } from './utils.js';
 import { Dirent } from './dirent.js';
-
-import { realpathPromise as realpath } from '@gjsify/deno_std/node/_fs/_fs_realpath';
-import { readdirPromise as readdir } from '@gjsify/deno_std/node/_fs/_fs_readdir';
-import { symlinkPromise as symlink } from '@gjsify/deno_std/node/_fs/_fs_symlink';
-import { lstatPromise as lstat } from '@gjsify/deno_std/node/_fs/_fs_lstat';
-import { statPromise as stat } from '@gjsify/deno_std/node/_fs/_fs_stat';
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from './stats.js';
+import { createNodeError } from './errors.js';
 
 import type { 
   OpenFlags,
@@ -26,7 +24,7 @@ import type {
   BufferEncodingOption,
   MakeDirectoryOptions,
   RmDirOptions
-} from 'fs';
+} from 'node:fs';
 
 /**
  * Asynchronously creates a directory.
@@ -70,39 +68,110 @@ async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | nul
 async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined | void> {
 
   let recursive: boolean | undefined;
-  let mode: Mode | undefined = 0o777;
+  let _mode: Mode | undefined = 0o777;
 
   if (typeof options === 'object') {
     if(options.recursive) recursive = options.recursive;
-    if(options.mode) mode = options.mode
+    if(options.mode) _mode = options.mode
   } else {
-    mode = options;
+    _mode = options;
+  }
+
+  const pathStr = path.toString();
+
+  if (recursive) {
+    return mkdirRecursiveAsync(pathStr);
   }
 
-  // TODO async
-  const firstPath = mkdirSync(path, {
-    recursive,
-    mode
+  const file = Gio.File.new_for_path(pathStr);
+  return new Promise<undefined>((resolve, reject) => {
+    file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        file.make_directory_finish(res);
+        resolve(undefined);
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'mkdir', path));
+      }
+    });
   });
-  return firstPath;
+}
+
+/**
+ * Recursively creates directories, similar to `mkdir -p`.
+ * Returns the first directory path created, or undefined if all directories already existed.
+ */
+async function mkdirRecursiveAsync(pathStr: string): Promise<string | undefined> {
+  const file = Gio.File.new_for_path(pathStr);
+
+  // Try to create the directory directly first
+  try {
+    await new Promise<void>((resolve, reject) => {
+      file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+        try {
+          file.make_directory_finish(res);
+          resolve();
+        } catch (err: unknown) {
+          reject(err);
+        }
+      });
+    });
+    // This directory was created; it's the deepest one.
+    // Now check if we also created parents by recursing on the parent first.
+    // Since we succeeded directly, this is the "first created" path candidate.
+    return pathStr;
+  } catch (err: unknown) {
+    const gErr = err as { code?: number };
+    // If it already exists, nothing to create
+    if (gErr.code === Gio.IOErrorEnum.EXISTS) {
+      return undefined;
+    }
+    // If parent doesn't exist, create parent first then retry
+    if (gErr.code === Gio.IOErrorEnum.NOT_FOUND) {
+      const parentPath = dirname(pathStr);
+      if (parentPath === pathStr) {
+        // Reached root, cannot go further
+        throw createNodeError(err, 'mkdir', pathStr);
+      }
+      const firstCreated = await mkdirRecursiveAsync(parentPath);
+      // Now create this directory
+      const retryFile = Gio.File.new_for_path(pathStr);
+      await new Promise<void>((resolve, reject) => {
+        retryFile.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+          try {
+            retryFile.make_directory_finish(res);
+            resolve();
+          } catch (retryErr: unknown) {
+            reject(createNodeError(retryErr, 'mkdir', pathStr));
+          }
+        });
+      });
+      return firstCreated ?? pathStr;
+    }
+    throw createNodeError(err, 'mkdir', pathStr);
+  }
 }
 
 async function readFile(path: PathLike | FileHandle, options: ReadOptions = { encoding: null, flag: 'r' }) {
   const file = Gio.File.new_for_path(path.toString());
 
-  const [ok, data] = await new Promise<[boolean, Uint8Array, string]>((resolve, reject) => {
-    file.load_contents_async(null, (self, res) => {
-      try {
-        resolve(file.load_contents_finish(res));
-      } catch (error) {
-        reject(error);
-      }
+  let ok: boolean;
+  let data: Uint8Array;
+  try {
+    [ok, data] = await new Promise<[boolean, Uint8Array, string]>((resolve, reject) => {
+      file.load_contents_async(null, (self, res) => {
+        try {
+          resolve(file.load_contents_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
     });
-  });
+  } catch (error) {
+    throw createNodeError(error, 'open', path.toString() as PathLike);
+  }
 
   if (!ok) {
-    // TODO: throw a better error
-    throw new Error('failed to read file');
+    throw createNodeError(new Error('failed to read file'), 'open', path.toString() as PathLike);
   }
 
   return encodeUint8Array(getEncodingFromOptions(options, 'buffer'), data);
@@ -119,7 +188,7 @@ async function readFile(path: PathLike | FileHandle, options: ReadOptions = { en
  * object with an `encoding` property specifying the character encoding to use.
  *
  * ```js
- * import { mkdtemp } from 'fs/promises';
+ * import { mkdtemp } from 'node:fs/promises';
  *
  * try {
  *   await mkdtemp(path.join(os.tmpdir(), 'foo-'));
@@ -161,9 +230,57 @@ async function mkdtemp(prefix: string, options?: BufferEncodingOption | ObjectEn
   return decode(path, encoding);
 }
 
-async function writeFile(path: string, data: any) {
-  // TODO async
-  return writeFileSync(path, data);
+async function writeFile(path: string, data: string | Uint8Array | unknown) {
+  const file = Gio.File.new_for_path(path);
+
+  // Convert data to Uint8Array if it's a string
+  let bytes: Uint8Array;
+  if (typeof data === 'string') {
+    bytes = new TextEncoder().encode(data);
+  } else if (data instanceof Uint8Array) {
+    bytes = data;
+  } else {
+    // Fallback: convert to string first
+    bytes = new TextEncoder().encode(String(data));
+  }
+
+  // Open the file for writing (replace contents), creating if needed
+  const outputStream = await new Promise<Gio.FileOutputStream>((resolve, reject) => {
+    file.replace_async(null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        resolve(file.replace_finish(res));
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'open', path));
+      }
+    });
+  });
+
+  // Write the bytes to the stream (skip if empty — GLib rejects null/empty buffer)
+  if (bytes.length > 0) {
+    const glibBytes = new GLib.Bytes(bytes);
+    await new Promise<void>((resolve, reject) => {
+      outputStream.write_bytes_async(glibBytes, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+        try {
+          outputStream.write_bytes_finish(res);
+          resolve();
+        } catch (err: unknown) {
+          reject(createNodeError(err, 'write', path));
+        }
+      });
+    });
+  }
+
+  // Close the output stream
+  await new Promise<void>((resolve, reject) => {
+    outputStream.close_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        outputStream.close_finish(res);
+        resolve();
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'close', path));
+      }
+    });
+  });
 }
 
 /**
@@ -176,22 +293,67 @@ async function writeFile(path: string, data: any) {
  * @since v10.0.0
  * @return Fulfills with `undefined` upon success.
  */
-async function rmdir(path: PathLike, options?: RmDirOptions): Promise<void> {
-  // TODO async
-  return rmdirSync(path, options);
+async function rmdir(path: PathLike, _options?: RmDirOptions): Promise<void> {
+  const file = Gio.File.new_for_path(path.toString());
+  // Check if it's a directory
+  const info = await new Promise<Gio.FileInfo>((resolve, reject) => {
+    file.query_info_async('standard::type', Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        resolve(file.query_info_finish(res));
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'rmdir', path));
+      }
+    });
+  });
+  if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
+    const err = Object.assign(new Error(), { code: 4 }); // Gio.IOErrorEnum.NOT_DIRECTORY
+    throw createNodeError(err, 'rmdir', path);
+  }
+  // Check if empty
+  const children = await new Promise<Gio.FileEnumerator>((resolve, reject) => {
+    file.enumerate_children_async('standard::name', Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        resolve(file.enumerate_children_finish(res));
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'rmdir', path));
+      }
+    });
+  });
+  const firstChild = children.next_file(null);
+  if (firstChild !== null) {
+    const err = Object.assign(new Error(), { code: 5 }); // Gio.IOErrorEnum.NOT_EMPTY
+    throw createNodeError(err, 'rmdir', path);
+  }
+  // Delete the empty directory
+  await new Promise<void>((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'rmdir', path));
+      }
+    });
+  });
 }
 
-async function unlink(path: string) {
-  // TODO async
-  return unlinkSync(path);
+async function unlink(path: string): Promise<void> {
+  const file = Gio.File.new_for_path(path);
+  await new Promise<void>((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'unlink', path));
+      }
+    });
+  });
 }
 
 async function open(path: PathLike, flags?: OpenFlags, mode?: Mode): Promise<FileHandle> {
-  return new FileHandle({
-    path,
-    flags,
-    mode,
-  });
+  // FileHandle constructor maps GLib.FileError to NodeJS.ErrnoException on failure.
+  return new FileHandle({ path, flags, mode });
 }
 
 async function write<TBuffer extends Uint8Array>(
@@ -228,7 +390,7 @@ async function write<TBuffer extends Uint8Array>(
   if(typeof data === 'string') {
     return _writeStr(fd, data, positionOrOffset, encodingOrLength as BufferEncoding | null);
   }
-  return _writeBuf<any>(fd, data, positionOrOffset as number | null, encodingOrLength as  null | number, position);
+  return _writeBuf(fd, data, positionOrOffset as number | null, encodingOrLength as null | number, position) as unknown as Promise<{ bytesWritten: number; buffer: string }>;
 }
 
 async function _writeBuf<TBuffer extends Uint8Array>(
@@ -241,11 +403,9 @@ async function _writeBuf<TBuffer extends Uint8Array>(
   bytesWritten: number;
   buffer: TBuffer;
 }> {
-  warnNotImplemented("fs.promises.write");
-  return {
-    bytesWritten: 0,
-    buffer
-  }
+  const fileHandle = FileHandle.getInstance(fd);
+  const result = await fileHandle.write(buffer, offset, length, position);
+  return { bytesWritten: result.bytesWritten, buffer };
 }
 
 async function _writeStr(
@@ -257,61 +417,155 @@ async function _writeStr(
   bytesWritten: number;
   buffer: string;
 }> {
-  warnNotImplemented("fs.promises.write");
-  return {
-    bytesWritten: 0,
-    buffer: data,
+  const fileHandle = FileHandle.getInstance(fd);
+  const result = await fileHandle.write(data, position, encoding);
+  return { bytesWritten: result.bytesWritten, buffer: data };
+}
+
+// --- helpers ---
+
+function queryInfoAsync(path: PathLike, flags: Gio.FileQueryInfoFlags, syscall: string, options?: { bigint?: boolean }): Promise<Stats | BigIntStats> {
+  return new Promise((resolve, reject) => {
+    const file = Gio.File.new_for_path(path.toString());
+    file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        const info = file.query_info_finish(res);
+        resolve(options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+      } catch (err: unknown) {
+        reject(createNodeError(err, syscall, path));
+      }
+    });
+  });
+}
+
+// --- stat / lstat ---
+
+async function stat(path: PathLike, options?: { bigint?: boolean }): Promise<Stats | BigIntStats> {
+  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NONE, 'stat', options);
+}
+
+async function lstat(path: PathLike, options?: { bigint?: boolean }): Promise<Stats | BigIntStats> {
+  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, 'lstat', options);
+}
+
+// --- readdir / realpath / symlink — delegate to sync (sync is the canonical impl) ---
+
+async function readdir(path: PathLike, options?: { withFileTypes?: boolean; encoding?: string; recursive?: boolean }): Promise<string[] | Dirent[]> {
+  try {
+    return readdirSyncFn(path, options);
+  } catch (error) {
+    throw createNodeError(error, 'scandir', path);
   }
 }
 
+async function realpath(path: PathLike): Promise<string> {
+  return realpathSync(path);
+}
+
+async function symlink(target: PathLike, path: PathLike, _type?: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const file = Gio.File.new_for_path(path.toString());
+    file.make_symbolic_link_async(target.toString(), GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        file.make_symbolic_link_finish(res);
+        resolve();
+      } catch (err: unknown) {
+        reject(createNodeError(err, 'symlink', target, path));
+      }
+    });
+  });
+}
+
 /**
  * Removes files and directories (modeled on the standard POSIX `rm` utility).
  * @since v14.14.0
  * @return Fulfills with `undefined` upon success.
  */
 async function rm(path: PathLike, options?: RmOptions): Promise<void> {
-  const file = Gio.File.new_for_path(path.toString());
-
+  const pathStr = path.toString();
+  const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
-
-  const dirent = new Dirent(path.toString());
+  const force = options?.force || false;
+
+  let dirent: Dirent;
+  try {
+    dirent = new Dirent(pathStr);
+  } catch (err: unknown) {
+    if (force) return; // force: ignore non-existent paths
+    throw createNodeError(err, 'rm', path);
+  }
 
   if (dirent.isDirectory()) {
     const childFiles = await readdir(path, { withFileTypes: true });
 
     if (!recursive && childFiles.length) {
-      throw new Error('Dir is not empty!');
+      const err = Object.assign(new Error(), { code: 5 }); // Gio.IOErrorEnum.NOT_EMPTY
+      throw createNodeError(err, 'rm', path);
     }
-  
+
     for (const childFile of childFiles) {
-      if (childFile.isDirectory()) {
-        await rmdir(join(path.toString(), childFile.name), options);
-      } else if (childFile.isFile()) {
-        await rm(join(path.toString(), childFile.name), options);
+      if (typeof childFile !== 'string') {
+        await rm(join(pathStr, childFile.name), options);
       }
     }
   }
 
-  const ok = await new Promise<boolean>((resolve, reject) => {
-    try {
-      file.delete_async(GLib.PRIORITY_DEFAULT, null, (self, res) => {
-        try {
-          resolve(file.delete_finish(res));
-        } catch (error) {
-          reject(error);
-        }
-      });
-    } catch (error) {
-      reject(error);
-    }
-
+  await new Promise<void>((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_self: unknown, res: Gio.AsyncResult) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err: unknown) {
+        if (force) { resolve(); return; }
+        reject(createNodeError(err, 'rm', path));
+      }
+    });
   });
+}
 
-  if (!ok) {
-    // TODO: throw a better error
-    const err = new Error('failed to remove file ' + path);
-    throw err;
-  }
+// --- rename ---
+async function rename(oldPath: PathLike, newPath: PathLike): Promise<void> {
+  renameSync(oldPath, newPath);
+}
+
+// --- copyFile ---
+async function copyFile(src: PathLike, dest: PathLike, mode?: number): Promise<void> {
+  copyFileSync(src, dest, mode);
+}
+
+// --- access ---
+async function access(path: PathLike, mode?: number): Promise<void> {
+  accessSync(path, mode);
+}
+
+// --- appendFile ---
+async function appendFile(path: PathLike, data: string | Uint8Array, options?: { encoding?: string; mode?: number; flag?: string } | string): Promise<void> {
+  appendFileSync(path, data, options);
+}
+
+// --- readlink ---
+async function readlink(path: PathLike, options?: { encoding?: string } | string): Promise<string | Buffer> {
+  return readlinkSync(path, options);
+}
+
+// --- truncate ---
+async function truncate(path: PathLike, len?: number): Promise<void> {
+  truncateSync(path, len);
+}
+
+// --- chmod ---
+async function chmod(path: PathLike, mode: number | string): Promise<void> {
+  chmodSync(path, mode);
+}
+
+// --- chown ---
+async function chown(path: PathLike, uid: number, gid: number): Promise<void> {
+  chownSync(path, uid, gid);
+}
+
+// --- link ---
+async function link(existingPath: PathLike, newPath: PathLike): Promise<void> {
+  linkSync(existingPath, newPath);
 }
 
 export {
@@ -329,6 +583,15 @@ export {
   lstat,
   symlink,
   stat,
+  rename,
+  copyFile,
+  access,
+  appendFile,
+  readlink,
+  truncate,
+  chmod,
+  chown,
+  link,
 };
 
 export default {
@@ -346,4 +609,13 @@ export default {
   lstat,
   symlink,
   stat,
+  rename,
+  copyFile,
+  access,
+  appendFile,
+  readlink,
+  truncate,
+  chmod,
+  chown,
+  link,
 };