fix(packages): maintain singleton config object

Author: kuhe

packages/core/src/submodules/account-id-endpoint/AccountIdEndpointModeConfigResolver.spec.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test as it } from "vitest";
+
+import { resolveAccountIdEndpointModeConfig } from "./AccountIdEndpointModeConfigResolver";
+
+describe(resolveAccountIdEndpointModeConfig.name, () => {
+  it("maintains object custody", () => {
+    const input = {};
+    expect(resolveAccountIdEndpointModeConfig(input)).toBe(input);
+  });
+});

packages/core/src/submodules/account-id-endpoint/AccountIdEndpointModeConfigResolver.ts

@@ -38,11 +38,9 @@ export interface AccountIdEndpointModeResolvedConfig {
 export const resolveAccountIdEndpointModeConfig = <T>(
   input: T & AccountIdEndpointModeInputConfig & PreviouslyResolved
 ): T & AccountIdEndpointModeResolvedConfig => {
-  const accountIdEndpointModeProvider = normalizeProvider(
-    input.accountIdEndpointMode ?? DEFAULT_ACCOUNT_ID_ENDPOINT_MODE
-  );
-  return {
-    ...input,
+  const { accountIdEndpointMode } = input;
+  const accountIdEndpointModeProvider = normalizeProvider(accountIdEndpointMode ?? DEFAULT_ACCOUNT_ID_ENDPOINT_MODE);
+  return Object.assign(input, {
     accountIdEndpointMode: async () => {
       const accIdMode = await accountIdEndpointModeProvider();
       if (!validateAccountIdEndpointMode(accIdMode)) {
@@ -52,5 +50,5 @@ export const resolveAccountIdEndpointModeConfig = <T>(
       }
       return accIdMode;
     },
-  };
+  });
 };

packages/core/src/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.spec.ts

@@ -9,4 +9,9 @@ describe(resolveAwsSdkSigV4AConfig.name, () => {
     expect(typeof config.sigv4aSigningRegionSet).toEqual("function");
     expect(await config.sigv4aSigningRegionSet()).toEqual(undefined);
   });
+
+  it("maintains object custody", () => {
+    const input = {};
+    expect(resolveAwsSdkSigV4AConfig(input)).toBe(input);
+  });
 });

packages/core/src/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.spec.ts

