@aws-sdk/middleware-flexible-checksums 3.183.0 → 3.186.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
+
+**Note:** Version bump only for package @aws-sdk/middleware-flexible-checksums
+
+
+
+
+
 # [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
 
 **Note:** Version bump only for package @aws-sdk/middleware-flexible-checksums

package/dist-es/flexibleChecksumsMiddleware.js

@@ -1,3 +1,4 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
 import { getChecksumLocationName } from "./getChecksumLocationName";
@@ -6,64 +7,62 @@ import { isStreaming } from "./isStreaming";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
 import { stringHasher } from "./stringHasher";
 import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
-export const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next) => async (args) => {
-    if (!HttpRequest.isInstance(args.request)) {
-        return next(args);
-    }
-    const { request } = args;
-    const { body: requestBody, headers } = request;
-    const { base64Encoder, streamHasher } = config;
-    const { input, requestChecksumRequired, requestAlgorithmMember } = middlewareConfig;
-    const checksumAlgorithm = getChecksumAlgorithmForRequest(input, {
-        requestChecksumRequired,
-        requestAlgorithmMember,
-    });
-    let updatedBody = requestBody;
-    let updatedHeaders = headers;
-    if (checksumAlgorithm) {
-        const checksumLocationName = getChecksumLocationName(checksumAlgorithm);
-        const checksumAlgorithmFn = selectChecksumAlgorithmFunction(checksumAlgorithm, config);
-        if (isStreaming(requestBody)) {
-            const { getAwsChunkedEncodingStream, bodyLengthChecker } = config;
-            updatedBody = getAwsChunkedEncodingStream(requestBody, {
-                base64Encoder,
-                bodyLengthChecker,
-                checksumLocationName,
-                checksumAlgorithmFn,
-                streamHasher,
+export var flexibleChecksumsMiddleware = function (config, middlewareConfig) {
+    return function (next) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var request, requestBody, headers, base64Encoder, streamHasher, input, requestChecksumRequired, requestAlgorithmMember, checksumAlgorithm, updatedBody, updatedHeaders, checksumLocationName, checksumAlgorithmFn, getAwsChunkedEncodingStream, bodyLengthChecker, rawChecksum, result, requestValidationModeMember, responseAlgorithms;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!HttpRequest.isInstance(args.request)) {
+                            return [2, next(args)];
+                        }
+                        request = args.request;
+                        requestBody = request.body, headers = request.headers;
+                        base64Encoder = config.base64Encoder, streamHasher = config.streamHasher;
+                        input = middlewareConfig.input, requestChecksumRequired = middlewareConfig.requestChecksumRequired, requestAlgorithmMember = middlewareConfig.requestAlgorithmMember;
+                        checksumAlgorithm = getChecksumAlgorithmForRequest(input, {
+                            requestChecksumRequired: requestChecksumRequired,
+                            requestAlgorithmMember: requestAlgorithmMember,
+                        });
+                        updatedBody = requestBody;
+                        updatedHeaders = headers;
+                        if (!checksumAlgorithm) return [3, 3];
+                        checksumLocationName = getChecksumLocationName(checksumAlgorithm);
+                        checksumAlgorithmFn = selectChecksumAlgorithmFunction(checksumAlgorithm, config);
+                        if (!isStreaming(requestBody)) return [3, 1];
+                        getAwsChunkedEncodingStream = config.getAwsChunkedEncodingStream, bodyLengthChecker = config.bodyLengthChecker;
+                        updatedBody = getAwsChunkedEncodingStream(requestBody, {
+                            base64Encoder: base64Encoder,
+                            bodyLengthChecker: bodyLengthChecker,
+                            checksumLocationName: checksumLocationName,
+                            checksumAlgorithmFn: checksumAlgorithmFn,
+                            streamHasher: streamHasher,
+                        });
+                        updatedHeaders = __assign(__assign({}, headers), { "content-encoding": "aws-chunked", "transfer-encoding": "chunked", "x-amz-decoded-content-length": headers["content-length"], "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER", "x-amz-trailer": checksumLocationName });
+                        delete updatedHeaders["content-length"];
+                        return [3, 3];
+                    case 1:
+                        if (!!hasHeader(checksumLocationName, headers)) return [3, 3];
+                        return [4, stringHasher(checksumAlgorithmFn, requestBody)];
+                    case 2:
+                        rawChecksum = _b.sent();
+                        updatedHeaders = __assign(__assign({}, headers), (_a = {}, _a[checksumLocationName] = base64Encoder(rawChecksum), _a));
+                        _b.label = 3;
+                    case 3: return [4, next(__assign(__assign({}, args), { request: __assign(__assign({}, request), { headers: updatedHeaders, body: updatedBody }) }))];
+                    case 4:
+                        result = _b.sent();
+                        requestValidationModeMember = middlewareConfig.requestValidationModeMember, responseAlgorithms = middlewareConfig.responseAlgorithms;
+                        if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
+                            validateChecksumFromResponse(result.response, {
+                                config: config,
+                                responseAlgorithms: responseAlgorithms,
+                            });
+                        }
+                        return [2, result];
+                }
             });
-            updatedHeaders = {
-                ...headers,
-                "content-encoding": "aws-chunked",
-                "transfer-encoding": "chunked",
-                "x-amz-decoded-content-length": headers["content-length"],
-                "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
-                "x-amz-trailer": checksumLocationName,
-            };
-            delete updatedHeaders["content-length"];
-        }
-        else if (!hasHeader(checksumLocationName, headers)) {
-            const rawChecksum = await stringHasher(checksumAlgorithmFn, requestBody);
-            updatedHeaders = {
-                ...headers,
-                [checksumLocationName]: base64Encoder(rawChecksum),
-            };
-        }
-    }
-    const result = await next({
-        ...args,
-        request: {
-            ...request,
-            headers: updatedHeaders,
-            body: updatedBody,
-        },
-    });
-    const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
-    if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
-        validateChecksumFromResponse(result.response, {
-            config,
-            responseAlgorithms,
-        });
-    }
-    return result;
+        }); };
+    };
 };

