chore(config-resolver): refactor RegionConfig into multiple files (#2721)

Author: trivikr

packages/config-resolver/src/RegionConfig.spec.ts

@@ -1,3 +1,3 @@
 export * from "./endpointsConfig";
-export * from "./RegionConfig";
+export * from "./regionConfig";
 export * from "./regionInfo";

packages/config-resolver/src/RegionConfig.ts

@@ -0,0 +1,38 @@
+import {
+  NODE_REGION_CONFIG_FILE_OPTIONS,
+  NODE_REGION_CONFIG_OPTIONS,
+  REGION_ENV_NAME,
+  REGION_INI_NAME,
+} from "./config";
+
+describe("config", () => {
+  describe("NODE_REGION_CONFIG_OPTIONS", () => {
+    describe("environmentVariableSelector", () => {
+      const { environmentVariableSelector } = NODE_REGION_CONFIG_OPTIONS;
+      it.each([undefined, "mockRegion"])(`when env[${REGION_ENV_NAME}]: %s`, (mockEndpoint) => {
+        expect(environmentVariableSelector({ [REGION_ENV_NAME]: mockEndpoint })).toBe(mockEndpoint);
+      });
+    });
+
+    describe("configFileSelector", () => {
+      const { configFileSelector } = NODE_REGION_CONFIG_OPTIONS;
+      it.each([undefined, "mockRegion"])(`when env[${REGION_INI_NAME}]: %s`, (mockEndpoint) => {
+        expect(configFileSelector({ [REGION_INI_NAME]: mockEndpoint })).toBe(mockEndpoint);
+      });
+    });
+
+    it("default throws error", () => {
+      const { default: defaultKey } = NODE_REGION_CONFIG_OPTIONS;
+      expect(() => {
+        (defaultKey as any)();
+      }).toThrowError(new Error("Region is missing"));
+    });
+  });
+
+  describe("NODE_REGION_CONFIG_FILE_OPTIONS", () => {
+    it("preferredFile contains credentials", () => {
+      const { preferredFile } = NODE_REGION_CONFIG_FILE_OPTIONS;
+      expect(preferredFile).toBe("credentials");
+    });
+  });
+});

packages/config-resolver/src/index.ts

@@ -0,0 +1,16 @@
+import { LoadedConfigSelectors, LocalConfigOptions } from "@aws-sdk/node-config-provider";
+
+export const REGION_ENV_NAME = "AWS_REGION";
+export const REGION_INI_NAME = "region";
+
+export const NODE_REGION_CONFIG_OPTIONS: LoadedConfigSelectors<string> = {
+  environmentVariableSelector: (env) => env[REGION_ENV_NAME],
+  configFileSelector: (profile) => profile[REGION_INI_NAME],
+  default: () => {
+    throw new Error("Region is missing");
+  },
+};
+
+export const NODE_REGION_CONFIG_FILE_OPTIONS: LocalConfigOptions = {
+  preferredFile: "credentials",
+};

packages/config-resolver/src/regionConfig/config.spec.ts

@@ -0,0 +1,2 @@
+export * from "./config";
+export * from "./resolveRegionConfig";

packages/config-resolver/src/regionConfig/config.ts

@@ -0,0 +1,15 @@
+import { normalizeRegion } from "./normalizeRegion";
+
+describe(normalizeRegion.name, () => {
+  const mockRegion = "mockRegion";
+
+  it("returns Provider if value is string", async () => {
+    const output = normalizeRegion(mockRegion);
+    expect(await output()).toEqual(mockRegion);
+  });
+
+  it("returns Provider if it's a Provider", () => {
+    const mockRegionProvider = () => Promise.resolve(mockRegion);
+    expect(normalizeRegion(mockRegionProvider)).toBe(mockRegionProvider);
+  });
+});

packages/config-resolver/src/regionConfig/index.ts

@@ -0,0 +1,9 @@
+import { Provider } from "@aws-sdk/types";
+
+export const normalizeRegion = (region: string | Provider<string>): Provider<string> => {
+  if (typeof region === "string") {
+    const promisified = Promise.resolve(region);
+    return () => promisified;
+  }
+  return region as Provider<string>;
+};

packages/config-resolver/src/regionConfig/normalizeRegion.spec.ts

@@ -0,0 +1,28 @@
+import { normalizeRegion } from "./normalizeRegion";
+import { resolveRegionConfig } from "./resolveRegionConfig";
+
+jest.mock("./normalizeRegion");
+
+describe("RegionConfig", () => {
+  const mockRegionProvider = () => Promise.resolve("mockRegion");
+
+  beforeEach(() => {
+    (normalizeRegion as jest.Mock).mockReturnValue(mockRegionProvider);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("assigns value returned by normalizeRegion to region", async () => {
+    const region = "mockRegion";
+    expect(resolveRegionConfig({ region }).region).toBe(mockRegionProvider);
+    expect(normalizeRegion).toHaveBeenCalledTimes(1);
+    expect(normalizeRegion).toHaveBeenCalledWith(region);
+  });
+
+  it("throw if region is not supplied", () => {
+    expect(() => resolveRegionConfig({})).toThrow();
+    expect(normalizeRegion).not.toHaveBeenCalled();
+  });
+});

packages/config-resolver/src/regionConfig/normalizeRegion.ts

@@ -0,0 +1,29 @@
+import { Provider } from "@aws-sdk/types";
+
+import { normalizeRegion } from "./normalizeRegion";
+
+export interface RegionInputConfig {
+  /**
+   * The AWS region to which this client will send requests
+   */
+  region?: string | Provider<string>;
+}
+
+interface PreviouslyResolved {}
+
+export interface RegionResolvedConfig {
+  /**
+   * Resolved value for input config {@link RegionInputConfig.region}
+   */
+  region: Provider<string>;
+}
+
+export const resolveRegionConfig = <T>(input: T & RegionInputConfig & PreviouslyResolved): T & RegionResolvedConfig => {
+  if (!input.region) {
+    throw new Error("Region is missing");
+  }
+  return {
+    ...input,
+    region: normalizeRegion(input.region!),
+  };
+};