js-10-memoize-async

# Async memoize with TTL and in-flight dedup

Implement an ES module **`solution.js`** (no external libraries):

```js
export function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) { /* ... */ }
```

Return a memoized version of the async function `fn`. The cache key is
`JSON.stringify(args)` (the array of arguments the wrapper was called with).

Behavior:
- **Cache hit:** if a previous call with the same key resolved within the last `ttlMs`
  milliseconds, return the cached value **without calling `fn` again**.
- **In-flight dedup:** if a call with the same key is already pending (its promise has not
  settled yet), a new call with that key must return the **same in-flight promise** — `fn`
  is invoked only once for concurrent identical calls.
- **Expiry:** once a cached entry is older than `ttlMs`, the next call with that key calls
  `fn` again and refreshes the entry.
- Different keys are cached independently.

**Injectable clock:** time is read via the `now` option (a function returning the current
time in ms), which defaults to `Date.now`. Tests pass a controllable `now` so expiry is
deterministic. Timestamp a cache entry using `now()` when it resolves (or when the call
starts — either is acceptable as long as expiry is measured against `now()`).

If a pending call rejects, the entry must not be cached (the next call retries).

Example:
```js
let calls = 0;
let t = 1000;
const slow = async (x) => { calls++; return x * 2; };
const m = memoizeAsync(slow, { ttlMs: 100, now: () => t });

await Promise.all([m(5), m(5)]); // calls === 1 (deduped)
await m(5);                      // calls === 1 (cache hit)
t += 200;                        // advance past ttl
await m(5);                      // calls === 2 (expired)
```

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { memoizeAsync } from "./solution.js";

const tick = () => new Promise((res) => setTimeout(res, 1));

test("concurrent identical calls share one in-flight promise (dedup)", async () => {
  let calls = 0;
  const fn = async (x) => {
    calls++;
    await tick();
    return x * 2;
  };
  const m = memoizeAsync(fn, { ttlMs: 1000, now: () => 0 });
  const [a, b, c] = await Promise.all([m(5), m(5), m(5)]);
  assert.equal(a, 10);
  assert.equal(b, 10);
  assert.equal(c, 10);
  assert.equal(calls, 1);
});

test("cache hit within ttl does not call fn again", async () => {
  let calls = 0;
  let t = 1000;
  const fn = async (x) => {
    calls++;
    return x + 1;
  };
  const m = memoizeAsync(fn, { ttlMs: 100, now: () => t });
  assert.equal(await m(7), 8);
  t = 1050; // still within ttl
  assert.equal(await m(7), 8);
  assert.equal(calls, 1);
});

test("entry expires after ttl, fn is called again", async () => {
  let calls = 0;
  let t = 1000;
  const fn = async (x) => {
    calls++;
    return x;
  };
  const m = memoizeAsync(fn, { ttlMs: 100, now: () => t });
  await m("k");
  assert.equal(calls, 1);
  t = 1200; // past ttl
  await m("k");
  assert.equal(calls, 2);
});

test("different keys are cached independently", async () => {
  let calls = 0;
  const fn = async (x) => {
    calls++;
    return x * 10;
  };
  const m = memoizeAsync(fn, { ttlMs: 1000, now: () => 0 });
  assert.equal(await m(1), 10);
  assert.equal(await m(2), 20);
  assert.equal(await m(1), 10); // cached
  assert.equal(calls, 2);
});

test("multiple arguments form the key", async () => {
  let calls = 0;
  const fn = async (a, b) => {
    calls++;
    return a + b;
  };
  const m = memoizeAsync(fn, { ttlMs: 1000, now: () => 0 });
  assert.equal(await m(1, 2), 3);
  assert.equal(await m(1, 2), 3); // hit
  assert.equal(await m(2, 1), 3); // different key
  assert.equal(calls, 2);
});

test("rejections are not cached; next call retries", async () => {
  let calls = 0;
  const fn = async () => {
    calls++;
    throw new Error(`boom ${calls}`);
  };
  const m = memoizeAsync(fn, { ttlMs: 1000, now: () => 0 });
  await assert.rejects(() => m("x"), /boom 1/);
  await assert.rejects(() => m("x"), /boom 2/);
  assert.equal(calls, 2);
});

test("defaults to Date.now when no clock provided", async () => {
  let calls = 0;
  const fn = async (x) => {
    calls++;
    return x;
  };
  const m = memoizeAsync(fn, { ttlMs: 10000 });
  await m(42);
  await m(42);
  assert.equal(calls, 1);
});

