fix: solve changing retry strategy

Author: Hweinstock

packages/core/src/shared/awsClientBuilderV3.ts

@@ -33,7 +33,7 @@ import { extensionVersion } from './vscode/env'
 import { getLogger } from './logger/logger'
 import { partialClone } from './utilities/collectionUtils'
 import { selectFrom } from './utilities/tsUtils'
-import { memoizeAsync } from './utilities/functionUtils'
+import { memoizeWith } from './utilities/functionUtils'
 
 export type AwsClientConstructor<C> = new (o: AwsClientOptions) => C
 
@@ -78,7 +78,23 @@ export class AWSClientBuilderV3 {
         return shim
     }
 
-    public getAwsService = memoizeAsync(this.createAwsService.bind(this))
+    private keyAwsService<C extends AwsClient>(
+        type: AwsClientConstructor<C>,
+        options?: Partial<AwsClientOptions>,
+        region?: string,
+        userAgent: boolean = true,
+        settings?: DevSettings
+    ): string {
+        return [
+            String(type),
+            JSON.stringify(options), // Serializing this allows us to detect when nested objects change (ex. new retry strategy)
+            region,
+            userAgent ? '1' : '0',
+            settings ? String(settings.get('endpoints', {})) : '',
+        ].join(':')
+    }
+
+    public getAwsService = memoizeWith(this.createAwsService.bind(this), this.keyAwsService.bind(this))
 
     public async createAwsService<C extends AwsClient>(
         type: AwsClientConstructor<C>,

packages/core/src/shared/utilities/functionUtils.ts

@@ -77,15 +77,18 @@ export function memoize<T, U extends any[]>(fn: (...args: U) => T): (...args: U)
     return (...args) => (cache[args.map(String).join(':')] ??= fn(...args))
 }
 
-export function memoizeAsync<T, U extends any[]>(fn: (...args: U) => Promise<T>): (...args: U) => Promise<T> {
+export function memoizeWith<T, U extends any[]>(
+    fn: (...args: U) => Promise<T>,
+    key: (...args: U) => Promise<string> | string = (...args: U) => args.map(String).join(':')
+): (...args: U) => Promise<T> {
     const cache: Map<string, T> = new Map()
 
     return async (...args) => {
-        const key = args.map(String).join(':')
-        if (!cache.has(key)) {
-            cache.set(key, await fn(...args))
+        const cacheKey = await key(...args)
+        if (!cache.has(cacheKey)) {
+            cache.set(cacheKey, await fn(...args))
         }
-        return cache.get(key)!
+        return cache.get(cacheKey)!
     }
 }
 

packages/core/src/test/shared/awsClientBuilderV3.test.ts

@@ -31,6 +31,7 @@ import { CredentialsShim } from '../../auth/deprecated/loginManager'
 import { Credentials, MetadataBearer, MiddlewareStack } from '@aws-sdk/types'
 import { oneDay } from '../../shared/datetime'
 import { ConfiguredRetryStrategy } from '@smithy/util-retry'
+import { StandardRetryStrategy } from '@smithy/util-retry'
 
 describe('AwsClientBuilderV3', function () {
     let builder: AWSClientBuilderV3
@@ -98,20 +99,19 @@ describe('AwsClientBuilderV3', function () {
         })
 
         it('recreates client when config options change', async function () {
+            const retryStrategy = new ConfiguredRetryStrategy(10)
             const firstClient = await builder.getAwsService(TestClient, {
-                retryStrategy: new ConfiguredRetryStrategy(10),
+                retryStrategy: retryStrategy,
             })
 
             const secondClient = await builder.getAwsService(TestClient, {
-                retryStrategy: new ConfiguredRetryStrategy(11),
+                retryStrategy: new StandardRetryStrategy(1),
             })
 
             const thirdClient = await builder.getAwsService(TestClient, {
-                retryStrategy: new ConfiguredRetryStrategy(10),
+                retryStrategy: retryStrategy,
             })
-
             assert.notStrictEqual(firstClient.id, secondClient.id)
-            console.log('%s %s %s', firstClient.id, secondClient.id, thirdClient.id)
             assert.strictEqual(firstClient.id, thirdClient.id)
         })
     })