node: add ReadStream and createReadStream

node/_fs/_fs_access.ts

@@ -17,5 +17,6 @@ export function access(
 // TODO(bartlomieju) 'path' can also be a Buffer.  Neither of these polyfills
 // is available yet.  See https://github.com/denoland/deno/issues/3403
 export function accessSync(_path: string | URL, _mode?: number): void {
-  notImplemented("Not yet available");
+  // TODO(lucacasonato): this is not the right syscall, but it shoudl work for now sorta.
+  Deno.lstatSync(_path);
 }

node/_fs/_fs_stat.ts

@@ -284,6 +284,14 @@ export function statSync(
   path: string | URL,
   options: statOptions = { bigint: false },
 ): Stats | BigIntStats {
-  const origin = Deno.statSync(path);
+  let origin;
+  try {
+    origin = Deno.statSync(path);
+  } catch (e) {
+    if (e instanceof Deno.errors.NotFound) {
+      e.code = "ENOENT";
+    }
+    throw e;
+  }
   return CFISBIS(origin, options.bigint);
 }

node/_fs/_fs_streams.ts

@@ -0,0 +1,48 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+import { notImplemented } from "../_utils.ts";
+import { fromFileUrl } from "../path.ts";
+import { Buffer } from "../buffer.ts";
+import { Readable as NodeReadable } from "../stream.ts";
+
+class ReadStream extends NodeReadable {
+  public path: string;
+
+  constructor(path: string | URL, opts: Record<string, unknown>) {
+    path = path instanceof URL ? fromFileUrl(path) : path;
+    const hasBadOptions = opts && (
+      opts.fd || opts.start || opts.end || opts.fs
+    );
+    if (hasBadOptions) {
+      notImplemented();
+    }
+    const file = Deno.openSync(path, { read: true });
+    const buffer = new Uint8Array(16 * 1024);
+    super({
+      autoDestroy: true,
+      emitClose: true,
+      objectMode: false,
+      read: async function (_size) {
+        try {
+          const n = await file.read(buffer);
+          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
+        } catch (err) {
+          this.destroy(err as Error);
+        }
+      },
+      destroy: (err, cb) => {
+        try {
+          file.close();
+        } catch {}
+        cb(err);
+      },
+    });
+    this.path = path;
+  }
+}
+
+export function createReadStream(
+  path: string | URL,
+  options: ReadStreamOptions,
+): ReadStream {
+  return new ReadStream(path, options);
+}

node/_fs/_fs_unlink.ts

@@ -4,5 +4,12 @@ export function unlink(path: string | URL, callback: (err?: Error) => void) {
 }
 
 export function unlinkSync(path: string | URL) {
-  Deno.removeSync(path);
+  try {
+    Deno.removeSync(path);
+  } catch (e) {
+    if (e instanceof Deno.errors.NotFound) {
+      e.code = "ENOENT";
+    }
+    throw e;
+  }
 }

node/child_process.ts

@@ -168,11 +168,11 @@ export class ChildProcess extends EventEmitter {
   }
 
   ref(): void {
-    notImplemented("ChildProcess.ref()");
+    // notImplemented("ChildProcess.ref()");
   }
 
   unref(): void {
-    notImplemented("ChildProcess.unref()");
+    // notImplemented("ChildProcess.unref()");
   }
 
   private async _waitForChildStreamsToClose(): Promise<void> {
@@ -318,7 +318,21 @@ export function spawn(
   return new ChildProcess(command, args, options);
 }
 
-export default { spawn };
+export function fork(
+  modulePath: string,
+  argsOrOptions?: string[] | SpawnOptions,
+  maybeOptions?: SpawnOptions,
+): ChildProcess {
+  const args = Array.isArray(argsOrOptions) ? argsOrOptions : [];
+  const options = !Array.isArray(argsOrOptions) && argsOrOptions != null
+    ? argsOrOptions
+    : maybeOptions;
+  args.push(modulePath);
+  console.log("fork", Deno.execPath, args, options);
+  return new ChildProcess(Deno.execPath(), args, options);
+}
+
+export default { spawn, fork };
 
 function ensureClosed(closer: Deno.Closer): void {
   try {

node/fs.ts

@@ -26,6 +26,7 @@ import { realpath, realpathSync } from "./_fs/_fs_realpath.ts";
 import { rename, renameSync } from "./_fs/_fs_rename.ts";
 import { rmdir, rmdirSync } from "./_fs/_fs_rmdir.ts";
 import { stat, statSync } from "./_fs/_fs_stat.ts";
+import { createReadStream } from "./_fs/_fs_streams.ts";
 import { symlink, symlinkSync } from "./_fs/_fs_symlink.ts";
 import { truncate, truncateSync } from "./_fs/_fs_truncate.ts";
 import { unlink, unlinkSync } from "./_fs/_fs_unlink.ts";
@@ -35,6 +36,11 @@ import { writeFile, writeFileSync } from "./_fs/_fs_writeFile.ts";
 
 import * as promises from "./fs/promises.ts";
 
+realpath.native = realpath;
+realpathSync.native = realpathSync;
+function read() {
+}
+
 export default {
   access,
   accessSync,
@@ -49,6 +55,7 @@ export default {
   constants,
   copyFile,
   copyFileSync,
+  createReadStream,
   Dir,
   Dirent,
   exists,
@@ -74,6 +81,7 @@ export default {
   open,
   openSync,
   promises,
+  read,
   readdir,
   readdirSync,
   readFile,
@@ -141,6 +149,7 @@ export {
   open,
   openSync,
   promises,
+  read,
   readdir,
   readdirSync,
   readFile,
@@ -162,7 +171,6 @@ export {
   unlink,
   unlinkSync,
   utimes,
-  utimesSync,
   watch,
   watchFile,
   writeFile,

node/internal_binding/handle_wrap.ts

@@ -42,7 +42,7 @@ export class HandleWrap extends AsyncWrap {
   }
 
   unref() {
-    notImplemented();
+    // notImplemented();
   }
 
   // deno-lint-ignore no-explicit-any

node/module_all.ts

@@ -54,6 +54,7 @@ export default {
   fs,
   "fs/promises": fsPromises,
   http,
+  https: {},
   "internal/readline/utils": internalReadlineUtils,
   net,
   os,
@@ -69,8 +70,11 @@ export default {
   timers,
   "timers/promises": timersPromises,
   tty,
+  tls: {},
   url,
+  "worker_threads": {},
   util,
+  v8: {},
   vm,
   zlib: {},
 } as Record<string, unknown>;

node/process.ts

@@ -218,6 +218,9 @@ Object.defineProperty(stdin, "isTTY", {
     return Deno.isatty(Deno.stdin.rid);
   },
 });
+stdin.setRawMode = () => {
+  console.log("called setRawMode");
+};
 
 /** https://nodejs.org/api/process.html#process_process_stdout */
 export const stdout = createWritableStdioStream(Deno.stdout);