@aws-sdk/middleware-signing 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-signing
+
+
+
+
+
 # [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-signing

package/dist-es/configurations.js

@@ -1,76 +1,78 @@
+import { __assign, __awaiter, __generator, __read } from "tslib";
 import { memoize } from "@aws-sdk/property-provider";
 import { SignatureV4 } from "@aws-sdk/signature-v4";
 import { normalizeProvider } from "@aws-sdk/util-middleware";
-const CREDENTIAL_EXPIRE_WINDOW = 300000;
-export const resolveAwsAuthConfig = (input) => {
-    const normalizedCreds = input.credentials
+var CREDENTIAL_EXPIRE_WINDOW = 300000;
+export var resolveAwsAuthConfig = function (input) {
+    var normalizedCreds = input.credentials
         ? normalizeCredentialProvider(input.credentials)
         : input.credentialDefaultProvider(input);
-    const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
-    let signer;
+    var _a = input.signingEscapePath, signingEscapePath = _a === void 0 ? true : _a, _b = input.systemClockOffset, systemClockOffset = _b === void 0 ? input.systemClockOffset || 0 : _b, sha256 = input.sha256;
+    var signer;
     if (input.signer) {
         signer = normalizeProvider(input.signer);
     }
     else if (input.regionInfoProvider) {
-        signer = () => normalizeProvider(input.region)()
-            .then(async (region) => [
-            (await input.regionInfoProvider(region, {
-                useFipsEndpoint: await input.useFipsEndpoint(),
-                useDualstackEndpoint: await input.useDualstackEndpoint(),
-            })) || {},
-            region,
-        ])
-            .then(([regionInfo, region]) => {
-            const { signingRegion, signingService } = regionInfo;
-            input.signingRegion = input.signingRegion || signingRegion || region;
-            input.signingName = input.signingName || signingService || input.serviceId;
-            const params = {
-                ...input,
-                credentials: normalizedCreds,
-                region: input.signingRegion,
-                service: input.signingName,
-                sha256,
-                uriEscapePath: signingEscapePath,
-            };
-            const SignerCtor = input.signerConstructor || SignatureV4;
-            return new SignerCtor(params);
-        });
+        signer = function () {
+            return normalizeProvider(input.region)()
+                .then(function (region) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, _b, _c;
+                var _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            _b = (_a = input).regionInfoProvider;
+                            _c = [region];
+                            _d = {};
+                            return [4, input.useFipsEndpoint()];
+                        case 1:
+                            _d.useFipsEndpoint = _e.sent();
+                            return [4, input.useDualstackEndpoint()];
+                        case 2: return [4, _b.apply(_a, _c.concat([(_d.useDualstackEndpoint = _e.sent(),
+                                    _d)]))];
+                        case 3: return [2, [
+                                (_e.sent()) || {},
+                                region
+                            ]];
+                    }
+                });
+            }); })
+                .then(function (_a) {
+                var _b = __read(_a, 2), regionInfo = _b[0], region = _b[1];
+                var signingRegion = regionInfo.signingRegion, signingService = regionInfo.signingService;
+                input.signingRegion = input.signingRegion || signingRegion || region;
+                input.signingName = input.signingName || signingService || input.serviceId;
+                var params = __assign(__assign({}, input), { credentials: normalizedCreds, region: input.signingRegion, service: input.signingName, sha256: sha256, uriEscapePath: signingEscapePath });
+                var SignerCtor = input.signerConstructor || SignatureV4;
+                return new SignerCtor(params);
+            });
+        };
     }
     else {
-        signer = async (authScheme) => {
-            if (!authScheme) {
-                throw new Error("Unexpected empty auth scheme config");
-            }
-            const signingRegion = authScheme.signingScope;
-            const signingService = authScheme.signingName;
-            input.signingRegion = input.signingRegion || signingRegion;
-            input.signingName = input.signingName || signingService || input.serviceId;
-            const params = {
-                ...input,
-                credentials: normalizedCreds,
-                region: input.signingRegion,
-                service: input.signingName,
-                sha256,
-                uriEscapePath: signingEscapePath,
-            };
-            const SignerCtor = input.signerConstructor || SignatureV4;
-            return new SignerCtor(params);
-        };
+        signer = function (authScheme) { return __awaiter(void 0, void 0, void 0, function () {
+            var signingRegion, signingService, params, SignerCtor;
+            return __generator(this, function (_a) {
+                if (!authScheme) {
+                    throw new Error("Unexpected empty auth scheme config");
+                }
+                signingRegion = authScheme.signingScope;
+                signingService = authScheme.signingName;
+                input.signingRegion = input.signingRegion || signingRegion;
+                input.signingName = input.signingName || signingService || input.serviceId;
+                params = __assign(__assign({}, input), { credentials: normalizedCreds, region: input.signingRegion, service: input.signingName, sha256: sha256, uriEscapePath: signingEscapePath });
+                SignerCtor = input.signerConstructor || SignatureV4;
+                return [2, new SignerCtor(params)];
+            });
+        }); };
     }
