@aws-sdk/middleware-bucket-endpoint 3.34.0 → 3.38.0

package/CHANGELOG.md

@@ -3,6 +3,41 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.38.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.37.0...v3.38.0) (2021-10-22)
+
+**Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint
+
+
+
+
+
+# [3.37.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.1...v3.37.0) (2021-10-15)
+
+**Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint
+
+
+
+
+
+# [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
+
+
+### Features
+
+* publish files in dist-* only ([#2873](https://github.com/aws/aws-sdk-js-v3/issues/2873)) ([53b4243](https://github.com/aws/aws-sdk-js-v3/commit/53b4243b066f25ff2412d5f0dea1036054b2df32))
+
+
+
+
+
+# [3.35.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.34.0...v3.35.0) (2021-10-04)
+
+**Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint
+
+
+
+
+
 # [3.34.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.33.0...v3.34.0) (2021-09-24)
 
 

package/dist-cjs/bucketEndpointMiddleware.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBucketEndpointPlugin = exports.bucketEndpointMiddlewareOptions = exports.bucketEndpointMiddleware = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const util_arn_parser_1 = require("@aws-sdk/util-arn-parser");
+const bucketHostname_1 = require("./bucketHostname");
+const bucketHostnameUtils_1 = require("./bucketHostnameUtils");
+const bucketEndpointMiddleware = (options) => (next, context) => async (args) => {
+    const { Bucket: bucketName } = args.input;
+    let replaceBucketInPath = options.bucketEndpoint;
+    const request = args.request;
+    if (protocol_http_1.HttpRequest.isInstance(request)) {
+        if (options.bucketEndpoint) {
+            request.hostname = bucketName;
+        }
+        else if (util_arn_parser_1.validate(bucketName)) {
+            const bucketArn = util_arn_parser_1.parse(bucketName);
+            const clientRegion = bucketHostnameUtils_1.getPseudoRegion(await options.region());
+            const { partition, signingRegion = clientRegion } = (await options.regionInfoProvider(clientRegion)) || {};
+            const useArnRegion = await options.useArnRegion();
+            const { hostname, bucketEndpoint, signingRegion: modifiedSigningRegion, signingService } = bucketHostname_1.bucketHostname({
+                bucketName: bucketArn,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint: options.useDualstackEndpoint,
+                pathStyleEndpoint: options.forcePathStyle,
+                tlsCompatible: request.protocol === "https:",
+                useArnRegion,
+                clientPartition: partition,
+                clientSigningRegion: signingRegion,
+                clientRegion: clientRegion,
+                isCustomEndpoint: options.isCustomEndpoint,
+                disableMultiregionAccessPoints: await options.disableMultiregionAccessPoints(),
+            });
+            if (modifiedSigningRegion && modifiedSigningRegion !== signingRegion) {
+                context["signing_region"] = modifiedSigningRegion;
+            }
+            if (signingService && signingService !== "s3") {
+                context["signing_service"] = signingService;
+            }
+            request.hostname = hostname;
+            replaceBucketInPath = bucketEndpoint;
+        }
+        else {
+            const clientRegion = bucketHostnameUtils_1.getPseudoRegion(await options.region());
+            const { hostname, bucketEndpoint } = bucketHostname_1.bucketHostname({
+                bucketName,
+                clientRegion,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint: options.useDualstackEndpoint,
+                pathStyleEndpoint: options.forcePathStyle,
+                tlsCompatible: request.protocol === "https:",
+                isCustomEndpoint: options.isCustomEndpoint,
+            });
+            request.hostname = hostname;
+            replaceBucketInPath = bucketEndpoint;
+        }
+        if (replaceBucketInPath) {
+            request.path = request.path.replace(/^(\/)?[^\/]+/, "");
+            if (request.path === "") {
+                request.path = "/";
+            }
+        }
+    }
+    return next({ ...args, request });
+};
+exports.bucketEndpointMiddleware = bucketEndpointMiddleware;
+exports.bucketEndpointMiddlewareOptions = {
+    tags: ["BUCKET_ENDPOINT"],
+    name: "bucketEndpointMiddleware",
+    relation: "before",
+    toMiddleware: "hostHeaderMiddleware",
+    override: true,
+};
+const getBucketEndpointPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(exports.bucketEndpointMiddleware(options), exports.bucketEndpointMiddlewareOptions);
+    },
+});
+exports.getBucketEndpointPlugin = getBucketEndpointPlugin;

