compat(fs): opendir and opendirSync

node/_fs/_fs_opendir.ts

@@ -0,0 +1,89 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+import Dir from "./_fs_dir.ts";
+import { Buffer } from "../buffer.ts";
+import { assertEncoding, getValidatedPath } from "../internal/fs/utils.mjs";
+import { denoErrorToNodeError } from "../internal/errors.ts";
+import { validateFunction } from "../internal/validators.mjs";
+import { promisify } from "../internal/util.mjs";
+
+type Options = {
+  encoding?: string;
+  bufferSize?: number;
+};
+type Callback = (err?: Error | null, dir?: Dir) => void;
+
+function _validateFunction(callback: unknown): asserts callback is Callback {
+  validateFunction(callback, "callback");
+}
+
+function checkBufferSize(value: number, name: string) {
+  if (!Number.isInteger(value) || value < 1 || value > 4294967295) {
+    throw new RangeError(
+      `The value of "${name}" is out of range. It must be >= 1 && <= 4294967295. Received ${value}`,
+    );
+  }
+}
+
+export function opendir(
+  path: string | Buffer | URL,
+  options: Options | Callback,
+  callback?: Callback,
+) {
+  callback = typeof options === "function" ? options : callback;
+  _validateFunction(callback);
+
+  path = getValidatedPath(path).toString();
+
+  options = typeof options === "object" ? options : {};
+  options = Object.assign({
+    encoding: "utf8",
+    bufferSize: 32,
+  }, options);
+
+  try {
+    assertEncoding(options.encoding);
+
+    checkBufferSize(options.bufferSize!, "options.bufferSize");
+
+    /** Throws if path is invalid */
+    Deno.readDirSync(path);
+
+    callback(null, new Dir(path));
+  } catch (err) {
+    callback(denoErrorToNodeError(err as Error, { syscall: "opendir" }));
+  }
+}
+
+export const opendirPromise = promisify(opendir) as (
+  path: string | Buffer | URL,
+  options?: Options,
+) => Promise<Dir>;
+
+export function opendirSync(
+  path: string | Buffer | URL,
+  options: Options = {
+    encoding: "utf8",
+    bufferSize: 32,
+  },
+): Dir {
+  path = getValidatedPath(path).toString();
+
+  options = Object.assign({
+    encoding: "utf8",
+    bufferSize: 32,
+  }, options);
+
+  try {
+    assertEncoding(options.encoding);
+
+    checkBufferSize(options.bufferSize!, "options.bufferSize");
+
+    /** Throws if path is invalid */
+    Deno.readDirSync(path);
+
+    return new Dir(path);
+  } catch (err) {
+    throw denoErrorToNodeError(err as Error, { syscall: "opendir" });
+  }
+}

node/_fs/_fs_opendir_test.ts

@@ -0,0 +1,135 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+import {
+  assert,
+  assertEquals,
+  assertFalse,
+  assertInstanceOf,
+  assertThrows,
+} from "../../testing/asserts.ts";
+import { opendir, opendirSync } from "./_fs_opendir.ts";
+import { Buffer } from "../buffer.ts";
+
+Deno.test("[node/fs] opendir()", async (t) => {
+  const path = await Deno.makeTempDir();
+  const file = await Deno.makeTempFile();
+
+  await t.step(
+    "fails if encoding is invalid",
+    () =>
+      opendir(
+        path,
+        { encoding: "invalid-encoding" },
+        (err) => assertInstanceOf(err, TypeError),
+      ),
+  );
+
+  await t.step(
+    "fails if bufferSize is invalid",
+    () =>
+      opendir(
+        path,
+        { bufferSize: -1 },
+        (err) => assertInstanceOf(err, RangeError),
+      ),
+  );
+
+  await t.step(
+    "fails if directory does not exist",
+    () =>
+      opendir(
+        "directory-that-does-not-exist",
+        (err) => assertInstanceOf(err, Error),
+      ),
+  );
+
+  await t.step(
+    "fails if not a directory",
+    () =>
+      opendir(
+        file,
+        (err) => assertInstanceOf(err, Error),
+      ),
+  );
+
+  await t.step(
+    "passes if path is a string",
+    () =>
+      opendir(
+        path,
+        (err, dir) => {
+          assertEquals(err, null);
+          assert(dir);
+        },
+      ),
+  );
+
+  await t.step(
+    "passes if path is a Buffer",
+    () =>
+      opendir(
+        Buffer.from(path),
+        (err, dir) => {
+          assertFalse(err);
+          assert(dir);
+        },
+      ),
+  );
+
+  await t.step(
+    "passes if path is a URL",
+    () =>
+      opendir(
+        new URL(`file://` + path),
+        (err, dir) => {
+          assertFalse(err);
+          assert(dir);
+        },
+      ),
+  );
+
+  await Deno.remove(path);
+  await Deno.remove(file);
+});
+
+Deno.test("[node/fs] opendirSync()", async (t) => {
+  const path = await Deno.makeTempDir();
+  const file = await Deno.makeTempFile();
+
+  await t.step("fails if encoding is invalid", () => {
+    assertThrows(
+      () => opendirSync(path, { encoding: "invalid-encoding" }),
+      TypeError,
+    );
+  });
+
+  await t.step("fails if bufferSize is invalid", () => {
+    assertThrows(
+      () => opendirSync(path, { bufferSize: -1 }),
+      RangeError,
+    );
+  });
+
+  await t.step("fails if directory does not exist", () => {
+    assertThrows(() => opendirSync("directory-that-does-not-exist"));
+  });
+
+  await t.step("fails if not a directory", () => {
+    assertThrows(() => opendirSync(file));
+  });
+
+  await t.step("passes if path is a string", () => {
+    assert(opendirSync(path));
+  });
+
+  await t.step("passes if path is a Buffer", () => {
+    assert(opendirSync(Buffer.from(path)));
+  });
+
+  await t.step("passes if path is a URL", () => {
+    assert(opendirSync(new URL(`file://` + path)));
+  });
+
+  await Deno.remove(path);
+  await Deno.remove(file);
+});

node/_tools/config.json

@@ -34,6 +34,7 @@
       "test-fs-append-file.js",
       "test-fs-chmod-mask.js",
       "test-fs-chmod.js",
+      "test-fs-opendir.js",
       "test-fs-rmdir-recursive.js",
       "test-fs-write-file.js",
       "test-fs-write.js",