src/lib/server/hf-bucket/ranking-cache.ts

import type { BucketDataState } from '$lib/types/bucket-state';
import type { RankingDataset } from '$lib/types/ranking-data';
import { adaptBucketRanking } from './adapt-ranking';
import { fetchBucketDetailsSnapshot } from './details-snapshot';
import { emptyRankingDataset } from './fallback-data';
import { toPublicBucketError } from './public-error';
import { fetchBucketRankingSnapshot } from './ranking-snapshot';

let cached: { value: RankingDataset; snapshotId: string } | undefined;
let inFlight: Promise<RankingDataset> | undefined;

async function refreshRanking() {
	const snapshot = await fetchBucketRankingSnapshot({ refreshManifest: true });
	if (cached?.snapshotId === snapshot.manifest.snapshot_id) {
		return cached.value;
	}

	const value = adaptBucketRanking(await fetchBucketDetailsSnapshot(snapshot));
	cached = {
		value,
		snapshotId: snapshot.manifest.snapshot_id
	};
	return value;
}

export async function getHfBucketRanking() {
	const state = await getHfBucketRankingState();
	if (state.status === 'unavailable') throw new Error(state.error.message);
	return state.data;
}

export async function getHfBucketRankingState(): Promise<BucketDataState<RankingDataset>> {
	if (!inFlight) {
		inFlight = refreshRanking().finally(() => {
			inFlight = undefined;
		});
	}

	try {
		return {
			status: 'ok',
			source: 'remote',
			data: await inFlight
		};
	} catch (error) {
		if (cached) {
			console.warn('[hf-bucket] Serving stale Ranking data after refresh failure.', error);
			return {
				status: 'stale',
				source: 'stale',
				data: cached.value,
				error: toPublicBucketError(error)
			};
		}
		console.error('[hf-bucket] Ranking data is unavailable.', error);
		return {
			status: 'unavailable',
			source: 'unavailable',
			data: emptyRankingDataset(),
			error: toPublicBucketError(error)
		};
	}
}