-    return {
-        ...input,
-        systemClockOffset,
-        signingEscapePath,
-        credentials: normalizedCreds,
-        signer,
-    };
+    return __assign(__assign({}, input), { systemClockOffset: systemClockOffset, signingEscapePath: signingEscapePath, credentials: normalizedCreds, signer: signer });
 };
-export const resolveSigV4AuthConfig = (input) => {
-    const normalizedCreds = input.credentials
+export var resolveSigV4AuthConfig = function (input) {
+    var normalizedCreds = input.credentials
         ? normalizeCredentialProvider(input.credentials)
         : input.credentialDefaultProvider(input);
-    const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
-    let signer;
+    var _a = input.signingEscapePath, signingEscapePath = _a === void 0 ? true : _a, _b = input.systemClockOffset, systemClockOffset = _b === void 0 ? input.systemClockOffset || 0 : _b, sha256 = input.sha256;
+    var signer;
     if (input.signer) {
         signer = normalizeProvider(input.signer);
     }
@@ -79,22 +81,18 @@ export const resolveSigV4AuthConfig = (input) => {
             credentials: normalizedCreds,
             region: input.region,
             service: input.signingName,
-            sha256,
+            sha256: sha256,
             uriEscapePath: signingEscapePath,
         }));
     }
-    return {
-        ...input,
-        systemClockOffset,
-        signingEscapePath,
-        credentials: normalizedCreds,
-        signer,
-    };
+    return __assign(__assign({}, input), { systemClockOffset: systemClockOffset, signingEscapePath: signingEscapePath, credentials: normalizedCreds, signer: signer });
 };
-const normalizeCredentialProvider = (credentials) => {
+var normalizeCredentialProvider = function (credentials) {
     if (typeof credentials === "function") {
-        return memoize(credentials, (credentials) => credentials.expiration !== undefined &&
-            credentials.expiration.getTime() - Date.now() < CREDENTIAL_EXPIRE_WINDOW, (credentials) => credentials.expiration !== undefined);
+        return memoize(credentials, function (credentials) {
+            return credentials.expiration !== undefined &&
+                credentials.expiration.getTime() - Date.now() < CREDENTIAL_EXPIRE_WINDOW;
+        }, function (credentials) { return credentials.expiration !== undefined; });
     }
     return normalizeProvider(credentials);
 };

package/dist-es/middleware.js

@@ -1,42 +1,63 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { getSkewCorrectedDate } from "./utils/getSkewCorrectedDate";
 import { getUpdatedSystemClockOffset } from "./utils/getUpdatedSystemClockOffset";
-export const awsAuthMiddleware = (options) => (next, context) => async function (args) {
-    if (!HttpRequest.isInstance(args.request))
-        return next(args);
-    const authScheme = (context.endpointV2)?.properties?.authSchemes?.[0];
-    const signer = await options.signer(authScheme);
-    const output = await next({
-        ...args,
-        request: await signer.sign(args.request, {
-            signingDate: getSkewCorrectedDate(options.systemClockOffset),
-            signingRegion: context["signing_region"],
-            signingService: context["signing_service"],
-        }),
-    }).catch((error) => {
-        const serverTime = error.ServerTime ?? getDateHeader(error.$response);
-        if (serverTime) {
-            options.systemClockOffset = getUpdatedSystemClockOffset(serverTime, options.systemClockOffset);
-        }
-        throw error;
-    });
-    const dateHeader = getDateHeader(output.response);
-    if (dateHeader) {
-        options.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, options.systemClockOffset);
-    }
-    return output;
+export var awsAuthMiddleware = function (options) {
+    return function (next, context) {
+        return function (args) {
+            var _a, _b, _c;
+            return __awaiter(this, void 0, void 0, function () {
+                var authScheme, signer, output, _d, _e, dateHeader;
+                var _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
+                        case 0:
+                            if (!HttpRequest.isInstance(args.request))
+                                return [2, next(args)];
+                            authScheme = (_c = (_b = (_a = (context.endpointV2)) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.authSchemes) === null || _c === void 0 ? void 0 : _c[0];
+                            return [4, options.signer(authScheme)];
+                        case 1:
+                            signer = _g.sent();
+                            _d = next;
+                            _e = [__assign({}, args)];
+                            _f = {};
+                            return [4, signer.sign(args.request, {
+                                    signingDate: getSkewCorrectedDate(options.systemClockOffset),
+                                    signingRegion: context["signing_region"],
+                                    signingService: context["signing_service"],
+                                })];
+                        case 2: return [4, _d.apply(void 0, [__assign.apply(void 0, _e.concat([(_f.request = _g.sent(), _f)]))]).catch(function (error) {
+                                var _a;
+                                var serverTime = (_a = error.ServerTime) !== null && _a !== void 0 ? _a : getDateHeader(error.$response);
+                                if (serverTime) {
+                                    options.systemClockOffset = getUpdatedSystemClockOffset(serverTime, options.systemClockOffset);
+                                }
+                                throw error;
+                            })];
+                        case 3:
+                            output = _g.sent();
+                            dateHeader = getDateHeader(output.response);
+                            if (dateHeader) {
+                                options.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, options.systemClockOffset);
+                            }
+                            return [2, output];
+                    }
+                });
+            });
+        };
+    };
 };
