From 629f1632b1f86625eb0fd979236dbdd4bdb08068 Mon Sep 17 00:00:00 2001 From: "shakespeare.diy" Date: Tue, 17 Feb 2026 23:16:16 -0600 Subject: [PATCH] Implement two-phase profile loading from agora - Add PROFILE_RELAYS constant with known reliable profile relays - Add parseAuthorEvent helper for consistent parsing - Fast path: pool races all relays with 500ms EOSE timeout - Slow path: race individual profile relays, resolve on first hit - useAuthors also gets fallback for missing pubkeys - Cache seeding continues to make individual useAuthor calls instant Co-authored-by: shakespeare.diy --- src/hooks/useAuthor.ts | 63 ++++++++++++++++++++++++++++------- src/hooks/useAuthors.ts | 73 ++++++++++++++++++++++++++--------------- 2 files changed, 99 insertions(+), 37 deletions(-) diff --git a/src/hooks/useAuthor.ts b/src/hooks/useAuthor.ts index 271d4c2b..110ce72e 100644 --- a/src/hooks/useAuthor.ts +++ b/src/hooks/useAuthor.ts @@ -2,6 +2,24 @@ import { type NostrEvent, type NostrMetadata, NSchema as n } from '@nostrify/nos import { useNostr } from '@nostrify/react'; import { useQuery } from '@tanstack/react-query'; +/** Profile relay URLs used as fallback when the pool's EOSE timeout returns empty. */ +export const PROFILE_RELAYS = [ + 'wss://relay.primal.net', + 'wss://relay.damus.io', + 'wss://relay.ditto.pub', + 'wss://ditto.pub/relay', +]; + +/** Parse a kind-0 event into metadata + event, or return just the event on parse failure. */ +export function parseAuthorEvent(event: NostrEvent): { event: NostrEvent; metadata?: NostrMetadata } { + try { + const metadata = n.json().pipe(n.metadata()).parse(event.content); + return { metadata, event }; + } catch { + return { event }; + } +} + export function useAuthor(pubkey: string | undefined) { const { nostr } = useNostr(); @@ -12,23 +30,46 @@ export function useAuthor(pubkey: string | undefined) { return {}; } + const combinedSignal = AbortSignal.any([signal, AbortSignal.timeout(5000)]); + + // Fast path: use the pool (races all relays, returns quickly via EOSE timeout) const [event] = await nostr.query( [{ kinds: [0], authors: [pubkey!], limit: 1 }], - { signal: AbortSignal.any([signal, AbortSignal.timeout(1500)]) }, + { signal: combinedSignal }, ); - if (!event) { - throw new Error('No event found'); + if (event) { + return parseAuthorEvent(event); } - try { - const metadata = n.json().pipe(n.metadata()).parse(event.content); - return { metadata, event }; - } catch { - return { event }; - } + // Slow path: pool returned empty (EOSE timeout may have cut off slower relays). + // Query each relay individually and resolve on first hit. + return new Promise<{ event?: NostrEvent; metadata?: NostrMetadata }>((resolve) => { + let settled = false; + let pending = PROFILE_RELAYS.length; + + for (const url of PROFILE_RELAYS) { + nostr.relay(url).query( + [{ kinds: [0], authors: [pubkey!], limit: 1 }], + { signal: combinedSignal }, + ).then((events) => { + if (settled) return; + if (events.length > 0) { + settled = true; + resolve(parseAuthorEvent(events[0])); + } else if (--pending === 0) { + resolve({}); + } + }).catch(() => { + if (settled) return; + if (--pending === 0) resolve({}); + }); + } + }); }, - staleTime: 5 * 60 * 1000, // Keep cached data fresh for 5 minutes - retry: 3, + staleTime: 5 * 60 * 1000, + gcTime: 10 * 60 * 1000, + retry: 1, + enabled: !!pubkey, }); } diff --git a/src/hooks/useAuthors.ts b/src/hooks/useAuthors.ts index 3105458e..d9319934 100644 --- a/src/hooks/useAuthors.ts +++ b/src/hooks/useAuthors.ts @@ -1,6 +1,7 @@ -import { type NostrEvent, type NostrMetadata, NSchema as n } from '@nostrify/nostrify'; +import { type NostrEvent, type NostrMetadata } from '@nostrify/nostrify'; import { useNostr } from '@nostrify/react'; import { useQuery, useQueryClient } from '@tanstack/react-query'; +import { parseAuthorEvent, PROFILE_RELAYS } from '@/hooks/useAuthor'; export interface AuthorData { pubkey: string; @@ -9,15 +10,13 @@ export interface AuthorData { } /** - * Batch-fetch multiple author profiles in a single relay query. - * - * Much more efficient than calling `useAuthor` once per pubkey — one - * round-trip instead of N. Results are also seeded into the individual - * `['author', pubkey]` cache entries so that later `useAuthor()` calls - * for the same pubkeys resolve instantly from cache. - * - * @param pubkeys - Array of hex pubkeys to fetch profiles for - * @returns React Query result with a Map + * Batch fetch multiple author profiles in a single query. + * More efficient than calling useAuthor for each pubkey individually. + * Results are also seeded into the individual ['author', pubkey] cache + * so that subsequent useAuthor() calls for the same pubkeys are instant. + * + * @param pubkeys - Array of pubkeys to fetch profiles for + * @returns Query result with map of pubkey -> AuthorData */ export function useAuthors(pubkeys: string[]) { const { nostr } = useNostr(); @@ -35,33 +34,55 @@ export function useAuthors(pubkeys: string[]) { const combinedSignal = AbortSignal.any([signal, AbortSignal.timeout(5000)]); + // Fast path: use the pool (races all relays, returns quickly via EOSE timeout) const events = await nostr.query( [{ kinds: [0], authors: uniquePubkeys, limit: uniquePubkeys.length }], { signal: combinedSignal }, ); const authorMap = new Map(); + const found = new Set(); - // Initialize every requested pubkey so callers always get an entry - for (const pk of uniquePubkeys) { - authorMap.set(pk, { pubkey: pk }); + // Initialize all pubkeys with empty data + for (const pubkey of uniquePubkeys) { + authorMap.set(pubkey, { pubkey }); } - // Process returned kind-0 events + // Process pool results for (const event of events) { - let metadata: NostrMetadata | undefined; - try { - metadata = n.json().pipe(n.metadata()).parse(event.content); - } catch { - // unparseable — leave metadata undefined - } + const parsed = parseAuthorEvent(event); + authorMap.set(event.pubkey, { pubkey: event.pubkey, ...parsed }); + queryClient.setQueryData(['author', event.pubkey], parsed); + found.add(event.pubkey); + } - const data: AuthorData = { pubkey: event.pubkey, event, metadata }; - authorMap.set(event.pubkey, data); + // Slow path: for any pubkeys not found by the pool, query relays individually. + const missing = uniquePubkeys.filter(pk => !found.has(pk)); + if (missing.length > 0) { + await new Promise((resolve) => { + const needed = new Set(missing); + let pending = PROFILE_RELAYS.length; - // Seed the individual `useAuthor(pubkey)` cache so it resolves - // instantly for any card that mounts later. - queryClient.setQueryData(['author', event.pubkey], { event, metadata }); + for (const url of PROFILE_RELAYS) { + nostr.relay(url).query( + [{ kinds: [0], authors: missing, limit: missing.length }], + { signal: combinedSignal }, + ).then((relayEvents) => { + for (const event of relayEvents) { + if (needed.has(event.pubkey)) { + const parsed = parseAuthorEvent(event); + authorMap.set(event.pubkey, { pubkey: event.pubkey, ...parsed }); + queryClient.setQueryData(['author', event.pubkey], parsed); + needed.delete(event.pubkey); + } + } + if (needed.size === 0) resolve(); + if (--pending === 0) resolve(); + }).catch(() => { + if (--pending === 0) resolve(); + }); + } + }); } return authorMap; @@ -71,4 +92,4 @@ export function useAuthors(pubkeys: string[]) { enabled: uniquePubkeys.length > 0, placeholderData: (prev) => prev, }); -} +} \ No newline at end of file