package/dist-cjs/bucketHostname.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucketHostname = void 0;
+const bucketHostnameUtils_1 = require("./bucketHostnameUtils");
+const bucketHostname = (options) => {
+    bucketHostnameUtils_1.validateCustomEndpoint(options);
+    return bucketHostnameUtils_1.isBucketNameOptions(options)
+        ?
+            getEndpointFromBucketName(options)
+        :
+            getEndpointFromArn(options);
+};
+exports.bucketHostname = bucketHostname;
+const getEndpointFromBucketName = ({ accelerateEndpoint = false, clientRegion: region, baseHostname, bucketName, dualstackEndpoint = false, pathStyleEndpoint = false, tlsCompatible = true, isCustomEndpoint = false, }) => {
+    const [clientRegion, hostnameSuffix] = isCustomEndpoint ? [region, baseHostname] : bucketHostnameUtils_1.getSuffix(baseHostname);
+    if (pathStyleEndpoint || !bucketHostnameUtils_1.isDnsCompatibleBucketName(bucketName) || (tlsCompatible && bucketHostnameUtils_1.DOT_PATTERN.test(bucketName))) {
+        return {
+            bucketEndpoint: false,
+            hostname: dualstackEndpoint ? `s3.dualstack.${clientRegion}.${hostnameSuffix}` : baseHostname,
+        };
+    }
+    if (accelerateEndpoint) {
+        baseHostname = `s3-accelerate${dualstackEndpoint ? ".dualstack" : ""}.${hostnameSuffix}`;
+    }
+    else if (dualstackEndpoint) {
+        baseHostname = `s3.dualstack.${clientRegion}.${hostnameSuffix}`;
+    }
+    return {
+        bucketEndpoint: true,
+        hostname: `${bucketName}.${baseHostname}`,
+    };
+};
+const getEndpointFromArn = (options) => {
+    const { isCustomEndpoint, baseHostname, clientRegion } = options;
+    const hostnameSuffix = isCustomEndpoint ? baseHostname : bucketHostnameUtils_1.getSuffixForArnEndpoint(baseHostname)[1];
+    const { pathStyleEndpoint, accelerateEndpoint = false, tlsCompatible = true, bucketName, clientPartition = "aws", } = options;
+    bucketHostnameUtils_1.validateArnEndpointOptions({ pathStyleEndpoint, accelerateEndpoint, tlsCompatible });
+    const { service, partition, accountId, region, resource } = bucketName;
+    bucketHostnameUtils_1.validateService(service);
+    bucketHostnameUtils_1.validatePartition(partition, { clientPartition });
+    bucketHostnameUtils_1.validateAccountId(accountId);
+    const { accesspointName, outpostId } = bucketHostnameUtils_1.getArnResources(resource);
+    if (service === "s3-object-lambda") {
+        return getEndpointFromObjectLambdaArn({ ...options, tlsCompatible, bucketName, accesspointName, hostnameSuffix });
+    }
+    if (region === "") {
+        return getEndpointFromMRAPArn({ ...options, clientRegion, mrapAlias: accesspointName, hostnameSuffix });
+    }
+    if (outpostId) {
+        return getEndpointFromOutpostArn({ ...options, clientRegion, outpostId, accesspointName, hostnameSuffix });
+    }
+    return getEndpointFromAccessPointArn({ ...options, clientRegion, accesspointName, hostnameSuffix });
+};
+const getEndpointFromObjectLambdaArn = ({ dualstackEndpoint = false, tlsCompatible = true, useArnRegion, clientRegion, clientSigningRegion = clientRegion, accesspointName, bucketName, hostnameSuffix, }) => {
+    const { accountId, region, service } = bucketName;
+    bucketHostnameUtils_1.validateRegionalClient(clientRegion);
+    bucketHostnameUtils_1.validateRegion(region, { useArnRegion, clientRegion, clientSigningRegion, allowFipsRegion: true });
+    bucketHostnameUtils_1.validateNoDualstack(dualstackEndpoint);
+    const DNSHostLabel = `${accesspointName}-${accountId}`;
+    bucketHostnameUtils_1.validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? region : clientRegion;
+    const signingRegion = useArnRegion ? region : clientSigningRegion;
+    return {
+        bucketEndpoint: true,
+        hostname: `${DNSHostLabel}.${service}${bucketHostnameUtils_1.isFipsRegion(clientRegion) ? "-fips" : ""}.${bucketHostnameUtils_1.getPseudoRegion(endpointRegion)}.${hostnameSuffix}`,
+        signingRegion,
+        signingService: service,
+    };
+};
+const getEndpointFromMRAPArn = ({ disableMultiregionAccessPoints, dualstackEndpoint = false, isCustomEndpoint, mrapAlias, hostnameSuffix, }) => {
+    if (disableMultiregionAccessPoints === true) {
+        throw new Error("SDK is attempting to use a MRAP ARN. Please enable to feature.");
+    }
+    bucketHostnameUtils_1.validateMrapAlias(mrapAlias);
+    bucketHostnameUtils_1.validateNoDualstack(dualstackEndpoint);
+    return {
+        bucketEndpoint: true,
+        hostname: `${mrapAlias}${isCustomEndpoint ? "" : `.accesspoint.s3-global`}.${hostnameSuffix}`,
+        signingRegion: "*",
+    };
+};
+const getEndpointFromOutpostArn = ({ useArnRegion, clientRegion, clientSigningRegion = clientRegion, bucketName, outpostId, dualstackEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
+    bucketHostnameUtils_1.validateRegionalClient(clientRegion);
+    bucketHostnameUtils_1.validateRegion(bucketName.region, { useArnRegion, clientRegion, clientSigningRegion });
+    const DNSHostLabel = `${accesspointName}-${bucketName.accountId}`;
+    bucketHostnameUtils_1.validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    bucketHostnameUtils_1.validateOutpostService(bucketName.service);
+    bucketHostnameUtils_1.validateDNSHostLabel(outpostId, { tlsCompatible });
+    bucketHostnameUtils_1.validateNoDualstack(dualstackEndpoint);
+    bucketHostnameUtils_1.validateNoFIPS(endpointRegion);
+    const hostnamePrefix = `${DNSHostLabel}.${outpostId}`;
+    return {
+        bucketEndpoint: true,
+        hostname: `${hostnamePrefix}${isCustomEndpoint ? "" : `.s3-outposts.${endpointRegion}`}.${hostnameSuffix}`,
+        signingRegion,
+        signingService: "s3-outposts",
+    };
+};
+const getEndpointFromAccessPointArn = ({ useArnRegion, clientRegion, clientSigningRegion = clientRegion, bucketName, dualstackEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
+    bucketHostnameUtils_1.validateRegionalClient(clientRegion);
+    bucketHostnameUtils_1.validateRegion(bucketName.region, { useArnRegion, clientRegion, clientSigningRegion, allowFipsRegion: true });
+    const hostnamePrefix = `${accesspointName}-${bucketName.accountId}`;
+    bucketHostnameUtils_1.validateDNSHostLabel(hostnamePrefix, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    bucketHostnameUtils_1.validateS3Service(bucketName.service);
+    return {
+        bucketEndpoint: true,
+        hostname: `${hostnamePrefix}${isCustomEndpoint
+            ? ""
+            : `.s3-accesspoint${bucketHostnameUtils_1.isFipsRegion(clientRegion) ? "-fips" : ""}${dualstackEndpoint ? ".dualstack" : ""}.${bucketHostnameUtils_1.getPseudoRegion(endpointRegion)}`}.${hostnameSuffix}`,
+        signingRegion,
+    };
+};

package/dist-cjs/bucketHostnameUtils.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMrapAlias = exports.validateNoFIPS = exports.validateNoDualstack = exports.getArnResources = exports.validateCustomEndpoint = exports.validateDNSHostLabel = exports.validateAccountId = exports.isFipsRegion = exports.validateRegionalClient = exports.validateRegion = exports.validatePartition = exports.validateOutpostService = exports.validateS3Service = exports.validateService = exports.validateArnEndpointOptions = exports.getSuffixForArnEndpoint = exports.getSuffix = exports.isDnsCompatibleBucketName = exports.getPseudoRegion = exports.isBucketNameOptions = exports.S3_HOSTNAME_PATTERN = exports.DOT_PATTERN = void 0;
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+exports.DOT_PATTERN = /\./;
+exports.S3_HOSTNAME_PATTERN = /^(.+\.)?s3[.-]([a-z0-9-]+)\./;
+const S3_US_EAST_1_ALTNAME_PATTERN = /^s3(-external-1)?\.amazonaws\.com$/;
+const AWS_PARTITION_SUFFIX = "amazonaws.com";
+const isBucketNameOptions = (options) => typeof options.bucketName === "string";
+exports.isBucketNameOptions = isBucketNameOptions;
+const getPseudoRegion = (region) => (exports.isFipsRegion(region) ? region.replace(/fips-|-fips/, "") : region);
+exports.getPseudoRegion = getPseudoRegion;
+const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+exports.isDnsCompatibleBucketName = isDnsCompatibleBucketName;
+const getRegionalSuffix = (hostname) => {
+    const parts = hostname.match(exports.S3_HOSTNAME_PATTERN);
+    return [parts[2], hostname.replace(new RegExp(`^${parts[0]}`), "")];
+};
+const getSuffix = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname) ? ["us-east-1", AWS_PARTITION_SUFFIX] : getRegionalSuffix(hostname);
+exports.getSuffix = getSuffix;
+const getSuffixForArnEndpoint = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname)
+    ? [hostname.replace(`.${AWS_PARTITION_SUFFIX}`, ""), AWS_PARTITION_SUFFIX]
+    : getRegionalSuffix(hostname);
+exports.getSuffixForArnEndpoint = getSuffixForArnEndpoint;
+const validateArnEndpointOptions = (options) => {
+    if (options.pathStyleEndpoint) {
+        throw new Error("Path-style S3 endpoint is not supported when bucket is an ARN");
+    }
+    if (options.accelerateEndpoint) {
+        throw new Error("Accelerate endpoint is not supported when bucket is an ARN");
+    }
+    if (!options.tlsCompatible) {
+        throw new Error("HTTPS is required when bucket is an ARN");
+    }
+};
+exports.validateArnEndpointOptions = validateArnEndpointOptions;
+const validateService = (service) => {
+    if (service !== "s3" && service !== "s3-outposts" && service !== "s3-object-lambda") {
+        throw new Error("Expect 's3' or 's3-outposts' or 's3-object-lambda' in ARN service component");
+    }
+};
+exports.validateService = validateService;
+const validateS3Service = (service) => {
+    if (service !== "s3") {
+        throw new Error("Expect 's3' in Accesspoint ARN service component");
+    }
+};
+exports.validateS3Service = validateS3Service;
+const validateOutpostService = (service) => {
+    if (service !== "s3-outposts") {
+        throw new Error("Expect 's3-posts' in Outpost ARN service component");
+    }
+};
+exports.validateOutpostService = validateOutpostService;
+const validatePartition = (partition, options) => {
+    if (partition !== options.clientPartition) {
+        throw new Error(`Partition in ARN is incompatible, got "${partition}" but expected "${options.clientPartition}"`);
+    }
+};
+exports.validatePartition = validatePartition;
+const validateRegion = (region, options) => {
+    if (region === "") {
+        throw new Error("ARN region is empty");
+    }
+    if (exports.isFipsRegion(options.clientRegion)) {
+        if (!options.allowFipsRegion) {
+            throw new Error("FIPS region is not supported");
+        }
+        else if (!isEqualRegions(region, options.clientRegion)) {
+            throw new Error(`Client FIPS region ${options.clientRegion} doesn't match region ${region} in ARN`);
+        }
+    }
+    if (!options.useArnRegion &&
+        !isEqualRegions(region, options.clientRegion || "") &&
+        !isEqualRegions(region, options.clientSigningRegion || "")) {
+        throw new Error(`Region in ARN is incompatible, got ${region} but expected ${options.clientRegion}`);
+    }
+};
+exports.validateRegion = validateRegion;
+const validateRegionalClient = (region) => {
+    if (["s3-external-1", "aws-global"].includes(exports.getPseudoRegion(region))) {
+        throw new Error(`Client region ${region} is not regional`);
+    }
+};
+exports.validateRegionalClient = validateRegionalClient;
+const isFipsRegion = (region) => region.startsWith("fips-") || region.endsWith("-fips");
+exports.isFipsRegion = isFipsRegion;
+const isEqualRegions = (regionA, regionB) => regionA === regionB || exports.getPseudoRegion(regionA) === regionB || regionA === exports.getPseudoRegion(regionB);
+const validateAccountId = (accountId) => {
+    if (!/[0-9]{12}/.exec(accountId)) {
+        throw new Error("Access point ARN accountID does not match regex '[0-9]{12}'");
+    }
+};
+exports.validateAccountId = validateAccountId;
+const validateDNSHostLabel = (label, options = { tlsCompatible: true }) => {
+    if (label.length >= 64 ||
+        !/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(label) ||
+        /(\d+\.){3}\d+/.test(label) ||
+        /[.-]{2}/.test(label) ||
+        ((options === null || options === void 0 ? void 0 : options.tlsCompatible) && exports.DOT_PATTERN.test(label))) {
+        throw new Error(`Invalid DNS label ${label}`);
+    }
+};
+exports.validateDNSHostLabel = validateDNSHostLabel;
+const validateCustomEndpoint = (options) => {
+    if (options.isCustomEndpoint) {
+        if (options.dualstackEndpoint)
+            throw new Error("Dualstack endpoint is not supported with custom endpoint");
+        if (options.accelerateEndpoint)
+            throw new Error("Accelerate endpoint is not supported with custom endpoint");
+    }
+};
+exports.validateCustomEndpoint = validateCustomEndpoint;
+const getArnResources = (resource) => {
+    const delimiter = resource.includes(":") ? ":" : "/";
+    const [resourceType, ...rest] = resource.split(delimiter);
+    if (resourceType === "accesspoint") {
+        if (rest.length !== 1 || rest[0] === "") {
+            throw new Error(`Access Point ARN should have one resource accesspoint${delimiter}{accesspointname}`);
+        }
+        return { accesspointName: rest[0] };
+    }
+    else if (resourceType === "outpost") {
+        if (!rest[0] || rest[1] !== "accesspoint" || !rest[2] || rest.length !== 3) {
+            throw new Error(`Outpost ARN should have resource outpost${delimiter}{outpostId}${delimiter}accesspoint${delimiter}{accesspointName}`);
+        }
+        const [outpostId, _, accesspointName] = rest;
+        return { outpostId, accesspointName };
+    }
+    else {
+        throw new Error(`ARN resource should begin with 'accesspoint${delimiter}' or 'outpost${delimiter}'`);
+    }
+};
+exports.getArnResources = getArnResources;
+const validateNoDualstack = (dualstackEndpoint) => {
+    if (dualstackEndpoint)
+        throw new Error("Dualstack endpoint is not supported with Outpost or Multi-region Access Point ARN.");
+};
+exports.validateNoDualstack = validateNoDualstack;
+const validateNoFIPS = (region) => {
+    if (exports.isFipsRegion(region !== null && region !== void 0 ? region : ""))
+        throw new Error(`FIPS region is not supported with Outpost, got ${region}`);
+};
+exports.validateNoFIPS = validateNoFIPS;
+const validateMrapAlias = (name) => {
+    try {
+        name.split(".").forEach((label) => {
+            exports.validateDNSHostLabel(label);
+        });
+    }
+    catch (e) {
+        throw new Error(`"${name}" is not a DNS compatible name.`);
+    }
+};
+exports.validateMrapAlias = validateMrapAlias;

package/dist-cjs/configurations.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = exports.NODE_USE_ARN_REGION_CONFIG_OPTIONS = exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = exports.NODE_USE_ARN_REGION_INI_NAME = exports.NODE_USE_ARN_REGION_ENV_NAME = exports.resolveBucketEndpointConfig = void 0;
+function resolveBucketEndpointConfig(input) {
+    const { bucketEndpoint = false, forcePathStyle = false, useAccelerateEndpoint = false, useDualstackEndpoint = false, useArnRegion = false, disableMultiregionAccessPoints = false, } = input;
+    return {
+        ...input,
+        bucketEndpoint,
+        forcePathStyle,
+        useAccelerateEndpoint,
+        useDualstackEndpoint,
+        useArnRegion: typeof useArnRegion === "function" ? useArnRegion : () => Promise.resolve(useArnRegion),
+        disableMultiregionAccessPoints: typeof disableMultiregionAccessPoints === "function"
+            ? disableMultiregionAccessPoints
+            : () => Promise.resolve(disableMultiregionAccessPoints),
+    };
+}
+exports.resolveBucketEndpointConfig = resolveBucketEndpointConfig;
+exports.NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
+exports.NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
+exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
+exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
+exports.NODE_USE_ARN_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => {
+        if (!Object.prototype.hasOwnProperty.call(env, exports.NODE_USE_ARN_REGION_ENV_NAME))
+            return undefined;
+        if (env[exports.NODE_USE_ARN_REGION_ENV_NAME] === "true")
+            return true;
+        if (env[exports.NODE_USE_ARN_REGION_ENV_NAME] === "false")
+            return false;
+        throw new Error(`Cannot load env ${exports.NODE_USE_ARN_REGION_ENV_NAME}. Expected "true" or "false", got ${env[exports.NODE_USE_ARN_REGION_ENV_NAME]}.`);
+    },
+    configFileSelector: (profile) => {
+        if (!Object.prototype.hasOwnProperty.call(profile, exports.NODE_USE_ARN_REGION_INI_NAME))
+            return undefined;
+        if (profile[exports.NODE_USE_ARN_REGION_INI_NAME] === "true")
+            return true;
+        if (profile[exports.NODE_USE_ARN_REGION_INI_NAME] === "false")
+            return false;
+        throw new Error(`Cannot load shared config entry ${exports.NODE_USE_ARN_REGION_INI_NAME}. Expected "true" or "false", got ${profile[exports.NODE_USE_ARN_REGION_INI_NAME]}.`);
+    },
+    default: false,
+};
+exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => {
+        if (!Object.prototype.hasOwnProperty.call(env, exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME))
+            return undefined;
+        if (env[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME] === "true")
+            return true;
+        if (env[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME] === "false")
+            return false;
+        throw new Error(`Cannot load env ${exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME}. Expected "true" or "false", got ${env[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME]}.`);
+    },
+    configFileSelector: (profile) => {
+        if (!Object.prototype.hasOwnProperty.call(profile, exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME))
+            return undefined;
+        if (profile[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME] === "true")
+            return true;
+        if (profile[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME] === "false")
+            return false;
+        throw new Error(`Cannot load shared config entry ${exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME}. Expected "true" or "false", got ${profile[exports.NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME]}.`);
+    },
+    default: false,
+};

