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

package/dist-es/configurations.js

@@ -1,8 +1,6 @@
+import { __assign } from "tslib";
 export { NODE_USE_ARN_REGION_CONFIG_OPTIONS } from "@aws-sdk/middleware-bucket-endpoint";
 export function resolveS3ControlConfig(input) {
-    const { useArnRegion = false } = input;
-    return {
-        ...input,
-        useArnRegion: typeof useArnRegion === "function" ? useArnRegion : () => Promise.resolve(useArnRegion),
-    };
+    var _a = input.useArnRegion, useArnRegion = _a === void 0 ? false : _a;
+    return __assign(__assign({}, input), { useArnRegion: typeof useArnRegion === "function" ? useArnRegion : function () { return Promise.resolve(useArnRegion); } });
 }

package/dist-es/constants.js

@@ -1,5 +1,5 @@
-export const CONTEXT_OUTPOST_ID = "outpost_id";
-export const CONTEXT_ACCOUNT_ID = "account_id";
-export const CONTEXT_ARN_REGION = "outpost_arn_region";
-export const CONTEXT_SIGNING_SERVICE = "signing_service";
-export const CONTEXT_SIGNING_REGION = "signing_region";
+export var CONTEXT_OUTPOST_ID = "outpost_id";
+export var CONTEXT_ACCOUNT_ID = "account_id";
+export var CONTEXT_ARN_REGION = "outpost_arn_region";
+export var CONTEXT_SIGNING_SERVICE = "signing_service";
+export var CONTEXT_SIGNING_REGION = "signing_region";

package/dist-es/process-arnables-plugin/getOutpostEndpoint.js

