Files
otunes/apps/web/hooks/use-cached-query.ts
T

112 lines
3.4 KiB
TypeScript

"use client"
import {
usePaginatedQuery,
useQuery,
type OptionalRestArgsOrSkip,
type PaginatedQueryArgs,
type PaginatedQueryItem,
type PaginatedQueryReference,
} from "convex/react"
import type { FunctionReference } from "convex/server"
import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { queryCacheKey } from "@otunes/convex/client/cached-query"
import { readCache, subscribeCache, writeCache } from "@/lib/persistent-cache"
const MAX_CACHED_PAGINATED_ITEMS = 200
const MAX_RESTORED_PAGINATED_ITEMS = 1000
// Items loaded per paginated query this session, so a remount (e.g. back
// navigation) loads as much as before and scroll restoration can reach it.
const loadedItemCounts = new Map<string, number>()
const noopUnsubscribe = () => {}
function useCachedValue<T>(key: string | null) {
const subscribe = useCallback(
(listener: () => void) =>
key ? subscribeCache(key, listener) : noopUnsubscribe,
[key]
)
return useSyncExternalStore(
subscribe,
() => (key ? readCache<T>(key) : undefined),
() => undefined
)
}
/**
* `useQuery` that falls back to the last result persisted on this device while
* the live subscription is loading, so revisits render immediately.
*/
export function useCachedQuery<Query extends FunctionReference<"query">>(
query: Query,
...args: OptionalRestArgsOrSkip<Query>
): Query["_returnType"] | undefined {
const scope = useCacheScope()
const live = useQuery(query, ...args)
const queryArgs = args[0]
const key =
queryArgs === "skip"
? null
: queryCacheKey(
scope,
query,
(queryArgs ?? {}) as Record<string, unknown>
)
const cached = useCachedValue<Query["_returnType"]>(key)
useEffect(() => {
if (key && live !== undefined) {
writeCache(key, live)
}
}, [key, live])
return live !== undefined ? live : cached
}
/**
* `usePaginatedQuery` that shows the first persisted pages while the first live
* page loads. `isCached` is true while those persisted results are shown.
* Remounts start with as many items as were last loaded this session.
*/
export function useCachedPaginatedQuery<Query extends PaginatedQueryReference>(
query: Query,
args: PaginatedQueryArgs<Query> | "skip",
options: { initialNumItems: number }
) {
const scope = useCacheScope()
const key =
args === "skip"
? null
: `${queryCacheKey(scope, query, args as Record<string, unknown>)}:pages`
// Fixed per key: `usePaginatedQuery` restarts when this changes.
const initialNumItems = useMemo(
() =>
Math.max(
options.initialNumItems,
Math.min(
(key && loadedItemCounts.get(key)) || 0,
MAX_RESTORED_PAGINATED_ITEMS
)
),
[key, options.initialNumItems]
)
const result = usePaginatedQuery(query, args, { initialNumItems })
const cached = useCachedValue<PaginatedQueryItem<Query>[]>(key)
useEffect(() => {
if (key && result.status !== "LoadingFirstPage") {
loadedItemCounts.set(key, result.results.length)
writeCache(key, result.results.slice(0, MAX_CACHED_PAGINATED_ITEMS))
}
}, [key, result.status, result.results])
if (result.status === "LoadingFirstPage" && cached !== undefined) {
return { ...result, results: cached, isCached: true }
}
return { ...result, isCached: false }
}