@@ -4,6 +4,17 @@ import { describe, expect, test as it, vi } from "vitest";
 import { resolveAwsSdkSigV4Config } from "./resolveAwsSdkSigV4Config";
 
 describe(resolveAwsSdkSigV4Config.name, () => {
+  it("maintains object custody", () => {
+    const input = {
+      region: "",
+      sha256: vi.fn(),
+      serviceId: "",
+      useFipsEndpoint: async () => false,
+      useDualstackEndpoint: async () => false,
+    };
+    expect(resolveAwsSdkSigV4Config(input)).toBe(input);
+  });
+
   it("should allow one argument to be passed to the resolved credentials function", async () => {
     const fn = vi.fn();
 

packages/core/src/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.ts

@@ -220,8 +220,7 @@ export const resolveAwsSdkSigV4Config = <T>(
     };
   }
 
-  return {
-    ...config,
+  return Object.assign(config, {
     systemClockOffset,
     signingEscapePath,
     credentials: isUserSupplied
@@ -231,7 +230,7 @@ export const resolveAwsSdkSigV4Config = <T>(
           )
       : boundCredentialsProvider!,
     signer,
-  };
+  });
 };
 
 /**

packages/middleware-api-key/src/apiKeyConfiguration.spec.ts

@@ -3,6 +3,12 @@ import { describe, expect, test as it } from "vitest";
 import { resolveApiKeyConfig } from "./index";
 
 describe("ApiKeyConfig", () => {
+  it("maintains object custody", () => {
+    const config = {
+      apiKey: () => Promise.resolve("example-api-key"),
+    };
+    expect(resolveApiKeyConfig(config)).toBe(config);
+  });
   it("should return the input unchanged", () => {
     const config = {
       apiKey: () => Promise.resolve("example-api-key"),

packages/middleware-api-key/src/apiKeyConfiguration.ts

@@ -31,8 +31,8 @@ export interface ApiKeyResolvedConfig {
 export const resolveApiKeyConfig = <T>(
   input: T & ApiKeyPreviouslyResolved & ApiKeyInputConfig
 ): T & ApiKeyResolvedConfig => {
-  return {
-    ...input,
-    apiKey: input.apiKey ? normalizeProvider(input.apiKey) : undefined,
-  };
+  const { apiKey } = input;
+  return Object.assign(input, {
+    apiKey: apiKey ? normalizeProvider(apiKey) : undefined,
+  });
 };

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

@@ -0,0 +1,15 @@
+import { describe, expect, test as it, vi } from "vitest";
+
+import { resolveBucketEndpointConfig } from "./configurations";
+
+describe(resolveBucketEndpointConfig.name, () => {
+  it("maintains object custody", () => {
+    const input = {
+      region: async () => "",
+      regionInfoProvider: vi.fn(),
+      useFipsEndpoint: async () => false,
+      useDualstackEndpoint: async () => false,
+    };
+    expect(resolveBucketEndpointConfig(input)).toBe(input);
+  });
+});

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

@@ -93,8 +93,7 @@ export function resolveBucketEndpointConfig<T>(
     useArnRegion = false,
     disableMultiregionAccessPoints = false,
   } = input;
-  return {
-    ...input,
+  return Object.assign(input, {
     bucketEndpoint,
     forcePathStyle,
     useAccelerateEndpoint,
@@ -103,5 +102,5 @@ export function resolveBucketEndpointConfig<T>(
       typeof disableMultiregionAccessPoints === "function"
         ? disableMultiregionAccessPoints
         : () => Promise.resolve(disableMultiregionAccessPoints),
-  };
+  });
 }

packages/middleware-endpoint-discovery/src/resolveEndpointDiscoveryConfig.spec.ts

@@ -7,18 +7,26 @@ vi.mock("@aws-sdk/endpoint-cache");
 
 describe(resolveEndpointDiscoveryConfig.name, () => {
   const endpointDiscoveryCommandCtor = vi.fn();
-  const mockInput = {
+  const mockInput = () => ({
     isCustomEndpoint: false,
     credentials: vi.fn(),
     endpointDiscoveryEnabledProvider: vi.fn(),
-  };
+  });
 
   afterEach(() => {
     vi.clearAllMocks();
   });
 
+  it("maintains object custody", () => {
+    const input = {
+      credentials: vi.fn(),
+      endpointDiscoveryEnabledProvider: async () => false,
+    };
+    expect(resolveEndpointDiscoveryConfig(input, { endpointDiscoveryCommandCtor })).toBe(input);
+  });
+
   it("assigns endpointDiscoveryCommandCtor in resolvedConfig", () => {
-    const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
+    const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput(), { endpointDiscoveryCommandCtor });
     expect(resolvedConfig.endpointDiscoveryCommandCtor).toStrictEqual(endpointDiscoveryCommandCtor);
   });
 
@@ -27,7 +35,7 @@ describe(resolveEndpointDiscoveryConfig.name, () => {
       const endpointCacheSize = 100;
       resolveEndpointDiscoveryConfig(
         {
-          ...mockInput,
+          ...mockInput(),
           endpointCacheSize,
         },
         { endpointDiscoveryCommandCtor }
@@ -36,28 +44,30 @@ describe(resolveEndpointDiscoveryConfig.name, () => {
     });
 
     it("creates cache of size 1000 if endpointCacheSize not passed", () => {
-      resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
+      resolveEndpointDiscoveryConfig(mockInput(), { endpointDiscoveryCommandCtor });
       expect(EndpointCache).toBeCalledWith(1000);
     });
   });
 
   describe("endpointDiscoveryEnabled", () => {
     it.each<boolean>([false, true])(`sets to value passed in the config: %s`, async (endpointDiscoveryEnabled) => {
+      const input = mockInput();
       const resolvedConfig = resolveEndpointDiscoveryConfig(
         {
-          ...mockInput,
+          ...input,
           endpointDiscoveryEnabled,
         },
         { endpointDiscoveryCommandCtor }
       );
       await expect(resolvedConfig.endpointDiscoveryEnabled()).resolves.toBe(endpointDiscoveryEnabled);
-      expect(mockInput.endpointDiscoveryEnabledProvider).not.toHaveBeenCalled();
+      expect(input.endpointDiscoveryEnabledProvider).not.toHaveBeenCalled();
       expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(true);
     });
 
     it(`sets to endpointDiscoveryEnabledProvider if value is not passed`, () => {
-      const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-      expect(resolvedConfig.endpointDiscoveryEnabled).toBe(mockInput.endpointDiscoveryEnabledProvider);
+      const input = mockInput();
+      const resolvedConfig = resolveEndpointDiscoveryConfig(input, { endpointDiscoveryCommandCtor });
+      expect(resolvedConfig.endpointDiscoveryEnabled).toBe(input.endpointDiscoveryEnabledProvider);
       expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(false);
     });
   });