@gjsify/fs 0.0.4 → 0.1.1

package/src/sync.ts

@@ -1,23 +1,20 @@
+// Reference: Node.js lib/fs.js (sync API)
+// Reimplemented for GJS using Gio.File synchronous operations
+
 import GLib from '@girs/glib-2.0';
 import Gio from '@girs/gio-2.0';
 import { existsSync } from '@gjsify/utils';
-import { Buffer } from 'buffer';
-import { join } from 'path';
+import { Buffer } from 'node:buffer';
+import { join } from 'node:path';
 
 import FSWatcher from './fs-watcher.js';
 import { getEncodingFromOptions, encodeUint8Array, decode } from './encoding.js';
 import { FileHandle } from './file-handle.js';
 import { Dirent } from './dirent.js';
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from './stats.js';
+import { createNodeError, isNotFoundError } from './errors.js';
 import { tempDirPath } from './utils.js';
 
-export { realpathSync } from '@gjsify/deno_std/node/_fs/_fs_realpath';
-import { readdirSync } from '@gjsify/deno_std/node/_fs/_fs_readdir';
-export { symlinkSync } from '@gjsify/deno_std/node/_fs/_fs_symlink';
-export { lstatSync } from '@gjsify/deno_std/node/_fs/_fs_lstat';
-export { statSync } from '@gjsify/deno_std/node/_fs/_fs_stat';
-
-
-
 import type { OpenFlags, EncodingOption } from './types/index.js';
 import type {
   PathLike,
@@ -26,21 +23,131 @@ import type {
   BufferEncodingOption,
   RmOptions,
   RmDirOptions,
-} from 'fs'; // Types from @types/node
+  StatSyncOptions,
+} from 'node:fs'; // Types from @types/node
+
+export { existsSync }
+
+// --- stat / lstat ---
+
+export function statSync(path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined {
+  try {
+    const file = Gio.File.new_for_path(path.toString());
+    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, null);
+    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+  } catch (err: unknown) {
+    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
+    throw createNodeError(err, 'stat', path);
+  }
+}
+
+export function lstatSync(path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined {
+  try {
+    const file = Gio.File.new_for_path(path.toString());
+    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+  } catch (err: unknown) {
+    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
+    throw createNodeError(err, 'lstat', path);
+  }
+}
+
+// --- readdir ---
+
+export function readdirSync(
+  path: PathLike,
+  options?: { withFileTypes?: boolean; encoding?: string; recursive?: boolean }
+): string[] | Dirent[] {
+  const pathStr = path.toString();
+  const file = Gio.File.new_for_path(pathStr);
+  const enumerator = file.enumerate_children(
+    'standard::name,standard::type',
+    Gio.FileQueryInfoFlags.NONE,
+    null,
+  );
+
+  const result: (string | Dirent)[] = [];
+  let info = enumerator.next_file(null);
+
+  while (info !== null) {
+    const childName = info.get_name();
+    const childPath = join(pathStr, childName);
+
+    if (options?.withFileTypes) {
+      result.push(new Dirent(childPath, childName));
+    } else {
+      result.push(childName);
+    }
+
+    if (options?.recursive && info.get_file_type() === Gio.FileType.DIRECTORY) {
+      const subEntries = readdirSync(childPath, options);
+      for (const entry of subEntries) {
+        if (typeof entry === 'string') {
+          result.push(join(childName, entry));
+        } else {
+          result.push(entry);
+        }
+      }
+    }
+
+    info = enumerator.next_file(null);
+  }
+
+  return result as string[] | Dirent[];
+}
+
+// --- realpath ---
+
+const MAX_SYMLINK_DEPTH = 40; // matches Linux MAXSYMLINKS
+
+export function realpathSync(path: PathLike): string {
+  let current = Gio.File.new_for_path(path.toString());
+  let depth = 0;
+
+  while (true) {
+    const info = current.query_info(
+      'standard::is-symlink,standard::symlink-target',
+      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null,
+    );
 
-export { existsSync, readdirSync }
+    if (!info.get_is_symlink()) {
+      return current.get_path()!;
+    }
+
+    const target = info.get_symlink_target()!;
+    const parent = current.get_parent();
+    current = parent ? parent.resolve_relative_path(target) : Gio.File.new_for_path(target);
+
+    if (++depth > MAX_SYMLINK_DEPTH) {
+      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${path}'`);
+    }
+  }
+}
+(realpathSync as unknown as { native: typeof realpathSync }).native = realpathSync;
+
+// --- symlink ---
+
+export function symlinkSync(target: PathLike, path: PathLike, _type?: 'file' | 'dir' | 'junction'): void {
+  const file = Gio.File.new_for_path(path.toString());
+  file.make_symbolic_link(target.toString(), null);
+}
 
 export function readFileSync(path: string, options = { encoding: null, flag: 'r' }) {
   const file = Gio.File.new_for_path(path);
 
-  const [ok, data] = file.load_contents(null);
+  try {
+    const [ok, data] = file.load_contents(null);
 
-  if (!ok) {
-    // TODO: throw a better error
-    throw new Error('failed to read file');
-  }
+    if (!ok) {
+      throw createNodeError(new Error('failed to read file'), 'read', path);
+    }
 
-  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+    return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+  } catch (err: unknown) {
+    if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node error
+    throw createNodeError(err, 'read', path);
+  }
 }
 
 /**
@@ -104,18 +211,60 @@ export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions
     throw new TypeError("mode as string is currently not supported!");
   }
 
-  if (GLib.mkdir_with_parents(path, mode) !== 0) {
-    // TODO: throw a better error
-    throw new Error(`failed to make ${path} directory`);
+  if (recursive) {
+    return mkdirSyncRecursive(path, mode as number);
   }
 
-  if (recursive) {
-    // TODO: Returns `undefined`, or if `recursive` is`true`, the first directory path created.
-    return path.split('/')[0];
+  // Non-recursive: create a single directory
+  const file = Gio.File.new_for_path(path);
+  try {
+    file.make_directory(null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'mkdir', path);
   }
   return undefined;
 }
 
+/**
+ * Recursively creates directories, similar to `mkdir -p`.
+ * Returns the first directory path created, or undefined if all directories already existed.
+ */
+function mkdirSyncRecursive(pathStr: string, mode: number): string | undefined {
+  const file = Gio.File.new_for_path(pathStr);
+
+  // Try to create the directory directly
+  try {
+    file.make_directory(null);
+    // This directory was created successfully — it's a candidate for "first created"
+    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 = join(pathStr, '..');
+      const resolvedParent = Gio.File.new_for_path(parentPath).get_path()!;
+      if (resolvedParent === pathStr) {
+        // Reached root, cannot go further
+        throw createNodeError(err, 'mkdir', pathStr);
+      }
+      const firstCreated = mkdirSyncRecursive(resolvedParent, mode);
+      // Now create this directory
+      const retryFile = Gio.File.new_for_path(pathStr);
+      try {
+        retryFile.make_directory(null);
+      } catch (retryErr: unknown) {
+        throw createNodeError(retryErr, 'mkdir', pathStr);
+      }
+      return firstCreated ?? pathStr;
+    }
+    throw createNodeError(err, 'mkdir', pathStr);
+  }
+}
+
 /**
  * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
  *
@@ -125,41 +274,191 @@ export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions
  * To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`.
  * @since v0.1.21
  */
