@aws-sdk/middleware-flexible-checksums 3.178.0 → 3.183.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.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
+
+
+
+
+
 # [3.178.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.177.0...v3.178.0) (2022-09-23)
 
 **Note:** Version bump only for package @aws-sdk/middleware-flexible-checksums

package/dist-es/flexibleChecksumsMiddleware.js

@@ -1,4 +1,3 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
 import { getChecksumLocationName } from "./getChecksumLocationName";
@@ -7,62 +6,64 @@ import { isStreaming } from "./isStreaming";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
 import { stringHasher } from "./stringHasher";
 import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
-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];
-                }
+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,
             });
-        }); };
-    };
+            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,18 +1,6 @@
-import { __awaiter, __generator } from "tslib";
 import { isStreaming } from "./isStreaming";
 import { stringHasher } from "./stringHasher";
-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()])];
-            }
-        });
-    });
+export const getChecksum = async (body, { streamHasher, checksumAlgorithmFn, base64Encoder }) => {
+    const digest = isStreaming(body) ? streamHasher(checksumAlgorithmFn, body) : stringHasher(checksumAlgorithmFn, body);
+    return base64Encoder(await digest);
 };

package/dist-es/getChecksumAlgorithmForRequest.js

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

package/dist-es/getChecksumAlgorithmListForResponse.js

@@ -1,24 +1,11 @@
-import { __values } from "tslib";
 import { CLIENT_SUPPORTED_ALGORITHMS, PRIORITY_ORDER_ALGORITHMS } from "./types";
-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);
+export const getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => {
+    const validChecksumAlgorithms = [];
+    for (const algorithm of PRIORITY_ORDER_ALGORITHMS) {
+        if (!responseAlgorithms.includes(algorithm) || !CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
+            continue;
         }
-    }
-    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; }
+        validChecksumAlgorithms.push(algorithm);
     }
     return validChecksumAlgorithms;
 };

package/dist-es/getChecksumLocationName.js

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

package/dist-es/getFlexibleChecksumsPlugin.js

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

package/dist-es/hasHeader.js

@@ -1,21 +1,9 @@
-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;
-            }
+export const hasHeader = (header, headers) => {
+    const soughtHeader = header.toLowerCase();
+    for (const headerName of Object.keys(headers)) {
+        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,4 +1,2 @@
 import { isArrayBuffer } from "@aws-sdk/is-array-buffer";
-export var isStreaming = function (body) {
-    return body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);
-};
+export const isStreaming = (body) => body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);

package/dist-es/selectChecksumAlgorithmFunction.js

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

package/dist-es/stringHasher.js

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

package/dist-es/types.js

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

package/dist-es/validateChecksumFromResponse.js

@@ -1,55 +1,22 @@
-import { __awaiter, __generator, __values } from "tslib";
 import { getChecksum } from "./getChecksum";
 import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
 import { getChecksumLocationName } from "./getChecksumLocationName";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
-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];
+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;
             }
-        });
-    });
+            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.178.0",
+  "version": "3.183.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.170.0",
-    "@aws-sdk/protocol-http": "3.178.0",
-    "@aws-sdk/types": "3.178.0",
+    "@aws-sdk/is-array-buffer": "3.183.0",
+    "@aws-sdk/protocol-http": "3.183.0",
+    "@aws-sdk/types": "3.183.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {