chore(config-resolver): use normalizeProvider from util-middleware (#3457)

Author: trivikr

packages/config-resolver/package.json

@@ -22,6 +22,7 @@
     "@aws-sdk/signature-v4": "*",
     "@aws-sdk/types": "*",
     "@aws-sdk/util-config-provider": "*",
+    "@aws-sdk/util-middleware": "*",
     "tslib": "^2.3.1"
   },
   "devDependencies": {

packages/config-resolver/src/endpointsConfig/resolveCustomEndpointsConfig.spec.ts

@@ -1,7 +1,8 @@
+import { normalizeProvider } from "@aws-sdk/util-middleware";
+
 import { resolveCustomEndpointsConfig } from "./resolveCustomEndpointsConfig";
-import { normalizeEndpoint } from "./utils/normalizeEndpoint";
 
-jest.mock("./utils/normalizeEndpoint");
+jest.mock("@aws-sdk/util-middleware");
 
 describe(resolveCustomEndpointsConfig.name, () => {
   const mockEndpoint = {
@@ -10,18 +11,26 @@ describe(resolveCustomEndpointsConfig.name, () => {
     path: "/",
   };
 
-  const mockInput = { endpoint: mockEndpoint } as any;
+  const mockInput = {
+    endpoint: mockEndpoint,
+    urlParser: jest.fn(() => mockEndpoint),
+    useDualstackEndpoint: () => Promise.resolve(false),
+  } as any;
 
   beforeEach(() => {
-    (normalizeEndpoint as jest.Mock).mockReturnValueOnce(() => Promise.resolve(mockEndpoint));
+    (normalizeProvider as jest.Mock).mockImplementation((input) =>
+      typeof input === "function" ? input : () => Promise.resolve(input)
+    );
   });
 
   afterEach(() => {
+    expect(normalizeProvider).toHaveBeenCalledTimes(2);
+    expect(normalizeProvider).toHaveBeenNthCalledWith(2, mockInput.useDualstackEndpoint);
     jest.clearAllMocks();
   });
 
   describe("tls", () => {
-    it.each([true, false])("returns %s when it's %s", (tls) => {
+    it.each([true, false])("returns %s when the value is passed", (tls) => {
       expect(resolveCustomEndpointsConfig({ ...mockInput, tls }).tls).toStrictEqual(tls);
     });
 
@@ -34,10 +43,22 @@ describe(resolveCustomEndpointsConfig.name, () => {
     expect(resolveCustomEndpointsConfig(mockInput).isCustomEndpoint).toStrictEqual(true);
   });
 
-  it("returns normalized endpoint", async () => {
-    const endpoint = await resolveCustomEndpointsConfig(mockInput).endpoint();
-    expect(endpoint).toStrictEqual(mockEndpoint);
-    expect(normalizeEndpoint).toHaveBeenCalledTimes(1);
-    expect(normalizeEndpoint).toHaveBeenCalledWith(mockInput);
+  describe("returns normalized endpoint", () => {
+    afterEach(() => {
+      expect(normalizeProvider).toHaveBeenNthCalledWith(1, mockInput.endpoint);
+    });
+
+    it("calls urlParser endpoint is of type string", async () => {
+      const mockEndpointString = "http://localhost/";
+      const endpoint = await resolveCustomEndpointsConfig({ ...mockInput, endpoint: mockEndpointString }).endpoint();
+      expect(endpoint).toStrictEqual(mockEndpoint);
+      expect(mockInput.urlParser).toHaveBeenCalledWith(mockEndpointString);
+    });
+
+    it("passes endpoint to normalize if not string", async () => {
+      const endpoint = await resolveCustomEndpointsConfig(mockInput).endpoint();
+      expect(endpoint).toStrictEqual(mockEndpoint);
+      expect(mockInput.urlParser).not.toHaveBeenCalled();
+    });
   });
 });

packages/config-resolver/src/endpointsConfig/resolveCustomEndpointsConfig.ts

@@ -1,8 +1,7 @@
 import { Endpoint, Provider, UrlParser } from "@aws-sdk/types";
+import { normalizeProvider } from "@aws-sdk/util-middleware";
 
 import { EndpointsInputConfig, EndpointsResolvedConfig } from "./resolveEndpointsConfig";
-import { normalizeBoolean } from "./utils/normalizeBoolean";
-import { normalizeEndpoint } from "./utils/normalizeEndpoint";
 
 export interface CustomEndpointsInputConfig extends EndpointsInputConfig {
   /**
@@ -25,10 +24,13 @@ export interface CustomEndpointsResolvedConfig extends EndpointsResolvedConfig {
 
 export const resolveCustomEndpointsConfig = <T>(
   input: T & CustomEndpointsInputConfig & PreviouslyResolved
-): T & CustomEndpointsResolvedConfig => ({
-  ...input,
-  tls: input.tls ?? true,
-  endpoint: normalizeEndpoint(input),
-  isCustomEndpoint: true,
-  useDualstackEndpoint: normalizeBoolean(input.useDualstackEndpoint!),
-});
+): T & CustomEndpointsResolvedConfig => {
+  const { endpoint, urlParser } = input;
+  return {
+    ...input,
+    tls: input.tls ?? true,
+    endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint),
+    isCustomEndpoint: true,
+    useDualstackEndpoint: normalizeProvider(input.useDualstackEndpoint!),
+  };
+};

packages/config-resolver/src/endpointsConfig/resolveEndpointsConfig.spec.ts

@@ -1,9 +1,10 @@
+import { normalizeProvider } from "@aws-sdk/util-middleware";
+
 import { resolveEndpointsConfig } from "./resolveEndpointsConfig";
 import { getEndpointFromRegion } from "./utils/getEndpointFromRegion";
-import { normalizeEndpoint } from "./utils/normalizeEndpoint";
 
+jest.mock("@aws-sdk/util-middleware");
 jest.mock("./utils/getEndpointFromRegion");
-jest.mock("./utils/normalizeEndpoint");
 
 describe(resolveEndpointsConfig.name, () => {
   const mockEndpoint = {
@@ -12,14 +13,22 @@ describe(resolveEndpointsConfig.name, () => {
     path: "/",
   };
 
-  const mockInput = { endpoint: mockEndpoint } as any;
+  const mockInput = {
+    endpoint: mockEndpoint,
+    urlParser: jest.fn(() => mockEndpoint),
+    useDualstackEndpoint: () => Promise.resolve(false),
+    useFipsEndpoint: () => Promise.resolve(false),
+  } as any;
 
   beforeEach(() => {
     (getEndpointFromRegion as jest.Mock).mockResolvedValueOnce(mockEndpoint);
-    (normalizeEndpoint as jest.Mock).mockReturnValueOnce(() => Promise.resolve(mockEndpoint));
+    (normalizeProvider as jest.Mock).mockImplementation((input) =>
+      typeof input === "function" ? input : () => Promise.resolve(input)
+    );
   });
 
   afterEach(() => {
+    expect(normalizeProvider).toHaveBeenNthCalledWith(1, mockInput.useDualstackEndpoint);
     jest.clearAllMocks();
   });
 
@@ -39,25 +48,40 @@ describe(resolveEndpointsConfig.name, () => {
     });
 
     it("returns false when endpoint is not defined", () => {
-      expect(resolveEndpointsConfig({} as any).isCustomEndpoint).toStrictEqual(false);
+      const { endpoint, ...mockInputWithoutEndpoint } = mockInput;
+      expect(resolveEndpointsConfig(mockInputWithoutEndpoint).isCustomEndpoint).toStrictEqual(false);
     });
   });
 
   describe("endpoint", () => {
-    it("returns from normalizeEndpoint when endpoint is defined", async () => {
-      const endpoint = await resolveEndpointsConfig(mockInput).endpoint();
-      expect(endpoint).toStrictEqual(mockEndpoint);
-      expect(normalizeEndpoint).toHaveBeenCalledTimes(1);
-      expect(normalizeEndpoint).toHaveBeenCalledWith(mockInput);
-      expect(getEndpointFromRegion).not.toHaveBeenCalled();
+    describe("returns from normalizeProvider when endpoint is defined", () => {
+      afterEach(() => {
+        expect(normalizeProvider).toHaveBeenCalledTimes(2);
+        expect(normalizeProvider).toHaveBeenNthCalledWith(2, mockInput.endpoint);
+        expect(getEndpointFromRegion).not.toHaveBeenCalled();
+      });
+
+      it("calls urlParser endpoint is of type string", async () => {
+        const mockEndpointString = "http://localhost/";
+        const endpoint = await resolveEndpointsConfig({ ...mockInput, endpoint: mockEndpointString }).endpoint();
+        expect(endpoint).toStrictEqual(mockEndpoint);
+        expect(mockInput.urlParser).toHaveBeenCalledWith(mockEndpointString);
+      });
+
+      it("passes endpoint to normalize if not string", async () => {
+        const endpoint = await resolveEndpointsConfig(mockInput).endpoint();
+        expect(endpoint).toStrictEqual(mockEndpoint);
+        expect(mockInput.urlParser).not.toHaveBeenCalled();
+      });
     });
 
     it("returns from getEndpointFromRegion when endpoint is not defined", async () => {
-      const endpoint = await resolveEndpointsConfig({} as any).endpoint();
-      expect(endpoint).toStrictEqual(mockEndpoint);
-      expect(normalizeEndpoint).not.toHaveBeenCalled();
+      const { endpoint, ...mockInputWithoutEndpoint } = mockInput;
+      const returnedEndpoint = await resolveEndpointsConfig(mockInputWithoutEndpoint).endpoint();
+      expect(returnedEndpoint).toStrictEqual(mockEndpoint);
+      expect(normalizeProvider).toHaveBeenCalledTimes(1);
       expect(getEndpointFromRegion).toHaveBeenCalledTimes(1);
-      expect(getEndpointFromRegion).toHaveBeenCalledWith({});
+      expect(getEndpointFromRegion).toHaveBeenCalledWith(mockInputWithoutEndpoint);
     });
   });
 });

packages/config-resolver/src/endpointsConfig/resolveEndpointsConfig.ts

@@ -1,8 +1,7 @@
 import { Endpoint, Provider, RegionInfoProvider, UrlParser } from "@aws-sdk/types";
+import { normalizeProvider } from "@aws-sdk/util-middleware";
 
 import { getEndpointFromRegion } from "./utils/getEndpointFromRegion";
-import { normalizeBoolean } from "./utils/normalizeBoolean";
-import { normalizeEndpoint } from "./utils/normalizeEndpoint";
 
 export interface EndpointsInputConfig {
   /**
@@ -49,13 +48,13 @@ export interface EndpointsResolvedConfig extends Required<EndpointsInputConfig>
 export const resolveEndpointsConfig = <T>(
   input: T & EndpointsInputConfig & PreviouslyResolved
 ): T & EndpointsResolvedConfig => {
-  const useDualstackEndpoint = normalizeBoolean(input.useDualstackEndpoint!);
-  const { endpoint, useFipsEndpoint } = input;
+  const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint!);
+  const { endpoint, useFipsEndpoint, urlParser } = input;
   return {
     ...input,
     tls: input.tls ?? true,
     endpoint: endpoint
-      ? normalizeEndpoint({ ...input, endpoint })
+      ? normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint)
       : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }),
     isCustomEndpoint: endpoint ? true : false,
     useDualstackEndpoint,