-export function rmdirSync(path: PathLike, options?: RmDirOptions): void {
+export function rmdirSync(path: PathLike, _options?: RmDirOptions): void {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    // Check if it's a directory
+    const info = file.query_info('standard::type', Gio.FileQueryInfoFlags.NONE, null);
+    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 — rmdir only removes empty directories (use rmSync for recursive)
+    const enumerator = file.enumerate_children('standard::name', Gio.FileQueryInfoFlags.NONE, null);
+    if (enumerator.next_file(null) !== null) {
+      const err = Object.assign(new Error(), { code: 5 }); // Gio.IOErrorEnum.NOT_EMPTY
+      throw createNodeError(err, 'rmdir', path);
+    }
+    file.delete(null);
+  } catch (err: unknown) {
+    if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node error
+    throw createNodeError(err, 'rmdir', path);
+  }
+}
 
-  const recursive = options?.recursive || false;
+export function unlinkSync(path: PathLike): void {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    file.delete(null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'unlink', path);
+  }
+}
+
+export function writeFileSync(path: string, data: string | Uint8Array) {
+  GLib.file_set_contents(path, data);
+}
+
+// --- rename ---
+
+export function renameSync(oldPath: PathLike, newPath: PathLike): void {
+  const src = Gio.File.new_for_path(oldPath.toString());
+  const dest = Gio.File.new_for_path(newPath.toString());
+  try {
+    src.move(dest, Gio.FileCopyFlags.OVERWRITE, null, null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'rename', oldPath, newPath);
+  }
+}
+
+// --- copyFile ---
+
+export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void {
+  const srcFile = Gio.File.new_for_path(src.toString());
+  const destFile = Gio.File.new_for_path(dest.toString());
+  let flags = Gio.FileCopyFlags.NONE;
+  // mode 0 = default (overwrite), COPYFILE_EXCL (1) = no overwrite
+  if (mode && (mode & 1) === 0) {
+    flags = Gio.FileCopyFlags.OVERWRITE;
+  } else if (!mode) {
+    flags = Gio.FileCopyFlags.OVERWRITE;
+  }
+  try {
+    srcFile.copy(destFile, flags, null, null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'copyfile', src, dest);
+  }
+}
+
+// --- access ---
+
+export function accessSync(path: PathLike, mode?: number): void {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const info = file.query_info('access::*', Gio.FileQueryInfoFlags.NONE, null);
+    // mode: F_OK=0, R_OK=4, W_OK=2, X_OK=1
+    if (mode !== undefined && mode !== 0) {
+      // Gio.IOErrorEnum.PERMISSION_DENIED = 14 → maps to EACCES via createNodeError
+      const permErr = { code: 14, message: `permission denied, access '${path}'` };
+      if ((mode & 4) && !info.get_attribute_boolean('access::can-read')) {
+        throw createNodeError(permErr, 'access', path);
+      }
+      if ((mode & 2) && !info.get_attribute_boolean('access::can-write')) {
+        throw createNodeError(permErr, 'access', path);
+      }
+      if ((mode & 1) && !info.get_attribute_boolean('access::can-execute')) {
+        throw createNodeError(permErr, 'access', path);
+      }
+    }
+  } catch (err: unknown) {
+    if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node-style error
+    throw createNodeError(err, 'access', path);
+  }
+}
 
