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

package/dist-es/configurations.js

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

package/dist-es/constants.js

@@ -1,5 +1,5 @@
-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";
+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";

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

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

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

@@ -1,116 +1,95 @@
-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 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)];
-                }
-            });
-        }); };
+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,
     };
+    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 var parseOutpostArnablesMiddleawareOptions = {
+export const parseOutpostArnablesMiddleawareOptions = {
     step: "initialize",
     tags: ["CONVERT_ARN", "OUTPOST_BUCKET_ARN", "OUTPOST_ACCESS_POINT_ARN", "OUTPOST"],
     name: "parseOutpostArnablesMiddleaware",
 };
-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;
+const validateOutpostsArn = (arn, { clientRegion, signingRegion, clientPartition, useArnRegion, useFipsEndpoint, useDualstackEndpoint, }) => {
+    const { service, partition, accountId, region } = arn;
     validateOutpostService(service);
-    validatePartition(partition, { clientPartition: clientPartition });
+    validatePartition(partition, { clientPartition });
     validateAccountId(accountId);
     validateRegion(region, {
-        useArnRegion: useArnRegion,
-        clientRegion: clientRegion,
+        useArnRegion,
+        clientRegion,
         clientSigningRegion: signingRegion,
-        useFipsEndpoint: useFipsEndpoint,
+        useFipsEndpoint,
         allowFipsRegion: true,
     });
     validateNoDualstack(useDualstackEndpoint);
 };
-var parseOutpostsAccessPointArnResource = function (resource) {
-    var _a = getS3AccesspointArnResources(resource), outpostId = _a.outpostId, accesspointName = _a.accesspointName;
+const parseOutpostsAccessPointArnResource = (resource) => {
+    const { outpostId, accesspointName } = getS3AccesspointArnResources(resource);
     if (!outpostId) {
         throw new Error("ARN resource should begin with 'outpost'");
     }
     return {
-        outpostId: outpostId,
-        accesspointName: accesspointName,
+        outpostId,
+        accesspointName,
     };
 };
-var parseOutpostBucketArnResource = function (resource) {
-    var delimiter = resource.includes(":") ? ":" : "/";
-    var _a = __read(resource.split(delimiter)), resourceType = _a[0], rest = _a.slice(1);
+const parseOutpostBucketArnResource = (resource) => {
+    const delimiter = resource.includes(":") ? ":" : "/";
+    const [resourceType, ...rest] = resource.split(delimiter);
     if (resourceType === "outpost") {
         if (!rest[0] || rest[1] !== "bucket" || !rest[2] || rest.length !== 3) {
-            throw new Error("Outpost Bucket ARN should have resource outpost".concat(delimiter, "{outpostId}").concat(delimiter, "bucket").concat(delimiter, "{bucketName}"));
+            throw new Error(`Outpost Bucket ARN should have resource outpost${delimiter}{outpostId}${delimiter}bucket${delimiter}{bucketName}`);
         }
-        var _b = __read(rest, 3), outpostId = _b[0], _1 = _b[1], bucketName = _b[2];
-        return { outpostId: outpostId, bucketName: bucketName };
+        const [outpostId, _, bucketName] = rest;
+        return { outpostId, bucketName };
     }
     else {
-        throw new Error("ARN resource should begin with 'outpost".concat(delimiter, "'"));
+        throw new Error(`ARN resource should begin with 'outpost${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 var getProcessArnablesPlugin = function (options) { return ({
-    applyToStack: function (clientStack) {
+export const getProcessArnablesPlugin = (options) => ({
+    applyToStack: (clientStack) => {
         clientStack.add(parseOutpostArnablesMiddleaware(options), parseOutpostArnablesMiddleawareOptions);
         clientStack.add(updateArnablesRequestMiddleware(options), updateArnablesRequestMiddlewareOptions);
     },
-}); };
+});

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

@@ -1,40 +1,27 @@
-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";
-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)];
-                }
-            });
-        }); };
-    };
+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);
 };
-export var updateArnablesRequestMiddlewareOptions = {
+export const updateArnablesRequestMiddlewareOptions = {
     step: "build",
     name: "updateArnablesRequestMiddleware",
     tags: ["ACCOUNT_ID", "OUTPOST_ID", "OUTPOST"],

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

@@ -1,39 +1,26 @@
-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 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 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 redirectFromPostIdMiddlewareOptions = {
+export const redirectFromPostIdMiddlewareOptions = {
     step: "build",
     name: "redirectFromPostIdMiddleware",
     tags: ["OUTPOST"],
     override: true,
 };
-export var getRedirectFromPostIdPlugin = function (options) { return ({
-    applyToStack: function (clientStack) {
+export const getRedirectFromPostIdPlugin = (options) => ({
+    applyToStack: (clientStack) => {
         clientStack.add(redirectFromPostIdMiddleware(options), redirectFromPostIdMiddlewareOptions);
     },
-}); };
+});

package/package.json

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