@@ -1,14 +1,16 @@
-const REGEX_S3CONTROL_HOSTNAME = /^(.+\.)?s3-control(-fips)?[.-]([a-z0-9-]+)\./;
-export const getOutpostEndpoint = (hostname, { isCustomEndpoint, regionOverride, useFipsEndpoint }) => {
+import { __read } from "tslib";
+var REGEX_S3CONTROL_HOSTNAME = /^(.+\.)?s3-control(-fips)?[.-]([a-z0-9-]+)\./;
+export var getOutpostEndpoint = function (hostname, _a) {
+    var isCustomEndpoint = _a.isCustomEndpoint, regionOverride = _a.regionOverride, useFipsEndpoint = _a.useFipsEndpoint;
     if (isCustomEndpoint) {
         return hostname;
     }
-    const [matched, prefix, fips, region] = hostname.match(REGEX_S3CONTROL_HOSTNAME);
+    var _b = __read(hostname.match(REGEX_S3CONTROL_HOSTNAME), 4), matched = _b[0], prefix = _b[1], fips = _b[2], region = _b[3];
     return [
-        `s3-outposts${useFipsEndpoint ? "-fips" : ""}`,
+        "s3-outposts".concat(useFipsEndpoint ? "-fips" : ""),
         regionOverride || region,
-        hostname.replace(new RegExp(`^${matched}`), ""),
+        hostname.replace(new RegExp("^".concat(matched)), ""),
     ]
-        .filter((part) => part !== undefined)
+        .filter(function (part) { return part !== undefined; })
         .join(".");
 };

package/dist-es/process-arnables-plugin/parse-outpost-arnables.js

@@ -1,95 +1,116 @@
+import { __awaiter, __generator, __read } from "tslib";
 import { getArnResources as getS3AccesspointArnResources, validateAccountId, validateNoDualstack, validateOutpostService, validatePartition, validateRegion, } from "@aws-sdk/middleware-bucket-endpoint";
 import { parse as parseArn, validate as validateArn } from "@aws-sdk/util-arn-parser";
 import { CONTEXT_ARN_REGION, CONTEXT_OUTPOST_ID, CONTEXT_SIGNING_REGION, CONTEXT_SIGNING_SERVICE } from "../constants";
-export const parseOutpostArnablesMiddleaware = (options) => (next, context) => async (args) => {
-    const { input } = args;
-    const parameter = input.Name && validateArn(input.Name) ? "Name" : input.Bucket && validateArn(input.Bucket) ? "Bucket" : undefined;
-    if (!parameter)
-        return next(args);
-    const clientRegion = await options.region();
-    const useArnRegion = await options.useArnRegion();
-    const useFipsEndpoint = await options.useFipsEndpoint();
-    const useDualstackEndpoint = await options.useDualstackEndpoint();
-    const baseRegion = clientRegion;
-    const { partition: clientPartition, signingRegion = baseRegion } = (await options.regionInfoProvider(baseRegion, {
-        useFipsEndpoint,
-        useDualstackEndpoint,
-    }));
-    const validatorOptions = {
-        useFipsEndpoint,
-        useDualstackEndpoint,
-        clientRegion,
-        clientPartition,
-        signingRegion,
-        useArnRegion,
+export var parseOutpostArnablesMiddleaware = function (options) {
+    return function (next, context) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var input, parameter, clientRegion, useArnRegion, useFipsEndpoint, useDualstackEndpoint, baseRegion, _a, clientPartition, _b, signingRegion, validatorOptions, arn, _c, outpostId, accesspointName, _d, outpostId, bucketName;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        input = args.input;
+                        parameter = input.Name && validateArn(input.Name) ? "Name" : input.Bucket && validateArn(input.Bucket) ? "Bucket" : undefined;
+                        if (!parameter)
+                            return [2, next(args)];
+                        return [4, options.region()];
+                    case 1:
+                        clientRegion = _e.sent();
+                        return [4, options.useArnRegion()];
+                    case 2:
+                        useArnRegion = _e.sent();
+                        return [4, options.useFipsEndpoint()];
+                    case 3:
+                        useFipsEndpoint = _e.sent();
+                        return [4, options.useDualstackEndpoint()];
+                    case 4:
+                        useDualstackEndpoint = _e.sent();
+                        baseRegion = clientRegion;
+                        return [4, options.regionInfoProvider(baseRegion, {
+                                useFipsEndpoint: useFipsEndpoint,
+                                useDualstackEndpoint: useDualstackEndpoint,
+                            })];
+                    case 5:
+                        _a = (_e.sent()), clientPartition = _a.partition, _b = _a.signingRegion, signingRegion = _b === void 0 ? baseRegion : _b;
+                        validatorOptions = {
+                            useFipsEndpoint: useFipsEndpoint,
+                            useDualstackEndpoint: useDualstackEndpoint,
+                            clientRegion: clientRegion,
+                            clientPartition: clientPartition,
+                            signingRegion: signingRegion,
+                            useArnRegion: useArnRegion,
+                        };
+                        if (parameter === "Name") {
+                            arn = parseArn(input.Name);
+                            validateOutpostsArn(arn, validatorOptions);
+                            _c = parseOutpostsAccessPointArnResource(arn.resource), outpostId = _c.outpostId, accesspointName = _c.accesspointName;
+                            input.Name = accesspointName;
+                            context[CONTEXT_OUTPOST_ID] = outpostId;
+                        }
+                        else {
+                            arn = parseArn(input.Bucket);
+                            validateOutpostsArn(arn, validatorOptions);
+                            _d = parseOutpostBucketArnResource(arn.resource), outpostId = _d.outpostId, bucketName = _d.bucketName;
+                            input.Bucket = bucketName;
+                            context[CONTEXT_OUTPOST_ID] = outpostId;
+                        }
+                        context[CONTEXT_SIGNING_SERVICE] = arn.service;
+                        context[CONTEXT_SIGNING_REGION] = useArnRegion ? arn.region : signingRegion;
+                        if (!input.AccountId) {
+                            input.AccountId = arn.accountId;
+                        }
+                        else if (input.AccountId !== arn.accountId) {
+                            throw new Error("AccountId is incompatible with account id inferred from ".concat(parameter));
+                        }
+                        if (useArnRegion)
+                            context[CONTEXT_ARN_REGION] = arn.region;
+                        return [2, next(args)];
+                }
+            });
+        }); };
     };