-const getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
-export const awsAuthMiddlewareOptions = {
+var getDateHeader = function (response) { var _a, _b, _c; return HttpResponse.isInstance(response) ? (_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.date) !== null && _b !== void 0 ? _b : (_c = response.headers) === null || _c === void 0 ? void 0 : _c.Date : undefined; };
+export var awsAuthMiddlewareOptions = {
     name: "awsAuthMiddleware",
     tags: ["SIGNATURE", "AWSAUTH"],
     relation: "after",
     toMiddleware: "retryMiddleware",
     override: true,
 };
-export const getAwsAuthPlugin = (options) => ({
-    applyToStack: (clientStack) => {
+export var getAwsAuthPlugin = function (options) { return ({
+    applyToStack: function (clientStack) {
         clientStack.addRelativeTo(awsAuthMiddleware(options), awsAuthMiddlewareOptions);
     },
-});
-export const getSigV4AuthPlugin = getAwsAuthPlugin;
+}); };
+export var getSigV4AuthPlugin = getAwsAuthPlugin;

package/dist-es/utils/getSkewCorrectedDate.js

@@ -1 +1 @@
-export const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
+export var getSkewCorrectedDate = function (systemClockOffset) { return new Date(Date.now() + systemClockOffset); };

package/dist-es/utils/getUpdatedSystemClockOffset.js

@@ -1,6 +1,6 @@
 import { isClockSkewed } from "./isClockSkewed";
-export const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
-    const clockTimeInMs = Date.parse(clockTime);
+export var getUpdatedSystemClockOffset = function (clockTime, currentSystemClockOffset) {
+    var clockTimeInMs = Date.parse(clockTime);
     if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
         return clockTimeInMs - Date.now();
     }

package/dist-es/utils/isClockSkewed.js

@@ -1,2 +1,4 @@
 import { getSkewCorrectedDate } from "./getSkewCorrectedDate";
-export const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;
+export var isClockSkewed = function (clockTime, systemClockOffset) {
+    return Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-signing",
-  "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",
@@ -20,11 +20,11 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/property-provider": "3.183.0",
-    "@aws-sdk/protocol-http": "3.183.0",
-    "@aws-sdk/signature-v4": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
-    "@aws-sdk/util-middleware": "3.183.0",
+    "@aws-sdk/property-provider": "3.186.0",
+    "@aws-sdk/protocol-http": "3.186.0",
+    "@aws-sdk/signature-v4": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
+    "@aws-sdk/util-middleware": "3.186.0",
     "tslib": "^2.3.1"
   },
   "engines": {