feat(middleware-bucket-endpoint): set region from arn to handler context

Author: AllanZhengYP

packages/middleware-bucket-endpoint/src/bucketEndpointMiddleware.spec.ts

@@ -163,5 +163,23 @@ describe("bucketEndpointMiddleware", () => {
       expect(mockArnParse).toBeCalled();
       expect(mockArnValidation).toBeCalled();
     });
+
+    it("should set signing_region to middleware context if the request will use region from ARN", async () => {
+      const request = new HttpRequest(requestInput);
+      previouslyResolvedConfig.useArnRegion.mockReturnValue(true);
+      const arnRegion = "us-west-2";
+      mockArnParse.mockReturnValue({ region: arnRegion });
+      const handlerContext = {} as any;
+      const handler = bucketEndpointMiddleware(
+        resolveBucketEndpointConfig({
+          ...previouslyResolvedConfig,
+        })
+      )(next, handlerContext);
+      await handler({
+        input: { Bucket: `myendpoint-123456789012.s3-accesspoint.${arnRegion}.amazonaws.com` },
+        request,
+      });
+      expect(handlerContext).toMatchObject({ signing_region: arnRegion });
+    });
   });
 });

packages/middleware-bucket-endpoint/src/bucketEndpointMiddleware.ts

@@ -4,6 +4,7 @@ import {
   BuildHandlerArguments,
   BuildHandlerOutput,
   BuildMiddleware,
+  HandlerExecutionContext,
   MetadataBearer,
   Pluggable,
   RelativeMiddlewareOptions,
@@ -15,27 +16,50 @@ import { getPseudoRegion } from "./bucketHostnameUtils";
 import { BucketEndpointResolvedConfig } from "./configurations";
 
 export function bucketEndpointMiddleware(options: BucketEndpointResolvedConfig): BuildMiddleware<any, any> {
-  return <Output extends MetadataBearer>(next: BuildHandler<any, Output>): BuildHandler<any, Output> => async (
-    args: BuildHandlerArguments<any>
-  ): Promise<BuildHandlerOutput<Output>> => {
-    const { Bucket: bucketName } = args.input;
+  return <Output extends MetadataBearer>(
+    next: BuildHandler<any, Output>,
+    context: HandlerExecutionContext
+  ): BuildHandler<any, Output> => async (args: BuildHandlerArguments<any>): Promise<BuildHandlerOutput<Output>> => {
+    const { Bucket: bucketName } = args.input as { Bucket: string };
     let replaceBucketInPath = options.bucketEndpoint;
     const request = args.request;
     if (HttpRequest.isInstance(request)) {
       if (options.bucketEndpoint) {
         request.hostname = bucketName;
-      } else {
-        const isBucketNameArn = validateArn(bucketName);
+      } else if (validateArn(bucketName)) {
+        const bucketArn = parseArn(bucketName);
+        const clientRegion = getPseudoRegion(await options.region());
+        const { partition, signingRegion } = (await options.regionInfoProvider(clientRegion)) || {};
+        const useArnRegion = await options.useArnRegion();
         const { hostname, bucketEndpoint } = bucketHostname({
-          bucketName: isBucketNameArn ? parseArn(bucketName) : bucketName,
+          bucketName: bucketArn,
           baseHostname: request.hostname,
           accelerateEndpoint: options.useAccelerateEndpoint,
           dualstackEndpoint: options.useDualstackEndpoint,
           pathStyleEndpoint: options.forcePathStyle,
           tlsCompatible: request.protocol === "https:",
-          ...(isBucketNameArn ? await getArnHostnameParameters(options) : {}),
+          useArnRegion,
+          clientPartition: partition,
+          clientSigningRegion: signingRegion,
         });
 
+        // If the request needs to use a region inferred from ARN that different from client region, we need to set
+        // them in the handler context so the signer will use them
+        if (useArnRegion && clientRegion !== bucketArn.region) {
+          context["signing_region"] = bucketArn.region;
+        }
+
+        request.hostname = hostname;
+        replaceBucketInPath = bucketEndpoint;
+      } else {
+        const { hostname, bucketEndpoint } = bucketHostname({
+          bucketName,
+          baseHostname: request.hostname,
+          accelerateEndpoint: options.useAccelerateEndpoint,
+          dualstackEndpoint: options.useDualstackEndpoint,
+          pathStyleEndpoint: options.forcePathStyle,
+          tlsCompatible: request.protocol === "https:",
+        });
         request.hostname = hostname;
         replaceBucketInPath = bucketEndpoint;
       }
@@ -52,16 +76,6 @@ export function bucketEndpointMiddleware(options: BucketEndpointResolvedConfig):
   };
 }
 
-const getArnHostnameParameters = async (options: BucketEndpointResolvedConfig) => {
-  const clientRegion = await options.region();
-  const clientRegionInfo = await options.regionInfoProvider(getPseudoRegion(clientRegion));
-  return {
-    useArnRegion: await options.useArnRegion(),
-    clientPartition: clientRegionInfo?.partition,
-    clientSigningRegion: clientRegionInfo?.signingRegion,
-  };
-};
-
 export const bucketEndpointMiddlewareOptions: RelativeMiddlewareOptions = {
   tags: ["BUCKET_ENDPOINT"],
   name: "bucketEndpointMiddleware",