fix(resources): dedupe and invalidate memoized AWS caches

memoize() cached only a promise's resolved value, set inside .then(), so
concurrent callers each fired their own request before the first resolved
— defeating the cache exactly during tree expansion, when many nodes
resolve at once. Cached data also lived for the whole session with no way
to invalidate, so the refresh button replayed stale account ids / region
lists and never picked up re-authenticated credentials.

Cache the promise itself (concurrent callers now share one in-flight
request) and evict it on rejection so failures aren't served forever.
Add clear() per memoized function plus a registry-backed
clearMemoizedCaches(), and wire it into the refreshResources command so a
manual refresh re-queries AWS and rebuilds clients (also picking up an
endpoint change for the profile-only-keyed clients).

Add memoize.test.ts covering dedup, rejection-eviction, and clear paths.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: peter-smith-phd

src/plugins/resource-browser.ts

@@ -2,6 +2,7 @@ import { commands, window, workspace } from "vscode";
 
 import { ProviderFactory } from "../platforms/aws/services/providerFactory.ts";
 import { createPlugin } from "../plugins.ts";
+import { clearMemoizedCaches } from "../utils/memoize.ts";
 import { registerLocalStackCommands } from "../views/explore/commands.ts";
 import { LocalStackViewProvider } from "../views/explore/viewProvider.ts";
 import { ResourceDetailsViewProvider } from "../views/resource-details/viewProvider.ts";
@@ -66,9 +67,13 @@ export default createPlugin(
 		);
 
 		context.subscriptions.push(
-			commands.registerCommand("localstack.refreshResources", () =>
-				resourcesProvider.refresh(),
-			),
+			commands.registerCommand("localstack.refreshResources", () => {
+				/* A manual refresh should re-query AWS, not replay cached account
+				 * ids / region lists / clients — drop the caches first so newly
+				 * created resources and re-authenticated credentials are picked up. */
+				clearMemoizedCaches();
+				return resourcesProvider.refresh();
+			}),
 			commands.registerCommand("localstack.refreshResourceDetails", () =>
 				detailsProvider.refresh(),
 			),

src/test/memoize.test.ts

@@ -0,0 +1,75 @@
+import * as assert from "node:assert";
+
+import { clearMemoizedCaches, memoize } from "../utils/memoize.ts";
+
+suite("memoize", () => {
+	test("caches by argument key", () => {
+		let calls = 0;
+		const m = memoize((x: number) => {
+			calls++;
+			return x * 2;
+		});
+		assert.strictEqual(m(2), 4);
+		assert.strictEqual(m(2), 4);
+		assert.strictEqual(calls, 1);
+		assert.strictEqual(m(3), 6);
+		assert.strictEqual(calls, 2);
+	});
+
+	test("dedupes concurrent in-flight async callers into one invocation", async () => {
+		let calls = 0;
+		const m = memoize((key: string) => {
+			calls++;
+			return Promise.resolve(`${key}!`);
+		});
+
+		/* Both calls happen before the first resolves; with promise caching they
+		 * share the single in-flight request rather than each invoking `func`. */
+		const [a, b] = await Promise.all([m("x"), m("x")]);
+		assert.strictEqual(a, "x!");
+		assert.strictEqual(b, "x!");
+		assert.strictEqual(calls, 1);
+	});
+
+	test("does not cache a rejected promise; the next call retries", async () => {
+		let attempts = 0;
+		const m = memoize((key: string) => {
+			attempts++;
+			return attempts === 1
+				? Promise.reject(new Error("transient"))
+				: Promise.resolve(`${key}-ok`);
+		});
+
+		await assert.rejects(m("x"), /transient/);
+		/* The failure was evicted, so the retry re-invokes and succeeds. */
+		assert.strictEqual(await m("x"), "x-ok");
+		assert.strictEqual(attempts, 2);
+	});
+
+	test("clear() drops a single function's cache", () => {
+		let calls = 0;
+		const m = memoize((x: number) => {
+			calls++;
+			return x;
+		});
+		m(1);
+		m(1);
+		assert.strictEqual(calls, 1);
+		m.clear();
+		m(1);
+		assert.strictEqual(calls, 2);
+	});
+
+	test("clearMemoizedCaches() drops registered caches", () => {
+		let calls = 0;
+		const m = memoize((x: number) => {
+			calls++;
+			return x;
+		});
+		m(1);
+		assert.strictEqual(calls, 1);
+		clearMemoizedCaches();
+		m(1);
+		assert.strictEqual(calls, 2);
+	});
+});

src/utils/memoize.ts

@@ -1,35 +1,69 @@
+/**
+ * A memoized function, with a `clear()` to drop its cached results.
+ */
+export type Memoized<Args extends unknown[], Result> = ((
+	...args: Args
+) => Result) & { clear: () => void };
+
+/*
+ * Every memoized function's `clear` is registered here so all caches can be
+ * dropped at once — e.g. when the user refreshes to re-query AWS, or when
+ * credentials/endpoints may have changed and cached clients/results are stale.
+ */
+const registry = new Set<() => void>();
+
+/** Drop every memoized cache (cached SDK clients and fetched data alike). */
+export function clearMemoizedCaches(): void {
+	for (const clear of registry) {
+		clear();
+	}
+}
+
 /**
  * Memoizes a function's results based on its arguments.
  *
+ * For promise-returning functions the *promise* is cached (not just its
+ * resolved value), so concurrent callers share a single in-flight request
+ * instead of each firing their own. A rejected promise is evicted so the
+ * failure is not served forever and the next call retries.
+ *
+ * Note: keys are derived via `JSON.stringify(args)`, so this is intended for
+ * primitive arguments (strings/numbers). Object args with differing key order
+ * — or non-serializable values — will not key reliably.
+ *
  * @param func The function to memoize.
- * @returns A memoized version of the function.
+ * @returns A memoized version of `func`, with a `clear()` to drop its cache.
  */
 export function memoize<Args extends unknown[], Result>(
 	func: (...args: Args) => Result,
-): (...args: Args) => Result {
-	/* For promise-returning functions we cache the resolved value (not the
-	 * promise), so the cache holds `Awaited<Result>`. */
-	const cache = new Map<string, Awaited<Result>>();
-
-	return (...args: Args): Result => {
-		const key = JSON.stringify(args); // Create a unique key from arguments
+): Memoized<Args, Result> {
+	const cache = new Map<string, Result>();
 
+	const memoized = ((...args: Args): Result => {
+		const key = JSON.stringify(args);
 		if (cache.has(key)) {
 			return cache.get(key) as Result;
 		}
 
 		const result = func(...args);
+		cache.set(key, result);
 
-		/* for Promises, only cache them if they're successful */
 		if (result instanceof Promise) {
-			return (result as Promise<Awaited<Result>>).then((res) => {
-				cache.set(key, res);
-				return res;
-			}) as Result;
-
-			/* For non-Promises, always cache the result */
+			/* Don't let a rejection stick in the cache. Evict only if this exact
+			 * promise is still the cached entry (a clear/refresh may have replaced
+			 * it). The caller handles the rejection on its own copy of the promise;
+			 * this handler exists solely to evict. */
+			result.catch(() => {
+				if (cache.get(key) === result) {
+					cache.delete(key);
+				}
+			});
 		}
-		cache.set(key, result as Awaited<Result>);
+
 		return result;
-	};
+	}) as Memoized<Args, Result>;
+
+	memoized.clear = () => cache.clear();
+	registry.add(memoized.clear);
+	return memoized;
 }