package/dist-es/getChecksum.js

@@ -1,6 +1,18 @@
+import { __awaiter, __generator } from "tslib";
 import { isStreaming } from "./isStreaming";
 import { stringHasher } from "./stringHasher";
-export const getChecksum = async (body, { streamHasher, checksumAlgorithmFn, base64Encoder }) => {
-    const digest = isStreaming(body) ? streamHasher(checksumAlgorithmFn, body) : stringHasher(checksumAlgorithmFn, body);
-    return base64Encoder(await digest);
+export var getChecksum = function (body, _a) {
+    var streamHasher = _a.streamHasher, checksumAlgorithmFn = _a.checksumAlgorithmFn, base64Encoder = _a.base64Encoder;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var digest, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    digest = isStreaming(body) ? streamHasher(checksumAlgorithmFn, body) : stringHasher(checksumAlgorithmFn, body);
+                    _b = base64Encoder;
+                    return [4, digest];
+                case 1: return [2, _b.apply(void 0, [_c.sent()])];
+            }
+        });
+    });
 };

package/dist-es/getChecksumAlgorithmForRequest.js

@@ -1,13 +1,14 @@
 import { ChecksumAlgorithm } from "./constants";
 import { CLIENT_SUPPORTED_ALGORITHMS } from "./types";
