Review brief

Advanced40 min

An account API moves reads to a replica while preserving read-your-write behavior. Database positions are opaque unsigned decimal sequence numbers that may exceed JavaScript's safe integer range.

Behavioral contract

primary.update returns the commit position; the update response must read an account at or beyond that position.
Positions are canonical unsigned decimal strings and compare by integer value without conversion to Number.
A read with minPosition may use a cached or replica value only when its associated position is at least the minimum; otherwise wait up to 50 ms, then fall back to primary if the replica is still behind.
A read without minPosition may use the newest cached entry. Every cached account is stored together with the database position that produced it.

Review instructions

1Trace the commit position through update, cache, replica wait, and fallback.
2Distinguish latency choices from violations of the explicit consistency floor.
3Prioritize no more than four findings.

Learning objectives

• Carry commit positions across write-then-read flows
• Compare and wait for replication positions correctly
• Keep caches from bypassing session guarantees

src/account-store-types.tsTypeScript

@@ -0,0 +1,21 @@

1+export interface Account {

2+ id: string;

3+ displayName: string;

4+}

6+export interface PositionedAccount {

7+ account: Account;

8+ position: string;

9+}

10+

11+export interface AccountStores {

12+ primary: {

13+ update(id: string, displayName: string): Promise<{ position: string }>;

14+ read(id: string): Promise<PositionedAccount>;

15+ };

16+ replica: {

17+ position(): Promise<string>;

18+ waitUntil(position: string, timeoutMs: number): Promise<boolean>;

19+ read(id: string): Promise<PositionedAccount>;

20+ };

21+}

Reference solution

The findings below are ordered by priority.

Findings

1. The update path discards its consistency position

Location: src/update-account-handler.ts:9-11

The primary commit result is ignored and the following read has no minimum. It can use any cached or replica value, so a successful update response may immediately show the old display name.

Capture the commit position and pass it as minPosition to the reader.

2. Cached accounts have no position and bypass the requested floor

Location: src/consistent-account-reader.ts:7-15

The map stores only an account and returns it before inspecting minPosition. Even if the caller carries a fresh commit position, an older cached value wins with no way to prove it satisfies the session guarantee.

Cache PositionedAccount values and reuse one only when there is no minimum or its position compares at least as new.

3. Decimal positions are compared lexicographically

Location: src/consistent-account-reader.ts:18-20

String >= does not follow integer ordering: for example, position "9" compares greater than "10". The reader can treat a lagging replica as current or wait unnecessarily.

Compare canonical decimal strings by integer semantics, such as BigInt, without converting through imprecise Number.

4. A timed-out wait still reads the stale replica

Location: src/consistent-account-reader.ts:21-24

The boolean from waitUntil is discarded. On timeout the code immediately reads the replica even though it has not reached the minimum, violating the consistency floor instead of using the primary.

Read the replica only after a true wait result; otherwise call primary.read and cache its positioned result.

Reasonable non-findings

A 50 ms wait before primary fallback matches the contract.
Using the replica when no minimum is supplied is allowed.
Process-local caching is acceptable when each entry carries and enforces its source position.