feat: remove $ input options

Author: Chase Coalwell

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

@@ -54,39 +54,6 @@ describe("bucketEndpointMiddleware", () => {
     expect(path).toBe("/bucket");
   });
 
-  it("should not convert the request provided into one directed to a virtual hosted-style endpoint if so directed on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(resolveBucketEndpointConfig({}))(
-      next,
-      {} as any
-    );
-    await handler({ input: { ...input, $forcePathStyle: true }, request });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("s3.us-west-2.amazonaws.com");
-    expect(path).toBe("/bucket");
-  });
-
-  it("should convert the request provided into one directed to a virtual hosted-style endpoint if path-style is disabled on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(
-      resolveBucketEndpointConfig({
-        forcePathStyle: true
-      })
-    )(next, {} as any);
-    await handler({ input: { ...input, $forcePathStyle: false }, request });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("bucket.s3.us-west-2.amazonaws.com");
-    expect(path).toBe("/");
-  });
-
   it("should not convert the request provided into one without the bucket in the path if so configured", async () => {
     const request = new HttpRequest(requestInput);
     const handler = bucketEndpointMiddleware(
@@ -111,12 +78,13 @@ describe("bucketEndpointMiddleware", () => {
 
   it("should use the bucket name as a virtual hosted-style endpoint if so configured", async () => {
     const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(resolveBucketEndpointConfig({}))(
-      next,
-      {} as any
-    );
+    const handler = bucketEndpointMiddleware(
+      resolveBucketEndpointConfig({
+        bucketEndpoint: true
+      })
+    )(next, {} as any);
     await handler({
-      input: { Bucket: "files.domain.com", $bucketEndpoint: true },
+      input: { Bucket: "files.domain.com" },
       request: { ...request, path: "/files.domain.com/path/to/key.ext" }
     });
 
@@ -147,45 +115,6 @@ describe("bucketEndpointMiddleware", () => {
     expect(path).toBe("/");
   });
 
-  it("should use a transfer acceleration endpoint if so directed on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(resolveBucketEndpointConfig({}))(
-      next,
-      {} as any
-    );
-    await handler({
-      input: { ...input, $useAccelerateEndpoint: true },
-      request
-    });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("bucket.s3-accelerate.amazonaws.com");
-    expect(path).toBe("/");
-  });
-
-  it("should not use a transfer acceleration endpoint if disabled on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(
-      resolveBucketEndpointConfig({
-        useAccelerateEndpoint: true
-      })
-    )(next, {} as any);
-    await handler({
-      input: { ...input, $useAccelerateEndpoint: false },
-      request
-    });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("bucket.s3.us-west-2.amazonaws.com");
-    expect(path).toBe("/");
-  });
-
   it("should use a dualstack endpoint if so configured", async () => {
     const request = new HttpRequest(requestInput);
     const handler = bucketEndpointMiddleware(
@@ -205,45 +134,6 @@ describe("bucketEndpointMiddleware", () => {
     expect(path).toBe("/");
   });
 
-  it("should use a dualstack endpoint if so directed on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(resolveBucketEndpointConfig({}))(
-      next,
-      {} as any
-    );
-    await handler({
-      input: { ...input, $useDualstackEndpoint: true },
-      request
-    });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("bucket.s3.dualstack.us-west-2.amazonaws.com");
-    expect(path).toBe("/");
-  });
-
-  it("should not use a dualstack endpoint if disabled on the input", async () => {
-    const request = new HttpRequest(requestInput);
-    const handler = bucketEndpointMiddleware(
-      resolveBucketEndpointConfig({
-        useDualstackEndpoint: true
-      })
-    )(next, {} as any);
-    await handler({
-      input: { ...input, $useDualstackEndpoint: false },
-      request
-    });
-
-    const {
-      request: { hostname, path }
-    } = next.mock.calls[0][0];
-
-    expect(hostname).toBe("bucket.s3.us-west-2.amazonaws.com");
-    expect(path).toBe("/");
-  });
-
   it("should use an accelerate dualstack endpoint if configured", async () => {
     const request = new HttpRequest(requestInput);
     const handler = bucketEndpointMiddleware(

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

@@ -19,26 +19,20 @@ export function bucketEndpointMiddleware(
   ): BuildHandler<any, Output> => async (
     args: BuildHandlerArguments<any>
   ): Promise<BuildHandlerOutput<Output>> => {
-    const {
-      Bucket: bucketName,
-      $bucketEndpoint,
-      $forcePathStyle = options.forcePathStyle,
-      $useAccelerateEndpoint = options.useAccelerateEndpoint,
-      $useDualstackEndpoint = options.useDualstackEndpoint
-    } = args.input;
+    const { Bucket: bucketName } = args.input;
     let replaceBucketInPath =
-      options.preformedBucketEndpoint || $bucketEndpoint;
+      options.preformedBucketEndpoint || options.bucketEndpoint;
     let request = args.request;
     if (HttpRequest.isInstance(request)) {
-      if ($bucketEndpoint) {
+      if (options.bucketEndpoint) {
         request.hostname = bucketName;
       } else if (!options.preformedBucketEndpoint) {
         const { hostname, bucketEndpoint } = bucketHostname({
           bucketName,
           baseHostname: request.hostname,
-          accelerateEndpoint: $useAccelerateEndpoint,
-          dualstackEndpoint: $useDualstackEndpoint,
-          pathStyleEndpoint: $forcePathStyle,
+          accelerateEndpoint: options.useAccelerateEndpoint,
+          dualstackEndpoint: options.useDualstackEndpoint,
+          pathStyleEndpoint: options.forcePathStyle,
           sslCompatible: request.protocol === "https:"
         });
 

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

@@ -1,11 +1,13 @@
 export interface BucketEndpointInputConfig {
+  bucketEndpoint?: boolean;
   forcePathStyle?: boolean;
   preformedBucketEndpoint?: boolean;
   useAccelerateEndpoint?: boolean;
   useDualstackEndpoint?: boolean;
 }
 
 export interface BucketEndpointResolvedConfig {
+  bucketEndpoint: boolean;
   forcePathStyle: boolean;
   preformedBucketEndpoint: boolean;
   useAccelerateEndpoint: boolean;
@@ -15,6 +17,7 @@ export interface BucketEndpointResolvedConfig {
 export function resolveBucketEndpointConfig<T>(
   input: T & BucketEndpointInputConfig
 ): T & BucketEndpointResolvedConfig {
+  const bucketEndpoint = input.bucketEndpoint ? input.bucketEndpoint : false;
   const forcePathStyle = input.forcePathStyle ? input.forcePathStyle : false;
   const preformedBucketEndpoint = input.preformedBucketEndpoint
     ? input.preformedBucketEndpoint
@@ -27,6 +30,7 @@ export function resolveBucketEndpointConfig<T>(
     : false;
   return {
     ...input,
+    bucketEndpoint,
     forcePathStyle,
     preformedBucketEndpoint,
     useAccelerateEndpoint,