-export const getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember }) => {
+export var getChecksumAlgorithmForRequest = function (input, _a) {
+    var requestChecksumRequired = _a.requestChecksumRequired, requestAlgorithmMember = _a.requestAlgorithmMember;
     if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
         return requestChecksumRequired ? ChecksumAlgorithm.MD5 : undefined;
     }
-    const checksumAlgorithm = input[requestAlgorithmMember];
+    var checksumAlgorithm = input[requestAlgorithmMember];
     if (!CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {
-        throw new Error(`The checksum algorithm "${checksumAlgorithm}" is not supported by the client.` +
-            ` Select one of ${CLIENT_SUPPORTED_ALGORITHMS}.`);
+        throw new Error("The checksum algorithm \"".concat(checksumAlgorithm, "\" is not supported by the client.") +
+            " Select one of ".concat(CLIENT_SUPPORTED_ALGORITHMS, "."));
     }
     return checksumAlgorithm;
 };

package/dist-es/getChecksumAlgorithmListForResponse.js

@@ -1,11 +1,24 @@
+import { __values } from "tslib";
 import { CLIENT_SUPPORTED_ALGORITHMS, PRIORITY_ORDER_ALGORITHMS } from "./types";
-export const getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => {
-    const validChecksumAlgorithms = [];
-    for (const algorithm of PRIORITY_ORDER_ALGORITHMS) {
-        if (!responseAlgorithms.includes(algorithm) || !CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
-            continue;
+export var getChecksumAlgorithmListForResponse = function (responseAlgorithms) {
+    var e_1, _a;
+    if (responseAlgorithms === void 0) { responseAlgorithms = []; }
+    var validChecksumAlgorithms = [];
+    try {
+        for (var PRIORITY_ORDER_ALGORITHMS_1 = __values(PRIORITY_ORDER_ALGORITHMS), PRIORITY_ORDER_ALGORITHMS_1_1 = PRIORITY_ORDER_ALGORITHMS_1.next(); !PRIORITY_ORDER_ALGORITHMS_1_1.done; PRIORITY_ORDER_ALGORITHMS_1_1 = PRIORITY_ORDER_ALGORITHMS_1.next()) {
+            var algorithm = PRIORITY_ORDER_ALGORITHMS_1_1.value;
+            if (!responseAlgorithms.includes(algorithm) || !CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
+                continue;
+            }
+            validChecksumAlgorithms.push(algorithm);
         }
-        validChecksumAlgorithms.push(algorithm);
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (PRIORITY_ORDER_ALGORITHMS_1_1 && !PRIORITY_ORDER_ALGORITHMS_1_1.done && (_a = PRIORITY_ORDER_ALGORITHMS_1.return)) _a.call(PRIORITY_ORDER_ALGORITHMS_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     return validChecksumAlgorithms;
 };

package/dist-es/getChecksumLocationName.js

@@ -1,2 +1,4 @@
 import { ChecksumAlgorithm } from "./constants";
-export const getChecksumLocationName = (algorithm) => algorithm === ChecksumAlgorithm.MD5 ? "content-md5" : `x-amz-checksum-${algorithm.toLowerCase()}`;
+export var getChecksumLocationName = function (algorithm) {
+    return algorithm === ChecksumAlgorithm.MD5 ? "content-md5" : "x-amz-checksum-".concat(algorithm.toLowerCase());
+};

package/dist-es/getFlexibleChecksumsPlugin.js

@@ -1,12 +1,12 @@
 import { flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
-export const flexibleChecksumsMiddlewareOptions = {
+export var flexibleChecksumsMiddlewareOptions = {
     name: "flexibleChecksumsMiddleware",
     step: "build",
     tags: ["BODY_CHECKSUM"],
     override: true,
 };
-export const getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({
-    applyToStack: (clientStack) => {
+export var getFlexibleChecksumsPlugin = function (config, middlewareConfig) { return ({
+    applyToStack: function (clientStack) {
         clientStack.add(flexibleChecksumsMiddleware(config, middlewareConfig), flexibleChecksumsMiddlewareOptions);
     },
-});
+}); };

package/dist-es/hasHeader.js

@@ -1,9 +1,21 @@
-export const hasHeader = (header, headers) => {
-    const soughtHeader = header.toLowerCase();
-    for (const headerName of Object.keys(headers)) {
-        if (soughtHeader === headerName.toLowerCase()) {
-            return true;
+import { __values } from "tslib";
+export var hasHeader = function (header, headers) {
+    var e_1, _a;
+    var soughtHeader = header.toLowerCase();
+    try {
+        for (var _b = __values(Object.keys(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var headerName = _c.value;
+            if (soughtHeader === headerName.toLowerCase()) {
+                return true;
+            }
         }
     }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
     return false;
 };

package/dist-es/isStreaming.js

@@ -1,2 +1,4 @@
 import { isArrayBuffer } from "@aws-sdk/is-array-buffer";
-export const isStreaming = (body) => body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);
+export var isStreaming = function (body) {
+    return body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);
+};

package/dist-es/selectChecksumAlgorithmFunction.js

@@ -1,10 +1,13 @@
 import { AwsCrc32 } from "@aws-crypto/crc32";
 import { AwsCrc32c } from "@aws-crypto/crc32c";
 import { ChecksumAlgorithm } from "./constants";
-export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => ({
-    [ChecksumAlgorithm.MD5]: config.md5,
-    [ChecksumAlgorithm.CRC32]: AwsCrc32,
-    [ChecksumAlgorithm.CRC32C]: AwsCrc32c,
-    [ChecksumAlgorithm.SHA1]: config.sha1,
-    [ChecksumAlgorithm.SHA256]: config.sha256,
-}[checksumAlgorithm]);
+export var selectChecksumAlgorithmFunction = function (checksumAlgorithm, config) {
+    var _a;
+    return ((_a = {},
+        _a[ChecksumAlgorithm.MD5] = config.md5,
+        _a[ChecksumAlgorithm.CRC32] = AwsCrc32,
+        _a[ChecksumAlgorithm.CRC32C] = AwsCrc32c,
+        _a[ChecksumAlgorithm.SHA1] = config.sha1,
+        _a[ChecksumAlgorithm.SHA256] = config.sha256,
+        _a)[checksumAlgorithm]);
+};

package/dist-es/stringHasher.js

@@ -1,5 +1,5 @@
-export const stringHasher = (checksumAlgorithmFn, body) => {
-    const hash = new checksumAlgorithmFn();
+export var stringHasher = function (checksumAlgorithmFn, body) {
+    var hash = new checksumAlgorithmFn();
     hash.update(body || "");
     return hash.digest();
 };

package/dist-es/types.js

@@ -1,11 +1,11 @@
 import { ChecksumAlgorithm } from "./constants";
-export const CLIENT_SUPPORTED_ALGORITHMS = [
+export var CLIENT_SUPPORTED_ALGORITHMS = [
     ChecksumAlgorithm.CRC32,
     ChecksumAlgorithm.CRC32C,
     ChecksumAlgorithm.SHA1,
     ChecksumAlgorithm.SHA256,
 ];
-export const PRIORITY_ORDER_ALGORITHMS = [
+export var PRIORITY_ORDER_ALGORITHMS = [
     ChecksumAlgorithm.CRC32,
     ChecksumAlgorithm.CRC32C,
     ChecksumAlgorithm.SHA1,

package/dist-es/validateChecksumFromResponse.js

@@ -1,22 +1,55 @@
+import { __awaiter, __generator, __values } from "tslib";
 import { getChecksum } from "./getChecksum";
 import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
 import { getChecksumLocationName } from "./getChecksumLocationName";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
-export const validateChecksumFromResponse = async (response, { config, responseAlgorithms }) => {
-    const checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
-    const { body: responseBody, headers: responseHeaders } = response;
-    for (const algorithm of checksumAlgorithms) {
-        const responseHeader = getChecksumLocationName(algorithm);
-        const checksumFromResponse = responseHeaders[responseHeader];
-        if (checksumFromResponse) {
-            const checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
-            const { streamHasher, base64Encoder } = config;
-            const checksum = await getChecksum(responseBody, { streamHasher, checksumAlgorithmFn, base64Encoder });
-            if (checksum === checksumFromResponse) {
-                break;
+export var validateChecksumFromResponse = function (response, _a) {
+    var config = _a.config, responseAlgorithms = _a.responseAlgorithms;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var checksumAlgorithms, responseBody, responseHeaders, checksumAlgorithms_1, checksumAlgorithms_1_1, algorithm, responseHeader, checksumFromResponse, checksumAlgorithmFn, streamHasher, base64Encoder, checksum, e_1_1;
+        var e_1, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
+                    responseBody = response.body, responseHeaders = response.headers;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, 7, 8]);
+                    checksumAlgorithms_1 = __values(checksumAlgorithms), checksumAlgorithms_1_1 = checksumAlgorithms_1.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!checksumAlgorithms_1_1.done) return [3, 5];
+                    algorithm = checksumAlgorithms_1_1.value;
+                    responseHeader = getChecksumLocationName(algorithm);
+                    checksumFromResponse = responseHeaders[responseHeader];
+                    if (!checksumFromResponse) return [3, 4];
+                    checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+                    streamHasher = config.streamHasher, base64Encoder = config.base64Encoder;
+                    return [4, getChecksum(responseBody, { streamHasher: streamHasher, checksumAlgorithmFn: checksumAlgorithmFn, base64Encoder: base64Encoder })];
+                case 3:
+                    checksum = _c.sent();
+                    if (checksum === checksumFromResponse) {
+                        return [3, 5];
+                    }
+                    throw new Error("Checksum mismatch: expected \"".concat(checksum, "\" but received \"").concat(checksumFromResponse, "\"") +
+                        " in response header \"".concat(responseHeader, "\"."));
+                case 4:
+                    checksumAlgorithms_1_1 = checksumAlgorithms_1.next();
+                    return [3, 2];
+                case 5: return [3, 8];
+                case 6:
+                    e_1_1 = _c.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 8];
+                case 7:
+                    try {
+                        if (checksumAlgorithms_1_1 && !checksumAlgorithms_1_1.done && (_b = checksumAlgorithms_1.return)) _b.call(checksumAlgorithms_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7];
+                case 8: return [2];
             }
-            throw new Error(`Checksum mismatch: expected "${checksum}" but received "${checksumFromResponse}"` +
-                ` in response header "${responseHeader}".`);
-        }
-    }
+        });
+    });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-flexible-checksums",
-  "version": "3.183.0",
+  "version": "3.186.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -22,9 +22,9 @@
   "dependencies": {
     "@aws-crypto/crc32": "2.0.0",
     "@aws-crypto/crc32c": "2.0.0",
-    "@aws-sdk/is-array-buffer": "3.183.0",
-    "@aws-sdk/protocol-http": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/is-array-buffer": "3.186.0",
+    "@aws-sdk/protocol-http": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {