Public Access
112 lines
4.6 KiB
JavaScript
112 lines
4.6 KiB
JavaScript
import {useCallback, useEffect, useRef, useState} from 'react';
|
|
import {apiFetch} from '../utils/api.js';
|
|
import {hasSession} from '../utils/auth.js';
|
|
|
|
const POLL_INTERVAL_MS = 3000;
|
|
const MAX_POLL_DURATION_MS = 120_000;
|
|
const INITIAL_SYNC_GRACE_MS = 15_000;
|
|
|
|
/**
|
|
* Polls /api/library/sync-status while a sync is running (or expected), and fires onComplete once when the run ends.
|
|
* A run that still runs after 2 minutes is shown as `stale` and polling stops. `watch()` polls again after the
|
|
* user started a sync: that run counts as ended when `lastSyncedAt` changes, also when no poll saw it running.
|
|
*
|
|
* @param {Object} opts
|
|
* @param {boolean} opts.enabled - skip work entirely when false (e.g. user has no steamId)
|
|
* @param {boolean} opts.expectInitialSync - if true and no row yet, keep polling (covers the
|
|
* gap between async sync dispatch and first DB write)
|
|
* @param {() => void} opts.onComplete - called once per run that ends
|
|
* @returns {{status: string|null, lastSyncedAt: string|null, isRunning: boolean, stale: boolean, error: string|null,
|
|
* watch: () => void}}
|
|
*/
|
|
export default function useLibrarySync({enabled, expectInitialSync = false, onComplete}) {
|
|
const [state, setState] = useState({status: null, lastSyncedAt: null, error: null, stale: false});
|
|
// count starts polling again; since is the last known end, so a new one shows that the started run is over
|
|
const [watched, setWatched] = useState({count: 0, since: undefined});
|
|
const lastSyncedAtRef = useRef(undefined);
|
|
// The count of the last watch whose run ended; a later restart of the polling must not report that run again.
|
|
const endedWatch = useRef(0);
|
|
const onCompleteRef = useRef(onComplete);
|
|
onCompleteRef.current = onComplete;
|
|
|
|
const watch = useCallback(() => {
|
|
setWatched((current) => ({count: current.count + 1, since: lastSyncedAtRef.current}));
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
if (!enabled) return undefined;
|
|
|
|
let cancelled = false;
|
|
let timer = null;
|
|
let wasRunning = false;
|
|
const startedAt = Date.now();
|
|
const watching = watched.count > endedWatch.current;
|
|
// Before the first answer the last end is unknown; then the first answer is the one to compare with.
|
|
let since = watched.since;
|
|
|
|
const fetchOnce = async () => {
|
|
if (!hasSession()) return;
|
|
|
|
try {
|
|
const response = await apiFetch(
|
|
`${import.meta.env.VITE_CORE_API_URL}/api/library/sync-status`
|
|
);
|
|
if (cancelled) return;
|
|
|
|
// The session is over; polling stops.
|
|
if (response.status === 401) return;
|
|
if (!response.ok) {
|
|
setState((s) => ({...s, error: 'sync-status fetch failed'}));
|
|
return;
|
|
}
|
|
|
|
const json = await response.json();
|
|
if (cancelled) return;
|
|
|
|
const status = json.lastSyncStatus;
|
|
const lastSyncedAt = json.lastSyncedAt;
|
|
lastSyncedAtRef.current = lastSyncedAt;
|
|
const isRunning = status === 'RUNNING';
|
|
const elapsed = Date.now() - startedAt;
|
|
const stale = isRunning && elapsed >= MAX_POLL_DURATION_MS;
|
|
setState({status, lastSyncedAt, error: null, stale});
|
|
|
|
if (since === undefined) since = lastSyncedAt;
|
|
const ended = !isRunning && (wasRunning || (watching && lastSyncedAt !== since));
|
|
if (ended) {
|
|
endedWatch.current = watched.count;
|
|
onCompleteRef.current?.();
|
|
return;
|
|
}
|
|
wasRunning = isRunning;
|
|
|
|
const waitingForInitial = expectInitialSync && status == null;
|
|
const waitingForStart = (watching || waitingForInitial) && elapsed < INITIAL_SYNC_GRACE_MS;
|
|
if ((isRunning && !stale) || waitingForStart) {
|
|
timer = setTimeout(fetchOnce, POLL_INTERVAL_MS);
|
|
}
|
|
} catch (err) {
|
|
if (cancelled) return;
|
|
console.error('sync-status poll error:', err);
|
|
setState((s) => ({...s, error: 'network'}));
|
|
}
|
|
};
|
|
|
|
fetchOnce();
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
if (timer) clearTimeout(timer);
|
|
};
|
|
}, [enabled, expectInitialSync, watched]);
|
|
|
|
return {
|
|
status: state.status,
|
|
lastSyncedAt: state.lastSyncedAt,
|
|
isRunning: state.status === 'RUNNING' && !state.stale,
|
|
stale: state.stale,
|
|
error: state.error,
|
|
watch,
|
|
};
|
|
}
|