fix(packages): maintain singleton config object

Author: kuhe

Diff for: clients/client-s3/src/S3Client.ts

@@ -862,6 +862,9 @@ export class S3Client extends __Client<
     this.middlewareStack.use(getRegionRedirectMiddlewarePlugin(this.config));
     this.middlewareStack.use(getS3ExpressPlugin(this.config));
     this.middlewareStack.use(getS3ExpressHttpSigningPlugin(this.config));
+    if ((_config_0 as unknown) !== this.config) {
+      throw new Error(`${this.constructor.name} - ConfigCustodyError`);
+    }
   }
 
   /**

Diff for: clients/client-s3/src/auth/httpAuthSchemeProvider.ts

@@ -324,7 +324,5 @@ export const resolveHttpAuthSchemeConfig = <T>(
 ): T & HttpAuthSchemeResolvedConfig => {
   const config_0 = resolveAwsSdkSigV4Config(config);
   const config_1 = resolveAwsSdkSigV4AConfig(config_0);
-  return {
-    ...config_1,
-  } as T & HttpAuthSchemeResolvedConfig;
+  return Object.assign(config_1, {}) as T & HttpAuthSchemeResolvedConfig;
 };

Diff for: clients/client-s3/src/endpoint/EndpointParameters.ts

@@ -24,16 +24,15 @@ export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
 export const resolveClientEndpointParameters = <T>(
   options: T & ClientInputEndpointParameters
 ): T & ClientResolvedEndpointParameters => {
-  return {
-    ...options,
+  return Object.assign(options, {
     useFipsEndpoint: options.useFipsEndpoint ?? false,
     useDualstackEndpoint: options.useDualstackEndpoint ?? false,
     forcePathStyle: options.forcePathStyle ?? false,
     useAccelerateEndpoint: options.useAccelerateEndpoint ?? false,
     useGlobalEndpoint: options.useGlobalEndpoint ?? false,
     disableMultiregionAccessPoints: options.disableMultiregionAccessPoints ?? false,
     defaultSigningName: "s3",
-  };
+  });
 };
 
 export const commonParams = {

Diff for: clients/client-s3/src/models/models_0.ts

@@ -1,6 +1,5 @@
 // smithy-typescript generated code
 import { ExceptionOptionType as __ExceptionOptionType, SENSITIVE_STRING } from "@smithy/smithy-client";
-
 import { StreamingBlobTypes } from "@smithy/types";
 
 import { S3ServiceException as __BaseException } from "./S3ServiceException";

Diff for: clients/client-s3/src/models/models_1.ts

@@ -1,6 +1,5 @@
 // smithy-typescript generated code
 import { ExceptionOptionType as __ExceptionOptionType, SENSITIVE_STRING } from "@smithy/smithy-client";
-
 import { StreamingBlobTypes } from "@smithy/types";
 
 import {
@@ -41,7 +40,6 @@ import {
   Tag,
   TransitionDefaultMinimumObjectSize,
 } from "./models_0";
-
 import { S3ServiceException as __BaseException } from "./S3ServiceException";
 
 /**

Diff for: clients/client-s3/src/runtimeExtensions.ts

@@ -23,26 +23,24 @@ export interface RuntimeExtensionsConfig {
   extensions: RuntimeExtension[];
 }
 
-const asPartial = <T extends Partial<S3ExtensionConfiguration>>(t: T) => t;
-
 /**
  * @internal
  */
 export const resolveRuntimeExtensions = (runtimeConfig: any, extensions: RuntimeExtension[]) => {
-  const extensionConfiguration: S3ExtensionConfiguration = {
-    ...asPartial(getAwsRegionExtensionConfiguration(runtimeConfig)),
-    ...asPartial(getDefaultExtensionConfiguration(runtimeConfig)),
-    ...asPartial(getHttpHandlerExtensionConfiguration(runtimeConfig)),
-    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig)),
-  };
+  const extensionConfiguration: S3ExtensionConfiguration = Object.assign(
+    getAwsRegionExtensionConfiguration(runtimeConfig),
+    getDefaultExtensionConfiguration(runtimeConfig),
+    getHttpHandlerExtensionConfiguration(runtimeConfig),
+    getHttpAuthExtensionConfiguration(runtimeConfig)
+  );
 
   extensions.forEach((extension) => extension.configure(extensionConfiguration));
 
