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 cached = cache.get(key);

    if (cached) {
      // Check if cache entry is still valid
      if (cached.promise && (ttlMs === undefined || now() - cached.timestamp < ttlMs)) {
        return cached.promise;
      }
      // If expired or rejected, remove from cache
      cache.delete(key);
    }

    // Create new promise for this key
    const promise = fn(...args).then(
      (value) => {
        // Only cache successful results
        cache.set(key, {
          promise,
          timestamp: now(),
        });
        return value;
      },
      (error) => {
        // Don't cache rejected promises
        cache.delete(key);
        throw error;
      }
    );

    // Store the in-flight promise
    cache.set(key, { promise });
    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 cached = cache.get(key);\n\n    if (cached) {\n      // Check if cache entry is still valid\n      if (cached.promise && (ttlMs === undefined || now() - cached.timestamp < ttlMs)) {\n        return cached.promise;\n      }\n      // If expired or rejected, remove from cache\n      cache.delete(key);\n    }\n\n    // Create new promise for this key\n    const promise = fn(...args).then(\n      (value) => {\n        // Only cache successful results\n        cache.set(key, {\n          promise,\n          timestamp: now(),\n        });\n        return value;\n      },\n      (error) => {\n        // Don't cache rejected promises\n        cache.delete(key);\n        throw error;\n      }\n    );\n\n    // Store the in-flight promise\n    cache.set(key, { promise });\n    return promise;\n  };\n}\n```",
    "passed": 7,
    "test_error": "TAP version 13\n# Subtest: concurrent identical calls share one in-flight promise (dedup)\nnot ok 1 - concurrent identical calls share one in-flight promise (dedup)\n  ---\n  duration_ms: 5.761066\n  type: 'test'\n  location: '/tmp/llmlab-js-10-memoize-async-63wp7n2z/solution.test.js:7:1'\n  failureType: 'testCodeFailure'\n  error: |-\n    Expected values to be strictly equal:\n    \n    3 !== 1\n    \n  code: 'ERR_ASSERTION'\n  name: 'AssertionError'\n  expected: 1\n  actual: 3\n  operator: 'strictEqual'\n  stack: |-\n    TestContext.<anonymous> (file:///tmp/llmlab-js-10-memoize-async-63wp7n2z/solution.test.js:19:10)\n    async Test.run (node:internal/test_runner/test:1313:7)\n    async startSubtestAfterBootstrap (node:internal/test_runner/harness:385:3)\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.327162\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.086531\n  type: 'test'\n  ...\n# Subtest: different keys are cached independently\nok 4 - different keys are cached independently\n  ---\n  duration_ms: 0.09088\n  type: 'test'\n  ...\n# Subtest: multiple arguments form the key\nok 5 - multiple arguments form the key\n  ---\n  duration_ms: 0.089941\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.288002\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.083861\n  type: 'test'\n  ...\n# Subtest: expiry boundary: exactly ttl old is treated as expired\nok 8 - expiry boundary: exactly ttl old is treated as expired\n  ---\n  duration_ms: 0.0752\n  type: 'test'\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 33.901522"
  },
  {
    "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 cached = cache.get(key);\n\n    if (cached) {\n      // If there's an in-flight promise, return it\n      if (cached.promise) {\n        return cached.promise;\n      }\n      // If cache entry exists and is still valid, return the value\n      if (ttlMs === undefined || now() - cached.timestamp < ttlMs) {\n        return cached.value;\n      }\n      // If expired, remove from cache\n      cache.delete(key);\n    }\n\n    // Create new promise for this key\n    const promise = fn(...args).then(\n      (value) => {\n        // Only cache successful results\n        cache.set(key, {\n          value,\n          timestamp: now(),\n        });\n        return value;\n      },\n      (error) => {\n        // Don't cache rejected promises\n        cache.delete(key);\n        throw error;\n      }\n    );\n\n    // Store the in-flight promise\n    cache.set(key, { promise });\n    return promise;\n  };\n}\n```",
    "passed": 8,
    "test_error": ""
  }
]