-    let arn;
-    if (parameter === "Name") {
-        arn = parseArn(input.Name);
-        validateOutpostsArn(arn, validatorOptions);
-        const { outpostId, accesspointName } = parseOutpostsAccessPointArnResource(arn.resource);
-        input.Name = accesspointName;
-        context[CONTEXT_OUTPOST_ID] = outpostId;
-    }
-    else {
-        arn = parseArn(input.Bucket);
-        validateOutpostsArn(arn, validatorOptions);
-        const { outpostId, bucketName } = parseOutpostBucketArnResource(arn.resource);
-        input.Bucket = bucketName;
-        context[CONTEXT_OUTPOST_ID] = outpostId;
-    }
-    context[CONTEXT_SIGNING_SERVICE] = arn.service;
-    context[CONTEXT_SIGNING_REGION] = useArnRegion ? arn.region : signingRegion;
-    if (!input.AccountId) {
-        input.AccountId = arn.accountId;
-    }
-    else if (input.AccountId !== arn.accountId) {
-        throw new Error(`AccountId is incompatible with account id inferred from ${parameter}`);
-    }
-    if (useArnRegion)
-        context[CONTEXT_ARN_REGION] = arn.region;
-    return next(args);
 };
-export const parseOutpostArnablesMiddleawareOptions = {
+export var parseOutpostArnablesMiddleawareOptions = {
     step: "initialize",
     tags: ["CONVERT_ARN", "OUTPOST_BUCKET_ARN", "OUTPOST_ACCESS_POINT_ARN", "OUTPOST"],
     name: "parseOutpostArnablesMiddleaware",
 };
-const validateOutpostsArn = (arn, { clientRegion, signingRegion, clientPartition, useArnRegion, useFipsEndpoint, useDualstackEndpoint, }) => {
-    const { service, partition, accountId, region } = arn;
+var validateOutpostsArn = function (arn, _a) {
+    var clientRegion = _a.clientRegion, signingRegion = _a.signingRegion, clientPartition = _a.clientPartition, useArnRegion = _a.useArnRegion, useFipsEndpoint = _a.useFipsEndpoint, useDualstackEndpoint = _a.useDualstackEndpoint;
+    var service = arn.service, partition = arn.partition, accountId = arn.accountId, region = arn.region;
     validateOutpostService(service);
-    validatePartition(partition, { clientPartition });
+    validatePartition(partition, { clientPartition: clientPartition });
     validateAccountId(accountId);
     validateRegion(region, {
-        useArnRegion,
-        clientRegion,
+        useArnRegion: useArnRegion,
+        clientRegion: clientRegion,
         clientSigningRegion: signingRegion,
-        useFipsEndpoint,
+        useFipsEndpoint: useFipsEndpoint,
         allowFipsRegion: true,
     });
     validateNoDualstack(useDualstackEndpoint);
 };
-const parseOutpostsAccessPointArnResource = (resource) => {
-    const { outpostId, accesspointName } = getS3AccesspointArnResources(resource);
+var parseOutpostsAccessPointArnResource = function (resource) {
+    var _a = getS3AccesspointArnResources(resource), outpostId = _a.outpostId, accesspointName = _a.accesspointName;
     if (!outpostId) {
         throw new Error("ARN resource should begin with 'outpost'");
     }
     return {
-        outpostId,
-        accesspointName,
+        outpostId: outpostId,
+        accesspointName: accesspointName,
     };
 };
-const parseOutpostBucketArnResource = (resource) => {
-    const delimiter = resource.includes(":") ? ":" : "/";
-    const [resourceType, ...rest] = resource.split(delimiter);
+var parseOutpostBucketArnResource = function (resource) {
+    var delimiter = resource.includes(":") ? ":" : "/";
+    var _a = __read(resource.split(delimiter)), resourceType = _a[0], rest = _a.slice(1);
     if (resourceType === "outpost") {
         if (!rest[0] || rest[1] !== "bucket" || !rest[2] || rest.length !== 3) {
-            throw new Error(`Outpost Bucket ARN should have resource outpost${delimiter}{outpostId}${delimiter}bucket${delimiter}{bucketName}`);
+            throw new Error("Outpost Bucket ARN should have resource outpost".concat(delimiter, "{outpostId}").concat(delimiter, "bucket").concat(delimiter, "{bucketName}"));
         }
-        const [outpostId, _, bucketName] = rest;
-        return { outpostId, bucketName };
+        var _b = __read(rest, 3), outpostId = _b[0], _1 = _b[1], bucketName = _b[2];
+        return { outpostId: outpostId, bucketName: bucketName };
     }
     else {
-        throw new Error(`ARN resource should begin with 'outpost${delimiter}'`);
+        throw new Error("ARN resource should begin with 'outpost".concat(delimiter, "'"));
     }
 };

package/dist-es/process-arnables-plugin/plugin.js

@@ -1,8 +1,8 @@
 import { parseOutpostArnablesMiddleaware, parseOutpostArnablesMiddleawareOptions } from "./parse-outpost-arnables";
 import { updateArnablesRequestMiddleware, updateArnablesRequestMiddlewareOptions } from "./update-arnables-request";
-export const getProcessArnablesPlugin = (options) => ({
-    applyToStack: (clientStack) => {
+export var getProcessArnablesPlugin = function (options) { return ({
+    applyToStack: function (clientStack) {
         clientStack.add(parseOutpostArnablesMiddleaware(options), parseOutpostArnablesMiddleawareOptions);
         clientStack.add(updateArnablesRequestMiddleware(options), updateArnablesRequestMiddlewareOptions);
     },
-});
+}); };

package/dist-es/process-arnables-plugin/update-arnables-request.js

@@ -1,27 +1,40 @@
+import { __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { CONTEXT_ACCOUNT_ID, CONTEXT_ARN_REGION, CONTEXT_OUTPOST_ID } from "../constants";
 import { getOutpostEndpoint } from "./getOutpostEndpoint";
-const ACCOUNT_ID_HEADER = "x-amz-account-id";
-const OUTPOST_ID_HEADER = "x-amz-outpost-id";
-export const updateArnablesRequestMiddleware = (config) => (next, context) => async (args) => {
-    const { request } = args;
-    if (!HttpRequest.isInstance(request))
-        return next(args);
-    if (context[CONTEXT_ACCOUNT_ID])
-        request.headers[ACCOUNT_ID_HEADER] = context[CONTEXT_ACCOUNT_ID];
-    if (context[CONTEXT_OUTPOST_ID]) {
-        const { isCustomEndpoint } = config;
-        const useFipsEndpoint = await config.useFipsEndpoint();
-        request.headers[OUTPOST_ID_HEADER] = context[CONTEXT_OUTPOST_ID];
-        request.hostname = getOutpostEndpoint(request.hostname, {
-            isCustomEndpoint,
-            regionOverride: context[CONTEXT_ARN_REGION],
-            useFipsEndpoint,
-        });
-    }
-    return next(args);
+var ACCOUNT_ID_HEADER = "x-amz-account-id";
+var OUTPOST_ID_HEADER = "x-amz-outpost-id";
+export var updateArnablesRequestMiddleware = function (config) {
+    return function (next, context) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var request, isCustomEndpoint, useFipsEndpoint;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        request = args.request;
+                        if (!HttpRequest.isInstance(request))
+                            return [2, next(args)];
+                        if (context[CONTEXT_ACCOUNT_ID])
+                            request.headers[ACCOUNT_ID_HEADER] = context[CONTEXT_ACCOUNT_ID];
+                        if (!context[CONTEXT_OUTPOST_ID]) return [3, 2];
+                        isCustomEndpoint = config.isCustomEndpoint;
+                        return [4, config.useFipsEndpoint()];
+                    case 1:
+                        useFipsEndpoint = _a.sent();
+                        request.headers[OUTPOST_ID_HEADER] = context[CONTEXT_OUTPOST_ID];
+                        request.hostname = getOutpostEndpoint(request.hostname, {
+                            isCustomEndpoint: isCustomEndpoint,
+                            regionOverride: context[CONTEXT_ARN_REGION],
+                            useFipsEndpoint: useFipsEndpoint,
+                        });
+                        _a.label = 2;
+                    case 2: return [2, next(args)];
+                }
+            });
+        }); };
+    };
 };
