Ilia Denisov
84ecc85f51
A dropped/reset/timed-out connection can surface as a Connect code other than Unavailable (Canceled/DeadlineExceeded/Unknown/…) which fell through to the generic 'internal' -> a red 'something went wrong' toast appeared alongside the Connecting spinner. Now toGatewayError (moved to the pure retry.ts, unit-tested) collapses every transport-level code to 'unavailable' so it is retried + flips offline; and handleError suppresses the toast for any connection code AND whenever the app is mid-reconnect (!connection.online), covering the race where a unary error lands before the stream reports the drop. Genuine server-internal / domain errors still toast while online.
86 lines
3.5 KiB
TypeScript
86 lines
3.5 KiB
TypeScript
// Retry policy + error classification for the gateway transport (Stage 17). When a unary call
|
|
// fails at the transport level the app retries it with capped exponential backoff while showing
|
|
// the "Connecting…" indicator, instead of flashing a red toast each time.
|
|
//
|
|
// Idempotency: a rate-limit rejection (ResourceExhausted) never reached the backend, so any op is
|
|
// safe to retry. A transport 'unavailable' is ambiguous for a mutation (its response could have
|
|
// been lost after the backend applied it), so only **read-only** ops are auto-retried on
|
|
// 'unavailable'; a mutation is surfaced instead (its button is disabled while offline and
|
|
// re-enables on reconnect, so the player re-issues it deliberately).
|
|
|
|
import { Code, ConnectError } from '@connectrpc/connect';
|
|
import { GatewayError } from './client';
|
|
|
|
/**
|
|
* toGatewayError normalises a thrown Connect/transport error to a GatewayError with a stable code.
|
|
* Connection-level failures — the server is unreachable, the request timed out, was reset or
|
|
* cancelled, or a raw network error — all collapse to **'unavailable'**, so they are handled as
|
|
* connectivity (the indicator + retry), never as a red error toast. A genuine server-side
|
|
* 'internal' or a domain code is preserved.
|
|
*/
|
|
export function toGatewayError(e: unknown): GatewayError {
|
|
if (e instanceof ConnectError) {
|
|
switch (e.code) {
|
|
case Code.Unauthenticated:
|
|
return new GatewayError('session_invalid', e.message);
|
|
case Code.ResourceExhausted:
|
|
return new GatewayError('rate_limited', e.message);
|
|
case Code.Unavailable:
|
|
case Code.DeadlineExceeded:
|
|
case Code.Canceled:
|
|
case Code.Aborted:
|
|
case Code.Unknown:
|
|
return new GatewayError('unavailable', e.message);
|
|
case Code.NotFound:
|
|
return new GatewayError('not_found', e.message);
|
|
default:
|
|
return new GatewayError('internal', e.message);
|
|
}
|
|
}
|
|
return new GatewayError('unavailable', String(e));
|
|
}
|
|
|
|
/** READ_OPS is the set of side-effect-free message types (safe to auto-retry on any failure). */
|
|
export const READ_OPS: ReadonlySet<string> = new Set([
|
|
'profile.get',
|
|
'games.list',
|
|
'game.state',
|
|
'game.history',
|
|
'game.gcg',
|
|
'game.evaluate',
|
|
'game.check_word',
|
|
'stats.get',
|
|
'lobby.poll',
|
|
'chat.list',
|
|
'draft.get',
|
|
'friends.list',
|
|
'friends.incoming',
|
|
'friends.outgoing',
|
|
'blocks.list',
|
|
'invitation.list',
|
|
]);
|
|
|
|
/**
|
|
* retryable reports whether a failed op should be auto-retried. A rate-limit rejection is always
|
|
* safe (the gateway rejected it before processing); a transport 'unavailable' is retried only for
|
|
* read-only ops, never a mutation; every other code (a domain rejection, not-found, …) is final.
|
|
*/
|
|
export function retryable(code: string, op: string): boolean {
|
|
if (code === 'rate_limited') return true;
|
|
if (code === 'unavailable') return READ_OPS.has(op);
|
|
return false;
|
|
}
|
|
|
|
/** isConnectionCode reports whether a code is a transport/connectivity failure the Connecting
|
|
* indicator covers (so the UI suppresses its red toast). */
|
|
export function isConnectionCode(code: string): boolean {
|
|
return code === 'unavailable' || code === 'rate_limited';
|
|
}
|
|
|
|
/** backoffMs is the delay before retry attempt n (1-based): capped exponential growth plus a
|
|
* little jitter, so a fleet of clients does not retry in lockstep after an outage. */
|
|
export function backoffMs(attempt: number): number {
|
|
const base = Math.min(8000, 500 * 2 ** Math.max(0, attempt - 1));
|
|
return base + Math.floor(Math.random() * 250);
|
|
}
|