fix: support all the webs

* Collapse stream-collector-browser and stream-collector-native into stream-collector-web
* Update FetchHttpHandler to return blob if stream not implemented

Author: russell-dot-js

package.json

@@ -15,7 +15,7 @@
     "build:smithy-client": "yarn build:crypto-dependencies && lerna run --scope '@aws-sdk/client-rds-data' --include-dependencies pretest",
     "build:all": "yarn build:crypto-dependencies && lerna run pretest --include-dependencies --include-dependents",
     "pretest:all": "yarn build:all",
-    "test:all": "jest --coverage --passWithNoTests && lerna run test --scope @aws-sdk/stream-collector-browser --scope @aws-sdk/hash-blob-browser",
+    "test:all": "jest --coverage --passWithNoTests && lerna run test --scope @aws-sdk/stream-collector-web --scope @aws-sdk/hash-blob-browser",
     "test:functional": "jest --config tests/functional/jest.config.js --passWithNoTests",
     "test:integration": "cucumber-js --fail-fast",
     "test:protocols": "yarn build:protocols && lerna run test --scope '@aws-sdk/protocol-tests-*'"

packages/fetch-http-handler/src/fetch-http-handler.spec.ts

@@ -40,7 +40,7 @@ describe("httpHandler", () => {
           ["bizz", "bazz"]
         ])
       },
-      body: "FOO" //should be a ReadableStream in real life.
+      blob: jest.fn().mockResolvedValue(new Blob(["FOO"])),
     };
     const mockFetch = jest.fn().mockResolvedValue(mockResponse);
 
@@ -50,7 +50,8 @@ describe("httpHandler", () => {
     let response = await fetchHttpHandler.handle({} as any, {});
 
     expect(mockFetch.mock.calls.length).toBe(1);
-    expect(response.response.body).toBe("FOO");
+    console.log(response.response.body, typeof response.response.body);
+    expect(await blobToText(response.response.body)).toBe("FOO");
   });
 
   it("properly constructs url", async () => {
@@ -61,7 +62,7 @@ describe("httpHandler", () => {
           ["bizz", "bazz"]
         ])
       },
-      body: ""
+      blob: jest.fn().mockResolvedValue(new Blob()),
     };
     const mockFetch = jest.fn().mockResolvedValue(mockResponse);
 
@@ -92,8 +93,7 @@ describe("httpHandler", () => {
           ["bizz", "bazz"]
         ])
       },
-      blob: jest.fn().mockResolvedValue(""),
-      body: "test"
+      blob: jest.fn().mockResolvedValue(new Blob()),
     };
     const mockFetch = jest.fn().mockResolvedValue(mockResponse);
 
@@ -119,8 +119,7 @@ describe("httpHandler", () => {
           ["bizz", "bazz"]
         ])
       },
-      blob: jest.fn().mockResolvedValue(""),
-      body: "test"
+      blob: jest.fn().mockResolvedValue(new Blob()),
     };
     const mockFetch = jest.fn().mockResolvedValue(mockResponse);
     (global as any).fetch = mockFetch;
@@ -145,8 +144,7 @@ describe("httpHandler", () => {
           ["bizz", "bazz"]
         ])
       },
-      blob: jest.fn().mockResolvedValue(""),
-      body: "test"
+      blob: jest.fn().mockResolvedValue(new Blob()),
     };
     const mockFetch = jest.fn().mockResolvedValue(mockResponse);
     (global as any).fetch = mockFetch;
@@ -207,4 +205,20 @@ describe("httpHandler", () => {
       expect(httpHandler.destroy()).toBeUndefined();
     });
   });
+
+  // The Blob implementation does not implement Blob.text, so we deal with it here.
+  async function blobToText(blob: Blob): Promise<string> {
+    const reader = new FileReader();
+
+    return new Promise((resolve) => {
+      // This fires after the blob has been read/loaded.
+      reader.addEventListener('loadend', (e) => {
+        const text = e.target!.result as string;
+        resolve(text);
+      });
+
+      // Start reading the blob as text.
+      reader.readAsText(blob);
+    });
+  }
 });

packages/fetch-http-handler/src/fetch-http-handler.ts

@@ -14,14 +14,6 @@ export interface BrowserHttpOptions {
    * terminated.
    */
   requestTimeout?: number;
-  /**
-   * Buffer the whole response body before returning. This option is useful in the
-   * runtime that doesn't support ReadableStream in response like ReactNative. When
-   * set to true, the response body of http handler will be a Blob instead of
-   * ReadableStream.
-   * This option is only useful in ReactNative.
-   */
-  bufferBody?: boolean;
 }
 
 export class FetchHttpHandler implements HttpHandler {
@@ -80,8 +72,16 @@ export class FetchHttpHandler implements HttpHandler {
           transformedHeaders[pair[0]] = pair[1];
         }
 
+        // todo is this safe? what if different polyfills / libraries conflict
+        //   with eachother, e.g. a polyfilled response.body in a browser with
+        //   native window.ReadableStream.
+        //   can we just check for existence of response.body, as that should be
+        //   guaranteed to be a ReadableStream if it exists?
+        const hasResponseStream = typeof ReadableStream === 'function' &&
+          response.body instanceof ReadableStream;
+
         // Return the response with buffered body
-        if (this.httpOptions.bufferBody) {
+        if (!hasResponseStream) {
           return response.blob().then(body => ({
             response: new HttpResponse({
               headers: transformedHeaders,