@aws-sdk/middleware-sdk-s3 3.972.46 → 3.972.48

package/dist-cjs/submodules/s3-control/index.js

@@ -0,0 +1,215 @@
+'use strict';
+
+var s3 = require('@aws-sdk/middleware-sdk-s3/s3');
+var client = require('@aws-sdk/core/client');
+var util = require('@aws-sdk/core/util');
+var protocols = require('@smithy/core/protocols');
+
+function resolveS3ControlConfig(input) {
+    const { useArnRegion } = input;
+    return Object.assign(input, {
+        useArnRegion: typeof useArnRegion === "function" ? useArnRegion : () => Promise.resolve(useArnRegion),
+    });
+}
+
+const CONTEXT_OUTPOST_ID = "outpost_id";
+const CONTEXT_ACCOUNT_ID = "account_id";
+const CONTEXT_ARN_REGION = "outpost_arn_region";
+const CONTEXT_SIGNING_SERVICE = "signing_service";
+const CONTEXT_SIGNING_REGION = "signing_region";
+
+const parseOutpostArnablesMiddleaware = (options) => (next, context) => async (args) => {
+    const { input } = args;
+    const parameter = input.Name && util.validate(input.Name) ? "Name" : input.Bucket && util.validate(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;
+    let clientPartition;
+    let signingRegion;
+    if (options.regionInfoProvider) {
+        ({ partition: clientPartition, signingRegion = baseRegion } = (await options.regionInfoProvider(baseRegion, {
+            useFipsEndpoint,
+            useDualstackEndpoint,
+        })));
+    }
+    else {
+        signingRegion = context.endpointV2?.properties?.authSchemes?.[0]?.signingRegion || baseRegion;
+        clientPartition = client.partition(signingRegion).name;
+    }
+    const validatorOptions = {
+        clientPartition};
+    let arn;
+    if (parameter === "Name") {
+        arn = util.parse(input.Name);
+        validateOutpostsArn(arn, validatorOptions);
+        const { outpostId, accesspointName } = parseOutpostsAccessPointArnResource(arn.resource);
+        input.Name = accesspointName;
+        context[CONTEXT_OUTPOST_ID] = outpostId;
+    }
+    else {
+        arn = util.parse(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;
+    }
+    if (useArnRegion)
+        context[CONTEXT_ARN_REGION] = arn.region;
+    return next(args);
+};
+const parseOutpostArnablesMiddleawareOptions = {
+    toMiddleware: "serializerMiddleware",
+    relation: "before",
+    tags: ["CONVERT_ARN", "OUTPOST_BUCKET_ARN", "OUTPOST_ACCESS_POINT_ARN", "OUTPOST"],
+    name: "parseOutpostArnablesMiddleaware",
+};
+const validateOutpostsArn = (arn, { clientPartition }) => {
+    const { service, partition, accountId, region } = arn;
+    s3.validateOutpostService(service);
+    s3.validatePartition(partition, { clientPartition });
+    s3.validateAccountId(accountId);
+};
+const parseOutpostsAccessPointArnResource = (resource) => {
+    const { outpostId, accesspointName } = s3.getArnResources(resource);
+    if (!outpostId) {
+        throw new Error("ARN resource should begin with 'outpost'");
+    }
+    return {
+        outpostId,
+        accesspointName,
+    };
+};
+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${delimiter}{outpostId}${delimiter}bucket${delimiter}{bucketName}`);
+        }
+        const [outpostId, _, bucketName] = rest;
+        return { outpostId, bucketName };
+    }
+    else {
+        throw new Error(`ARN resource should begin with 'outpost${delimiter}'`);
+    }
+};
+
+const REGEX_S3CONTROL_HOSTNAME = /^(.+\.)?s3-control(-fips)?[.-]([a-z0-9-]+)\./;
+const getOutpostEndpoint = (hostname, { isCustomEndpoint, regionOverride, useFipsEndpoint }) => {
+    if (isCustomEndpoint) {
+        return hostname;
+    }
+    const match = hostname.match(REGEX_S3CONTROL_HOSTNAME);
+    if (!match) {
+        return hostname;
+    }
+    const [matched, prefix, fips, region] = hostname.match(REGEX_S3CONTROL_HOSTNAME);
+    return [
+        `s3-outposts${useFipsEndpoint ? "-fips" : ""}`,
+        regionOverride || region,
+        hostname.replace(new RegExp(`^${matched}`), ""),
+    ]
+        .filter((part) => part !== undefined)
+        .join(".");
+};
+
+const ACCOUNT_ID_HEADER = "x-amz-account-id";
+const OUTPOST_ID_HEADER = "x-amz-outpost-id";
+const updateArnablesRequestMiddleware = (config) => (next, context) => async (args) => {
+    const { request } = args;
+    if (!protocols.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);
+};
+const updateArnablesRequestMiddlewareOptions = {
+    toMiddleware: "serializerMiddleware",
+    relation: "after",
+    name: "updateArnablesRequestMiddleware",
+    tags: ["ACCOUNT_ID", "OUTPOST_ID", "OUTPOST"],
+};
+
+const getProcessArnablesPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(parseOutpostArnablesMiddleaware(options), parseOutpostArnablesMiddleawareOptions);
+        clientStack.addRelativeTo(updateArnablesRequestMiddleware(options), updateArnablesRequestMiddlewareOptions);
+    },
+});
+
+const hostPrefixDeduplicationMiddleware = () => {
+    return (next, context) => (args) => {
+        return next(args);
+    };
+};
+const hostPrefixDeduplicationMiddlewareOptions = {
+    tags: ["HOST_PREFIX_DEDUPLICATION", "ENDPOINT_V2", "ENDPOINT"],
+    toMiddleware: "serializerMiddleware",
+    relation: "after",
+    name: "hostPrefixDeduplicationMiddleware",
+    override: true,
+};
+const getHostPrefixDeduplicationPlugin = (config) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(hostPrefixDeduplicationMiddleware(), hostPrefixDeduplicationMiddlewareOptions);
+    },
+});
+
+const redirectFromPostIdMiddleware = (config) => (next, context) => async (args) => {
+    const { input, request } = args;
+    if (!protocols.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);
+};
+const redirectFromPostIdMiddlewareOptions = {
+    step: "build",
+    name: "redirectFromPostIdMiddleware",
+    tags: ["OUTPOST"],
+    override: true,
+};
+const getRedirectFromPostIdPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.add(redirectFromPostIdMiddleware(options), redirectFromPostIdMiddlewareOptions);
+    },
+});
+
+exports.getHostPrefixDeduplicationPlugin = getHostPrefixDeduplicationPlugin;
+exports.getOutpostEndpoint = getOutpostEndpoint;
+exports.getProcessArnablesPlugin = getProcessArnablesPlugin;
+exports.getRedirectFromPostIdPlugin = getRedirectFromPostIdPlugin;
+exports.hostPrefixDeduplicationMiddleware = hostPrefixDeduplicationMiddleware;
+exports.hostPrefixDeduplicationMiddlewareOptions = hostPrefixDeduplicationMiddlewareOptions;
+exports.parseOutpostArnablesMiddleaware = parseOutpostArnablesMiddleaware;
+exports.parseOutpostArnablesMiddleawareOptions = parseOutpostArnablesMiddleawareOptions;
+exports.redirectFromPostIdMiddleware = redirectFromPostIdMiddleware;
+exports.redirectFromPostIdMiddlewareOptions = redirectFromPostIdMiddlewareOptions;
+exports.resolveS3ControlConfig = resolveS3ControlConfig;
+exports.updateArnablesRequestMiddleware = updateArnablesRequestMiddleware;
+exports.updateArnablesRequestMiddlewareOptions = updateArnablesRequestMiddlewareOptions;

package/dist-es/index.browser.js

@@ -0,0 +1 @@
+export { checkContentLengthHeader, checkContentLengthHeaderMiddlewareOptions, getCheckContentLengthHeaderPlugin, regionRedirectEndpointMiddleware, regionRedirectEndpointMiddlewareOptions, regionRedirectMiddleware, regionRedirectMiddlewareOptions, getRegionRedirectMiddlewarePlugin, resolveS3Config, s3ExpiresMiddleware, s3ExpiresMiddlewareOptions, getS3ExpiresMiddlewarePlugin, S3ExpressIdentityCache, S3ExpressIdentityCacheEntry, S3ExpressIdentityProviderImpl, SignatureV4S3Express, NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS, getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions, getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, throw200ExceptionsMiddleware, throw200ExceptionsMiddlewareOptions, getThrow200ExceptionsPlugin, validateBucketNameMiddleware, validateBucketNameMiddlewareOptions, getValidateBucketNamePlugin, S3RestXmlProtocol, } from "./submodules/s3/index.browser";

package/dist-es/index.js

@@ -1,9 +1 @@
-export * from "./check-content-length-header";
-export * from "./region-redirect-endpoint-middleware";
-export * from "./region-redirect-middleware";
-export * from "./s3-expires-middleware";
-export * from "./s3-express/index";
-export * from "./s3Configuration";
-export * from "./throw-200-exceptions";
-export * from "./validate-bucket-name";
-export { S3RestXmlProtocol } from "./protocol/S3RestXmlProtocol";
+export { checkContentLengthHeader, checkContentLengthHeaderMiddlewareOptions, getCheckContentLengthHeaderPlugin, regionRedirectEndpointMiddleware, regionRedirectEndpointMiddlewareOptions, regionRedirectMiddleware, regionRedirectMiddlewareOptions, getRegionRedirectMiddlewarePlugin, resolveS3Config, s3ExpiresMiddleware, s3ExpiresMiddlewareOptions, getS3ExpiresMiddlewarePlugin, S3ExpressIdentityCache, S3ExpressIdentityCacheEntry, S3ExpressIdentityProviderImpl, SignatureV4S3Express, NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS, getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions, getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, throw200ExceptionsMiddleware, throw200ExceptionsMiddlewareOptions, getThrow200ExceptionsPlugin, validateBucketNameMiddleware, validateBucketNameMiddlewareOptions, getValidateBucketNamePlugin, S3RestXmlProtocol, } from "./submodules/s3/index";

package/dist-es/submodules/s3/NodeDisableMultiregionAccessPointConfigOptions.js

@@ -0,0 +1,8 @@
+import { booleanSelector, SelectorType } from "@smithy/core/config";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME, SelectorType.CONFIG),
+    default: false,
+};

package/dist-es/submodules/s3/NodeUseArnRegionConfigOptions.js

@@ -0,0 +1,8 @@
+import { booleanSelector, SelectorType } from "@smithy/core/config";
+export const NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
+export const NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
+export const NODE_USE_ARN_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, NODE_USE_ARN_REGION_ENV_NAME, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, NODE_USE_ARN_REGION_INI_NAME, SelectorType.CONFIG),
+    default: undefined,
+};

package/dist-es/submodules/s3/index.browser.js

@@ -0,0 +1,30 @@
+const no = Symbol.for("node-only");
+export { checkContentLengthHeader, checkContentLengthHeaderMiddlewareOptions, getCheckContentLengthHeaderPlugin, } from "./middleware-check-content-length-header/check-content-length-header";
+export { regionRedirectEndpointMiddleware, regionRedirectEndpointMiddlewareOptions, } from "./middleware-region-redirect/region-redirect-endpoint-middleware";
+export { regionRedirectMiddleware, regionRedirectMiddlewareOptions, getRegionRedirectMiddlewarePlugin, } from "./middleware-region-redirect/region-redirect-middleware";
+export { resolveS3Config } from "./middleware-s3-configuration/s3Configuration";
+export { s3ExpiresMiddleware, s3ExpiresMiddlewareOptions, getS3ExpiresMiddlewarePlugin, } from "./middleware-s3-expires/s3-expires-middleware";
+export { S3ExpressIdentityCache } from "./middleware-s3-express/classes/S3ExpressIdentityCache";
+export { S3ExpressIdentityCacheEntry } from "./middleware-s3-express/classes/S3ExpressIdentityCacheEntry";
+export { S3ExpressIdentityProviderImpl } from "./middleware-s3-express/classes/S3ExpressIdentityProviderImpl";
+export { SignatureV4S3Express } from "./middleware-s3-express/classes/SignatureV4S3Express";
+export const NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS = no;
+export { getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions, } from "./middleware-s3-express/functions/s3ExpressMiddleware";
+export { getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, } from "./middleware-s3-express/functions/s3ExpressHttpSigningMiddleware";
+export { throw200ExceptionsMiddleware, throw200ExceptionsMiddlewareOptions, getThrow200ExceptionsPlugin, } from "./middleware-throw-200-exceptions/throw-200-exceptions";
+export { validateBucketNameMiddleware, validateBucketNameMiddlewareOptions, getValidateBucketNamePlugin, } from "./middleware-validate-bucket-name/validate-bucket-name";
+export { S3RestXmlProtocol } from "./protocol/S3RestXmlProtocol";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = no;
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = no;
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = no;
+export const NODE_USE_ARN_REGION_CONFIG_OPTIONS = no;
+export const NODE_USE_ARN_REGION_ENV_NAME = no;
+export const NODE_USE_ARN_REGION_INI_NAME = no;
+export { bucketEndpointMiddleware, bucketEndpointMiddlewareOptions, getBucketEndpointPlugin, } from "./middleware-bucket-endpoint/bucketEndpointMiddleware";
+export { bucketHostname } from "./middleware-bucket-endpoint/bucketHostname";
+export { resolveBucketEndpointConfig } from "./middleware-bucket-endpoint/configurations";
+export { getArnResources, getSuffixForArnEndpoint, validateOutpostService, validatePartition, validateAccountId, validateRegion, validateDNSHostLabel, validateNoDualstack, validateNoFIPS, } from "./middleware-bucket-endpoint/bucketHostnameUtils";
+export { addExpectContinueMiddleware, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin, } from "./middleware-expect-continue/middleware-expect-continue";
+export { locationConstraintMiddleware, locationConstraintMiddlewareOptions, getLocationConstraintPlugin, } from "./middleware-location-constraint/middleware-location-constraint";
+export { resolveLocationConstraintConfig } from "./middleware-location-constraint/configuration";
+export { ssecMiddleware, ssecMiddlewareOptions, getSsecPlugin, isValidBase64EncodedSSECustomerKey, } from "./middleware-ssec/middleware-ssec";

package/dist-es/submodules/s3/index.js

@@ -0,0 +1,25 @@
+export { checkContentLengthHeader, checkContentLengthHeaderMiddlewareOptions, getCheckContentLengthHeaderPlugin, } from "./middleware-check-content-length-header/check-content-length-header";
+export { regionRedirectEndpointMiddleware, regionRedirectEndpointMiddlewareOptions, } from "./middleware-region-redirect/region-redirect-endpoint-middleware";
+export { regionRedirectMiddleware, regionRedirectMiddlewareOptions, getRegionRedirectMiddlewarePlugin, } from "./middleware-region-redirect/region-redirect-middleware";
+export { resolveS3Config } from "./middleware-s3-configuration/s3Configuration";
+export { s3ExpiresMiddleware, s3ExpiresMiddlewareOptions, getS3ExpiresMiddlewarePlugin, } from "./middleware-s3-expires/s3-expires-middleware";
+export { S3ExpressIdentityCache } from "./middleware-s3-express/classes/S3ExpressIdentityCache";
+export { S3ExpressIdentityCacheEntry } from "./middleware-s3-express/classes/S3ExpressIdentityCacheEntry";
+export { S3ExpressIdentityProviderImpl } from "./middleware-s3-express/classes/S3ExpressIdentityProviderImpl";
+export { SignatureV4S3Express } from "./middleware-s3-express/classes/SignatureV4S3Express";
+export { NODE_DISABLE_S3_EXPRESS_SESSION_AUTH_OPTIONS } from "./middleware-s3-express/constants";
+export { getS3ExpressPlugin, s3ExpressMiddleware, s3ExpressMiddlewareOptions, } from "./middleware-s3-express/functions/s3ExpressMiddleware";
+export { getS3ExpressHttpSigningPlugin, s3ExpressHttpSigningMiddleware, s3ExpressHttpSigningMiddlewareOptions, } from "./middleware-s3-express/functions/s3ExpressHttpSigningMiddleware";
+export { throw200ExceptionsMiddleware, throw200ExceptionsMiddlewareOptions, getThrow200ExceptionsPlugin, } from "./middleware-throw-200-exceptions/throw-200-exceptions";
+export { validateBucketNameMiddleware, validateBucketNameMiddlewareOptions, getValidateBucketNamePlugin, } from "./middleware-validate-bucket-name/validate-bucket-name";
+export { S3RestXmlProtocol } from "./protocol/S3RestXmlProtocol";
+export { NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS, NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME, NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME, } from "./NodeDisableMultiregionAccessPointConfigOptions";
+export { NODE_USE_ARN_REGION_CONFIG_OPTIONS, NODE_USE_ARN_REGION_ENV_NAME, NODE_USE_ARN_REGION_INI_NAME, } from "./NodeUseArnRegionConfigOptions";
+export { bucketEndpointMiddleware, bucketEndpointMiddlewareOptions, getBucketEndpointPlugin, } from "./middleware-bucket-endpoint/bucketEndpointMiddleware";
+export { bucketHostname } from "./middleware-bucket-endpoint/bucketHostname";
+export { resolveBucketEndpointConfig } from "./middleware-bucket-endpoint/configurations";
+export { getArnResources, getSuffixForArnEndpoint, validateOutpostService, validatePartition, validateAccountId, validateRegion, validateDNSHostLabel, validateNoDualstack, validateNoFIPS, } from "./middleware-bucket-endpoint/bucketHostnameUtils";
+export { addExpectContinueMiddleware, addExpectContinueMiddlewareOptions, getAddExpectContinuePlugin, } from "./middleware-expect-continue/middleware-expect-continue";
+export { locationConstraintMiddleware, locationConstraintMiddlewareOptions, getLocationConstraintPlugin, } from "./middleware-location-constraint/middleware-location-constraint";
+export { resolveLocationConstraintConfig } from "./middleware-location-constraint/configuration";
+export { ssecMiddleware, ssecMiddlewareOptions, getSsecPlugin, isValidBase64EncodedSSECustomerKey, } from "./middleware-ssec/middleware-ssec";

package/dist-es/submodules/s3/middleware-bucket-endpoint/bucketEndpointMiddleware.js

@@ -0,0 +1,81 @@
+import { parse as parseArn, validate as validateArn } from "@aws-sdk/core/util";
+import { HttpRequest } from "@smithy/core/protocols";
+import { bucketHostname } from "./bucketHostname";
+export const bucketEndpointMiddleware = (options) => (next, context) => async (args) => {
+    const { Bucket: bucketName } = args.input;
+    let replaceBucketInPath = options.bucketEndpoint;
+    const request = args.request;
+    if (HttpRequest.isInstance(request)) {
+        if (options.bucketEndpoint) {
+            request.hostname = bucketName;
+        }
+        else if (validateArn(bucketName)) {
+            const bucketArn = parseArn(bucketName);
+            const clientRegion = await options.region();
+            const useDualstackEndpoint = await options.useDualstackEndpoint();
+            const useFipsEndpoint = await options.useFipsEndpoint();
+            const { partition, signingRegion = clientRegion } = (await options.regionInfoProvider(clientRegion, { useDualstackEndpoint, useFipsEndpoint })) || {};
+            const useArnRegion = await options.useArnRegion();
+            const { hostname, bucketEndpoint, signingRegion: modifiedSigningRegion, signingService, } = bucketHostname({
+                bucketName: bucketArn,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint: useDualstackEndpoint,
+                fipsEndpoint: useFipsEndpoint,
+                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 = await options.region();
+            const dualstackEndpoint = await options.useDualstackEndpoint();
+            const fipsEndpoint = await options.useFipsEndpoint();
+            const { hostname, bucketEndpoint } = bucketHostname({
+                bucketName,
+                clientRegion,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint,
+                fipsEndpoint,
+                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 });
+};
+export const bucketEndpointMiddlewareOptions = {
+    tags: ["BUCKET_ENDPOINT"],
+    name: "bucketEndpointMiddleware",
+    relation: "before",
+    toMiddleware: "hostHeaderMiddleware",
+    override: true,
+};
+export const getBucketEndpointPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(bucketEndpointMiddleware(options), bucketEndpointMiddlewareOptions);
+    },
+});

package/dist-es/submodules/s3/middleware-bucket-endpoint/bucketHostname.js

@@ -0,0 +1,106 @@
+import { DOT_PATTERN, getArnResources, getSuffix, getSuffixForArnEndpoint, isBucketNameOptions, isDnsCompatibleBucketName, validateAccountId, validateArnEndpointOptions, validateCustomEndpoint, validateDNSHostLabel, validateMrapAlias, validateNoFIPS, validateOutpostService, validatePartition, validateRegionalClient, validateS3Service, validateService, } from "./bucketHostnameUtils";
+export const bucketHostname = (options) => {
+    validateCustomEndpoint(options);
+    return isBucketNameOptions(options)
+        ?
+            getEndpointFromBucketName(options)
+        :
+            getEndpointFromArn(options);
+};
+const getEndpointFromBucketName = ({ accelerateEndpoint = false, clientRegion: region, baseHostname, bucketName, dualstackEndpoint = false, fipsEndpoint = false, pathStyleEndpoint = false, tlsCompatible = true, isCustomEndpoint = false, }) => {
+    const [clientRegion, hostnameSuffix] = isCustomEndpoint ? [region, baseHostname] : getSuffix(baseHostname);
+    if (pathStyleEndpoint || !isDnsCompatibleBucketName(bucketName) || (tlsCompatible && 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 : getSuffixForArnEndpoint(baseHostname)[1];
+    const { pathStyleEndpoint, accelerateEndpoint = false, fipsEndpoint = false, tlsCompatible = true, bucketName, clientPartition = "aws", } = options;
+    validateArnEndpointOptions({ pathStyleEndpoint, accelerateEndpoint, tlsCompatible });
+    const { service, partition, accountId, region, resource } = bucketName;
+    validateService(service);
+    validatePartition(partition, { clientPartition });
+    validateAccountId(accountId);
+    const { accesspointName, outpostId } = 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, fipsEndpoint = false, tlsCompatible = true, useArnRegion, clientRegion, clientSigningRegion = clientRegion, accesspointName, bucketName, hostnameSuffix, }) => {
+    const { accountId, region, service } = bucketName;
+    validateRegionalClient(clientRegion);
+    const DNSHostLabel = `${accesspointName}-${accountId}`;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? region : clientRegion;
+    const signingRegion = useArnRegion ? region : clientSigningRegion;
+    return {
+        bucketEndpoint: true,
+        hostname: `${DNSHostLabel}.${service}${fipsEndpoint ? "-fips" : ""}.${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.");
+    }
+    validateMrapAlias(mrapAlias);
+    return {
+        bucketEndpoint: true,
+        hostname: `${mrapAlias}${isCustomEndpoint ? "" : `.accesspoint.s3-global`}.${hostnameSuffix}`,
+        signingRegion: "*",
+    };
+};
+const getEndpointFromOutpostArn = ({ useArnRegion, clientRegion, clientSigningRegion = clientRegion, bucketName, outpostId, dualstackEndpoint = false, fipsEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
+    validateRegionalClient(clientRegion);
+    const DNSHostLabel = `${accesspointName}-${bucketName.accountId}`;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    validateOutpostService(bucketName.service);
+    validateDNSHostLabel(outpostId, { tlsCompatible });
+    validateNoFIPS(fipsEndpoint);
+    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, fipsEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
+    validateRegionalClient(clientRegion);
+    const hostnamePrefix = `${accesspointName}-${bucketName.accountId}`;
+    validateDNSHostLabel(hostnamePrefix, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    validateS3Service(bucketName.service);
+    return {
+        bucketEndpoint: true,
+        hostname: `${hostnamePrefix}${isCustomEndpoint
+            ? ""
+            : `.s3-accesspoint${fipsEndpoint ? "-fips" : ""}${dualstackEndpoint ? ".dualstack" : ""}.${endpointRegion}`}.${hostnameSuffix}`,
+        signingRegion,
+    };
+};

package/dist-es/submodules/s3/middleware-bucket-endpoint/bucketHostnameUtils.js

@@ -0,0 +1,111 @@
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+export const DOT_PATTERN = /\./;
+export const S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
+const S3_US_EAST_1_ALTNAME_PATTERN = /^s3(-external-1)?\.amazonaws\.com$/;
+const AWS_PARTITION_SUFFIX = "amazonaws.com";
+export const isBucketNameOptions = (options) => typeof options.bucketName === "string";
+export const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+const getRegionalSuffix = (hostname) => {
+    const parts = hostname.match(S3_HOSTNAME_PATTERN);
+    return [parts[4], hostname.replace(new RegExp(`^${parts[0]}`), "")];
+};
+export const getSuffix = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname) ? ["us-east-1", AWS_PARTITION_SUFFIX] : getRegionalSuffix(hostname);
+export const getSuffixForArnEndpoint = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname)
+    ? [hostname.replace(`.${AWS_PARTITION_SUFFIX}`, ""), AWS_PARTITION_SUFFIX]
+    : getRegionalSuffix(hostname);
+export 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");
+    }
+};
+export 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");
+    }
+};
+export const validateS3Service = (service) => {
+    if (service !== "s3") {
+        throw new Error("Expect 's3' in Accesspoint ARN service component");
+    }
+};
+export const validateOutpostService = (service) => {
+    if (service !== "s3-outposts") {
+        throw new Error("Expect 's3-posts' in Outpost ARN service component");
+    }
+};
+export const validatePartition = (partition, options) => {
+    if (partition !== options.clientPartition) {
+        throw new Error(`Partition in ARN is incompatible, got "${partition}" but expected "${options.clientPartition}"`);
+    }
+};
+export const validateRegion = (region, options) => { };
+export const validateRegionalClient = (region) => {
+    if (["s3-external-1", "aws-global"].includes(region)) {
+        throw new Error(`Client region ${region} is not regional`);
+    }
+};
+export const validateAccountId = (accountId) => {
+    if (!/[0-9]{12}/.exec(accountId)) {
+        throw new Error("Access point ARN accountID does not match regex '[0-9]{12}'");
+    }
+};
+export 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?.tlsCompatible && DOT_PATTERN.test(label))) {
+        throw new Error(`Invalid DNS label ${label}`);
+    }
+};
+export 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");
+    }
+};
+export 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}'`);
+    }
+};
+export const validateNoDualstack = (dualstackEndpoint) => { };
+export const validateNoFIPS = (useFipsEndpoint) => {
+    if (useFipsEndpoint)
+        throw new Error(`FIPS region is not supported with Outpost.`);
+};
+export const validateMrapAlias = (name) => {
+    try {
+        name.split(".").forEach((label) => {
+            validateDNSHostLabel(label);
+        });
+    }
+    catch (e) {
+        throw new Error(`"${name}" is not a DNS compatible name.`);
+    }
+};

package/dist-es/submodules/s3/middleware-bucket-endpoint/configurations.js

@@ -0,0 +1,12 @@
+export function resolveBucketEndpointConfig(input) {
+    const { bucketEndpoint = false, forcePathStyle = false, useAccelerateEndpoint = false, useArnRegion, disableMultiregionAccessPoints = false, } = input;
+    return Object.assign(input, {
+        bucketEndpoint,
+        forcePathStyle,
+        useAccelerateEndpoint,
+        useArnRegion: typeof useArnRegion === "function" ? useArnRegion : () => Promise.resolve(useArnRegion),
+        disableMultiregionAccessPoints: typeof disableMultiregionAccessPoints === "function"
+            ? disableMultiregionAccessPoints
+            : () => Promise.resolve(disableMultiregionAccessPoints),
+    });
+}