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 nowMs = now();

    // Check if there is an existing entry
    const entry = cache.get(key);

    // Case 1: Entry exists and is valid (hit)
    if (entry && nowMs - entry.timestamp <= ttlMs) {
      return entry.promise;
    }

    // Case 2: Entry is missing or expired (miss)
    // Create a new promise for this key
    const promise = fn(...args).then(
      (result) => {
        // If the promise resolves, cache it with the current timestamp
        cache.set(key, { promise, timestamp: nowMs });
        return result;
      },
      (error) => {
        // If the promise rejects, do NOT cache it
        cache.delete(key);
        throw error;
      }
    );

    // Store the promise in the cache immediately so concurrent calls dedupe
    cache.set(key, { promise, timestamp: nowMs });

    return promise;
  };
}
```

[
  {
    "total": 8,
    "answer": "```js\nexport function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) {\n  const cache = new Map();\n\n  return async function(...args) {\n    const key = JSON.stringify(args);\n    const nowMs = now();\n\n    // Check if there is an existing entry\n    const entry = cache.get(key);\n\n    // Case 1: Entry exists and is valid (hit)\n    if (entry && nowMs - entry.timestamp <= ttlMs) {\n      return entry.promise;\n    }\n\n    // Case 2: Entry is missing or expired (miss)\n    // Create a new promise for this key\n    const promise = fn(...args).then(\n      (result) => {\n        // If the promise resolves, cache it with the current timestamp\n        cache.set(key, { promise, timestamp: nowMs });\n        return result;\n      },\n      (error) => {\n        // If the promise rejects, do NOT cache it\n        cache.delete(key);\n        throw error;\n      }\n    );\n\n    // Store the promise in the cache immediately so concurrent calls dedupe\n    cache.set(key, { promise, timestamp: nowMs });\n\n    return promise;\n  };\n}\n```",
    "passed": 7,
    "test_error": "TAP version 13\n# Subtest: concurrent identical calls share one in-flight promise (dedup)\nok 1 - concurrent identical calls share one in-flight promise (dedup)\n  ---\n  duration_ms: 1.909828\n  type: 'test'\n  ...\n# Subtest: cache hit within ttl does not call fn again\nok 2 - cache hit within ttl does not call fn again\n  ---\n  duration_ms: 0.117891\n  type: 'test'\n  ...\n# Subtest: entry expires after ttl, fn is called again\nok 3 - entry expires after ttl, fn is called again\n  ---\n  duration_ms: 0.079591\n  type: 'test'\n  ...\n# Subtest: different keys are cached independently\nok 4 - different keys are cached independently\n  ---\n  duration_ms: 0.083301\n  type: 'test'\n  ...\n# Subtest: multiple arguments form the key\nok 5 - multiple arguments form the key\n  ---\n  duration_ms: 0.075571\n  type: 'test'\n  ...\n# Subtest: rejections are not cached; next call retries\nok 6 - rejections are not cached; next call retries\n  ---\n  duration_ms: 0.294553\n  type: 'test'\n  ...\n# Subtest: defaults to Date.now when no clock provided\nok 7 - defaults to Date.now when no clock provided\n  ---\n  duration_ms: 0.07745\n  type: 'test'\n  ...\n# Subtest: expiry boundary: exactly ttl old is treated as expired\nnot ok 8 - expiry boundary: exactly ttl old is treated as expired\n  ---\n  duration_ms: 0.383543\n  type: 'test'\n  location: '/tmp/llmlab-js-10-memoize-async-2gg0ybcc/solution.test.js:101:1'\n  failureType: 'testCodeFailure'\n  error: |-\n    Expected values to be strictly equal:\n    \n    1 !== 2\n    \n  code: 'ERR_ASSERTION'\n  name: 'AssertionError'\n  expected: 2\n  actual: 1\n  operator: 'strictEqual'\n  stack: |-\n    TestContext.<anonymous> (file:///tmp/llmlab-js-10-memoize-async-2gg0ybcc/solution.test.js:112:10)\n    async Test.run (node:internal/test_runner/test:1313:7)\n    async Test.processPendingSubtests (node:internal/test_runner/test:897:7)\n  ...\n1..8\n# tests 8\n# suites 0\n# pass 7\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 30.633508"
  },
  {
    "total": 8,
    "answer": "```js\nexport function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) {\n  const cache = new Map();\n\n  return async function(...args) {\n    const key = JSON.stringify(args);\n    const nowMs = now();\n\n    // Check if there is an existing entry\n    const entry = cache.get(key);\n\n    // Case 1: Entry exists and is valid (hit)\n    if (entry && nowMs - entry.timestamp <= ttlMs) {\n      return entry.promise;\n    }\n\n    // Case 2: Entry is missing or expired (miss)\n    // Create a new promise for this key\n    const promise = fn(...args).then(\n      (result) => {\n        // If the promise resolves, cache it with the current timestamp\n        cache.set(key, { promise, timestamp: nowMs });\n        return result;\n      },\n      (error) => {\n        // If the promise rejects, do NOT cache it\n        cache.delete(key);\n        throw error;\n      }\n    );\n\n    // Store the promise in the cache immediately so concurrent calls dedupe\n    cache.set(key, { promise, timestamp: nowMs });\n\n    return promise;\n  };\n}\n```",
    "passed": 7,
    "test_error": "TAP version 13\n# Subtest: concurrent identical calls share one in-flight promise (dedup)\nok 1 - concurrent identical calls share one in-flight promise (dedup)\n  ---\n  duration_ms: 1.801657\n  type: 'test'\n  ...\n# Subtest: cache hit within ttl does not call fn again\nok 2 - cache hit within ttl does not call fn again\n  ---\n  duration_ms: 0.118241\n  type: 'test'\n  ...\n# Subtest: entry expires after ttl, fn is called again\nok 3 - entry expires after ttl, fn is called again\n  ---\n  duration_ms: 0.073011\n  type: 'test'\n  ...\n# Subtest: different keys are cached independently\nok 4 - different keys are cached independently\n  ---\n  duration_ms: 0.084001\n  type: 'test'\n  ...\n# Subtest: multiple arguments form the key\nok 5 - multiple arguments form the key\n  ---\n  duration_ms: 0.077571\n  type: 'test'\n  ...\n# Subtest: rejections are not cached; next call retries\nok 6 - rejections are not cached; next call retries\n  ---\n  duration_ms: 0.283873\n  type: 'test'\n  ...\n# Subtest: defaults to Date.now when no clock provided\nok 7 - defaults to Date.now when no clock provided\n  ---\n  duration_ms: 0.076011\n  type: 'test'\n  ...\n# Subtest: expiry boundary: exactly ttl old is treated as expired\nnot ok 8 - expiry boundary: exactly ttl old is treated as expired\n  ---\n  duration_ms: 0.382983\n  type: 'test'\n  location: '/tmp/llmlab-js-10-memoize-async-iaki87s8/solution.test.js:101:1'\n  failureType: 'testCodeFailure'\n  error: |-\n    Expected values to be strictly equal:\n    \n    1 !== 2\n    \n  code: 'ERR_ASSERTION'\n  name: 'AssertionError'\n  expected: 2\n  actual: 1\n  operator: 'strictEqual'\n  stack: |-\n    TestContext.<anonymous> (file:///tmp/llmlab-js-10-memoize-async-iaki87s8/solution.test.js:112:10)\n    async Test.run (node:internal/test_runner/test:1313:7)\n    async Test.processPendingSubtests (node:internal/test_runner/test:897:7)\n  ...\n1..8\n# tests 8\n# suites 0\n# pass 7\n# fail 1\n# cancelled 0\n# skipped 0\n# todo 0\n# duration_ms 29.750309"
  },
  {
    "total": 8,
    "answer": "```js\nexport function memoizeAsync(fn, { ttlMs, now = Date.now } = {}) {\n  const cache = new Map();\n\n  return async function(...args) {\n    const key = JSON.stringify(args);\n    const nowMs = now();\n\n    // Check if there is an existing entry\n    const entry = cache.get(key);\n\n    // Case 1: Entry exists and is valid (hit)\n    if (entry && nowMs - entry.timestamp <= ttlMs) {\n      return entry.promise;\n    }\n\n    // Case 2: Entry is missing or expired (miss)\n    // Create a new promise for this key\n    const promise = fn(...args).then(\n      (result) => {\n        // If the promise resolves, cache it with the current timestamp\n        cache.set(key, { promise, timestamp: nowMs });\n        return result;\n      },\n      (error) => {\n        // If the promise rejects, do NOT cache it\n        cache.delete(key);\n        throw error;\n      }\n    );\n\n    // Store the promise in the cache immediately so concurrent calls dedupe\n    cache.set(key, { promise, timestamp: nowMs });\n\n    return promise;\n  };\n}\n```",
    "passed": 7,
    "test_error": ""
  }
]