Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
126 changes: 122 additions & 4 deletions frontend/src/features/realtime/RecoveryOverlay.tsx
Original file line number Diff line number Diff line change
@@ -1,9 +1,13 @@
// src/features/realtime/RecoveryOverlay.tsx — Gentle full-page overlay on comeback
// Shows when user returns after inactivity, provides encouragement
// src/features/realtime/RecoveryOverlay.tsx — Recovery surfaces for the realtime layer
// 1. Gentle full-page overlay on comeback (user returns after inactivity)
// 2. Small status banner while the SSE connection is down, with a retry countdown

import { useEffect, useState } from 'react';
import { motion, AnimatePresence } from 'framer-motion';
import { ArrowRight, Sparkles } from 'lucide-react';
import { useSse } from '../../hooks/useSse';
import { ArrowRight, Sparkles, WifiOff } from 'lucide-react';
import { useQueryClient } from '@tanstack/react-query';
import { reconnectNow, useSse } from '../../hooks/useSse';
import { useUserStore } from '../../store/userStore';
import { cn } from '../../lib/design-system/tokens.css';
import { copy } from '../../lib/copy';

Expand All @@ -18,7 +22,121 @@ interface RecoveryMessage {
expiresAt: string;
}

const CONNECTED_MESSAGE_MS = 1_500;
const RUNTIME_STATE_QUERY_KEY = ['runtime-state'] as const;

/** Whole seconds left until `nextReconnectAt`, never negative. */
export function secondsUntil(nextReconnectAt: number, now: number): number {
return Math.max(0, Math.ceil((nextReconnectAt - now) / 1000));
}

export function ConnectionRecoveryBanner() {
const isAuthenticated = useUserStore((s) => s.isAuthenticated);
const { connectionStatus, nextReconnectAt } = useSse();
const queryClient = useQueryClient();
// `interrupted` stays true from the first drop until the "Connected!" message is gone,
// so the first connect after page load (status 'connecting') never shows a banner.
const [interrupted, setInterrupted] = useState(false);
const [recovered, setRecovered] = useState(false);
const [now, setNow] = useState(() => Date.now());

useEffect(() => {
if (!isAuthenticated) {
setInterrupted(false);
setRecovered(false);
return;
}
if (connectionStatus === 'reconnecting') {
setInterrupted(true);
setRecovered(false);
} else if (connectionStatus === 'connected' && interrupted && !recovered) {
setRecovered(true);
// Events missed while offline are gone, so pull the runtime state fresh.
void queryClient.invalidateQueries({ queryKey: RUNTIME_STATE_QUERY_KEY });
}
}, [isAuthenticated, connectionStatus, interrupted, recovered, queryClient]);

useEffect(() => {
if (!recovered) return;
const timer = setTimeout(() => {
setRecovered(false);
setInterrupted(false);
}, CONNECTED_MESSAGE_MS);
return () => clearTimeout(timer);
}, [recovered]);

const waiting = connectionStatus === 'reconnecting' && nextReconnectAt !== null;
useEffect(() => {
if (!waiting) return;
setNow(Date.now());
const tick = setInterval(() => setNow(Date.now()), 1000);
return () => clearInterval(tick);
}, [waiting, nextReconnectAt]);

if (!isAuthenticated) return null;

const showBanner = interrupted && (recovered || connectionStatus !== 'connected');
const seconds = waiting && nextReconnectAt !== null ? secondsUntil(nextReconnectAt, now) : 0;
const attemptInFlight = connectionStatus === 'connecting' || (waiting && seconds === 0);

// The live region stays mounted so screen readers pick up the text changes inside it.
return (
<div role="status" aria-live="polite" aria-atomic="true" className="pointer-events-none fixed bottom-4 left-1/2 z-50 -translate-x-1/2 px-4">
<AnimatePresence>
{showBanner && (
<motion.div
key="connection-banner"
initial={{ opacity: 0, y: 12 }}
animate={{ opacity: 1, y: 0 }}
exit={{ opacity: 0, y: 12 }}
transition={{ duration: 0.25 }}
className="pointer-events-auto flex items-center gap-3 rounded-xl border border-zinc-200 bg-white px-4 py-3 text-sm shadow-lg"
>
{recovered ? (
<p className="font-medium text-[#12B76A]">Connected!</p>
) : (
<>
<WifiOff className="h-4 w-4 shrink-0 text-amber-500" aria-hidden="true" />
<div className="text-zinc-700">
{connectionStatus === 'disconnected' ? (
<p>Live updates paused. We could not reach the server.</p>
) : (
<p>
Reconnecting to live server...
{waiting && !attemptInFlight && (
// Hidden from the live region so it does not announce every second.
<span aria-hidden="true"> Next attempt in {seconds}s</span>
)}
</p>
)}
</div>
<button
type="button"
onClick={reconnectNow}
disabled={attemptInFlight}
className="rounded-lg border border-zinc-200 px-3 py-1.5 font-medium text-zinc-700 transition-colors hover:bg-zinc-50 disabled:opacity-50"
>
Reconnect Now
</button>
</>
)}
</motion.div>
)}
</AnimatePresence>
</div>
);
}

