chore: address feedbacks: prefer FP style

Author: AllanZhengYP

packages/eventstream-serde-browser/src/EventStreamMarshaller.ts

@@ -6,7 +6,7 @@ import {
   Message,
   EventStreamMarshaller as IEventStreamMarshaller
 } from "@aws-sdk/types";
-import { ReadableStreamtoIterable, iterableToReadableStream } from "./utils";
+import { readableStreamtoIterable, iterableToReadableStream } from "./utils";
 
 export interface EventStreamMarshaller extends IEventStreamMarshaller {}
 
@@ -47,7 +47,7 @@ export class EventStreamMarshaller {
     deserializer: (input: { [event: string]: Message }) => Promise<T>
   ): AsyncIterable<T> {
     const bodyIterable = isReadableStream(body)
-      ? ReadableStreamtoIterable(body)
+      ? readableStreamtoIterable(body)
       : body;
     return this.universalMarshaller.deserialize(bodyIterable, deserializer);
   }

packages/eventstream-serde-browser/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./provider";
 export * from "./EventStreamMarshaller";
+export * from "./utils";

packages/eventstream-serde-browser/src/utils.ts

@@ -1,37 +1,38 @@
 /**
- * Convert ReadableStream into an async iterable.
+ * A util function converting ReadableStream into an async iterable.
  * Reference: https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
  */
-export async function* ReadableStreamtoIterable<T>(
+export const readableStreamtoIterable = <T>(
   readableStream: ReadableStream<T>
-): AsyncIterable<T> {
-  const reader = readableStream.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) return;
-      yield value as T;
+): AsyncIterable<T> => ({
+  [Symbol.asyncIterator]: async function* () {
+    const reader = readableStream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) return;
+        yield value as T;
+      }
+    } finally {
+      reader.releaseLock();
     }
-  } finally {
-    reader.releaseLock();
   }
-}
+});
 
 /**
- * Convert async iterable to a ReadableStream.
+ * A util function converting async iterable to a ReadableStream.
  */
-export function iterableToReadableStream<T>(
+export const iterableToReadableStream = <T>(
   asyncIterable: AsyncIterable<T>
-): ReadableStream<T> {
+): ReadableStream<T> => {
   const iterator = asyncIterable[Symbol.asyncIterator]();
   return new ReadableStream({
-    pull(constroller) {
-      return iterator.next().then(({ done, value }) => {
-        if (done) {
-          return constroller.close();
-        }
-        constroller.enqueue(value);
-      });
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        return controller.close();
+      }
+      controller.enqueue(value);
     }
   });
-}
+};

packages/middleware-sdk-transcribe-streaming/package.json

@@ -18,6 +18,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
+    "@aws-sdk/eventstream-serde-browser": "1.0.0-gamma.1",
     "@aws-sdk/middleware-signing": "1.0.0-gamma.1",
     "@aws-sdk/protocol-http": "1.0.0-gamma.1",
     "@aws-sdk/signature-v4": "1.0.0-gamma.1",

packages/middleware-sdk-transcribe-streaming/src/configuration.ts

@@ -14,29 +14,25 @@ export interface WebSocketResolvedConfig {
   requestHandler: RequestHandler<any, any>;
 }
 
-export function resolveWebSocketConfig<T>(
+export const resolveWebSocketConfig = <T>(
   input: T & WebSocketInputConfig & PreviouslyResolved
-): T & WebSocketResolvedConfig {
-  if (input.requestHandler.metadata?.handlerProtocol === "websocket") {
-    return {
-      ...input,
-      signer: () =>
-        input.signer().then(signerObj => {
+): T & WebSocketResolvedConfig =>
+  input.requestHandler.metadata?.handlerProtocol !== "websocket"
+    ? input
+    : {
+        ...input,
+        signer: async () => {
+          const signerObj = await input.signer();
           if (validateSigner(signerObj)) {
             return new SignatureV4({ signer: signerObj });
           }
           throw new Error(
             "Expected SignatureV4 signer, please check the client constructor."
           );
-        })
-    };
-  } else {
-    return input;
-  }
-}
+        }
+      };
 
-function validateSigner(signer: any): signer is BaseSignatureV4 {
+const validateSigner = (signer: any): signer is BaseSignatureV4 =>
   // We cannot use instanceof here. Because we might import the wrong SignatureV4
   // constructor here as multiple version of packages maybe installed here.
-  return (signer.constructor.toString() as string).indexOf("SignatureV4") >= 0;
-}
+  (signer.constructor.toString() as string).indexOf("SignatureV4") >= 0;

packages/middleware-sdk-transcribe-streaming/src/middleware-session-id.ts