-  const childFiles = readdirSync(path, { withFileTypes: true });
+// --- appendFile ---
 
-  if (!recursive && childFiles.length) {
-    throw new Error('Dir is not empty!');
+export function appendFileSync(path: PathLike, data: string | Uint8Array, options?: { encoding?: string; mode?: number; flag?: string } | string): void {
+  const file = Gio.File.new_for_path(path.toString());
+  let bytes: Uint8Array;
+  if (typeof data === 'string') {
+    bytes = new TextEncoder().encode(data);
+  } else {
+    bytes = data;
   }
 
-  for (const childFile of childFiles) {
-    if (childFile.isDirectory()) {
-      rmdirSync(join(path.toString(), childFile.name));
-    } else if (childFile.isFile()) {
-      rmSync(join(path.toString(), childFile.name));
+  try {
+    const stream = file.append_to(Gio.FileCreateFlags.NONE, null);
+    if (bytes.length > 0) {
+      stream.write_bytes(new GLib.Bytes(bytes), null);
     }
+    stream.close(null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'appendfile', path);
   }
+}
 
-  const result = GLib.rmdir(path.toString());
+// --- readlink ---
 
-  if (result !== 0) {
-    // TODO: throw a better error
-    throw new Error(`Failed to remove ${path} directory`);
+export function readlinkSync(path: PathLike, options?: { encoding?: string } | string): string | Buffer {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const info = file.query_info('standard::symlink-target', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    const target = info.get_symlink_target();
+    if (!target) {
+      throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${path}'`), { code: 'EINVAL', errno: -22, syscall: 'readlink', path: path.toString() });
+    }
+    const encoding = typeof options === 'string' ? options : options?.encoding;
+    if (encoding === 'buffer') {
+      return Buffer.from(target);
+    }
+    return target;
+  } catch (err: unknown) {
+    if (typeof (err as { code?: unknown }).code === 'string') throw err;
+    throw createNodeError(err, 'readlink', path);
   }
 }
 
-export function unlinkSync(path: string) {
-  GLib.unlink(path);
+// --- link ---
+
+export function linkSync(existingPath: PathLike, newPath: PathLike): void {
+  // Gio doesn't have a direct hard link API, use GLib
+  const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+  if (!result[0]) {
+    throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingPath}' -> '${newPath}'`), { code: 'EPERM', errno: -1, syscall: 'link', path: existingPath.toString(), dest: newPath.toString() });
+  }
 }
 
-export function writeFileSync(path: string, data: any) {
-  GLib.file_set_contents(path, data);
+// --- truncate ---
+
+export function truncateSync(path: PathLike, len?: number): void {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const stream = file.replace(null, false, Gio.FileCreateFlags.NONE, null);
+    if (len && len > 0) {
+      // Read existing content, truncate to len
+      const [, data] = file.load_contents(null);
+      const truncated = data.slice(0, len);
+      if (truncated.length > 0) {
+        stream.write_bytes(new GLib.Bytes(truncated), null);
+      }
+    }
+    stream.close(null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'truncate', path);
+  }
 }
 
-export function watch(filename: string, options, listener) {
+// --- chmodSync ---
+
+export function chmodSync(path: PathLike, mode: Mode): void {
+  const modeNum = typeof mode === 'string' ? parseInt(mode, 8) : mode;
+  const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${path.toString()}`);
+  if (!result[0]) {
+    throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${path}'`), { code: 'EPERM', errno: -1, syscall: 'chmod', path: path.toString() });
+  }
+}
+
+// --- chownSync ---
+
+export function chownSync(path: PathLike, uid: number, gid: number): void {
+  const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${path.toString()}`);
+  if (!result[0]) {
+    throw Object.assign(new Error(`EPERM: operation not permitted, chown '${path}'`), { code: 'EPERM', errno: -1, syscall: 'chown', path: path.toString() });
+  }
+}
+
+export function watch(filename: string, options: { persistent?: boolean; recursive?: boolean; encoding?: string } | undefined, listener: ((eventType: string, filename: string | null) => void) | undefined) {
   return new FSWatcher(filename, options, listener);
 }
 
@@ -208,32 +507,38 @@ export function mkdtempSync(prefix: string, options?: EncodingOption | BufferEnc
  * @since v14.14.0
  */
 export function rmSync(path: PathLike, options?: RmOptions): 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 && isNotFoundError(err)) return;
+    throw createNodeError(err, 'rm', path);
+  }
 
   if (dirent.isDirectory()) {
     const childFiles = readdirSync(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()) {
-        rmdirSync(join(path.toString(), childFile.name), options);
-      } else if (childFile.isFile()) {
-        rmSync(join(path.toString(), childFile.name), options);
+      if (typeof childFile !== 'string') {
+        rmSync(join(pathStr, childFile.name), options);
       }
     }
   }
 
-  const ok = file.delete(null);
-
-  if (!ok) {
-    // TODO: throw a better error
-    const err = new Error('failed to remove file ' + path);
-    throw err;
+  try {
+    file.delete(null);
+  } catch (err: unknown) {
+    if (force && isNotFoundError(err)) return;
+    throw createNodeError(err, 'rm', path);
   }
 }

package/src/test.mts

@@ -1,4 +1,4 @@
-
+import '@gjsify/node-globals';
 import { run } from '@gjsify/unit';
 
 import testSuiteCallback from './callback.spec.js';
@@ -7,5 +7,10 @@ import testSuitePromise from './promises.spec.js';
 import testSuiteSync from './sync.spec.js';
 import testSuiteSymlink from './symlink.spec.js';
 import testSuiteStat from './stat.spec.js';
+import testSuiteNewApis from './new-apis.spec.js';
+import testSuiteExtended from './extended.spec.js';
+
+import testSuiteErrors from './errors.spec.js';
+import testSuiteStreams from './streams.spec.js';
 
-run({testSuiteCallback, testSuiteFileHandle, testSuitePromise, testSuiteSync, testSuiteSymlink, testSuiteStat});
+run({testSuiteCallback, testSuiteFileHandle, testSuitePromise, testSuiteSync, testSuiteSymlink, testSuiteStat, testSuiteNewApis, testSuiteExtended, testSuiteErrors, testSuiteStreams});

package/src/types/encoding-option.ts

@@ -1,3 +1,3 @@
-import type { ObjectEncodingOptions } from 'fs'; // Types from @types/node
+import type { ObjectEncodingOptions } from 'node:fs'; // Types from @types/node
 
 export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;

package/src/types/flag-and-open-mode.ts

@@ -1,4 +1,4 @@
-import type { Mode, OpenMode } from 'fs';
+import type { Mode, OpenMode } from 'node:fs';
 
 export interface FlagAndOpenMode {
     mode?: Mode | undefined;

package/src/types/read-options.ts

@@ -1,5 +1,5 @@
-import type { Abortable } from 'events';
-import type { ObjectEncodingOptions, OpenMode } from 'fs'; // Types from @types/node
+import type { Abortable } from 'node:events';
+import type { ObjectEncodingOptions, OpenMode } from 'node:fs'; // Types from @types/node
 
 export type ReadOptions = 
 | (ObjectEncodingOptions & Abortable & {

package/src/utils.ts

@@ -1,3 +1,5 @@
+// Shared filesystem utilities for GJS — original implementation using Gio
+
 import { existsSync } from './sync.js';
 
 const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

package/src/write-stream.ts

@@ -1,12 +1,16 @@
-import { Writable } from "stream";
-import { fileURLToPath, URL } from "url";
+// SPDX-License-Identifier: MIT
+// Adapted from Deno (refs/deno/ext/node/polyfills/internal/fs/streams.ts)
+// Copyright (c) 2018-2026 the Deno authors. MIT license.
+// Modifications: Rewritten to use Gio.File for GJS
+
+import { Writable } from "node:stream";
+import { fileURLToPath, URL } from "node:url";
 import { open, write, close } from "./callback.js";
 
 import type { OpenFlags } from './types/index.js';
-import type { PathLike, WriteStream as IWriteStream } from 'fs';
-import type { CreateWriteStreamOptions } from 'fs/promises'; // Types from @types/node
+import type { PathLike, WriteStream as IWriteStream } from 'node:fs';
+import type { CreateWriteStreamOptions } from 'node:fs/promises'; // Types from @types/node
 
-// From Deno
 const kIsPerformingIO = Symbol("kIsPerformingIO");
 const kIoDone = Symbol("kIoDone");
 
@@ -18,8 +22,6 @@ export function toPathIfFileURL(
   }
   return fileURLToPath(fileURLOrPath);
 }
-
-// Credits https://github.com/denoland/deno_std/blob/main/node/internal/fs/streams.ts
 export class WriteStream extends Writable implements IWriteStream {
 
     /**

package/tsconfig.json

@@ -1,18 +1,31 @@
 {
   "compilerOptions": {
     "module": "ESNext",
-    "types": ["node"],
     "target": "ESNext",
-    "moduleResolution": "NodeNext",
+    "moduleResolution": "bundler",
+    "types": [
+      "node"
+    ],
     "experimentalDecorators": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "allowImportingTsExtensions": true,
     "outDir": "lib",
     "rootDir": "src",
-    "composite": true
+    "declarationDir": "lib/types",
+    "composite": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": false
   },
-  "skipLibCheck": true,
-  "allowJs": true,
-  "checkJs": false,
-  "reflection": false,
-  "include": ["src/**/*.ts"],
-  "exclude": ["src/test.mts", "src/**/*.spec.ts"]
-}
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "src/test.ts",
+    "src/test.mts",
+    "src/**/*.spec.ts",
+    "src/**/*.spec.mts"
+  ]
+}