-  return {
-    ...runtimeConfig,
-    ...resolveAwsRegionExtensionConfiguration(extensionConfiguration),
-    ...resolveDefaultRuntimeConfig(extensionConfiguration),
-    ...resolveHttpHandlerRuntimeConfig(extensionConfiguration),
-    ...resolveHttpAuthRuntimeConfig(extensionConfiguration),
-  };
+  return Object.assign(
+    runtimeConfig,
+    resolveAwsRegionExtensionConfiguration(extensionConfiguration),
+    resolveDefaultRuntimeConfig(extensionConfiguration),
+    resolveHttpHandlerRuntimeConfig(extensionConfiguration),
+    resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  );
 };

Diff for: 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);
+  });
+});

Diff for: 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;
     },
-  };
+  });
 };

Diff for: 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);
+  });
 });

Diff for: packages/core/src/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.spec.ts

@@ -0,0 +1,16 @@
+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);
+  });
+});

Diff for: 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,
-  };
+  });
 };
 
 /**

Diff for: 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"),

Diff for: 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,
+  });
 };

Diff for: 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);
+  });
+});

Diff for: 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),
-  };
+  });
 }

Diff for: packages/middleware-endpoint-discovery/src/resolveEndpointDiscoveryConfig.spec.ts

@@ -17,6 +17,14 @@ describe(resolveEndpointDiscoveryConfig.name, () => {
     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 });
     expect(resolvedConfig.endpointDiscoveryCommandCtor).toStrictEqual(endpointDiscoveryCommandCtor);

Diff for: packages/middleware-endpoint-discovery/src/resolveEndpointDiscoveryConfig.ts

@@ -62,13 +62,16 @@ export interface EndpointDiscoveryConfigOptions {
 export const resolveEndpointDiscoveryConfig = <T>(
   input: T & PreviouslyResolved & EndpointDiscoveryInputConfig,
   { endpointDiscoveryCommandCtor }: EndpointDiscoveryConfigOptions
-): T & EndpointDiscoveryResolvedConfig => ({
-  ...input,
-  endpointDiscoveryCommandCtor,
-  endpointCache: new EndpointCache(input.endpointCacheSize ?? 1000),
-  endpointDiscoveryEnabled:
-    input.endpointDiscoveryEnabled !== undefined
-      ? () => Promise.resolve(input.endpointDiscoveryEnabled)
-      : input.endpointDiscoveryEnabledProvider,
-  isClientEndpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined,
-});
+): T & EndpointDiscoveryResolvedConfig => {
+  const { endpointCacheSize, endpointDiscoveryEnabled, endpointDiscoveryEnabledProvider } = input;
+
+  return Object.assign(input, {
+    endpointDiscoveryCommandCtor,
+    endpointCache: new EndpointCache(endpointCacheSize ?? 1000),
+    endpointDiscoveryEnabled:
+      endpointDiscoveryEnabled !== undefined
+        ? () => Promise.resolve(endpointDiscoveryEnabled)
+        : endpointDiscoveryEnabledProvider,
+    isClientEndpointDiscoveryEnabled: endpointDiscoveryEnabled !== undefined,
+  });
+};

Diff for: packages/middleware-eventstream/src/eventStreamConfiguration.ts

@@ -40,9 +40,8 @@ export function resolveEventStreamConfig<T>(
     ...input,
     messageSigner,
   });
-  return {
-    ...input,
+  return Object.assign(input, {
     eventSigner,
     eventStreamPayloadHandler,
-  };
+  });
 }

Diff for: packages/middleware-eventstream/src/middleware-eventstream.integ.spec.ts

@@ -1,9 +1,11 @@
 import { LexRuntimeV2 } from "@aws-sdk/client-lex-runtime-v2";
 import { RekognitionStreaming } from "@aws-sdk/client-rekognitionstreaming";
 import { TranscribeStreaming } from "@aws-sdk/client-transcribe-streaming";
-import { describe, expect, test as it } from "vitest";
+import { Decoder, Encoder, EventStreamPayloadHandlerProvider } from "@smithy/types";
+import { describe, expect, test as it, vi } from "vitest";
 
 import { requireRequestsFrom } from "../../../private/aws-util-test/src";
+import { resolveEventStreamConfig } from "./eventStreamConfiguration";
 
 describe("middleware-eventstream", () => {
   const logger = {
@@ -14,6 +16,18 @@ describe("middleware-eventstream", () => {
     error() {},
   };
 
+  describe("config resolver", () => {
+    it("maintains object custody", () => {
+      const input = {
+        utf8Encoder: vi.fn(),
+        utf8Decoder: vi.fn(),
+        signer: vi.fn(),
+        eventStreamPayloadHandlerProvider: vi.fn(),
+      };
+      expect(resolveEventStreamConfig(input)).toBe(input);
+    });
+  });
+
   // TODO: http2 in CI
   describe.skip(LexRuntimeV2.name, () => {
     it("should set streaming headers", async () => {

Diff for: packages/middleware-flexible-checksums/src/resolveFlexibleChecksumsConfig.spec.ts

@@ -20,6 +20,11 @@ describe(resolveFlexibleChecksumsConfig.name, () => {
     vi.clearAllMocks();
   });
 
+  it("maintains object custody", () => {
+    const input = {};
+    expect(resolveFlexibleChecksumsConfig(input)).toBe(input);
+  });
+
   it("returns default client checksums configuration, if not provided", () => {
     const resolvedConfig = resolveFlexibleChecksumsConfig({});
     expect(resolvedConfig).toEqual({

Diff for: packages/middleware-flexible-checksums/src/resolveFlexibleChecksumsConfig.ts

@@ -45,13 +45,11 @@ export interface FlexibleChecksumsResolvedConfig {
 
 export const resolveFlexibleChecksumsConfig = <T>(
   input: T & FlexibleChecksumsInputConfig
-): T & FlexibleChecksumsResolvedConfig => ({
-  ...input,
-  requestChecksumCalculation: normalizeProvider(
-    input.requestChecksumCalculation ?? DEFAULT_REQUEST_CHECKSUM_CALCULATION
-  ),
-  responseChecksumValidation: normalizeProvider(
-    input.responseChecksumValidation ?? DEFAULT_RESPONSE_CHECKSUM_VALIDATION
-  ),
-  requestStreamBufferSize: Number(input.requestStreamBufferSize ?? 0),
-});
+): T & FlexibleChecksumsResolvedConfig => {
+  const { requestChecksumCalculation, responseChecksumValidation, requestStreamBufferSize } = input;
+  return Object.assign(input, {
+    requestChecksumCalculation: normalizeProvider(requestChecksumCalculation ?? DEFAULT_REQUEST_CHECKSUM_CALCULATION),
+    responseChecksumValidation: normalizeProvider(responseChecksumValidation ?? DEFAULT_RESPONSE_CHECKSUM_VALIDATION),
+    requestStreamBufferSize: Number(requestStreamBufferSize ?? 0),
+  });
+};

Diff for: packages/middleware-host-header/src/index.spec.ts

@@ -1,14 +1,21 @@
 import { HttpRequest } from "@smithy/protocol-http";
 import { beforeEach, describe, expect, test as it, vi } from "vitest";
 
-import { hostHeaderMiddleware } from "./index";
+import { hostHeaderMiddleware, resolveHostHeaderConfig } from "./index";
 describe("hostHeaderMiddleware", () => {
   const mockNextHandler = vi.fn();
 
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
+  it("maintains object custody", () => {
+    const input = {
+      requestHandler: vi.fn() as any,
+    };
+    expect(resolveHostHeaderConfig(input)).toBe(input);
+  });
+
   it("should set host header if not already set", async () => {
     expect.assertions(2);
     const middleware = hostHeaderMiddleware({ requestHandler: {} as any });

Diff for: packages/middleware-location-constraint/src/configuration.ts

@@ -18,5 +18,5 @@ export interface LocationConstraintResolvedConfig {
 export function resolveLocationConstraintConfig<T>(
   input: T & LocationConstraintInputConfig & PreviouslyResolved
 ): T & LocationConstraintResolvedConfig {
-  return { ...input };
+  return input;
 }