@@ -16,7 +16,7 @@ type WithSession = {
  * Middleware that inject default sessionId for operations, and inject
  * the parameters from request to the response metadata. This is
  * necessary because the SDK cannot access any parameters other than
- * the result stream. So it copy the parameters from input to the same
+ * the result stream. So it copies the parameters from input to the same
  * parameters in the output.
  */
 export const injectSessionIdMiddleware = (config: {
@@ -40,9 +40,9 @@ export const injectSessionIdMiddleware = (config: {
   return response;
 };
 
-function isWebSocket(config: { requestHandler: RequestHandler<any, any> }) {
+const isWebSocket = (config: { requestHandler: RequestHandler<any, any> }) => {
   return config.requestHandler.metadata?.handlerProtocol === "websocket";
-}
+};
 
 export const injectSessionIdMiddlewareOptions: InitializeHandlerOptions = {
   step: "initialize",

packages/middleware-sdk-transcribe-streaming/src/signer.ts

@@ -28,13 +28,13 @@ export class SignatureV4 implements RequestSigner, RequestPresigner {
     if (HttpRequest.isInstance(toSign)) {
       // Presign the endpoint url with empty body, otherwise
       // the payload hash would be UNSINGED_PAYLOAD
-      const originalBody = toSign.body;
-      toSign.body = "";
-      const signedRequest = await this.signer.presign(toSign, {
+      const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
         expiresIn: 5 * 60 // presigned url must be expired within 5 mins
       } as any);
-      signedRequest.body = originalBody;
-      return signedRequest;
+      return {
+        ...signedRequest,
+        body: toSign.body
+      };
     } else {
       return this.signer.sign(toSign, options);
     }

packages/middleware-sdk-transcribe-streaming/src/websocket-handler.ts

@@ -1,12 +1,10 @@
 import { HttpHandlerOptions, RequestHandlerMetadata } from "@aws-sdk/types";
 import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { formatUrl } from "@aws-sdk/util-format-url";
-/**
- * Base handler for websocket requests. By default, the request input and output
- * body will be in a ReadableStream, because of interface consistency among middleware.
- * If ReadableStream is not available, like in React-Native, the response body
- * will be an async iterable.
- */
+import {
+  iterableToReadableStream,
+  readableStreamtoIterable
+} from "@aws-sdk/eventstream-serde-browser";
 
 export interface WebSocketHandlerOptions {
   /**
@@ -16,6 +14,12 @@ export interface WebSocketHandlerOptions {
   connectionTimeout?: number;
 }
 
+/**
+ * Base handler for websocket requests. By default, the request input and output
+ * body will be in a ReadableStream, because of interface consistency among middleware.
+ * If ReadableStream is not available, like in React-Native, the response body
+ * will be an async iterable.
+ */
 export class WebSocketHandler implements HttpHandler {
   public readonly metadata: RequestHandlerMetadata = {
     handlerProtocol: "websocket"
@@ -27,26 +31,24 @@ export class WebSocketHandler implements HttpHandler {
 
   destroy(): void {}
 
-  handle(
+  async handle(
     request: HttpRequest,
     options: HttpHandlerOptions = {}
   ): Promise<{ response: HttpResponse }> {
     const url = formatUrl(request);
     const socket: WebSocket = new WebSocket(url);
     socket.binaryType = "arraybuffer";
-    return waitForReady(socket, this.connectionTimeout)
-      .then(() => {
-        const { body } = request;
-        const bodyStream = getIterator(body);
-        return connect(socket, bodyStream);
+    await waitForReady(socket, this.connectionTimeout);
+    const { body } = request;
+    const bodyStream = getIterator(body);
+    const asyncIterable = connect(socket, bodyStream);
+    const outputPayload = toReadableStream(asyncIterable);
+    return {
+      response: new HttpResponse({
+        statusCode: 200, // indicates connection success
+        body: outputPayload
       })
-      .then(iterableToReadableStream)
-      .then(bodyStream => ({
-        response: new HttpResponse({
-          statusCode: 200, // indicates connection success
-          body: bodyStream
-        })
-      }));
+    };
   }
 }
 
@@ -128,29 +130,12 @@ const connect = (
  * the request body is ReadableStream, so we need to transfer it to AsyncIterable
  * to make the stream consumable by WebSocket.
  */
-function getIterator(stream: any): AsyncIterable<any> {
+const getIterator = (stream: any): AsyncIterable<any> => {
   // Noop if stream is already an async iterable
   if (stream[Symbol.asyncIterator]) return stream;
   else if (isReadableStream(stream)) {
     //If stream is a ReadableStream, transfer the ReadableStream to async iterable.
-    //Reference: https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
-    const reader = stream.getReader();
-    return {
-      [Symbol.asyncIterator]: async function* () {
-        try {
-          while (true) {
-            // Read from the stream
-            const { done, value } = await reader.read();
-            // Exit if we're done
-            if (done) return;
-            // Else yield the chunk
-            yield value;
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-    };
+    return readableStreamtoIterable(stream);
   } else {
     //For other types, just wrap them with an async iterable.
     return {
@@ -159,30 +144,16 @@ function getIterator(stream: any): AsyncIterable<any> {
       }
     };
   }
-}
+};
 
 /**
  * Convert async iterable to a ReadableStream when ReadableStream API
  * is available(browsers). Otherwise, leave as it is(ReactNative).
  */
-function iterableToReadableStream<T>(
-  asyncIterable: AsyncIterable<T>
-): ReadableStream<T> | AsyncIterable<T> {
-  if (typeof ReadableStream !== "function") {
-    return asyncIterable;
-  }
-  const iterator = asyncIterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    pull(controller) {
-      return iterator.next().then(({ done, value }) => {
-        if (done) {
-          return controller.close();
-        }
-        controller.enqueue(value);
-      });
-    }
-  });
-}
+const toReadableStream = <T>(asyncIterable: AsyncIterable<T>) =>
+  typeof ReadableStream === "function"
+    ? iterableToReadableStream(asyncIterable)
+    : asyncIterable;
 
 const isReadableStream = (payload: any): payload is ReadableStream =>
   typeof ReadableStream === "function" && payload instanceof ReadableStream;

scripts/generate-clients/code-gen.js

@@ -41,9 +41,7 @@ const generateClients = async models => {
         if (!lstatSync(file).isFile()) return;
         const name = path.basename(file);
         console.log(`copying model ${name}...`);
-        copyFileSync(file, path.join(TEMP_CODE_GEN_INPUT_DIR, name), {
-          overwrite: true
-        });
+        copyFileSync(file, path.join(TEMP_CODE_GEN_INPUT_DIR, name));
       });
     });
   } else {