package/{dist/cjs → dist-cjs}/index.js

@@ -16,4 +16,3 @@ Object.defineProperty(exports, "validateRegion", { enumerable: true, get: functi
 Object.defineProperty(exports, "validateDNSHostLabel", { enumerable: true, get: function () { return bucketHostnameUtils_1.validateDNSHostLabel; } });
 Object.defineProperty(exports, "validateNoDualstack", { enumerable: true, get: function () { return bucketHostnameUtils_1.validateNoDualstack; } });
 Object.defineProperty(exports, "validateNoFIPS", { enumerable: true, get: function () { return bucketHostnameUtils_1.validateNoFIPS; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLHFFQUEyQztBQUMzQywyREFBaUM7QUFDakMsMkRBQWlDO0FBQ2pDLDZEQVcrQjtBQVY3QixzSEFBQSxlQUFlLE9BQUE7QUFDZixzSEFBQSxlQUFlLE9BQUE7QUFDZiw4SEFBQSx1QkFBdUIsT0FBQTtBQUN2Qiw2SEFBQSxzQkFBc0IsT0FBQTtBQUN0Qix3SEFBQSxpQkFBaUIsT0FBQTtBQUNqQix3SEFBQSxpQkFBaUIsT0FBQTtBQUNqQixxSEFBQSxjQUFjLE9BQUE7QUFDZCwySEFBQSxvQkFBb0IsT0FBQTtBQUNwQiwwSEFBQSxtQkFBbUIsT0FBQTtBQUNuQixxSEFBQSxjQUFjLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9idWNrZXRFbmRwb2ludE1pZGRsZXdhcmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2J1Y2tldEhvc3RuYW1lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25maWd1cmF0aW9uc1wiO1xuZXhwb3J0IHtcbiAgZ2V0QXJuUmVzb3VyY2VzLFxuICBnZXRQc2V1ZG9SZWdpb24sXG4gIGdldFN1ZmZpeEZvckFybkVuZHBvaW50LFxuICB2YWxpZGF0ZU91dHBvc3RTZXJ2aWNlLFxuICB2YWxpZGF0ZVBhcnRpdGlvbixcbiAgdmFsaWRhdGVBY2NvdW50SWQsXG4gIHZhbGlkYXRlUmVnaW9uLFxuICB2YWxpZGF0ZUROU0hvc3RMYWJlbCxcbiAgdmFsaWRhdGVOb0R1YWxzdGFjayxcbiAgdmFsaWRhdGVOb0ZJUFMsXG59IGZyb20gXCIuL2J1Y2tldEhvc3RuYW1lVXRpbHNcIjtcbiJdfQ==

package/dist-es/bucketEndpointMiddleware.js

@@ -0,0 +1,100 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { parse as parseArn, validate as validateArn } from "@aws-sdk/util-arn-parser";
+import { bucketHostname } from "./bucketHostname";
+import { getPseudoRegion } from "./bucketHostnameUtils";
+export var bucketEndpointMiddleware = function (options) { return function (next, context) { return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+    var bucketName, replaceBucketInPath, request, bucketArn, clientRegion, _a, _b, partition, _c, signingRegion, useArnRegion, _d, hostname, bucketEndpoint, modifiedSigningRegion, signingService, _e, clientRegion, _f, _g, hostname, bucketEndpoint;
+    var _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0:
+                bucketName = args.input.Bucket;
+                replaceBucketInPath = options.bucketEndpoint;
+                request = args.request;
+                if (!HttpRequest.isInstance(request)) return [3, 9];
+                if (!options.bucketEndpoint) return [3, 1];
+                request.hostname = bucketName;
+                return [3, 8];
+            case 1:
+                if (!validateArn(bucketName)) return [3, 6];
+                bucketArn = parseArn(bucketName);
+                _a = getPseudoRegion;
+                return [4, options.region()];
+            case 2:
+                clientRegion = _a.apply(void 0, [_j.sent()]);
+                return [4, options.regionInfoProvider(clientRegion)];
+            case 3:
+                _b = (_j.sent()) || {}, partition = _b.partition, _c = _b.signingRegion, signingRegion = _c === void 0 ? clientRegion : _c;
+                return [4, options.useArnRegion()];
+            case 4:
+                useArnRegion = _j.sent();
+                _e = bucketHostname;
+                _h = {
+                    bucketName: bucketArn,
+                    baseHostname: request.hostname,
+                    accelerateEndpoint: options.useAccelerateEndpoint,
+                    dualstackEndpoint: options.useDualstackEndpoint,
+                    pathStyleEndpoint: options.forcePathStyle,
+                    tlsCompatible: request.protocol === "https:",
+                    useArnRegion: useArnRegion,
+                    clientPartition: partition,
+                    clientSigningRegion: signingRegion,
+                    clientRegion: clientRegion,
+                    isCustomEndpoint: options.isCustomEndpoint
+                };
+                return [4, options.disableMultiregionAccessPoints()];
+            case 5:
+                _d = _e.apply(void 0, [(_h.disableMultiregionAccessPoints = _j.sent(),
+                        _h)]), hostname = _d.hostname, bucketEndpoint = _d.bucketEndpoint, modifiedSigningRegion = _d.signingRegion, signingService = _d.signingService;
+                if (modifiedSigningRegion && modifiedSigningRegion !== signingRegion) {
+                    context["signing_region"] = modifiedSigningRegion;
+                }
+                if (signingService && signingService !== "s3") {
+                    context["signing_service"] = signingService;
+                }
+                request.hostname = hostname;
+                replaceBucketInPath = bucketEndpoint;
+                return [3, 8];
+            case 6:
+                _f = getPseudoRegion;
+                return [4, options.region()];
+            case 7:
+                clientRegion = _f.apply(void 0, [_j.sent()]);
+                _g = bucketHostname({
+                    bucketName: bucketName,
+                    clientRegion: clientRegion,
+                    baseHostname: request.hostname,
+                    accelerateEndpoint: options.useAccelerateEndpoint,
+                    dualstackEndpoint: options.useDualstackEndpoint,
+                    pathStyleEndpoint: options.forcePathStyle,
+                    tlsCompatible: request.protocol === "https:",
+                    isCustomEndpoint: options.isCustomEndpoint,
+                }), hostname = _g.hostname, bucketEndpoint = _g.bucketEndpoint;
+                request.hostname = hostname;
+                replaceBucketInPath = bucketEndpoint;
+                _j.label = 8;
+            case 8:
+                if (replaceBucketInPath) {
+                    request.path = request.path.replace(/^(\/)?[^\/]+/, "");
+                    if (request.path === "") {
+                        request.path = "/";
+                    }
+                }
+                _j.label = 9;
+            case 9: return [2, next(__assign(__assign({}, args), { request: request }))];
+        }
+    });
+}); }; }; };
+export var bucketEndpointMiddlewareOptions = {
+    tags: ["BUCKET_ENDPOINT"],
+    name: "bucketEndpointMiddleware",
+    relation: "before",
+    toMiddleware: "hostHeaderMiddleware",
+    override: true,
+};
+export var getBucketEndpointPlugin = function (options) { return ({
+    applyToStack: function (clientStack) {
+        clientStack.addRelativeTo(bucketEndpointMiddleware(options), bucketEndpointMiddlewareOptions);
+    },
+}); };