test("expiry boundary: exactly ttl old is treated as expired", async () => {
  let calls = 0;
  let t = 0;
  const fn = async (x) => {
    calls++;
    return x;
  };
  const m = memoizeAsync(fn, { ttlMs: 100, now: () => t });
  await m("b"); // stored at time 0
  t = 100; // age === ttl -> not < ttl -> expired
  await m("b");
  assert.equal(calls, 2);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```js
export function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) {
  const cache = new Map();

  return async function(...args) {
    const key = JSON.stringify(args);
    const entry = cache.get(key);

    if (entry) {
      // If the entry is pending (timestamp is null), return the in-flight promise.
      if (entry.timestamp === null) {
        return entry.promise;
      }

      // If the entry is resolved, check if it's within the TTL.
      if (now() - entry.timestamp < ttlMs) {
        return entry.promise;
      }

      // If expired, fall through to call fn again.
    }

    // Call the original function.
    const promise = fn(...args);

    // Store the promise in the cache with a null timestamp (pending).
    cache.set(key, { promise, timestamp: null });

    // Handle promise resolution.
    promise.then(
      (value) => {
        // Update the timestamp when the promise resolves.
        const entry = cache.get(key);
        if (entry && entry.promise === promise) {
          entry.timestamp = now();
        }
      },
      (error) => {
        // Remove the entry if the promise rejects.
        const entry = cache.get(key);
        if (entry && entry.promise === promise) {
          cache.delete(key);
        }
      }
    );

    return promise;
  };
}
```

The user wants an ES module `solution.js` that exports a `memoizeAsync` function.

Key requirements:
1. Input: `fn` (async function), options `{ ttlMs, now = Date.now }`.
2. Output: A wrapper function that behaves like `fn` but with caching.
3. Cache key: `JSON.stringify(args)`.
4. Cache hit: If a previous call with the same key resolved within `ttlMs`, return cached value.
5. In-flight dedup: If a call with the same key is pending, return the same promise.
6. Expiry: If cached entry is older than `ttlMs`, call `fn` again.
7. Injectable clock: Use `now` option for time.
8. Error handling: If a pending call rejects, do not cache the error. Next call retries.

Let's design the data structures.
We need to store:
- Pending promises (for in-flight dedup).
- Cached results (for cache hits).
- Timestamps (for expiry).

We can use a single Map for the cache, where the value is an object containing:
- `promise`: The promise for the current call (if pending) or the resolved value (if cached).
- `timestamp`: The time when the result was cached (or when the call started? The prompt says "Timestamp a cache entry using `now()` when it resolves (or when the call starts — either is acceptable as long as expiry is measured against `now()`)." Let's use when it resolves for simplicity, or when the call starts. Actually, if we use when it starts, we might cache a result that took longer than `ttlMs` to compute, which might be weird, but acceptable per prompt. Let's stick to "when it resolves" or "when the call starts". Let's use "when the call starts" for simplicity in implementation, or "when it resolves" to be safe. Let's read carefully: "Timestamp a cache entry using `now()` when it resolves (or when the call starts — either is acceptable as long as expiry is measured against `now()`)." Okay, either is fine. Let's use when it resolves.

Wait, if we use when it resolves, we need to handle the case where the promise is still pending.
Let's structure the cache entry as:
```js
{
  promise: Promise,
  timestamp: number | null // null if pending, set when resolved
}
```

Algorithm for the wrapper function:
1. Compute key: `JSON.stringify(args)`.
2. Check cache for key.
3. If cache has entry:
   - If entry has a timestamp and `now() - timestamp < ttlMs`:
     - Return the cached value (which is stored in the promise, but we need to extract it? Or just return the promise? The prompt says "return the cached value". If we return the promise, it's fine because it's already resolved. But we need to make sure we don't return a pending promise as a cache hit. So we check timestamp. If timestamp exists and not expired, return the promise (which is resolved).
   - Else (expired):
     - Proceed to call `fn`.
4. If cache does not have entry or expired:
   - Create a new promise by calling `fn(...args)`.
   - Store in cache: `{ promise: newPromise, timestamp: null }`.
   - When `newPromise` resolves:
     - Update timestamp to `now()`.
   - When `newPromise` rejects:
     - Delete the entry from cache (or mark as invalid). The prompt says "If a pending call rejects, the entry must not be cached (the next call retries)." So we should remove it.
   - Return `newPromise`.

Wait, there's a nuance with in-flight dedup.
If we have a pending promise, we return it.
If it resolves, we update the timestamp.
If it rejects, we remove the entry.

Let's refine the cache structure.
We can use a Map `cache`.
Key: string.
Value: `{ promise: Promise, timestamp: number | null }`.

Wrapper function:
```js
return async function(...args) {
  const key = JSON.stringify(args);
  const entry = cache.get(key);

  if (entry) {
    // Check if it's a cache hit (resolved and not expired)
    if (entry.timestamp !== null && now() - entry.timestamp < ttlMs) {
      return entry.promise; // It's resolved, so this returns the value immediately (as a resolved promise)
    }
    // If it's pending (timestamp is null), we return the promise (in-flight dedup)
    // But wait, if it's pending, we should return the promise regardless of ttl?
    // Yes, in-flight dedup means if it's pending, return the same promise.
    // But what if it's pending and the call started a long time ago?
    // The prompt says: "if a call with the same key is already pending (its promise has not settled yet), a new call with that key must return the same in-flight promise".
    // So yes, if pending, return the promise.
    // But what if it's expired and pending? That's a weird state.
    // If we timestamp when it starts, then a pending call could be "expired" by time, but it's still pending.
    // The prompt says "either is acceptable". Let's timestamp when it resolves.
    // So if it's pending, timestamp is null. We return the promise.
    // If it's resolved, timestamp is set. We check expiry.
    // So:
    if (entry.timestamp === null) {
      return entry.promise; // In-flight dedup
    }
    // If we are here, it's resolved but expired.
    // We need to call fn again.
  }

  // Call fn
  const promise = fn(...args);
  cache.set(key, { promise, timestamp: null });

  promise.then(
    (value) => {
      // Update timestamp on resolve
      const entry = cache.get(key);
      if (entry && entry.promise === promise) {
        entry.timestamp = now();
      }
    },
    (error) => {
      // Remove entry on reject
      const entry = cache.get(key);
      if (entry && entry.promise === promise) {
        cache.delete(key);
      }
    }
  );

  return promise;
};
```

Wait, there's a potential issue.
If we have a cache hit (resolved, not expired), we return `entry.promise`.
But `entry.promise` is a resolved promise. Returning it is fine.
But what if the caller expects a value, not a promise? The wrapper is async, so it returns a promise anyway.
The prompt says "return the cached value". In JS, async functions return promises. So returning the resolved promise is correct.

Let's double check the in-flight dedup logic.
If `entry` exists and `timestamp` is null, it means it's pending. We return `entry.promise`.
This satisfies in-flight dedup.

What if `entry` exists, `timestamp` is not null, but expired?
We fall thr
…[11194 chars elided]…
 P2, timestamp: null }`.
5. P1 resolves? No, P1 already resolved.
6. P2 resolves. Cache: `{ promise: P2, timestamp: 1200 }`.
This is correct.

What if P1 rejects?
1. Call `m(5)`. P1 created. Cache: `{ promise: P1, timestamp: null }`.
2. P1 rejects. Cache deleted.
3. Call `m(5)`. P2 created. Cache: `{ promise: P2, timestamp: null }`.
This is correct.

The code looks solid.

```js
export function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) {
  const cache = new Map();

  return async function(...args) {
    const key = JSON.stringify(args);
    const entry = cache.get(key);

    if (entry) {
      // If pending, return the in-flight promise (dedup)
      if (entry.timestamp === null) {
        return entry.promise;
      }

      // If resolved, check TTL
      if (now() - entry.timestamp < ttlMs) {
        return entry.promise;
      }

      // Expired, fall through
    }

    // Call fn
    const promise = fn(...args);
    cache.set(key, { promise, timestamp: null });

    promise.then(
      (value) => {
        const entry = cache.get(key);
        if (entry && entry.promise === promise) {
          entry.timestamp = now();
        }
      },
      (error) => {
        const entry = cache.get(key);
        if (entry && entry.promise === promise) {
          cache.delete(key);
        }
      }
    );

    return promise;
  };
}
```

I think this is correct.
One small thing: `ttlMs` might be undefined. If so, `now() - entry.timestamp < ttlMs` is `NaN`, which is false.
So it will always expire.
This is probably fine, as the prompt implies `ttlMs` is provided.
If I want to be extra safe, I could default `ttlMs` to `Infinity`, but the prompt doesn't say.
I'll leave it as is.

Actually, let's re-read the prompt: "if a previous call with the same key resolved within the last `ttlMs` milliseconds".
This implies `ttlMs` is a number.
I'll assume it's provided.

Final check: The prompt says "no external libraries". My code uses only built-in JS.
It's an ES module. `export function` is correct.

I think we're good.