chore: run prettier on WIP code in middleware-compression

Author: trivikr

packages/middleware-compression/package.json

@@ -1,24 +1,31 @@
 {
   "name": "middleware-compression",
   "version": "1.0.0",
-  "description": "Package that implements the compression middleware for request bodies. ",
-  "main": "index.js",
+  "description": "Package that implements the compression middleware for request bodies.",
   "scripts": {
     "test": "jest"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/aws/aws-sdk-js-v3.git"
+  "main": "./dist-cjs/index.js",
+  "types": "./dist-types/index.d.ts",
+  "module": "./dist-es/index.js",
+  "dependencies": {
+    "@smithy/types": "^2.7.0",
+    "tslib": "^2.5.0"
   },
   "keywords": [
     "middleware",
     "compression",
     "gzip"
   ],
-  "author": "AWS SDK for JavaScript Team",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/aws/aws-sdk-js-v3/issues"
+  "author": {
+    "name": "AWS SDK for JavaScript Team",
+    "url": "https://aws.amazon.com/javascript/"
   },
-  "homepage": "https://github.com/aws/aws-sdk-js-v3#readme"
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/middleware-compression",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/aws-sdk-js-v3.git",
+    "directory": "packages/middleware-compression"
+  }
 }

packages/middleware-compression/src/compress.ts

@@ -1,23 +1,23 @@
-import zlib from 'zlib';
-import { promisify } from 'util';
-import { CompressionAlgorithm } from './constants';
+import { promisify } from "util";
+import zlib from "zlib";
 
-// zlib.gzip( buffer, options, callback ) 
+import { CompressionAlgorithm } from "./constants";
 
-// reject stream if it goes into compress function 
+// zlib.gzip( buffer, options, callback )
+
+// reject stream if it goes into compress function
 export const compress = async (body: Uint8Array, algorithm: CompressionAlgorithm): Promise<Uint8Array> => {
-  // switch-case for algorithms: default -> unsupported 
+  // switch-case for algorithms: default -> unsupported
   if (algorithm !== "gzip") {
-    throw new Error('Unsupported compression algorithm');
+    throw new Error("Unsupported compression algorithm");
   }
   try {
     const compressedData = zlib.gzipSync(body);
     return compressedData as Uint8Array; // should it be returned as buffer?
   } catch (err) {
-    throw new Error('Compression failed: ' + err.message);
+    throw new Error("Compression failed: " + err.message);
   }
 };
 
-// type should be --> import type readable from stream and use readable as the type 
+// type should be --> import type readable from stream and use readable as the type
 // export const compressStream = (body: NodeJS.ReadableStream, algorithm: string): NodeJS.ReadableStream => {
-

packages/middleware-compression/src/compressionMiddleware.ts

@@ -1,54 +1,59 @@
 import { HttpRequest } from "@smithy/protocol-http";
-import { BuildHandler, BuildHandlerArguments, BuildHandlerOptions, BuildHandlerOutput, BuildMiddleware, HandlerExecutionContext, MetadataBearer, } from "@smithy/types";
-import { CompressionResolvedConfig } from "./configuration"
-import { isStreaming } from "./utils";
-import { CLIENT_SUPPORTED_ALGORITHMS as supportedAlgorithms } from "./types"; 
+import {
+  BuildHandler,
+  BuildHandlerArguments,
+  BuildHandlerOptions,
+  BuildHandlerOutput,
+  BuildMiddleware,
+  HandlerExecutionContext,
+  MetadataBearer,
+} from "@smithy/types";
+
 import { compress, compressStream } from "./compress";
+import { CompressionResolvedConfig } from "./configuration";
+import { CLIENT_SUPPORTED_ALGORITHMS as supportedAlgorithms } from "./types";
+import { isStreaming } from "./utils";
 
 /**
  * @internal
  */
