fix(hash-stream-node): do not create copy of file stream

packages/hash-stream-node/src/readableStreamHasher.spec.ts

@@ -1,16 +1,10 @@
 import { Hash } from "@aws-sdk/types";
-import { createReadStream } from "fs";
 import { Readable, Writable } from "stream";
 
-import { fsCreateReadStream } from "./fsCreateReadStream";
 import { HashCalculator } from "./HashCalculator";
-import { isFileStream } from "./isFileStream";
 import { readableStreamHasher } from "./readableStreamHasher";
 
-jest.mock("./fsCreateReadStream");
 jest.mock("./HashCalculator");
-jest.mock("./isFileStream");
-jest.mock("fs");
 
 describe(readableStreamHasher.name, () => {
   const mockDigest = jest.fn();
@@ -44,25 +38,13 @@ describe(readableStreamHasher.name, () => {
     (HashCalculator as unknown as jest.Mock).mockImplementation(
       (hash) => new MockHashCalculator(hash, mockHashCalculatorWrite, mockHashCalculatorEnd)
     );
-    (isFileStream as unknown as jest.Mock).mockReturnValue(false);
     mockDigest.mockResolvedValue(mockHash);
   });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it("creates a copy in case of fileStream", () => {
-    (fsCreateReadStream as jest.Mock).mockReturnValue(new Readable({ read: (size) => {} }));
-    (isFileStream as unknown as jest.Mock).mockReturnValue(true);
-
-    const fsReadStream = createReadStream(__filename);
-    readableStreamHasher(mockHashCtor, fsReadStream);
-
-    expect(isFileStream).toHaveBeenCalledWith(fsReadStream);
-    expect(fsCreateReadStream).toHaveBeenCalledWith(fsReadStream);
-  });
-
   it("computes hash for a readable stream", async () => {
     const readableStream = new Readable({ read: (size) => {} });
     const hashPromise = readableStreamHasher(mockHashCtor, readableStream);
@@ -86,7 +68,7 @@ describe(readableStreamHasher.name, () => {
     expect(mockHashCalculatorEnd).toHaveBeenCalledTimes(1);
   });
 
-  it("throws if readable stream is not a file stream and has started reading", async () => {
+  it("throws if readable stream has started reading", async () => {
     const readableStream = new Readable({ read: (size) => {} });
     // Simulate readableFlowing to true.
     readableStream.resume();

packages/hash-stream-node/src/readableStreamHasher.ts

@@ -1,24 +1,20 @@
 import { HashConstructor, StreamHasher } from "@aws-sdk/types";
 import { Readable } from "stream";
 
-import { fsCreateReadStream } from "./fsCreateReadStream";
 import { HashCalculator } from "./HashCalculator";
-import { isFileStream } from "./isFileStream";
 
 export const readableStreamHasher: StreamHasher<Readable> = (hashCtor: HashConstructor, readableStream: Readable) => {
-  // Throw if readableStream is already flowing and it's not a file stream.
-  if (!isFileStream(readableStream) && readableStream.readableFlowing !== null) {
+  // Throw if readableStream is already flowing.
+  if (readableStream.readableFlowing !== null) {
     throw new Error("Unable to calculate hash for flowing readable stream");
   }
 
-  const streamToPipe = isFileStream(readableStream) ? fsCreateReadStream(readableStream) : readableStream;
-
   const hash = new hashCtor();
   const hashCalculator = new HashCalculator(hash);
-  streamToPipe.pipe(hashCalculator);
+  readableStream.pipe(hashCalculator);
 
   return new Promise((resolve, reject) => {
-    streamToPipe.on("error", (err: Error) => {
+    readableStream.on("error", (err: Error) => {
       // if the source errors, the destination stream needs to manually end
       hashCalculator.end();
       reject(err);