export function RecoveryOverlay() {
return (
<>
<ConnectionRecoveryBanner />
<ComebackOverlay />
</>
);
}

function ComebackOverlay() {
const { eventHistory } = useSse();

// Filter for comeback messages
Expand Down
167 changes: 167 additions & 0 deletions frontend/src/features/realtime/__tests__/RecoveryOverlay.test.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,167 @@
import '@testing-library/jest-dom/vitest';
import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import type { ReactNode } from 'react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { useUserStore } from '../../../store/userStore';
import { ConnectionRecoveryBanner, RecoveryOverlay, secondsUntil } from '../RecoveryOverlay';

const sse = vi.hoisted(() => ({
state: {
connectionStatus: 'connected',
nextReconnectAt: null as number | null,
eventHistory: [] as unknown[],
},
reconnectNow: vi.fn(),
}));
vi.mock('../../../hooks/useSse', () => ({
useSse: () => sse.state,
reconnectNow: sse.reconnectNow,
}));
// Exit animations do not finish under fake timers, so render plain elements.
vi.mock('framer-motion', () => ({
AnimatePresence: ({ children }: { children: ReactNode }) => <>{children}</>,
motion: new Proxy({}, {
get: (_t, tag: string) =>
({ children, initial, animate, exit, transition, ...rest }: Record<string, unknown>) => {
void initial; void animate; void exit; void transition;
const Tag = tag as 'div';
return <Tag {...(rest as object)}>{children as ReactNode}</Tag>;
},
}),
}));

const queryClient = new QueryClient();
const invalidate = vi.spyOn(queryClient, 'invalidateQueries');

function ui() {
return (
<QueryClientProvider client={queryClient}>
<ConnectionRecoveryBanner />
</QueryClientProvider>
);
}

function setSse(connectionStatus: string, nextReconnectAt: number | null = null) {
sse.state.connectionStatus = connectionStatus;
sse.state.nextReconnectAt = nextReconnectAt;
}

describe('ConnectionRecoveryBanner', () => {
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
useUserStore.setState({ isAuthenticated: true });
setSse('connected');
sse.state.eventHistory = [];
sse.reconnectNow.mockClear();
invalidate.mockClear();
});
afterEach(() => {
cleanup();
vi.useRealTimers();
});

it('keeps an empty polite live region and no banner while connected', () => {
render(ui());
const region = screen.getByRole('status');
expect(region).toHaveAttribute('aria-live', 'polite');
expect(region).toBeEmptyDOMElement();
});

it('does not show a banner for the first connect after page load', () => {
setSse('connecting');
render(ui());
expect(screen.queryByText(/Reconnecting/)).toBeNull();
expect(screen.queryByRole('button', { name: 'Reconnect Now' })).toBeNull();
});

it('shows the reconnect message with a countdown that ticks down', () => {
setSse('reconnecting', Date.now() + 5_000);
render(ui());

expect(screen.getByRole('status')).toHaveTextContent('Reconnecting to live server...');
expect(screen.getByText('Next attempt in 5s')).toBeInTheDocument();

act(() => { vi.advanceTimersByTime(2_000); });
expect(screen.getByText('Next attempt in 3s')).toBeInTheDocument();
});

it('Reconnect Now calls reconnectNow', () => {
setSse('reconnecting', Date.now() + 9_000);
render(ui());
fireEvent.click(screen.getByRole('button', { name: 'Reconnect Now' }));
expect(sse.reconnectNow).toHaveBeenCalledTimes(1);
});

it('disables Reconnect Now while an attempt is already running', () => {
setSse('reconnecting', Date.now() + 9_000);
const view = render(ui());
setSse('connecting');
view.rerender(ui());
expect(screen.getByRole('button', { name: 'Reconnect Now' })).toBeDisabled();
expect(screen.queryByText(/Next attempt/)).toBeNull();
});

it('shows Connected! for 1.5s on recovery, refreshes runtime state, then goes away', () => {
setSse('reconnecting', Date.now() + 3_000);
const view = render(ui());
expect(invalidate).not.toHaveBeenCalled();

setSse('connected');
view.rerender(ui());
expect(screen.getByText('Connected!')).toBeInTheDocument();
expect(screen.queryByRole('button', { name: 'Reconnect Now' })).toBeNull();
expect(invalidate).toHaveBeenCalledTimes(1);
expect(invalidate).toHaveBeenCalledWith({ queryKey: ['runtime-state'] });

act(() => { vi.advanceTimersByTime(1_499); });
expect(screen.getByText('Connected!')).toBeInTheDocument();
act(() => { vi.advanceTimersByTime(1); });
expect(screen.queryByText('Connected!')).toBeNull();
expect(screen.getByRole('status')).toBeEmptyDOMElement();
expect(invalidate).toHaveBeenCalledTimes(1);
});

it('shows a paused state with Reconnect Now once the hook has given up', () => {
setSse('reconnecting', Date.now() + 3_000);
const view = render(ui());
setSse('disconnected');
view.rerender(ui());

expect(screen.getByText('Live updates paused. We could not reach the server.')).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Reconnect Now' }));
expect(sse.reconnectNow).toHaveBeenCalledTimes(1);
});

it('renders nothing for a signed out user', () => {
useUserStore.setState({ isAuthenticated: false });
setSse('reconnecting', Date.now() + 3_000);
const { container } = render(ui());
expect(container).toBeEmptyDOMElement();
});
});

describe('RecoveryOverlay', () => {
afterEach(cleanup);

it('still shows the comeback message next to the connection banner', () => {
useUserStore.setState({ isAuthenticated: true });
setSse('connected');
sse.state.eventHistory = [{
type: 'behavioral_message',
stats: { id: 'c1', tone: 'calm', text: 'Glad you are back', context: 'comeback', expiresAt: '2999-01-01T00:00:00Z' },
}];
render(<QueryClientProvider client={queryClient}><RecoveryOverlay /></QueryClientProvider>);
expect(screen.getByRole('dialog', { name: 'Welcome back' })).toBeInTheDocument();
expect(screen.getByText('Glad you are back')).toBeInTheDocument();
});
});

describe('secondsUntil', () => {
it('rounds up and never goes below zero', () => {
expect(secondsUntil(10_001, 10_000)).toBe(1);
expect(secondsUntil(12_000, 10_000)).toBe(2);
expect(secondsUntil(9_000, 10_000)).toBe(0);
});
});
Loading
Loading