112 lines
3.4 KiB
TypeScript
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 }
|
|
}
|