-export const updateArnablesRequestMiddlewareOptions = {
+export var updateArnablesRequestMiddlewareOptions = {
     step: "build",
     name: "updateArnablesRequestMiddleware",
     tags: ["ACCOUNT_ID", "OUTPOST_ID", "OUTPOST"],

package/dist-es/redirect-from-postid.js

@@ -1,26 +1,39 @@
+import { __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { CONTEXT_SIGNING_SERVICE } from "./constants";
 import { getOutpostEndpoint } from "./process-arnables-plugin";
-export const redirectFromPostIdMiddleware = (config) => (next, context) => async (args) => {
-    const { input, request } = args;
-    if (!HttpRequest.isInstance(request))
-        return next(args);
-    if (input.OutpostId) {
-        const { isCustomEndpoint } = config;
-        const useFipsEndpoint = await config.useFipsEndpoint();
-        request.hostname = getOutpostEndpoint(request.hostname, { isCustomEndpoint, useFipsEndpoint });
-        context[CONTEXT_SIGNING_SERVICE] = "s3-outposts";
-    }
-    return next(args);
+export var redirectFromPostIdMiddleware = function (config) {
+    return function (next, context) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var input, request, isCustomEndpoint, useFipsEndpoint;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        input = args.input, request = args.request;
+                        if (!HttpRequest.isInstance(request))
+                            return [2, next(args)];
+                        if (!input.OutpostId) return [3, 2];
+                        isCustomEndpoint = config.isCustomEndpoint;
+                        return [4, config.useFipsEndpoint()];
+                    case 1:
+                        useFipsEndpoint = _a.sent();
+                        request.hostname = getOutpostEndpoint(request.hostname, { isCustomEndpoint: isCustomEndpoint, useFipsEndpoint: useFipsEndpoint });
+                        context[CONTEXT_SIGNING_SERVICE] = "s3-outposts";
+                        _a.label = 2;
+                    case 2: return [2, next(args)];
+                }
+            });
+        }); };
+    };
 };
-export const redirectFromPostIdMiddlewareOptions = {
+export var redirectFromPostIdMiddlewareOptions = {
     step: "build",
     name: "redirectFromPostIdMiddleware",
     tags: ["OUTPOST"],
     override: true,
 };
-export const getRedirectFromPostIdPlugin = (options) => ({
-    applyToStack: (clientStack) => {
+export var getRedirectFromPostIdPlugin = function (options) { return ({
+    applyToStack: function (clientStack) {
         clientStack.add(redirectFromPostIdMiddleware(options), redirectFromPostIdMiddlewareOptions);
     },
-});
+}); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-sdk-s3-control",
-  "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,14 +20,14 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/middleware-bucket-endpoint": "3.183.0",
-    "@aws-sdk/protocol-http": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
-    "@aws-sdk/util-arn-parser": "3.183.0",
+    "@aws-sdk/middleware-bucket-endpoint": "3.186.0",
+    "@aws-sdk/protocol-http": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
+    "@aws-sdk/util-arn-parser": "3.186.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/middleware-stack": "3.183.0",
+    "@aws-sdk/middleware-stack": "3.186.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",