-export const compressionMiddleware = (config: CompressionResolvedConfig): 
-    BuildMiddleware<any, any> => {  
-        return <Output extends MetadataBearer>(next: BuildHandler<any, Output>, 
-            context: HandlerExecutionContext): 
-            BuildHandler<any, Output> => 
-            async (args: BuildHandlerArguments<any>): 
-            Promise<BuildHandlerOutput<Output>> => {
-            
-        if (!HttpRequest.isInstance(args.request) || config.disableRequestCompression) {
-            return next(args);
+export const compressionMiddleware = (config: CompressionResolvedConfig): BuildMiddleware<any, any> => {
+  return <Output extends MetadataBearer>(
+      next: BuildHandler<any, Output>,
+      context: HandlerExecutionContext
+    ): BuildHandler<any, Output> =>
+    async (args: BuildHandlerArguments<any>): Promise<BuildHandlerOutput<Output>> => {
+      if (!HttpRequest.isInstance(args.request) || config.disableRequestCompression) {
+        return next(args);
+      }
+
+      const { request } = args;
+      const { body, headers } = request;
+
+      for (const algorithm of supportedAlgorithms) {
+        // have to check for streaming length trait and @requiredLength trait; probably to be done in codegen part and not check in middleware
+        if (isStreaming(body) && !isStreamingLengthRequired(body)) {
+          // if isStreaming results in Transfer-Encoding: Chunked
+          request.body = compressStream(body, algorithm);
+          // body.length checks --> check for util body length in smithy pkg
+        } else if (!isStreaming(body) && body.length >= config.minCompressionSizeInBytes) {
+          request.body = await compress(body, algorithm);
         }
-    
-        const { request } = args;
-        const { body, headers } = request;
-    
-        for (const algorithm of supportedAlgorithms) {
-            // have to check for streaming length trait and @requiredLength trait; probably to be done in codegen part and not check in middleware
-            if (isStreaming(body) && !isStreamingLengthRequired(body)) {
-                // if isStreaming results in Transfer-Encoding: Chunked 
-                request.body = compressStream(body, algorithm);
-            // body.length checks --> check for util body length in smithy pkg 
-            } else if (!isStreaming(body) && body.length >= config.minCompressionSizeInBytes) {
-                request.body = await compress(body, algorithm);
-            }
-            if (headers["Content-Encoding"]) {
-                headers["Content-Encoding"] += `,${algorithm}`;
-            } else {
-                headers["Content-Encoding"] = algorithm;
-            }
-            break;
+        if (headers["Content-Encoding"]) {
+          headers["Content-Encoding"] += `,${algorithm}`;
+        } else {
+          headers["Content-Encoding"] = algorithm;
         }
-    
-        return next({ ...args, request });
-    };
+        break;
+      }
 
-    } 
-    
+      return next({ ...args, request });
+    };
+};
 
 export const compressionMiddlewareOptions: BuildHandlerOptions = {
   name: "compressionMiddleware",
   step: "build",
   tags: ["REQUEST_BODY_COMPRESSION", "GZIP"],
   override: true,
-};
+};

packages/middleware-compression/src/configuration.ts

@@ -1,4 +1,3 @@
-
 /**
  * @public
  *
@@ -19,13 +18,12 @@ export interface CompressionResolvedConfig {
   minCompressionSizeInBytes: number;
 }
 
-
 export const resolveCompressionConfig = <T>(input: T & CompressionInputConfig): T & CompressionResolvedConfig => {
   const minCompressionSizeInBytes = input.minCompressionSizeInBytes ?? 10240;
   const maxCompressionSizeInBytes = 10485760;
   // minCompressionSizeInBytes explanation
   if (minCompressionSizeInBytes < 0 || minCompressionSizeInBytes > maxCompressionSizeInBytes) {
-    throw new Error('minCompressionSizeInBytes must be between 0 and 10485760 bytes inclusive');
+    throw new Error("minCompressionSizeInBytes must be between 0 and 10485760 bytes inclusive");
   }
   return {
     ...input,

packages/middleware-compression/src/constants.ts

@@ -1,4 +1,4 @@
 /**
  * Compression algorithms supported by the SDK.
  */
-export type CompressionAlgorithm = "gzip"
+export type CompressionAlgorithm = "gzip";

packages/middleware-compression/src/index.ts

@@ -1 +1 @@
-export * from "./compressionMiddleware";
+export * from "./compressionMiddleware";

packages/middleware-compression/src/types.ts

@@ -1,11 +1,11 @@
 import { CompressionAlgorithm } from "./constants";
 
 export const CLIENT_SUPPORTED_ALGORITHMS: CompressionAlgorithm[] = [
-  'gzip',
+  "gzip",
   // add more supported compression algorithms here
 ];
 
 export const PRIORITY_ORDER_ALGORITHMS: CompressionAlgorithm[] = [
-  'gzip',
+  "gzip",
   // add more supported compression algorithms here in the order of their priority
-];
+];