feat(node): fs/promises implementation (#1083)

Author: guybedford

node/_fs/promises/_fs_readFile.ts

@@ -33,7 +33,7 @@ import { utimes, utimesSync } from "./_fs/_fs_utimes.ts";
 import { watch } from "./_fs/_fs_watch.ts";
 import { writeFile, writeFileSync } from "./_fs/_fs_writeFile.ts";
 
-import * as promises from "./_fs/promises/mod.ts";
+import * as promises from "./fs/promises.ts";
 
 export default {
   access,

node/_fs/promises/_fs_writeFile.ts

@@ -1,10 +1,10 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-import { readFile } from "./_fs_readFile.ts";
-import * as path from "../../../path/mod.ts";
-import { assert, assertEquals } from "../../../testing/asserts.ts";
+import { readFile } from "./promises.ts";
+import * as path from "../../path/mod.ts";
+import { assert, assertEquals } from "../../testing/asserts.ts";
 
 const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-const testData = path.resolve(moduleDir, "..", "testdata", "hello.txt");
+const testData = path.resolve(moduleDir, "..", "_fs", "testdata", "hello.txt");
 
 Deno.test("readFileSuccess", async function () {
   const data: Uint8Array = await readFile(testData);

node/_fs/promises/mod.ts

@@ -4,16 +4,15 @@ import {
   assertEquals,
   assertNotEquals,
   assertThrowsAsync,
-} from "../../../testing/asserts.ts";
-import { writeFile } from "./_fs_writeFile.ts";
-import type { TextEncodings } from "../../_utils.ts";
+} from "../../testing/asserts.ts";
+import { writeFile } from "./promises.ts";
+import type { TextEncodings } from "../_utils.ts";
 
 const decoder = new TextDecoder("utf-8");
 
 Deno.test("Invalid encoding results in error()", function testEncodingErrors() {
   assertThrowsAsync(
     async () => {
-      // @ts-expect-error Type '"made-up-encoding"' is not assignable to type
       await writeFile("some/path", "some data", "made-up-encoding");
     },
     Error,
@@ -22,7 +21,6 @@ Deno.test("Invalid encoding results in error()", function testEncodingErrors() {
   assertThrowsAsync(
     async () => {
       await writeFile("some/path", "some data", {
-        // @ts-expect-error Type '"made-up-encoding"' is not assignable to type
         encoding: "made-up-encoding",
       });
     },

node/fs.ts

@@ -0,0 +1,60 @@
+import { promisify } from "../util.ts";
+import * as fs from "../fs.ts";
+
+export const access = promisify(fs.access);
+export const copyFile = promisify(fs.copyFile);
+export const open = promisify(fs.open);
+// export const opendir = promisify(fs.opendir);
+export const rename = promisify(fs.rename);
+export const truncate = promisify(fs.truncate);
+// export const rm = promisify(fs.rm);
+export const rmdir = promisify(fs.rmdir);
+export const mkdir = promisify(fs.mkdir);
+export const readdir = promisify(fs.readdir);
+export const readlink = promisify(fs.readlink);
+export const symlink = promisify(fs.symlink);
+export const lstat = promisify(fs.lstat);
+export const stat = promisify(fs.stat);
+export const link = promisify(fs.link);
+export const unlink = promisify(fs.unlink);
+export const chmod = promisify(fs.chmod);
+// export const lchmod = promisify(fs.lchmod);
+// export const lchown = promisify(fs.lchown);
+export const chown = promisify(fs.chown);
+export const utimes = promisify(fs.utimes);
+// export const lutimes = promisify(fs.lutimes);
+export const realpath = promisify(fs.realpath);
+export const mkdtemp = promisify(fs.mkdtemp);
+export const writeFile = promisify(fs.writeFile);
+export const appendFile = promisify(fs.appendFile);
+export const readFile = promisify(fs.readFile);
+export const watch = promisify(fs.watch);
+
+export default {
+  open,
+  // opendir,
+  rename,
+  truncate,
+  // rm,
+  rmdir,
+  mkdir,
+  readdir,
+  readlink,
+  symlink,
+  lstat,
+  stat,
+  link,
+  unlink,
+  chmod,
+  // lchmod,
+  // lchown,
+  chown,
+  utimes,
+  // lutimes,
+  realpath,
+  mkdtemp,
+  writeFile,
+  appendFile,
+  readFile,
+  watch,
+};