Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(mobile): keep recent analytics and inbox available offline (#127543)

Chris Volzerf372195baacb
diff --git a/products/mobile/app/_layout.tsx b/products/mobile/app/_layout.tsx
index 716ac5c41d8b..7688c0e9fb5a 100644
--- a/products/mobile/app/_layout.tsx
+++ b/products/mobile/app/_layout.tsx
@@ -7,13 +7,13 @@ import { StyleSheet, View } from 'react-native'
import { GestureHandlerRootView } from 'react-native-gesture-handler'
import { KeyboardProvider } from 'react-native-keyboard-controller'
import { SafeAreaProvider } from 'react-native-safe-area-context'
-
import { queryClient } from '@/api/queryClient'
import { installAuthProvider, useAuthStore } from '@/auth/authStore'
import { BootSplash } from '@/auth/BootSplash'
import { SPLASH_TIMEOUT_MS, shouldHideSplash, useBootGate } from '@/auth/bootGate'
import { useAuthRedirect } from '@/auth/useAuthRedirect'
import { useDemoHydrated } from '@/demo/demoMode'
+import { installOfflineCache } from '@/features/offlineCache'
import '@/features/chat/draftPersistence'
import { AiApprovalDialog } from '@/features/ai/AiApprovalDialog'
import { useHedgehogWidgetSync } from '@/features/hedgehog/useHedgehogWidgetSync'
@@ -33,6 +33,7 @@ export { RouteErrorBoundary as ErrorBoundary }
SplashScreen.preventAutoHideAsync().catch(() => undefined)
SplashScreen.setOptions({ fade: true, duration: 250 })
installAuthProvider()
+installOfflineCache()
configureNotifications()
initAnalytics()
const bootStartedAt = Date.now()
diff --git a/products/mobile/docs/ARCHITECTURE.md b/products/mobile/docs/ARCHITECTURE.md
index 13790cb47b80..ad9db232f993 100644
--- a/products/mobile/docs/ARCHITECTURE.md
+++ b/products/mobile/docs/ARCHITECTURE.md
@@ -196,6 +196,28 @@ Details per domain: [DATA.md](DATA.md), [HANDOFF.md](HANDOFF.md), [CHAT.md](CHAT
- `usePushStore` (`src/features/notifications/pushStore.ts`, persisted): permission state and
the registered token.
+## Offline read cache
+
+`src/features/offlineCache.ts` scopes persistence to the verified account and project.
+`src/api/readCache.ts` restores and tracks eligible TanStack queries.
+`src/api/readCacheStore.ts` enforces limits and stores each entry through `src/lib/secureStorage.ts`.
+Native builds use SecureStore; the web preview uses memory.
+
+The allowlist covers aggregate Views and the first 20 Inbox rows, including signal counts.
+It excludes report bodies, transcripts, actor rows, searches, SQL results, and mutations.
+Inbox snapshots use a separate read-only query.
+
+- **Limits:** 24-hour TTL, 24 entries per project, 32 KiB per entry, 128 KiB per project, and eight projects per account.
+ Size limits measure UTF-8 JSON.
+- **Freshness:** Preserve successful capture times across failed refreshes, metadata updates, and pagination.
+ Query garbage collection leaves disk entries intact.
+- **Restoration:** Require the matching host, user, and project. Keep newer live data.
+ Retry failed reads before replacement saves resume.
+- **Access:** Evict denied data from its original project, including late responses after a project switch.
+ Missing Views scopes purge Views across the account. Sign-out clears the account cache.
+- **Storage:** Write only changed entries. Serialize operations per key and journal unfinished chunks until cleanup succeeds.
+ The adapter is shared with chat drafts; cache eviction preserves drafts.
+
## Module boundaries
- `app/` imports screens only.
diff --git a/products/mobile/src/api/readCache.test.ts b/products/mobile/src/api/readCache.test.ts
new file mode 100644
index 000000000000..d3106c206c37
--- /dev/null
+++ b/products/mobile/src/api/readCache.test.ts
@@ -0,0 +1,752 @@
+import { QueryClient } from '@tanstack/react-query'
+
+import type { StringStorage } from '@/lib/secureStorage'
+import { insightSnapshot } from '@/model/adapters/insightSnapshot'
+import { cacheable } from '@/model/adapters/readCache'
+import { webOverviewSnapshot } from '@/model/adapters/webOverview'
+import { ApiError } from './client'
+import { persistReadCache } from './readCache'
+import { inboxCacheKey } from './readCacheKeys'
+import { boundedEntries, cacheKey, READ_CACHE_TTL_MS, type ReadCacheScope, ReadCacheStore } from './readCacheStore'
+
+const scope: ReadCacheScope = { account: 'account-1', host: 'https://example.com', projectId: 1 }
+const key = ['views', scope.host, 1, 'insight', 'view-1', '-', '-']
+const aggregate = {
+ queryKind: 'TrendsQuery',
+ sqlTable: null,
+ value: 42,
+ readAt: 100,
+ lastRefreshAt: '2026-10-01T12:00:00Z',
+}
+
+function memoryStorage(): StringStorage {
+ const values = new Map<string, string>()
+ return {
+ getItem: async (name) => values.get(name) ?? null,
+ setItem: async (name, value) => {
+ values.set(name, value)
+ },
+ removeItem: async (name) => {
+ values.delete(name)
+ },
+ }
+}
+
+function client(): QueryClient {
+ return new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })
+}
+
+describe('bounded offline read cache', () => {
+ beforeEach(() => {
+ jest.useFakeTimers()
+ jest.setSystemTime(new Date('2026-10-01T13:00:00Z'))
+ })
+ afterEach(() => jest.useRealTimers())
+
+ it('restores supported aggregate data with its original age and excludes raw or unrelated queries', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const source = client()
+ const subscription = persistReadCache(source, store, scope, () => true)
+ await subscription.ready
+ const updatedAt = Date.now() - 60_000
+ source.setQueryData(key, aggregate, { updatedAt })
+ source.setQueryData(['views', scope.host, 1, 'actors', 'query'], [{ id: 'private-person' }])
+ source.setQueryData(['tasks', scope.host, 1, 'task', '1'], { transcript: 'Private message' })
+ source.setQueryData(['views', scope.host, 1, 'insight', 'sql', '-', '-'], {
+ queryKind: 'HogQLQuery',
+ sqlTable: { rows: [['private-person']] },
+ })
+ await subscription.flush()
+ await store.settled()
+ subscription.stop()
+ const restored = client()
+ const restarted = persistReadCache(restored, store, scope, () => true)
+ await restarted.ready
+ expect(restored.getQueryData(key)).toEqual({ ...aggregate, restoredFromDevice: true })
+ expect(restored.getQueryState(key)?.dataUpdatedAt).toBe(updatedAt)
+ expect(restored.getQueryCache().getAll()).toHaveLength(1)
+ restarted.stop()
+ })
+
+ test.each([401, 403, 404])('purges denied data on %s so the next restart cannot resurrect it', async (status) => {
+ const store = new ReadCacheStore(memoryStorage())
+ const otherRange = [...key.slice(0, -1), 'other-range']
+ await store.save(
+ scope,
+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),
+ () => true
+ )
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ expect(active.getQueryData(key)).toBeDefined()
+ await expect(
+ active.fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw new ApiError(status, {})
+ },
+ })
+ ).rejects.toBeInstanceOf(ApiError)
+ await store.settled()
+ expect(active.getQueryData(key)).toBeUndefined()
+ session.stop()
+ const next = client()
+ const restarted = persistReadCache(next, store, scope, () => true)
+ await restarted.ready
+ expect(next.getQueryData(key)).toBeUndefined()
+ expect(next.getQueryData(otherRange)).toBeUndefined()
+ restarted.stop()
+ })
+
+ it('drops the read-only inbox fallback after a live inbox denial', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const cached = inboxCacheKey(scope)
+ await store.save(
+ scope,
+ () => [{ key: cached, data: { items: [], sourceUpdatedAt: Date.now() }, updatedAt: Date.now() }],
+ () => true
+ )
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ await active
+ .fetchQuery({
+ queryKey: ['signals', scope.host, 1, 'inbox'],
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ })
+ .catch(() => undefined)
+ await store.settled()
+ session.stop()
+ const next = client()
+ const restarted = persistReadCache(next, store, scope, () => true)
+ await restarted.ready
+ expect(next.getQueryData(cached)).toBeUndefined()
+ restarted.stop()
+ })
+
+ it('does not let delayed hydration cross a scope switch or replace a newer response', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ await store.save(
+ scope,
+ () => [{ key, data: aggregate, updatedAt: Date.now() - 1000 }],
+ () => true
+ )
+ const read = storage.getItem
+ let finish!: () => void
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ storage.getItem = async (name) => {
+ await gate
+ return read(name)
+ }
+ let current = true
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => current)
+ current = false
+ finish()
+ await session.ready
+ expect(active.getQueryData(key)).toBeUndefined()
+ session.stop()
+ const newer = client()
+ newer.setQueryData(key, { ...aggregate, value: 99 }, { updatedAt: Date.now() })
+ const next = persistReadCache(newer, store, scope, () => true)
+ await next.ready
+ expect(newer.getQueryData(key)).toMatchObject({ value: 99 })
+ next.stop()
+ })
+
+ test.each(['timer', 'flush'] as const)(
+ 'retries failed hydration on %s before replacing saved entries',
+ async (retry) => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ const savedAt = Date.now() - 1000
+ await store.save(
+ scope,
+ () => [{ key, data: aggregate, updatedAt: savedAt }],
+ () => true
+ )
+ const read = storage.getItem
+ const original = await read(cacheKey(scope))
+ let unavailable = true
+ storage.getItem = async (name) => {
+ if (unavailable) throw new Error('Temporary read failure')
+ return read(name)
+ }
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ const newerKey = [...key.slice(0, 4), 'new-view', '-', '-']
+ active.setQueryData(newerKey, { ...aggregate, value: 99 })
+ await session.flush()
+ await jest.advanceTimersByTimeAsync(1000)
+ expect(await read(cacheKey(scope))).toBe(original)
+ unavailable = false
+ if (retry === 'timer') await jest.advanceTimersByTimeAsync(5000)
+ else await session.flush()
+ expect(active.getQueryData(key)).toMatchObject({ value: 42, restoredFromDevice: true })
+ expect(active.getQueryState(key)?.dataUpdatedAt).toBe(savedAt)
+ expect(active.getQueryData(newerKey)).toMatchObject({ value: 99 })
+ await session.flush()
+ expect(await store.load(scope)).toHaveLength(2)
+ session.stop()
+ }
+ )
+
+ it('clears every account project and pending writes on sign-out without touching another account', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const other = { ...scope, account: 'account-2' }
+ const entries = () => [{ key, data: aggregate, updatedAt: Date.now() }]
+ await store.save(scope, entries, () => true)
+ await store.save(
+ { ...scope, projectId: 2 },
+ () => [{ data: aggregate, updatedAt: Date.now(), key: ['views', scope.host, 2, 'web', '-'] }],
+ () => true
+ )
+ await store.save(other, entries, () => true)
+ const waiting = store.save(scope, entries, () => true)
+ const clearing = store.clearAccount(scope.account)
+ await Promise.all([waiting, clearing])
+ expect(await store.load(scope)).toEqual([])
+ expect(await store.load({ ...scope, projectId: 2 })).toEqual([])
+ expect(await store.load(other)).toHaveLength(1)
+ })
+
+ it('bounds age, count and encoded size and rejects host/project mismatches', async () => {
+ const now = Date.now()
+ const entries = Array.from({ length: 30 }, (_, index) => ({ key, updatedAt: now - index, data: aggregate }))
+ expect(boundedEntries(entries)).toHaveLength(24)
+ const beyondLimit = {
+ key,
+ updatedAt: now - 31,
+ data: {
+ toJSON: () => {
+ throw new Error('Outside the entry budget')
+ },
+ },
+ }
+ expect(() => boundedEntries([...entries, beyondLimit])).not.toThrow()
+ expect(boundedEntries([{ key, updatedAt: now - READ_CACHE_TTL_MS, data: aggregate }])).toEqual([])
+ expect(boundedEntries([{ key, updatedAt: now, data: '界'.repeat(20_000) }])).toEqual([])
+ const storage = memoryStorage()
+ await storage.setItem(
+ cacheKey(scope),
+ JSON.stringify([
+ { key: ['views', 'https://other.example.com', 1, 'web', '-'], updatedAt: now, data: aggregate },
+ ])
+ )
+ expect(await new ReadCacheStore(storage).load(scope)).toEqual([])
+ expect(cacheable(key, aggregate, { ...scope, projectId: 2 })).toBe(false)
+ })
+ it('purges a view denied during hydration and does not restore it on the next restart', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ await store.save(
+ scope,
+ () => [{ key, data: aggregate, updatedAt: Date.now() }],
+ () => true
+ )
+ const read = storage.getItem
+ let finish!: () => void
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ storage.getItem = async (name) => {
+ await gate
+ return read(name)
+ }
+ let blocked = false
+ const active = client()
+ const session = persistReadCache(
+ active,
+ store,
+ scope,
+ () => true,
+ () => blocked
+ )
+ blocked = true
+ session.purgeDeniedViews()
+ finish()
+ await session.ready
+ await session.flush()
+ await store.settled()
+ session.stop()
+ const next = client()
+ const reopened = persistReadCache(next, store, scope, () => true)
+ await reopened.ready
+ expect(next.getQueryData(key)).toBeUndefined()
+ reopened.stop()
+ })
+ it('coalesces read updates and strips nested dashboard response payloads', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ const dashboard = ['views', scope.host, 1, 'dashboard', '1', '-']
+ active.setQueryData(dashboard, {
+ view: {
+ id: 1,
+ name: 'Dashboard',
+ tiles: [
+ {
+ tileId: 1,
+ kind: 'insight',
+ shortId: 'view-1',
+ name: 'Count',
+ response: { persons: ['private-person-row'] },
+ query: { kind: 'HogQLQuery' },
+ },
+ ],
+ },
+ readAt: Date.now(),
+ refreshFailed: false,
+ })
+ active.setQueryData(key, { ...aggregate, value: 10, secretResponse: 'private-person-row' })
+ active.setQueryData(key, { ...aggregate, value: 20, secretResponse: 'private-person-row' })
+ expect(await storage.getItem(cacheKey(scope))).toBeNull()
+ await jest.advanceTimersByTimeAsync(500)
+ await store.settled()
+ const raw = await storage.getItem(cacheKey(scope))
+ expect(raw).not.toContain('private-person-row')
+ expect(raw).not.toContain('HogQLQuery')
+ expect((await store.load(scope)).find((entry) => entry.key[3] === 'insight')?.data).toMatchObject({ value: 20 })
+ session.stop()
+ })
+ it('does not renew the offline TTL when an attempted refresh only updates failure metadata', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ const savedAt = Date.now()
+ active.setQueryData(key, { ...aggregate, refreshFailed: false })
+ await session.flush()
+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS - 1000)
+ active.setQueryData(key, { ...aggregate, readAt: Date.now(), refreshFailed: true })
+ await session.flush()
+ expect((await store.load(scope))[0]?.updatedAt).toBe(savedAt)
+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS + 1000)
+ active.setQueryData(key, { ...aggregate, readAt: Date.now(), refreshFailed: true })
+ await session.flush()
+ expect(await store.load(scope)).toEqual([])
+ session.stop()
+ })
+
+ it('keeps a retained result age when a metadata-only insight or web read misses the server cache', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ const savedAt = Date.now()
+ const response = {
+ id: 1,
+ short_id: 'view-1',
+ name: 'Count',
+ derived_name: null,
+ query: {
+ kind: 'InsightVizNode',
+ source: { kind: 'TrendsQuery', series: [{ kind: 'EventsNode', event: 'example' }] },
+ },
+ result: [{ action: { order: 0 }, days: ['2026-10-01'], data: [42] }],
+ last_refresh: new Date(savedAt).toISOString(),
+ cache_target_age: null,
+ next_allowed_client_refresh: null,
+ }
+ const original = insightSnapshot(response, undefined, { readAt: savedAt, serverNow: savedAt })
+ const originalWeb = webOverviewSnapshot(
+ { results: [{ key: 'visitors', kind: 'unit', value: 42 }] },
+ undefined,
+ savedAt
+ )
+ const webKey = ['views', scope.host, 1, 'web', '-']
+ active.setQueryData(key, original)
+ active.setQueryData(webKey, originalWeb)
+ await session.flush()
+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS - 1000)
+ const miss = insightSnapshot({ ...response, result: null }, original, {
+ readAt: Date.now(),
+ serverNow: Date.now(),
+ })
+ active.setQueryData(key, miss)
+ active.setQueryData(webKey, webOverviewSnapshot({}, originalWeb, Date.now()))
+ await session.flush()
+ expect((await store.load(scope)).map((entry) => entry.updatedAt)).toEqual([savedAt, savedAt])
+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS + 1000)
+ active.setQueryData(
+ key,
+ insightSnapshot({ ...response, result: null }, miss, { readAt: Date.now(), serverNow: Date.now() })
+ )
+ active.setQueryData(webKey, webOverviewSnapshot({}, originalWeb, Date.now()))
+ await session.flush()
+ expect(await store.load(scope)).toEqual([])
+ session.stop()
+ })
+
+ test.each(['insight', 'web'] as const)(
+ 'restores %s results after a metadata-only read during hydration',
+ async (kind) => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ const savedAt = Date.now() - 1000
+ const response = {
+ id: 1,
+ short_id: 'view-1',
+ name: 'Saved name',
+ derived_name: null,
+ query: {
+ kind: 'InsightVizNode',
+ source: { kind: 'TrendsQuery', series: [{ kind: 'EventsNode', event: 'example' }] },
+ },
+ result: [{ action: { order: 0 }, days: ['2026-09-30'], data: [42], count: 42 }],
+ last_refresh: new Date(savedAt).toISOString(),
+ cache_target_age: null,
+ next_allowed_client_refresh: null,
+ }
+ const target = kind === 'insight' ? key : ['views', scope.host, 1, 'web', '-']
+ const original =
+ kind === 'insight'
+ ? insightSnapshot(response, undefined, { readAt: savedAt, serverNow: savedAt })
+ : webOverviewSnapshot(
+ { results: [{ key: 'visitors', kind: 'unit', value: 42 }] },
+ undefined,
+ savedAt
+ )
+ await store.save(
+ scope,
+ () => [{ key: target, data: original, updatedAt: savedAt }],
+ () => true
+ )
+ const read = storage.getItem
+ let finish!: () => void
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ storage.getItem = async (name) => {
+ await gate
+ return read(name)
+ }
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ const placeholder =
+ kind === 'insight'
+ ? insightSnapshot({ ...response, name: 'Current name', result: null }, undefined, {
+ readAt: Date.now(),
+ serverNow: Date.now(),
+ })
+ : webOverviewSnapshot({}, undefined, Date.now())
+ active.setQueryData(target, placeholder)
+ finish()
+ await session.ready
+ expect(active.getQueryData(target)).toMatchObject({
+ dataReadAt: savedAt,
+ readAt: Date.now(),
+ restoredFromDevice: true,
+ })
+ if (kind === 'insight')
+ expect(active.getQueryData(target)).toMatchObject({ value: 42, name: 'Current name' })
+ else
+ expect(active.getQueryData(target)).toMatchObject({
+ metrics: expect.arrayContaining([expect.objectContaining({ value: 42 })]),
+ })
+ await session.flush()
+ expect((await store.load(scope))[0]?.updatedAt).toBe(savedAt)
+ session.stop()
+ }
+ )
+
+ it('retains a hydrated inbox until its first visit after the normal query GC interval', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const inbox = inboxCacheKey(scope)
+ await store.save(
+ scope,
+ () => [
+ {
+ key: inbox,
+ data: { items: [], signalCounts: { report: 12 }, sourceUpdatedAt: Date.now() },
+ updatedAt: Date.now(),
+ },
+ ],
+ () => true
+ )
+ const active = new QueryClient({ defaultOptions: { queries: { gcTime: 5 * 60_000 } } })
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ await jest.advanceTimersByTimeAsync(6 * 60_000)
+ expect(active.getQueryData(inbox)).toMatchObject({ items: [], signalCounts: { report: 12 } })
+ session.stop()
+ active.clear()
+ })
+
+ it('bounds a full hydration batch without repeatedly serializing earlier entries', async () => {
+ const storage = memoryStorage()
+ const entries = Array.from({ length: 24 }, (_, index) => ({
+ key: [...key.slice(0, 4), String(index), '-', '-'],
+ data: { ...aggregate, value: String(index) },
+ updatedAt: Date.now(),
+ }))
+ await storage.setItem(cacheKey(scope), JSON.stringify(entries))
+ const stringify = jest.spyOn(JSON, 'stringify')
+ const active = client()
+ const session = persistReadCache(active, new ReadCacheStore(storage), scope, () => true)
+ await session.ready
+ const serializedEntries = stringify.mock.calls.filter(
+ ([value]) => typeof value === 'object' && value !== null && 'updatedAt' in value
+ ).length
+ stringify.mockRestore()
+ expect(serializedEntries).toBeLessThanOrEqual(entries.length * 2)
+ expect(active.getQueryCache().getAll()).toHaveLength(24)
+ session.stop()
+ })
+
+ it('writes only changed entries in a full project and removes all payloads on logout', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ const entries = Array.from({ length: 24 }, (_, index) => ({
+ key: [...key.slice(0, 4), String(index), '-', '-'],
+ data: { ...aggregate, series: 'x'.repeat(5000) },
+ updatedAt: Date.now(),
+ }))
+ const write = jest.spyOn(storage, 'setItem')
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ expect(await store.load(scope)).toHaveLength(24)
+ write.mockClear()
+ const changed = entries[0]
+ if (!changed) throw new Error('Missing full-cache fixture')
+ entries[0] = { ...changed, data: { ...changed.data, value: 43 } }
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ expect(write).toHaveBeenCalledTimes(1)
+ expect(write.mock.calls[0]?.[1].length).toBeLessThan(6000)
+ write.mockClear()
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ expect(write).not.toHaveBeenCalled()
+ await store.clearAccount(scope.account)
+ expect(await store.load(scope)).toEqual([])
+ for (let slot = 0; slot < 24; slot++)
+ expect(await storage.getItem(`${cacheKey(scope)}.entry.${slot}`)).toBeNull()
+ })
+
+ it('keeps disk copies after query garbage collection and still purges denied resource variants', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const otherRange = [...key.slice(0, -1), 'other-range']
+ await store.save(
+ scope,
+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),
+ () => true
+ )
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ active.removeQueries()
+ await session.flush()
+ expect(await store.load(scope)).toHaveLength(2)
+ await active
+ .fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ })
+ .catch(() => undefined)
+ await store.settled()
+ session.stop()
+ const next = client()
+ const restored = persistReadCache(next, store, scope, () => true)
+ await restored.ready
+ expect(next.getQueryData(key)).toBeUndefined()
+ expect(next.getQueryData(otherRange)).toBeUndefined()
+ restored.stop()
+ })
+
+ it('keeps at most eight recently saved projects without touching the draft namespace', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ await storage.setItem('mobile-drafts-example', 'Keep draft')
+ for (let projectId = 1; projectId <= 9; projectId++) {
+ const target = { ...scope, projectId }
+ await store.save(
+ target,
+ () => [
+ { key: ['views', scope.host, projectId, 'web', '-'], data: { metrics: [] }, updatedAt: Date.now() },
+ ],
+ () => true
+ )
+ }
+ expect(await store.load(scope)).toEqual([])
+ expect(await store.load({ ...scope, projectId: 9 })).toHaveLength(1)
+ expect(JSON.parse((await storage.getItem(`${scope.account}.scopes`)) ?? '[]')).toHaveLength(8)
+ expect(await storage.getItem('mobile-drafts-example')).toBe('Keep draft')
+ })
+ test.each([
+ { name: 'offline', error: new TypeError('Offline') },
+ { name: 'server error', error: new ApiError(500, {}) },
+ ])('keeps a saved value after transient refetch failure: $name', async ({ error }) => {
+ const store = new ReadCacheStore(memoryStorage())
+ const updatedAt = Date.now() - 60_000
+ await store.save(
+ scope,
+ () => [{ key, data: aggregate, updatedAt }],
+ () => true
+ )
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ await active
+ .fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw error
+ },
+ })
+ .catch(() => undefined)
+ expect(active.getQueryData(key)).toMatchObject({ value: 42 })
+ await session.flush()
+ session.stop()
+ const next = client()
+ const restored = persistReadCache(next, store, scope, () => true)
+ await restored.ready
+ expect(next.getQueryData(key)).toMatchObject({ value: 42 })
+ expect(next.getQueryState(key)?.dataUpdatedAt).toBe(updatedAt)
+ restored.stop()
+ })
+
+ it('respects a permission denial that arrived before the cache lifecycle started', async () => {
+ const store = new ReadCacheStore(memoryStorage())
+ const otherRange = [...key.slice(0, -1), 'other-range']
+ await store.save(
+ scope,
+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),
+ () => true
+ )
+ const active = client()
+ active.setQueryData(key, aggregate)
+ await active
+ .fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ })
+ .catch(() => undefined)
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ expect(active.getQueryData(otherRange)).toBeUndefined()
+ await session.flush()
+ session.stop()
+ const next = client()
+ const restored = persistReadCache(next, store, scope, () => true)
+ await restored.ready
+ expect(next.getQueryData(otherRange)).toBeUndefined()
+ restored.stop()
+ })
+
+ it('finishes denying an old project even when the active project changes during disk access', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ await store.save(
+ scope,
+ () => [{ key, data: aggregate, updatedAt: Date.now() }],
+ () => true
+ )
+ let current = true
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => current)
+ await session.ready
+ let started!: () => void
+ let finish!: () => void
+ const reading = new Promise<void>((resolve) => {
+ started = resolve
+ })
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ const read = storage.getItem
+ storage.getItem = async (name) => {
+ if (name === `${scope.account}.scopes` || name === cacheKey(scope)) {
+ started()
+ await gate
+ }
+ return read(name)
+ }
+ await active
+ .fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ })
+ .catch(() => undefined)
+ await reading
+ current = false
+ finish()
+ await store.settled()
+ session.stop()
+ const next = client()
+ const restored = persistReadCache(next, store, scope, () => true)
+ await restored.ready
+ expect(next.getQueryData(key)).toBeUndefined()
+ restored.stop()
+ })
+
+ it('does not resurrect denied data after an older device write finishes late', async () => {
+ const storage = memoryStorage()
+ const store = new ReadCacheStore(storage)
+ const active = client()
+ const session = persistReadCache(active, store, scope, () => true)
+ await session.ready
+ let started!: () => void
+ let finish!: () => void
+ const writing = new Promise<void>((resolve) => {
+ started = resolve
+ })
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ const write = storage.setItem
+ let delayed = false
+ storage.setItem = async (name, value) => {
+ if (name === cacheKey(scope) && !delayed) {
+ delayed = true
+ started()
+ await gate
+ }
+ await write(name, value)
+ }
+ active.setQueryData(key, aggregate)
+ const pending = session.flush()
+ await writing
+ await active
+ .fetchQuery({
+ queryKey: key,
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ })
+ .catch(() => undefined)
+ finish()
+ await pending
+ await store.settled()
+ session.stop()
+ const next = client()
+ const restored = persistReadCache(next, store, scope, () => true)
+ await restored.ready
+ expect(next.getQueryData(key)).toBeUndefined()
+ restored.stop()
+ })
+})
diff --git a/products/mobile/src/api/readCache.ts b/products/mobile/src/api/readCache.ts
new file mode 100644
index 000000000000..f0dd1d86104e
--- /dev/null
+++ b/products/mobile/src/api/readCache.ts
@@ -0,0 +1,251 @@
+import type { Query, QueryClient, QueryKey } from '@tanstack/react-query'
+import { asRecord } from '@/lib/records'
+import { cacheable, isReadCacheKey, projectedData } from '@/model/adapters/readCache'
+import { ApiError } from './client'
+import { inboxCacheKey } from './readCacheKeys'
+import { boundedEntries, type ReadCacheEntry, type ReadCacheScope, type ReadCacheStore } from './readCacheStore'
+
+export function deniedRead(error: unknown): boolean {
+ return error instanceof ApiError && [401, 403, 404].includes(error.status)
+}
+
+function keyId(key: QueryKey): string {
+ return JSON.stringify(key)
+}
+
+function resourceKey(key: QueryKey): string {
+ return keyId(key[0] === 'views' ? key.slice(0, key[3] === 'web' ? 4 : 5) : key)
+}
+
+export function persistReadCache(
+ client: QueryClient,
+ store: ReadCacheStore,
+ scope: ReadCacheScope,
+ current: () => boolean,
+ deniedView: (key: QueryKey) => boolean = () => false,
+ sameAccount: () => boolean = current
+): {
+ ready: Promise<void>
+ pause: () => void
+ stop: () => void
+ purgeDeniedViews: (keys?: readonly QueryKey[]) => void
+ flush: () => Promise<void>
+} {
+ // Saved inbox queries cannot refetch, so retain them before hydration creates inactive queries.
+ client.setQueryDefaults(['read-inbox'], { gcTime: Infinity })
+ let stopped = false
+ let loading = false
+ let hydrated = false
+ let retryTimer: ReturnType<typeof setTimeout> | undefined
+ let restoring = false
+ const denied = new Set<string>()
+ const deniedResources = new Set<string>()
+ const good = new Map<string, ReadCacheEntry>()
+ const valid = (): boolean => !stopped && current()
+ const keep = (candidates: readonly ReadCacheEntry[]): void => {
+ const entries = boundedEntries(candidates)
+ good.clear()
+ for (const saved of entries) good.set(keyId(saved.key), saved)
+ }
+ const remember = (key: QueryKey, data: unknown, updatedAt: number): void => {
+ if (!cacheable(key, data, scope)) {
+ good.delete(keyId(key))
+ return
+ }
+ const value = asRecord(data)
+ if (!value || value.refreshFailed === true) return
+ let capture = updatedAt
+ if (typeof value.dataReadAt === 'number') capture = value.dataReadAt
+ else if (value.restoredFromDevice === true) capture = good.get(keyId(key))?.updatedAt ?? updatedAt
+ if (capture <= 0) return
+ good.set(keyId(key), { key, data: projectedData(key, data), updatedAt: capture })
+ }
+ for (const query of client.getQueryCache().getAll()) {
+ remember(query.queryKey, query.state.data, query.state.dataUpdatedAt)
+ }
+ keep([...good.values()])
+ const collect = (): ReadCacheEntry[] =>
+ boundedEntries([...good.values()]).filter(
+ ({ key, data }) =>
+ !deniedRead(client.getQueryState(key)?.error) &&
+ !denied.has(keyId(key)) &&
+ !deniedResources.has(resourceKey(key)) &&
+ !deniedView(key) &&
+ cacheable(key, data, scope)
+ )
+ let timer: ReturnType<typeof setTimeout> | undefined
+ const flush = async (): Promise<void> => {
+ if (timer) clearTimeout(timer)
+ timer = undefined
+ if (!hydrated && valid()) await hydrate()
+ if (hydrated && valid()) await store.save(scope, collect, valid).catch(() => undefined)
+ }
+ const save = (): void => {
+ if (!hydrated || loading || !valid() || timer) return
+ timer = setTimeout(() => {
+ timer = undefined
+ void flush()
+ }, 500)
+ }
+ const clear = (key: QueryKey): void => {
+ denied.add(keyId(key))
+ good.delete(keyId(key))
+ const query = client.getQueryCache().find({ queryKey: key, exact: true })
+ if (query?.state.data !== undefined) query.setState({ data: undefined, dataUpdatedAt: 0 })
+ }
+ const clearResource = (key: QueryKey): void => {
+ deniedResources.add(resourceKey(key))
+ for (const saved of good.values()) {
+ if (resourceKey(saved.key) === resourceKey(key)) good.delete(keyId(saved.key))
+ }
+ for (const query of client.getQueryCache().getAll()) {
+ if (resourceKey(query.queryKey) === resourceKey(key)) clear(query.queryKey)
+ }
+ }
+ const isInboxSource = (key: QueryKey): boolean =>
+ key[0] === 'signals' && key[3] === 'inbox' && key[1] === scope.host && key[2] === scope.projectId
+ const denyQuery = (key: QueryKey): void => {
+ clearResource(key)
+ if (isInboxSource(key)) clear(inboxCacheKey(scope))
+ }
+ const evictDenied = (): Promise<void> => {
+ const resources = new Set(deniedResources)
+ const keys = new Set(denied)
+ return store
+ .evict(
+ scope,
+ (entry) => resources.has(resourceKey(entry.key)) || keys.has(keyId(entry.key)) || deniedView(entry.key)
+ )
+ .catch(() => undefined)
+ }
+ const onError = (query: Query): void => {
+ if (!deniedRead(query.state.error)) return
+ if (!isReadCacheKey(query.queryKey, scope) && !isInboxSource(query.queryKey)) return
+ denyQuery(query.queryKey)
+ // Leaving a project cancels saves, but its known-denied copies must still be removed.
+ void evictDenied()
+ }
+ const onSuccess = (query: Query): void => {
+ if (!isReadCacheKey(query.queryKey, scope)) return
+ denied.delete(keyId(query.queryKey))
+ remember(query.queryKey, query.state.data, query.state.dataUpdatedAt)
+ keep([...good.values()])
+ deniedResources.delete(resourceKey(query.queryKey))
+ save()
+ }
+ const unsubscribe = client.getQueryCache().subscribe((event) => {
+ if (restoring || event.type !== 'updated') return
+ if (sameAccount() && event.action.type === 'error') onError(event.query)
+ if (valid() && event.action.type === 'success') onSuccess(event.query)
+ })
+ for (const query of client.getQueryCache().getAll()) onError(query)
+ const purgeDeniedViews = (extraKeys: readonly QueryKey[] = []): void => {
+ if (!sameAccount()) return
+ let purged = false
+ const keys = [...good.values()]
+ .map((entry) => entry.key)
+ .concat(
+ extraKeys,
+ client
+ .getQueryCache()
+ .getAll()
+ .map((query) => query.queryKey)
+ )
+ for (const key of keys) {
+ if (isReadCacheKey(key, scope) && deniedView(key)) {
+ clearResource(key)
+ purged = true
+ }
+ }
+ if (purged) void evictDenied()
+ }
+ const mayRestore = (entry: ReadCacheEntry): boolean =>
+ cacheable(entry.key, entry.data, scope) &&
+ !denied.has(keyId(entry.key)) &&
+ !deniedResources.has(resourceKey(entry.key)) &&
+ !deniedView(entry.key)
+ const restore = (entry: ReadCacheEntry): void => {
+ if (!mayRestore(entry)) return
+ const state = client.getQueryState(entry.key)
+ const currentData = asRecord(state?.data)
+ const capturedAt =
+ typeof currentData?.dataReadAt === 'number' ? currentData.dataReadAt : (state?.dataUpdatedAt ?? 0)
+ if (deniedRead(state?.error) || capturedAt >= entry.updatedAt) return
+ const projected = projectedData(entry.key, entry.data)
+ const data =
+ entry.key[0] === 'views'
+ ? {
+ ...asRecord(projected),
+ ...(currentData && capturedAt === 0
+ ? Object.fromEntries(
+ [
+ 'readAt',
+ 'refreshFailed',
+ 'name',
+ 'description',
+ 'query',
+ 'savedRange',
+ 'usesOwnRange',
+ 'kindLabel',
+ 'createdBy',
+ 'createdAt',
+ ]
+ .filter((name) => name in currentData)
+ .map((name) => [name, currentData[name]])
+ )
+ : {}),
+ restoredFromDevice: true,
+ }
+ : projected
+ client.setQueryData(entry.key, data, { updatedAt: entry.updatedAt })
+ }
+ const hydrate = async (): Promise<void> => {
+ if (loading || hydrated || !valid()) return
+ if (retryTimer) clearTimeout(retryTimer)
+ retryTimer = undefined
+ loading = true
+ try {
+ const entries = await store.load(scope)
+ if (!valid()) return
+ restoring = true
+ for (const entry of entries) {
+ if (deniedView(entry.key)) deniedResources.add(resourceKey(entry.key))
+ }
+ const merged = new Map(good)
+ for (const entry of entries) {
+ if (!mayRestore(entry)) continue
+ const known = merged.get(keyId(entry.key))
+ if (!known || known.updatedAt < entry.updatedAt) merged.set(keyId(entry.key), entry)
+ }
+ keep([...merged.values()])
+ for (const entry of good.values()) restore(entry)
+ hydrated = true
+ } catch {
+ if (valid()) retryTimer = setTimeout(() => void hydrate(), 5000)
+ } finally {
+ restoring = false
+ loading = false
+ if (hydrated) {
+ if (valid() && (denied.size || deniedResources.size)) await evictDenied()
+ else save()
+ }
+ }
+ }
+ const ready = hydrate()
+ const pause = (): void => {
+ stopped = true
+ good.clear()
+ if (timer) clearTimeout(timer)
+ if (retryTimer) clearTimeout(retryTimer)
+ }
+ return {
+ ready,
+ pause,
+ purgeDeniedViews,
+ flush,
+ stop: () => {
+ pause()
+ unsubscribe()
+ },
+ }
+}
diff --git a/products/mobile/src/api/readCacheKeys.ts b/products/mobile/src/api/readCacheKeys.ts
new file mode 100644
index 000000000000..27806c385e18
--- /dev/null
+++ b/products/mobile/src/api/readCacheKeys.ts
@@ -0,0 +1,12 @@
+import type { InboxItem } from '@/model/types'
+import type { ProjectScope } from './reports'
+
+export interface SavedInbox {
+ items: InboxItem[]
+ signalCounts?: Record<string, number>
+ sourceUpdatedAt: number
+}
+
+export function inboxCacheKey(scope: ProjectScope | null): readonly unknown[] {
+ return ['read-inbox', scope?.host ?? 'none', scope?.projectId ?? null]
+}
diff --git a/products/mobile/src/api/readCacheStore.native.test.ts b/products/mobile/src/api/readCacheStore.native.test.ts
new file mode 100644
index 000000000000..e1196784d934
--- /dev/null
+++ b/products/mobile/src/api/readCacheStore.native.test.ts
@@ -0,0 +1,167 @@
+import { QueryClient } from '@tanstack/react-query'
+import * as SecureStore from 'expo-secure-store'
+import { Platform } from 'react-native'
+import { secureStorage } from '@/lib/secureStorage'
+import { persistReadCache } from './readCache'
+import { ReadCacheStore } from './readCacheStore'
+
+const mockValues = new Map<string, string>()
+let mockRevision = 0
+jest.mock('expo-crypto', () => ({ randomUUID: () => `revision-${mockRevision++}` }))
+jest.mock('expo-secure-store', () => ({
+ getItemAsync: jest.fn(async (key: string) => mockValues.get(key) ?? null),
+ setItemAsync: jest.fn(async (key: string, value: string) => {
+ mockValues.set(key, value)
+ }),
+ deleteItemAsync: jest.fn(async (key: string) => {
+ mockValues.delete(key)
+ }),
+}))
+
+describe('encrypted read cache native storage work', () => {
+ beforeEach(() => {
+ jest.useFakeTimers()
+ mockValues.clear()
+ jest.mocked(SecureStore.getItemAsync).mockImplementation(async (key) => mockValues.get(key) ?? null)
+ jest.mocked(SecureStore.setItemAsync).mockImplementation(async (key, value) => {
+ mockValues.set(key, value)
+ })
+ jest.mocked(SecureStore.deleteItemAsync).mockImplementation(async (key) => {
+ mockValues.delete(key)
+ })
+ jest.replaceProperty(Platform, 'OS', 'android')
+ })
+ afterEach(() => {
+ jest.restoreAllMocks()
+ jest.useRealTimers()
+ })
+
+ test.each(['chunk', 'manifest'] as const)(
+ 'propagates a temporary %s read failure without erasing saved data',
+ async (part) => {
+ const scope = { account: 'example-account', host: 'https://example.com', projectId: 1 }
+ const key = ['views', scope.host, 1, 'web', '-']
+ const store = new ReadCacheStore(secureStorage)
+ await store.save(
+ scope,
+ () => [{ key, updatedAt: Date.now(), data: { metrics: [], readAt: Date.now() } }],
+ () => true
+ )
+ const saved = new Map(mockValues)
+ const read = jest.mocked(SecureStore.getItemAsync)
+ const original = read.getMockImplementation()
+ if (!original) throw new Error('Missing native read mock')
+ read.mockImplementation(async (name, options) => {
+ if (part === 'manifest' ? name === `${scope.account}.1` : /revision-.*\.0$/.test(name))
+ throw new Error('Temporary read failure')
+ return original(name, options)
+ })
+ const client = new QueryClient({ defaultOptions: { queries: { gcTime: Infinity } } })
+ const session = persistReadCache(client, store, scope, () => true)
+ await session.ready
+ await session.flush()
+ expect(mockValues).toEqual(saved)
+ read.mockImplementation(original)
+ await session.flush()
+ expect(client.getQueryData(key)).toMatchObject({ metrics: [], restoredFromDevice: true })
+ session.stop()
+ client.clear()
+ }
+ )
+
+ test.each(['chunk', 'manifest', 'cleanup', 'remove'] as const)(
+ 'recovers all chunks after interruption during %s',
+ async (stage) => {
+ const key = 'example-value'
+ const oldValue = 'a'.repeat(1200)
+ const nextValue = 'b'.repeat(1200)
+ await secureStorage.setItem(key, oldValue)
+ const set = jest.mocked(SecureStore.setItemAsync)
+ const remove = jest.mocked(SecureStore.deleteItemAsync)
+ const read = jest.mocked(SecureStore.getItemAsync)
+ const originalSet = set.getMockImplementation()
+ const originalRemove = remove.getMockImplementation()
+ const originalRead = read.getMockImplementation()
+ if (!originalSet || !originalRemove || !originalRead) throw new Error('Missing native storage mock')
+ let interrupted = false
+ const fail = (): never => {
+ interrupted = true
+ throw new Error('Storage interrupted')
+ }
+ read.mockImplementation(async (name, options) => {
+ if (interrupted) fail()
+ return originalRead(name, options)
+ })
+ set.mockImplementation(async (name, value, options) => {
+ if (interrupted) fail()
+ await originalSet(name, value, options)
+ if ((stage === 'chunk' && name.endsWith('.0')) || (stage === 'manifest' && name === key)) fail()
+ })
+ remove.mockImplementation(async (name, options) => {
+ if (interrupted) fail()
+ if (stage === 'cleanup' && name.endsWith('.0')) fail()
+ await originalRemove(name, options)
+ if (stage === 'remove' && name === key) fail()
+ })
+ const work = stage === 'remove' ? secureStorage.removeItem(key) : secureStorage.setItem(key, nextValue)
+ await expect(work).rejects.toThrow('Storage interrupted')
+ read.mockImplementation(originalRead)
+ set.mockImplementation(originalSet)
+ remove.mockImplementation(originalRemove)
+ const expected = stage === 'remove' ? null : stage === 'chunk' ? oldValue : nextValue
+ expect(await secureStorage.getItem(key)).toBe(expected)
+ expect(mockValues.has(`${key}.revisions`)).toBe(false)
+ const current = JSON.parse(mockValues.get(key) ?? 'null')
+ expect([...mockValues.keys()].sort()).toEqual(
+ current
+ ? [
+ key,
+ ...Array.from({ length: current.count }, (_, i) => `${key}.${current.revision}.${i}`),
+ ].sort()
+ : []
+ )
+ await secureStorage.removeItem(key)
+ expect(mockValues.size).toBe(0)
+ }
+ )
+
+ it('limits a full-cache refresh to changed chunks and clears the account on logout', async () => {
+ jest.replaceProperty(Platform, 'OS', 'android')
+ const scope = { account: 'example-account', host: 'https://example.com', projectId: 1 }
+ const store = new ReadCacheStore(secureStorage)
+ const entries = Array.from({ length: 24 }, (_, index) => ({
+ key: ['views', scope.host, 1, 'insight', String(index), '-', '-'],
+ updatedAt: Date.now(),
+ data: { series: 'x'.repeat(5000), value: 42 },
+ }))
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ jest.mocked(SecureStore.setItemAsync).mockClear()
+ jest.mocked(SecureStore.deleteItemAsync).mockClear()
+ const first = entries[0]
+ if (!first) throw new Error('Missing full-cache fixture')
+ entries[0] = { ...first, data: { ...first.data, value: 43 } }
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ expect(jest.mocked(SecureStore.setItemAsync).mock.calls.length).toBeLessThan(16)
+ expect(jest.mocked(SecureStore.deleteItemAsync).mock.calls.length).toBeLessThan(16)
+ expect(await store.load(scope)).toHaveLength(24)
+ jest.mocked(SecureStore.setItemAsync).mockClear()
+ jest.mocked(SecureStore.deleteItemAsync).mockClear()
+ await store.save(
+ scope,
+ () => entries,
+ () => true
+ )
+ expect(SecureStore.setItemAsync).not.toHaveBeenCalled()
+ expect(SecureStore.deleteItemAsync).not.toHaveBeenCalled()
+ await store.clearAccount(scope.account)
+ expect(mockValues.size).toBe(0)
+ })
+})
diff --git a/products/mobile/src/api/readCacheStore.ts b/products/mobile/src/api/readCacheStore.ts
new file mode 100644
index 000000000000..f31e08f08b03
--- /dev/null
+++ b/products/mobile/src/api/readCacheStore.ts
@@ -0,0 +1,237 @@
+import type { QueryKey } from '@tanstack/react-query'
+import { asRecord } from '@/lib/records'
+import type { StringStorage } from '@/lib/secureStorage'
+
+export const READ_CACHE_TTL_MS = 24 * 60 * 60_000
+export const READ_CACHE_ENTRY_LIMIT = 24
+export const READ_CACHE_PROJECT_LIMIT = 8
+export const READ_CACHE_ENTRY_BYTES = 32 * 1024
+export const READ_CACHE_BYTES = 128 * 1024
+
+export interface ReadCacheScope {
+ account: string
+ host: string
+ projectId: number
+}
+
+export interface ReadCacheEntry {
+ key: QueryKey
+ updatedAt: number
+ data: unknown
+}
+
+export function cacheKey(scope: ReadCacheScope): string {
+ return `${scope.account}.${scope.projectId}`
+}
+
+export function boundedEntries(entries: readonly ReadCacheEntry[], now = Date.now()): ReadCacheEntry[] {
+ let bytes = 2
+ const saved: ReadCacheEntry[] = []
+ for (const entry of [...entries].sort((a, b) => b.updatedAt - a.updatedAt)) {
+ if (saved.length >= READ_CACHE_ENTRY_LIMIT) break
+ if (!Number.isFinite(entry.updatedAt) || entry.updatedAt > now || now - entry.updatedAt >= READ_CACHE_TTL_MS)
+ continue
+ const size = Array.from(JSON.stringify(entry)).reduce(
+ (total, character) => {
+ const code = character.codePointAt(0) ?? 0
+ return total + (code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4)
+ },
+ saved.length ? 1 : 0
+ )
+ if (size > READ_CACHE_ENTRY_BYTES || bytes + size > READ_CACHE_BYTES) continue
+ bytes += size
+ saved.push(entry)
+ }
+ return saved
+}
+
+export class ReadCacheStore {
+ private writes: Promise<unknown> = Promise.resolve()
+ private generation = 0
+
+ constructor(private readonly storage: StringStorage) {}
+
+ private enqueue<T>(work: () => Promise<T>): Promise<T> {
+ const result = this.writes.then(work)
+ this.writes = result.catch(() => undefined)
+ return result
+ }
+
+ private async bundle(scope: ReadCacheScope): Promise<{ slots: number[]; entries: (ReadCacheEntry | null)[] }> {
+ const key = cacheKey(scope)
+ const raw = await this.storage.getItem(key)
+ let value: unknown
+ try {
+ value = raw ? JSON.parse(raw) : []
+ } catch {
+ value = []
+ }
+ const slots =
+ value && typeof value === 'object' && 'slots' in value && Array.isArray(value.slots)
+ ? value.slots.filter(
+ (slot): slot is number => Number.isInteger(slot) && slot >= 0 && slot < READ_CACHE_ENTRY_LIMIT
+ )
+ : []
+ const entries: unknown[] = Array.isArray(value)
+ ? value
+ : await Promise.all(
+ slots.map(async (slot) => {
+ const entry = await this.storage.getItem(`${key}.entry.${slot}`)
+ try {
+ return entry ? JSON.parse(entry) : null
+ } catch {
+ return null
+ }
+ })
+ )
+ return {
+ slots,
+ entries: entries.map((entry): ReadCacheEntry | null => {
+ const record = asRecord(entry)
+ return record &&
+ Array.isArray(record.key) &&
+ typeof record.updatedAt === 'number' &&
+ record.key[1] === scope.host &&
+ record.key[2] === scope.projectId
+ ? { key: record.key, updatedAt: record.updatedAt, data: record.data }
+ : null
+ }),
+ }
+ }
+
+ private async read(scope: ReadCacheScope): Promise<ReadCacheEntry[]> {
+ return boundedEntries(
+ (await this.bundle(scope)).entries.filter((entry): entry is ReadCacheEntry => entry !== null)
+ )
+ }
+
+ private async remove(key: string): Promise<void> {
+ const raw = await this.storage.getItem(key)
+ let value: unknown
+ try {
+ value = raw ? JSON.parse(raw) : null
+ } catch {
+ value = null
+ }
+ if (value && typeof value === 'object' && 'slots' in value && Array.isArray(value.slots)) {
+ await Promise.all(
+ value.slots
+ .filter(
+ (slot): slot is number => Number.isInteger(slot) && slot >= 0 && slot < READ_CACHE_ENTRY_LIMIT
+ )
+ .map((slot) => this.storage.removeItem(`${key}.entry.${slot}`))
+ )
+ }
+ await this.storage.removeItem(key)
+ }
+
+ private serialize(entry: ReadCacheEntry | null): string {
+ return JSON.stringify(entry && { key: entry.key, updatedAt: entry.updatedAt, data: entry.data })
+ }
+
+ private async write(scope: ReadCacheScope, entries: ReadCacheEntry[]): Promise<void> {
+ const key = cacheKey(scope)
+ const previous = await this.bundle(scope)
+ const remaining = new Set(previous.slots)
+ const contents = new Map(previous.entries.map((entry, index) => [this.serialize(entry), previous.slots[index]]))
+ const slots = entries.map((entry) => {
+ const slot = contents.get(this.serialize(entry))
+ if (slot !== undefined) remaining.delete(slot)
+ return slot
+ })
+ for (const [index, entry] of entries.entries()) {
+ if (slots[index] !== undefined) continue
+ const slot = Array.from({ length: READ_CACHE_ENTRY_LIMIT }, (_, candidate) => candidate).find(
+ (candidate) => !slots.includes(candidate)
+ )
+ if (slot === undefined) continue
+ slots[index] = slot
+ remaining.delete(slot)
+ await this.storage.setItem(`${key}.entry.${slot}`, this.serialize(entry))
+ }
+ const manifest = JSON.stringify({ slots })
+ if (manifest !== JSON.stringify({ slots: previous.slots }) || !previous.slots.length) {
+ await this.storage.setItem(key, manifest)
+ }
+ await Promise.all([...remaining].map((slot) => this.storage.removeItem(`${key}.entry.${slot}`)))
+ }
+
+ load(scope: ReadCacheScope): Promise<ReadCacheEntry[]> {
+ return this.enqueue(() => this.read(scope))
+ }
+
+ evict(scope: ReadCacheScope, rejected: (entry: ReadCacheEntry) => boolean): Promise<void> {
+ const generation = this.generation
+ return this.enqueue(async () => {
+ if (generation !== this.generation) return
+ const remaining = (await this.read(scope)).filter((entry) => !rejected(entry))
+ if (generation !== this.generation) return
+ if (remaining.length) await this.write(scope, remaining)
+ else await this.remove(cacheKey(scope))
+ })
+ }
+
+ evictAccountViews(account: string, host: string): Promise<void> {
+ const generation = this.generation
+ return this.enqueue(async () => {
+ const raw = await this.storage.getItem(`${account}.scopes`)
+ const keys: unknown = raw ? JSON.parse(raw) : []
+ if (!Array.isArray(keys)) return
+ for (const key of keys) {
+ if (generation !== this.generation) return
+ if (typeof key !== 'string' || !key.startsWith(`${account}.`)) continue
+ const projectId = Number(key.slice(account.length + 1))
+ if (!Number.isSafeInteger(projectId) || projectId <= 0) continue
+ const scope = { account, host, projectId }
+ const remaining = (await this.read(scope)).filter((entry) => entry.key[0] !== 'views')
+ if (generation !== this.generation) return
+ if (remaining.length) await this.write(scope, remaining)
+ else await this.remove(key)
+ }
+ })
+ }
+
+ save(scope: ReadCacheScope, entries: () => ReadCacheEntry[], current: () => boolean): Promise<void> {
+ const generation = this.generation
+ return this.enqueue(async () => {
+ if (generation !== this.generation || !current()) return
+ const index = `${scope.account}.scopes`
+ const raw = await this.storage.getItem(index)
+ const parsed: unknown = raw ? JSON.parse(raw) : []
+ const scopes = Array.isArray(parsed)
+ ? parsed.filter(
+ (key): key is string =>
+ typeof key === 'string' && key.startsWith(`${scope.account}.`) && key !== index
+ )
+ : []
+ const key = cacheKey(scope)
+ const order = [...scopes.filter((saved) => saved !== key), key]
+ if (JSON.stringify(order) !== raw) await this.storage.setItem(index, JSON.stringify(order))
+ await Promise.all(order.slice(0, -READ_CACHE_PROJECT_LIMIT).map((stale) => this.remove(stale)))
+ if (order.length > READ_CACHE_PROJECT_LIMIT)
+ await this.storage.setItem(index, JSON.stringify(order.slice(-READ_CACHE_PROJECT_LIMIT)))
+ if (generation !== this.generation || !current()) return
+ await this.write(scope, boundedEntries(entries()))
+ })
+ }
+
+ clearAccount(account: string): Promise<void> {
+ this.generation++
+ return this.enqueue(async () => {
+ const index = `${account}.scopes`
+ const raw = await this.storage.getItem(index)
+ const parsed: unknown = raw ? JSON.parse(raw) : []
+ const keys = Array.isArray(parsed)
+ ? parsed.filter(
+ (key): key is string => typeof key === 'string' && key.startsWith(`${account}.`) && key !== index
+ )
+ : []
+ await Promise.all(keys.map((key) => this.remove(key)))
+ await this.storage.removeItem(index)
+ })
+ }
+
+ settled(): Promise<unknown> {
+ return this.writes
+ }
+}
diff --git a/products/mobile/src/auth/BootSplash.test.tsx b/products/mobile/src/auth/BootSplash.test.tsx
index 42096bfe9c88..5a090b3f3e22 100644
--- a/products/mobile/src/auth/BootSplash.test.tsx
+++ b/products/mobile/src/auth/BootSplash.test.tsx
@@ -43,6 +43,7 @@ jest.mock('@/ui/appearanceStore', () => ({
jest.mock('@/features/ai/AiApprovalDialog', () => ({ AiApprovalDialog: () => null }))
jest.mock('@/features/updates/useAutomaticUpdates', () => ({ useAutomaticUpdates: jest.fn() }))
jest.mock('@/features/chat/draftPersistence', () => ({}))
+jest.mock('@/features/offlineCache', () => ({ installOfflineCache: jest.fn() }))
jest.mock('@/features/hedgehog/useHedgehogWidgetSync', () => ({ useHedgehogWidgetSync: jest.fn() }))
jest.mock('@/features/notifications/pushRegistration', () => ({ configureNotifications: jest.fn() }))
jest.mock('@/features/notifications/useNotificationRouting', () => ({ useNotificationRouting: jest.fn() }))
diff --git a/products/mobile/src/auth/offlineSessionRestore.test.ts b/products/mobile/src/auth/offlineSessionRestore.test.ts
new file mode 100644
index 000000000000..08b534b48b0d
--- /dev/null
+++ b/products/mobile/src/auth/offlineSessionRestore.test.ts
@@ -0,0 +1,66 @@
+import { installAuthProvider, useAuthStore } from './authStore'
+import { saveTokens, setSessionTokens } from './tokens'
+
+jest.mock('@react-native-async-storage/async-storage', () =>
+ require('@react-native-async-storage/async-storage/jest/async-storage-mock')
+)
+jest.mock('expo-secure-store', () => {
+ const values = new Map<string, string>()
+ return {
+ getItemAsync: async (key: string) => values.get(key) ?? null,
+ setItemAsync: async (key: string, value: string) => {
+ values.set(key, value)
+ },
+ deleteItemAsync: async (key: string) => {
+ values.delete(key)
+ },
+ }
+})
+
+describe('offline session restoration', () => {
+ it('keeps an existing verified owner and selected project when refresh and account reads are offline', async () => {
+ await useAuthStore.persist.rehydrate()
+ const host = 'https://example.com'
+ await saveTokens(
+ {
+ kind: 'oauth',
+ accessToken: 'example-access',
+ refreshToken: 'example-refresh',
+ expiresAt: 0,
+ grantedScopes: null,
+ requestedScopes: null,
+ },
+ { host, clientId: 'example-client', method: 'oauth', userUuid: 'example-user' }
+ )
+ useAuthStore.setState({
+ status: 'loading',
+ signedIn: false,
+ clientId: 'example-client',
+ method: 'oauth',
+ host,
+ user: { uuid: 'example-user', distinctId: 'example-user', email: '[email protected]', name: 'Example' },
+ projectId: 1,
+ projects: [
+ {
+ id: 1,
+ name: 'Example project',
+ organizationId: 'example-org',
+ organizationName: 'Example organization',
+ },
+ ],
+ })
+ setSessionTokens(null)
+ globalThis.fetch = jest.fn(async () => {
+ throw new TypeError('Offline')
+ }) as typeof fetch
+ installAuthProvider()
+ await useAuthStore.getState().restore()
+ expect(useAuthStore.getState()).toMatchObject({
+ status: 'signed_in',
+ signedIn: true,
+ host,
+ user: { uuid: 'example-user' },
+ projectId: 1,
+ })
+ })
+})
diff --git a/products/mobile/src/features/chat/draftPersistence.ts b/products/mobile/src/features/chat/draftPersistence.ts
index a5d723a6fbb1..fc720b9829cd 100644
--- a/products/mobile/src/features/chat/draftPersistence.ts
+++ b/products/mobile/src/features/chat/draftPersistence.ts
@@ -1,107 +1,11 @@
import * as Crypto from 'expo-crypto'
-import * as SecureStore from 'expo-secure-store'
-import { Platform } from 'react-native'
import { addSessionEndTask, useAuthStore } from '@/auth/authStore'
import { getSessionTokens } from '@/auth/tokens'
-import { type DraftStorage, DraftStore } from './draftStore'
+import { secureStorage as storage } from '@/lib/secureStorage'
-const webMemory = new Map<string, string>()
-const itemStorage: DraftStorage = {
- getItem: (key) =>
- Platform.OS === 'web' ? Promise.resolve(webMemory.get(key) ?? null) : SecureStore.getItemAsync(key),
- setItem: async (key, value) => {
- if (Platform.OS === 'web') {
- webMemory.set(key, value)
- } else {
- await SecureStore.setItemAsync(key, value)
- }
- },
- removeItem: async (key) => {
- if (Platform.OS === 'web') {
- webMemory.delete(key)
- } else {
- await SecureStore.deleteItemAsync(key)
- }
- },
-}
-
-interface Manifest {
- revision: string
- count: number
-}
-
-async function manifest(key: string): Promise<Manifest | null> {
- const stored = await itemStorage.getItem(key)
- try {
- const value: unknown = JSON.parse(stored ?? 'null')
- if (value && typeof value === 'object') {
- const record = value as Record<string, unknown>
- if (
- typeof record.revision === 'string' &&
- typeof record.count === 'number' &&
- Number.isSafeInteger(record.count) &&
- record.count > 0 &&
- record.count <= 10000
- ) {
- return { revision: record.revision, count: record.count }
- }
- }
- } catch {}
- return null
-}
-
-async function removeChunks(key: string, saved: Manifest | null): Promise<void> {
- if (saved) {
- await Promise.all(
- Array.from({ length: saved.count }, (_, index) =>
- itemStorage.removeItem(`${key}.${saved.revision}.${index}`)
- )
- )
- }
-}
-
-// Each chunk stays below SecureStore's 2 KiB limit even for non-ASCII text. The manifest switches only after all
-// chunks are saved, so an interrupted write leaves the previous complete draft readable.
-const storage: DraftStorage = {
- getItem: async (key) => {
- const saved = await manifest(key)
- if (!saved) {
- return null
- }
- const parts = await Promise.all(
- Array.from({ length: saved.count }, (_, index) => itemStorage.getItem(`${key}.${saved.revision}.${index}`))
- )
- return parts.every((part) => part !== null) ? parts.join('') : null
- },
- setItem: async (key, value) => {
- const previous = await manifest(key)
- const revision = Crypto.randomUUID()
- const characters = Array.from(value)
- const parts: string[] = []
- for (let index = 0; index < characters.length; index += 500) {
- parts.push(characters.slice(index, index + 500).join(''))
- }
- if (!parts.length) {
- parts.push('')
- }
- const next = { revision, count: parts.length }
- try {
- await Promise.all(parts.map((part, index) => itemStorage.setItem(`${key}.${revision}.${index}`, part)))
- await itemStorage.setItem(key, JSON.stringify(next))
- } catch (error) {
- await removeChunks(key, next).catch(() => undefined)
- throw error
- }
- await removeChunks(key, previous)
- },
- removeItem: async (key) => {
- const previous = await manifest(key)
- await itemStorage.removeItem(key)
- await removeChunks(key, previous)
- },
-}
+import { DraftStore } from './draftStore'
export const chatDrafts = new DraftStore(storage)
diff --git a/products/mobile/src/features/inbox/hooks.test.tsx b/products/mobile/src/features/inbox/hooks.test.tsx
index c863247206e3..7f6d3239ed35 100644
--- a/products/mobile/src/features/inbox/hooks.test.tsx
+++ b/products/mobile/src/features/inbox/hooks.test.tsx
@@ -3,11 +3,16 @@ import { act, renderHook, waitFor } from '@testing-library/react-native'
import type { ReactElement, ReactNode } from 'react'
import { AppState, type AppStateStatus } from 'react-native'
import { setAuthProvider } from '@/api/client'
+import { inboxCacheKey, type SavedInbox } from '@/api/readCacheKeys'
import { INBOX_PAGE_SIZE, postReadStates, reportKeys } from '@/api/reports'
import { useAuthStore } from '@/auth/authStore'
import { type DataMode, useDemoMode } from '@/demo/demoMode'
+import { inboxFromReports } from '@/model/adapters/inbox'
import { reportFixture } from '@/model/adapters/testFixtures'
+import { snoozeKey } from '../snooze/snoozeEntries'
+import { useSnoozeStore } from '../snooze/snoozeStore'
+
import { useInboxItems, useMarkReadOnOpen, useSetReportRead } from './hooks'
jest.mock('@react-native-async-storage/async-storage', () =>
@@ -42,6 +47,7 @@ describe('inbox hooks', () => {
beforeEach(() => {
posted.length = 0
+ useSnoozeStore.setState({ entries: {} })
jest.spyOn(AppState, 'addEventListener').mockReturnValue({ remove: () => undefined })
setAuthProvider({
getAuth: () => ({ host: 'https://app.example.com', accessToken: 'token', projectId: 2, session: 1 }),
@@ -385,6 +391,8 @@ describe('inbox hooks', () => {
test.each(['server error', 'invalid page', 'invalid report'])(
'pages through the ranking, retrying after %s only when asked, reading states once per page',
async (failure) => {
+ let now = Date.now()
+ jest.spyOn(Date, 'now').mockImplementation(() => now)
const offsets: string[] = []
const readStateBatches: string[][] = []
const firstPage = Array.from({ length: INBOX_PAGE_SIZE }, (_, index) => reportFixture({ id: `r${index}` }))
@@ -421,6 +429,9 @@ describe('inbox hooks', () => {
await waitFor(() => expect(result.current.data).toHaveLength(INBOX_PAGE_SIZE))
expect(result.current.hasMore).toBe(true)
+ await waitFor(() => expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))).toBeDefined())
+ const firstCapture = queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))?.sourceUpdatedAt
+ now += 60_000
act(() => result.current.loadMore())
await waitFor(() => expect(result.current.loadMoreFailed).toBe(true))
expect(result.current.data).toHaveLength(INBOX_PAGE_SIZE)
@@ -432,6 +443,11 @@ describe('inbox hooks', () => {
await waitFor(() => expect(readStateBatches).toHaveLength(2))
expect(result.current.hasMore).toBe(false)
+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))).toMatchObject({
+ sourceUpdatedAt: firstCapture,
+ })
+ expect(queryClient.getQueryState(inboxCacheKey(scopeOf()))?.dataUpdatedAt).toBe(firstCapture)
+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))?.items).toHaveLength(INBOX_PAGE_SIZE)
expect(offsets).toEqual(['0', String(INBOX_PAGE_SIZE), String(INBOX_PAGE_SIZE)])
expect(readStateBatches.map((ids) => ids.length)).toEqual([INBOX_PAGE_SIZE, 1])
}
@@ -474,4 +490,83 @@ describe('inbox hooks', () => {
expect(result.current.data?.map((item) => item.id).slice(0, 3)).toEqual(['last', 'r19', 'r18'])
expect(result.current.data?.at(-1)?.id).toBe('r0')
})
+ test('preserves the first-page capture time through a delayed failed refresh', async () => {
+ let now = Date.now()
+ jest.spyOn(Date, 'now').mockImplementation(() => now)
+ let fail!: (error: Error) => void
+ let refreshing = false
+ globalThis.fetch = jest.fn(async (url: string) => {
+ if (new URL(url).pathname.endsWith('/read_state/')) return jsonResponse({ states: {} })
+ if (refreshing)
+ return new Promise<Response>((_resolve, reject) => {
+ fail = reject
+ })
+ return jsonResponse({ count: 1, next: null, results: [reportFixture({ id: 'r1' })] })
+ }) as typeof fetch
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })
+ const wrapper = ({ children }: { children: ReactNode }): ReactElement => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ )
+ const hook = renderHook(() => useInboxItems(), { wrapper })
+ const savedKey = inboxCacheKey(scopeOf())
+ await waitFor(() => expect(queryClient.getQueryData<SavedInbox>(savedKey)).toBeDefined())
+ const capturedAt = queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt
+ now += 60_000
+ refreshing = true
+ let pending: unknown
+ act(() => {
+ pending = hook.result.current.refetch()
+ })
+ await waitFor(() => expect(fail).toBeDefined())
+ expect(queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt).toBe(capturedAt)
+ await act(async () => {
+ fail(new TypeError('Offline'))
+ await pending
+ })
+ expect(queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt).toBe(capturedAt)
+ expect(queryClient.getQueryState(savedKey)?.dataUpdatedAt).toBe(capturedAt)
+ hook.unmount()
+ queryClient.clear()
+ })
+
+ test('shows a saved inbox offline, then replaces it with a successful live list', async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })
+ const scope = scopeOf()
+ const cached = inboxFromReports([reportFixture({ id: 'saved-report', status: 'pending_input' })])
+ useSnoozeStore
+ .getState()
+ .put(snoozeKey(scope, 'saved-report'), { kind: 'signals', threshold: 10, at: new Date().toISOString() })
+ const sourceUpdatedAt = Date.now() - 60_000
+ queryClient.setQueryData<SavedInbox>(inboxCacheKey(scope), {
+ items: cached,
+ signalCounts: { 'saved-report': 12 },
+ sourceUpdatedAt,
+ })
+ globalThis.fetch = jest.fn(async () => {
+ throw new TypeError('Offline')
+ }) as typeof fetch
+ const wrapper = ({ children }: { children: ReactNode }): ReactElement => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ )
+ const hook = renderHook(() => useInboxItems(), { wrapper })
+ await waitFor(() => expect(hook.result.current.data?.[0]?.id).toBe('saved-report'))
+ expect(hook.result.current.data?.[0]).toMatchObject({ needsInput: true })
+ expect(hook.result.current.data?.[0]?.state).not.toBe('snoozed')
+ globalThis.fetch = jest.fn(async (url: string) =>
+ new URL(url).pathname.endsWith('/read_state/')
+ ? jsonResponse({ states: {} })
+ : jsonResponse({ results: [reportFixture({ id: 'live-report' })], count: 1, next: null })
+ ) as typeof fetch
+ await act(async () => {
+ await hook.result.current.refetch()
+ })
+ await waitFor(() => expect(hook.result.current.data?.[0]?.id).toBe('live-report'))
+ await waitFor(() =>
+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scope))?.signalCounts).toEqual({
+ 'live-report': 12,
+ })
+ )
+ hook.unmount()
+ queryClient.clear()
+ })
})
diff --git a/products/mobile/src/features/inbox/hooks.ts b/products/mobile/src/features/inbox/hooks.ts
index cdf909c62fbd..d9df6ab4c1ac 100644
--- a/products/mobile/src/features/inbox/hooks.ts
+++ b/products/mobile/src/features/inbox/hooks.ts
@@ -2,14 +2,16 @@ import {
type InfiniteData,
type QueryClient,
type QueryKey,
+ skipToken,
type UseQueryResult,
useInfiniteQuery,
useQueries,
+ useQuery,
useQueryClient,
} from '@tanstack/react-query'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
import { NotSignedInError } from '@/api/client'
+import { inboxCacheKey, type SavedInbox } from '@/api/readCacheKeys'
import {
fetchInboxPage,
INBOX_PAGE_SIZE,
@@ -54,7 +56,8 @@ export interface InboxQueryState extends QueryState<InboxItem[]> {
unfiltered: readonly InboxItem[] | undefined
}
-type InboxPages = InfiniteData<InboxPageApi, number>
+type CapturedInboxPage = InboxPageApi & { capturedAt?: number }
+type InboxPages = InfiniteData<CapturedInboxPage, number>
const noop = (): void => undefined
const noMorePages = { hasMore: false, isLoadingMore: false, loadMoreFailed: false, loadMore: noop, retryLoadMore: noop }
@@ -111,8 +114,12 @@ function nextOffset(lastPage: InboxPageApi, _pages: InboxPageApi[], lastOffset:
// Refetching every loaded page ranks the whole list once per page, so a refresh starts again from the first page.
function keepFirstPage(queryClient: QueryClient, scope: ProjectScope): void {
- queryClient.setQueryData<InboxPages>(reportKeys.inbox(scope), (data) =>
- data ? { pages: data.pages.slice(0, 1), pageParams: data.pageParams.slice(0, 1) } : data
+ const key = reportKeys.inbox(scope)
+ const updatedAt = queryClient.getQueryState(key)?.dataUpdatedAt
+ queryClient.setQueryData<InboxPages>(
+ key,
+ (data) => (data ? { pages: data.pages.slice(0, 1), pageParams: data.pageParams.slice(0, 1) } : data),
+ { updatedAt }
)
}
@@ -131,14 +138,21 @@ function useLiveInboxItems(
const list = useInfiniteQuery({
queryKey: reportKeys.inbox(scope),
- queryFn: ({ pageParam, signal }) => fetchInboxPage(pageParam, signal),
+ queryFn: async ({ pageParam, signal }): Promise<CapturedInboxPage> => {
+ const page = await fetchInboxPage(pageParam, signal)
+ return { ...page, capturedAt: Date.now() }
+ },
initialPageParam: 0,
getNextPageParam: nextOffset,
enabled: active,
})
+ const saved = useQuery<SavedInbox>({ queryKey: inboxCacheKey(scope), queryFn: skipToken })
const reports = useMemo(() => (list.data ? reportsFromPages(list.data.pages) : undefined), [list.data])
- const baseItems = useMemo(() => (reports ? inboxFromReports(reports) : undefined), [reports])
- const signalCounts = useMemo(() => (reports ? signalCountsFromReports(reports) : {}), [reports])
+ const baseItems = useMemo(() => (reports ? inboxFromReports(reports) : saved.data?.items), [reports, saved.data])
+ const signalCounts = useMemo(
+ () => (reports ? signalCountsFromReports(reports) : (saved.data?.signalCounts ?? {})),
+ [reports, saved.data]
+ )
// One read-state request per page, so loading a page does not ask again for the pages before it.
const pageIds = useMemo(
@@ -168,6 +182,31 @@ function useLiveInboxItems(
combine: mergeReadStates,
})
+ const firstPage = list.data?.pages[0]
+ const capturedAt = firstPage?.capturedAt
+ const savedCounts = useMemo(() => (firstPage ? signalCountsFromReports(firstPage.results) : {}), [firstPage])
+ const savedItems = useMemo(
+ () =>
+ firstPage
+ ? inboxFromReports(firstPage.results).map((item) => ({
+ ...item,
+ read: readStates[item.reportId] !== false,
+ }))
+ : undefined,
+ [firstPage, readStates]
+ )
+ useEffect(() => {
+ if (!active || !scope || !list.isSuccess || !savedItems || !capturedAt) return
+ const key = inboxCacheKey(scope)
+ const previous = queryClient.getQueryData<SavedInbox>(key)
+ if (previous?.items === savedItems && previous.sourceUpdatedAt === capturedAt) return
+ queryClient.setQueryData<SavedInbox>(
+ key,
+ { items: savedItems, signalCounts: savedCounts, sourceUpdatedAt: capturedAt },
+ { updatedAt: capturedAt }
+ )
+ }, [active, scope, list.isSuccess, capturedAt, savedItems, savedCounts, queryClient])
+
const polling = active && appActive && refreshWhileVisible
const wasPolling = useRef(polling)
useEffect(() => {
@@ -181,9 +220,11 @@ function useLiveInboxItems(
if (!baseItems || !scope) {
return undefined
}
- const withRead = baseItems.map((item) => ({ ...item, read: readStates[item.reportId] !== false }))
+ const withRead = reports
+ ? baseItems.map((item) => ({ ...item, read: readStates[item.reportId] !== false }))
+ : baseItems
return applySnoozes(applyInboxFilters(withRead, filters, now.getTime()), snoozes, scope, now, signalCounts)
- }, [baseItems, readStates, filters, snoozes, scope, now, signalCounts])
+ }, [baseItems, reports, readStates, filters, snoozes, scope, now, signalCounts])
const {
refetch: refetchList,
diff --git a/products/mobile/src/features/offlineCache.test.ts b/products/mobile/src/features/offlineCache.test.ts
new file mode 100644
index 000000000000..c1267e94500f
--- /dev/null
+++ b/products/mobile/src/features/offlineCache.test.ts
@@ -0,0 +1,296 @@
+import { act, waitFor } from '@testing-library/react-native'
+import { AppState } from 'react-native'
+
+let mockOwner = { host: 'https://example.com', userUuid: 'user-1' }
+let mockTokens = true
+let mockReadGate: Promise<void> | undefined
+const mockDigestGates = new Map<string, Promise<void>>()
+const mockValues = new Map<string, string>()
+const mockReads: string[] = []
+const mockEndTasks = new Set<() => Promise<void>>()
+
+jest.mock('expo-crypto', () => ({
+ CryptoDigestAlgorithm: { SHA256: 'SHA256' },
+ digestStringAsync: async (_algorithm: string, input: string) => {
+ await mockDigestGates.get(input)
+ return input.replace(/\W/g, '_')
+ },
+}))
+jest.mock('@/auth/tokens', () => ({
+ getSessionTokens: () => (mockTokens ? {} : null),
+ getSessionIdentity: () => mockOwner,
+}))
+jest.mock('@/auth/authStore', () => {
+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')
+ return {
+ useAuthStore: create(() => ({
+ signedIn: true,
+ host: 'https://example.com',
+ user: { uuid: 'user-1' },
+ projectId: 1,
+ })),
+ addSessionEndTask: (task: () => Promise<void>) => {
+ mockEndTasks.add(task)
+ return () => {
+ mockEndTasks.delete(task)
+ }
+ },
+ }
+})
+jest.mock('@/features/views/viewsCache', () => {
+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')
+ return { useItemErrors: create(() => ({ errors: {} })) }
+})
+jest.mock('@/features/views/useViewsAccess', () => {
+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')
+ return { useScopeErrorStore: create(() => ({ reported: { views: null, errors: null, replay: null } })) }
+})
+jest.mock('@/lib/secureStorage', () => ({
+ secureStorage: {
+ getItem: async (key: string) => {
+ mockReads.push(key)
+ await mockReadGate
+ return mockValues.get(key) ?? null
+ },
+ setItem: async (key: string, value: string) => {
+ mockValues.set(key, value)
+ },
+ removeItem: async (key: string) => {
+ mockValues.delete(key)
+ },
+ },
+}))
+
+import { ApiError } from '@/api/client'
+import { queryClient } from '@/api/queryClient'
+import { useAuthStore } from '@/auth/authStore'
+import { useScopeErrorStore } from '@/features/views/useViewsAccess'
+import { useItemErrors } from '@/features/views/viewsCache'
+import { installOfflineCache } from './offlineCache'
+
+function account(user = 'user-1', host = 'https://example.com'): string {
+ return `mobile-read-cache-v1-${JSON.stringify([host, user]).replace(/\W/g, '_')}`
+}
+function seed(projectId: number, user = 'user-1'): readonly unknown[] {
+ const key = ['views', 'https://example.com', projectId, 'web', '-']
+ mockValues.set(
+ `${account(user)}.${projectId}`,
+ JSON.stringify([{ key, updatedAt: Date.now() - 1000, data: { metrics: [], readAt: Date.now() - 1000 } }])
+ )
+ const index = `${account(user)}.scopes`
+ const scopes: string[] = JSON.parse(mockValues.get(index) ?? '[]')
+ mockValues.set(index, JSON.stringify([...new Set([...scopes, `${account(user)}.${projectId}`])]))
+ return key
+}
+
+describe('authenticated offline-cache lifecycle', () => {
+ beforeEach(() => {
+ mockOwner = { host: 'https://example.com', userUuid: 'user-1' }
+ mockTokens = true
+ mockReadGate = undefined
+ mockDigestGates.clear()
+ mockValues.clear()
+ mockReads.length = 0
+ useScopeErrorStore.setState({ reported: { views: null, errors: null, replay: null } })
+ queryClient.clear()
+ useItemErrors.setState({ errors: {} })
+ useAuthStore.setState({
+ signedIn: true,
+ host: 'https://example.com',
+ user: { uuid: 'user-1', distinctId: 'user-1', email: '[email protected]', name: 'Example' },
+ projectId: 1,
+ })
+ jest.spyOn(AppState, 'addEventListener').mockReturnValue({ remove: () => undefined })
+ })
+ afterEach(() => {
+ jest.restoreAllMocks()
+ queryClient.clear()
+ })
+
+ test.each(['digest', 'load'])(
+ 'does not hydrate project 1 after switching while its %s is pending',
+ async (stage) => {
+ const first = seed(1)
+ const second = seed(2)
+ let finish!: () => void
+ const gate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ if (stage === 'digest') mockDigestGates.set(JSON.stringify(['https://example.com', 'user-1']), gate)
+ else mockReadGate = gate
+ const stop = installOfflineCache()
+ await act(async () => {
+ useAuthStore.setState({ projectId: 2 })
+ finish()
+ })
+ await waitFor(() => expect(queryClient.getQueryData(second)).toBeDefined())
+ expect(queryClient.getQueryData(first)).toBeUndefined()
+ stop()
+ }
+ )
+
+ it('requires the secure owner to match before reading cached data', async () => {
+ const key = seed(1)
+ mockOwner = { host: 'https://example.com', userUuid: 'other-user' }
+ const stop = installOfflineCache()
+ await act(async () => undefined)
+ expect(queryClient.getQueryData(key)).toBeUndefined()
+ stop()
+ })
+
+ it('purges the departing account after delayed hydration and leaves another account intact', async () => {
+ const key = seed(1)
+ seed(1, 'user-2')
+ let finish!: () => void
+ mockReadGate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ const stop = installOfflineCache()
+ await act(async () => undefined)
+ mockTokens = false
+ const cleanup = Promise.all([...mockEndTasks].map((task) => task()))
+ finish()
+ await cleanup
+ expect(queryClient.getQueryData(key)).toBeUndefined()
+ expect(mockValues.has(`${account()}.1`)).toBe(false)
+ expect(mockValues.has(`${account('user-2')}.1`)).toBe(true)
+ stop()
+ })
+ it('does not hydrate the previous account into the next account while its read is pending', async () => {
+ const key = seed(1)
+ mockValues.set(
+ `${account('user-2')}.1`,
+ JSON.stringify([
+ { key, updatedAt: Date.now() - 500, data: { metrics: [{ key: 'user-2' }], readAt: Date.now() - 500 } },
+ ])
+ )
+ let finish!: () => void
+ mockReadGate = new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ const stop = installOfflineCache()
+ await waitFor(() => expect(mockReads).toContain(`${account()}.1`))
+ await act(async () => {
+ mockOwner = { host: 'https://example.com', userUuid: 'user-2' }
+ useAuthStore.setState({
+ user: { uuid: 'user-2', distinctId: 'user-2', email: '[email protected]', name: 'Other' },
+ })
+ finish()
+ })
+ await waitFor(() => expect(queryClient.getQueryData(key)).toMatchObject({ metrics: [{ key: 'user-2' }] }))
+ stop()
+ })
+ it('does not restore an inbox refused before the account digest finishes', async () => {
+ const key = ['read-inbox', 'https://example.com', 1]
+ mockValues.set(
+ `${account()}.1`,
+ JSON.stringify([
+ { key, updatedAt: Date.now() - 1000, data: { items: [], sourceUpdatedAt: Date.now() - 1000 } },
+ ])
+ )
+ let finish!: () => void
+ mockDigestGates.set(
+ JSON.stringify(['https://example.com', 'user-1']),
+ new Promise<void>((resolve) => {
+ finish = resolve
+ })
+ )
+ const stop = installOfflineCache()
+ await queryClient
+ .fetchQuery({
+ queryKey: ['signals', 'https://example.com', 1, 'inbox'],
+ queryFn: async () => {
+ throw new ApiError(403, {})
+ },
+ retry: false,
+ })
+ .catch(() => undefined)
+ finish()
+ await waitFor(() => expect(JSON.parse(mockValues.get(`${account()}.1`) ?? '[]')).toEqual([]))
+ expect(queryClient.getQueryData(key)).toBeUndefined()
+ stop()
+ })
+
+ test.each(['view-error', 'query-error'] as const)(
+ 'evicts the original project after a late %s across a project switch',
+ async (source) => {
+ const first = seed(1)
+ const second = seed(2)
+ let stop = installOfflineCache()
+ await waitFor(() => expect(queryClient.getQueryData(first)).toBeDefined())
+ let deny = (): void => undefined
+ const request =
+ source === 'query-error'
+ ? queryClient
+ .fetchQuery({
+ queryKey: first,
+ staleTime: 0,
+ queryFn: () =>
+ new Promise<never>((_resolve, reject) => {
+ deny = () => reject(new ApiError(403, {}))
+ }),
+ retry: false,
+ })
+ .catch(() => undefined)
+ : Promise.resolve()
+ await act(async () => {
+ useAuthStore.setState({ projectId: 2 })
+ })
+ await waitFor(() => expect(queryClient.getQueryData(second)).toBeDefined())
+ await act(async () => {
+ if (source === 'view-error') {
+ queryClient.removeQueries({ queryKey: first })
+ useItemErrors.setState({ errors: { [JSON.stringify(first)]: 'no_access' } })
+ }
+ deny()
+ await request
+ })
+ await waitFor(() => expect(mockValues.has(`${account()}.1`)).toBe(false))
+ expect(queryClient.getQueryData(second)).toBeDefined()
+ stop()
+ queryClient.clear()
+ useItemErrors.setState({ errors: {} })
+ useAuthStore.setState({ projectId: 1 })
+ stop = installOfflineCache()
+ await act(async () => undefined)
+ expect(queryClient.getQueryData(first)).toBeUndefined()
+ stop()
+ }
+ )
+
+ it('clears Views from unvisited saved projects after a scope denial and preserves inbox and other accounts', async () => {
+ const first = seed(1)
+ const unvisited = seed(2)
+ seed(2, 'user-2')
+ const inbox = ['read-inbox', 'https://example.com', 2]
+ const saved = JSON.parse(mockValues.get(`${account()}.2`) ?? '[]')
+ saved.push({
+ key: inbox,
+ updatedAt: Date.now() - 1000,
+ data: { items: [], sourceUpdatedAt: Date.now() - 1000 },
+ })
+ mockValues.set(`${account()}.2`, JSON.stringify(saved))
+ let stop = installOfflineCache()
+ await waitFor(() => expect(queryClient.getQueryData(first)).toBeDefined())
+ useScopeErrorStore.setState({ reported: { views: 'insights:read', errors: null, replay: null } })
+ await waitFor(() => expect(mockValues.get(`${account()}.2`)).not.toContain('"views"'))
+ stop()
+ queryClient.clear()
+ useScopeErrorStore.setState({ reported: { views: null, errors: null, replay: null } })
+ useAuthStore.setState({ projectId: 2 })
+ stop = installOfflineCache()
+ await waitFor(() => expect(queryClient.getQueryData(inbox)).toBeDefined())
+ expect(queryClient.getQueryData(unvisited)).toBeUndefined()
+ expect(mockValues.get(`${account('user-2')}.2`)).toContain('"views"')
+ stop()
+ })
+
+ it('does not rehydrate views when the existing access gate reports a missing scope', async () => {
+ const key = seed(1)
+ useScopeErrorStore.setState({ reported: { views: 'insights:read', errors: null, replay: null } })
+ const stop = installOfflineCache()
+ await waitFor(() => expect(JSON.parse(mockValues.get(`${account()}.1`) ?? '[]')).toEqual([]))
+ expect(queryClient.getQueryData(key)).toBeUndefined()
+ stop()
+ })
+})
diff --git a/products/mobile/src/features/offlineCache.ts b/products/mobile/src/features/offlineCache.ts
new file mode 100644
index 000000000000..27afc37262db
--- /dev/null
+++ b/products/mobile/src/features/offlineCache.ts
@@ -0,0 +1,139 @@
+import type { QueryKey } from '@tanstack/react-query'
+import * as Crypto from 'expo-crypto'
+import { AppState } from 'react-native'
+import { queryClient } from '@/api/queryClient'
+import { persistReadCache } from '@/api/readCache'
+import { ReadCacheStore } from '@/api/readCacheStore'
+import { missingViewsScope } from '@/api/scopeErrors'
+import { addSessionEndTask, useAuthStore } from '@/auth/authStore'
+import { getSessionIdentity, getSessionTokens } from '@/auth/tokens'
+import { useScopeErrorStore } from '@/features/views/useViewsAccess'
+import { useItemErrors } from '@/features/views/viewsCache'
+import { secureStorage } from '@/lib/secureStorage'
+
+const store = new ReadCacheStore(secureStorage)
+
+function identity(): string | null {
+ const state = useAuthStore.getState()
+ const owner = getSessionIdentity()
+ return getSessionTokens() &&
+ state.signedIn &&
+ state.host &&
+ state.user &&
+ state.projectId !== null &&
+ owner?.host === state.host &&
+ owner.userUuid === state.user.uuid
+ ? JSON.stringify([state.host, state.user.uuid, state.projectId])
+ : null
+}
+
+async function accountKey(host: string, userId: string): Promise<string> {
+ const hash = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, JSON.stringify([host, userId]))
+ return `mobile-read-cache-v1-${hash}`
+}
+
+function viewsScopeDenied(): boolean {
+ const tokens = getSessionTokens()
+ return (
+ useScopeErrorStore.getState().reported.views !== null ||
+ (tokens?.kind === 'oauth' && missingViewsScope(tokens.grantedScopes) !== null)
+ )
+}
+
+export function installOfflineCache(): () => void {
+ let active: ReturnType<typeof persistReadCache> | undefined
+ const sessions = new Map<string, ReturnType<typeof persistReadCache>>()
+ let owner: string | null = null
+ let previous: string | null = null
+ let generation = 0
+ const update = (): void => {
+ const target = identity()
+ if (target === previous) return
+ previous = target
+ const mine = ++generation
+ active?.pause()
+ active = undefined
+ const nextOwner = target ? JSON.stringify(JSON.parse(target).slice(0, 2)) : null
+ if (owner !== nextOwner) {
+ for (const session of sessions.values()) session.stop()
+ sessions.clear()
+ owner = nextOwner
+ }
+ if (!target) return
+ const state = useAuthStore.getState()
+ if (!state.host || !state.user || state.projectId === null) return
+ const { host, projectId } = state
+ void accountKey(host, state.user.uuid)
+ .then(async (account) => {
+ if (mine !== generation || identity() !== target) return
+ if (viewsScopeDenied()) await store.evictAccountViews(account, host)
+ if (mine !== generation || identity() !== target) return
+ active = persistReadCache(
+ queryClient,
+ store,
+ { account, host, projectId },
+ () => identity() === target,
+ (key) =>
+ key[0] === 'views' &&
+ (viewsScopeDenied() ||
+ ['deleted', 'no_access', 'scope'].includes(
+ useItemErrors.getState().errors[JSON.stringify(key)] ?? ''
+ )),
+ () => {
+ const verified = identity()
+ return verified !== null && JSON.stringify(JSON.parse(verified).slice(0, 2)) === nextOwner
+ }
+ )
+ sessions.get(target)?.stop()
+ sessions.set(target, active)
+ })
+ .catch(() => undefined)
+ }
+ const unsubscribe = useAuthStore.subscribe(update)
+ const purge = (): void => {
+ const keys: QueryKey[] = []
+ for (const key of Object.keys(useItemErrors.getState().errors)) {
+ try {
+ const parsed: unknown = JSON.parse(key)
+ if (Array.isArray(parsed)) keys.push(parsed)
+ } catch {}
+ }
+ for (const session of sessions.values()) session.purgeDeniedViews(keys)
+ const target = identity()
+ if (!target || !viewsScopeDenied()) return
+ const [host, userId] = JSON.parse(target) as [string, string, number]
+ void accountKey(host, userId)
+ .then(async (account) => {
+ const verified = identity()
+ if (!verified || JSON.stringify(JSON.parse(verified).slice(0, 2)) !== JSON.stringify([host, userId]))
+ return
+ await store.evictAccountViews(account, host)
+ })
+ .catch(() => undefined)
+ }
+ const unsubscribeErrors = useItemErrors.subscribe(purge)
+ const unsubscribeScopes = useScopeErrorStore.subscribe(purge)
+ const unsubscribeEnd = addSessionEndTask(async () => {
+ generation++
+ previous = null
+ for (const session of sessions.values()) session.stop()
+ sessions.clear()
+ active = undefined
+ const state = useAuthStore.getState()
+ if (state.host && state.user) await store.clearAccount(await accountKey(state.host, state.user.uuid))
+ })
+ const appState = AppState.addEventListener('change', (state) => {
+ if (state !== 'active') void active?.flush()
+ })
+ update()
+ return () => {
+ generation++
+ for (const session of sessions.values()) session.stop()
+ sessions.clear()
+ unsubscribe()
+ unsubscribeErrors()
+ unsubscribeScopes()
+ unsubscribeEnd()
+ appState.remove()
+ }
+}
diff --git a/products/mobile/src/features/views/freshness.test.ts b/products/mobile/src/features/views/freshness.test.ts
index db7cd3992db8..4c4ee5b5664c 100644
--- a/products/mobile/src/features/views/freshness.test.ts
+++ b/products/mobile/src/features/views/freshness.test.ts
@@ -85,6 +85,19 @@ describe('freshness', () => {
false,
"Couldn't refresh. Updated 1 min ago",
],
+ ['a saved device snapshot', [snap({ restoredFromDevice: true })], false, 'Updated 10 min ago'],
+ [
+ 'a saved snapshot without a refresh time',
+ [snap({ restoredFromDevice: true, lastRefreshAt: null })],
+ false,
+ null,
+ ],
+ [
+ 'a failed refresh of a saved snapshot',
+ [snap({ restoredFromDevice: true, refreshFailed: true })],
+ false,
+ "Couldn't refresh. Updated 10 min ago",
+ ],
['no data items', [undefined, snap({ lastRefreshAt: null })], false, null],
])('statusLine for %s', (_name, snapshots, busy, expected) => {
expect(statusLine(snapshots, busy, T).text).toBe(expected)
diff --git a/products/mobile/src/features/views/offlineViews.test.tsx b/products/mobile/src/features/views/offlineViews.test.tsx
new file mode 100644
index 000000000000..bfbc0f39d5e8
--- /dev/null
+++ b/products/mobile/src/features/views/offlineViews.test.tsx
@@ -0,0 +1,104 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { act, renderHook, waitFor } from '@testing-library/react-native'
+import type { ReactElement, ReactNode } from 'react'
+
+import { setAuthProvider } from '@/api/client'
+import { persistReadCache } from '@/api/readCache'
+import { ReadCacheStore } from '@/api/readCacheStore'
+import { useAuthStore } from '@/auth/authStore'
+import { setSessionTokens } from '@/auth/tokens'
+import { demoAnchor, demoInsightResponse } from '@/demo/views'
+import { insightSnapshot } from '@/model/adapters/insightSnapshot'
+
+import { insightQueryKey } from './items'
+import { useViewsList } from './pinHooks'
+import { useDeviceRecent } from './recentStore'
+import { viewsQueue } from './refreshQueue'
+import { useInsightScreen } from './viewHooks'
+
+const scope = { host: 'https://example.com', projectId: 1 }
+jest.mock('expo-router', () => ({ useFocusEffect: () => {}, useIsFocused: () => false }))
+jest.mock('@/demo/demoMode', () => ({ ...jest.requireActual('@/demo/demoMode'), useDataMode: () => 'live' }))
+
+let client: QueryClient
+function wrapper({ children }: { children: ReactNode }): ReactElement {
+ return <QueryClientProvider client={client}>{children}</QueryClientProvider>
+}
+
+describe('cold offline Views navigation', () => {
+ it('opens a saved insight from the device Recent list without loading shortcuts or metadata', async () => {
+ await useAuthStore.persist.rehydrate()
+ await useDeviceRecent.persist.rehydrate()
+ const values = new Map<string, string>()
+ const store = new ReadCacheStore({
+ getItem: async (key) => values.get(key) ?? null,
+ setItem: async (key, value) => {
+ values.set(key, value)
+ },
+ removeItem: async (key) => {
+ values.delete(key)
+ },
+ })
+ const cacheScope = { ...scope, account: 'example-account' }
+ const shortId = 'demo-ins-signups'
+ const response = demoInsightResponse({ shortId, dashboardRef: null, override: null }, demoAnchor())
+ if (!response) throw new Error('Missing demo insight')
+ const snapshot = insightSnapshot(response, undefined, { readAt: Date.now(), serverNow: Date.now() })
+ const source = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })
+ const session = persistReadCache(source, store, cacheScope, () => true)
+ await session.ready
+ source.setQueryData(insightQueryKey(scope, { shortId, dashboardRef: null, override: null }), snapshot)
+ await session.flush()
+ session.stop()
+ source.clear()
+ useDeviceRecent.getState().record(`${scope.host}|${scope.projectId}`, {
+ kind: 'insight',
+ ref: shortId,
+ name: snapshot.name,
+ viewedAt: new Date().toISOString(),
+ })
+ useAuthStore.setState({
+ status: 'signed_in',
+ signedIn: true,
+ host: scope.host,
+ projectId: 1,
+ method: 'personal_api_key',
+ user: { uuid: 'example-user', distinctId: 'example-user', email: '[email protected]', name: 'Example' },
+ })
+ setSessionTokens({
+ kind: 'personal_api_key',
+ accessToken: 'example-token',
+ refreshToken: null,
+ expiresAt: null,
+ grantedScopes: null,
+ requestedScopes: null,
+ })
+ setAuthProvider({
+ getAuth: () => ({ ...scope, accessToken: 'example-token', session: 1 }),
+ refreshAccessToken: async () => null,
+ })
+ globalThis.fetch = jest.fn(async () => {
+ throw new TypeError('Offline')
+ }) as typeof fetch
+ client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })
+ const restored = persistReadCache(client, store, cacheScope, () => true)
+ await restored.ready
+ const list = renderHook(() => useViewsList(), { wrapper })
+ await waitFor(() => expect(list.result.current.recent.data?.some((item) => item.ref === shortId)).toBe(true))
+ const insight = renderHook(() => useInsightScreen(shortId, { from: 'recent' }), { wrapper })
+ await waitFor(() => expect(insight.result.current.insight.data?.value).toBe(snapshot.value))
+ expect(insight.result.current.insight.data?.restoredFromDevice).toBe(true)
+ expect(insight.result.current.refresh.status.text).toMatch(
+ /^(?:Couldn't refresh\. )?Updated \d+ (?:min|h) ago$/
+ )
+ await act(async () => {
+ insight.unmount()
+ list.unmount()
+ })
+ restored.stop()
+ client.clear()
+ viewsQueue.reset()
+ setAuthProvider(null)
+ setSessionTokens(null)
+ })
+})
diff --git a/products/mobile/src/lib/secureStorage.ts b/products/mobile/src/lib/secureStorage.ts
new file mode 100644
index 000000000000..ada2d2e24cf8
--- /dev/null
+++ b/products/mobile/src/lib/secureStorage.ts
@@ -0,0 +1,151 @@
+import * as Crypto from 'expo-crypto'
+import * as SecureStore from 'expo-secure-store'
+import { Platform } from 'react-native'
+
+export interface StringStorage {
+ getItem: (key: string) => Promise<string | null>
+ setItem: (key: string, value: string) => Promise<void>
+ removeItem: (key: string) => Promise<void>
+}
+
+const webMemory = new Map<string, string>()
+const itemStorage: StringStorage = {
+ getItem: (key) =>
+ Platform.OS === 'web' ? Promise.resolve(webMemory.get(key) ?? null) : SecureStore.getItemAsync(key),
+ setItem: async (key, value) => {
+ if (Platform.OS === 'web') {
+ webMemory.set(key, value)
+ } else {
+ await SecureStore.setItemAsync(key, value)
+ }
+ },
+ removeItem: async (key) => {
+ if (Platform.OS === 'web') {
+ webMemory.delete(key)
+ } else {
+ await SecureStore.deleteItemAsync(key)
+ }
+ },
+}
+
+interface Manifest {
+ revision: string
+ count: number
+}
+
+function asManifest(value: unknown): Manifest | null {
+ if (value && typeof value === 'object') {
+ const record = value as Record<string, unknown>
+ if (
+ typeof record.revision === 'string' &&
+ typeof record.count === 'number' &&
+ Number.isSafeInteger(record.count) &&
+ record.count > 0 &&
+ record.count <= 10000
+ ) {
+ return { revision: record.revision, count: record.count }
+ }
+ }
+ return null
+}
+
+async function storedJson(key: string): Promise<unknown> {
+ const raw = await itemStorage.getItem(key)
+ try {
+ return JSON.parse(raw ?? 'null')
+ } catch {
+ return null
+ }
+}
+
+async function revisions(key: string): Promise<Manifest[]> {
+ const value = await storedJson(`${key}.revisions`)
+ return Array.isArray(value) ? value.map(asManifest).filter((entry): entry is Manifest => entry !== null) : []
+}
+
+async function complete(work: Promise<void>[]): Promise<void> {
+ // Settle every native operation before cleanup can remove partially written chunks.
+ const results = await Promise.allSettled(work)
+ const failed = results.find((result) => result.status === 'rejected')
+ if (failed?.status === 'rejected') throw failed.reason
+}
+
+async function removeChunks(key: string, saved: Manifest | null): Promise<void> {
+ if (saved) {
+ await complete(
+ Array.from({ length: saved.count }, (_, index) =>
+ itemStorage.removeItem(`${key}.${saved.revision}.${index}`)
+ )
+ )
+ }
+}
+
+async function recover(key: string): Promise<Manifest | null> {
+ const saved = asManifest(await storedJson(key))
+ const journal = await revisions(key)
+ for (const entry of journal) {
+ if (entry.revision !== saved?.revision) await removeChunks(key, entry)
+ }
+ if (journal.length) await itemStorage.removeItem(`${key}.revisions`)
+ return saved
+}
+
+const operations = new Map<string, Promise<unknown>>()
+
+function serialized<T>(key: string, work: () => Promise<T>): Promise<T> {
+ const result = (operations.get(key) ?? Promise.resolve()).then(work)
+ const settled = result.catch(() => undefined)
+ operations.set(key, settled)
+ void settled.then(() => {
+ if (operations.get(key) === settled) operations.delete(key)
+ })
+ return result
+}
+
+// Each chunk stays below SecureStore's 2 KiB limit even for non-ASCII text. The journal retains
+// unfinished revisions across restarts, while the manifest points to the last complete value.
+export const secureStorage: StringStorage = {
+ getItem: (key) =>
+ serialized(key, async () => {
+ const saved = await recover(key)
+ if (!saved) return null
+ const parts = await Promise.all(
+ Array.from({ length: saved.count }, (_, index) =>
+ itemStorage.getItem(`${key}.${saved.revision}.${index}`)
+ )
+ )
+ if (parts.some((part) => part === null)) throw new Error('Incomplete secure storage value')
+ return parts.join('')
+ }),
+ setItem: (key, value) =>
+ serialized(key, async () => {
+ const previous = await recover(key)
+ const revision = Crypto.randomUUID()
+ const characters = Array.from(value)
+ const parts: string[] = []
+ for (let index = 0; index < characters.length; index += 500) {
+ parts.push(characters.slice(index, index + 500).join(''))
+ }
+ if (!parts.length) parts.push('')
+ const next = { revision, count: parts.length }
+ await itemStorage.setItem(`${key}.revisions`, JSON.stringify(previous ? [previous, next] : [next]))
+ try {
+ await complete(parts.map((part, index) => itemStorage.setItem(`${key}.${revision}.${index}`, part)))
+ await itemStorage.setItem(key, JSON.stringify(next))
+ } catch (error) {
+ await recover(key).catch(() => undefined)
+ throw error
+ }
+ await recover(key)
+ }),
+ removeItem: (key) =>
+ serialized(key, async () => {
+ const previous = asManifest(await storedJson(key))
+ const journal = await revisions(key)
+ if (previous && !journal.some((entry) => entry.revision === previous.revision)) journal.push(previous)
+ if (journal.length) await itemStorage.setItem(`${key}.revisions`, JSON.stringify(journal))
+ await itemStorage.removeItem(key)
+ for (const entry of journal) await removeChunks(key, entry)
+ if (journal.length) await itemStorage.removeItem(`${key}.revisions`)
+ }),
+}
diff --git a/products/mobile/src/model/adapters/insightSnapshot.ts b/products/mobile/src/model/adapters/insightSnapshot.ts
index 05f9b7393416..99f5c87561cc 100644
--- a/products/mobile/src/model/adapters/insightSnapshot.ts
+++ b/products/mobile/src/model/adapters/insightSnapshot.ts
@@ -494,6 +494,7 @@ export function insightSnapshot(
inProgressFrom: null,
capabilities: capabilitiesOf(query),
computed: false,
+ dataReadAt: 0,
}
}
const resolvedRange = resolvedRangeOf(response)
@@ -523,6 +524,7 @@ export function insightSnapshot(
nextAllowedRefreshAt: response.next_allowed_client_refresh,
readAt: context.readAt,
refreshFailed: false,
+ dataReadAt: context.readAt,
resolvedRange,
timezone: response.timezone ?? null,
interval,
diff --git a/products/mobile/src/model/adapters/readCache.ts b/products/mobile/src/model/adapters/readCache.ts
new file mode 100644
index 000000000000..ac8f9524d1d7
--- /dev/null
+++ b/products/mobile/src/model/adapters/readCache.ts
@@ -0,0 +1,158 @@
+import type { QueryKey } from '@tanstack/react-query'
+import type { ProjectScope } from '@/api/reports'
+import { asRecord } from '@/lib/records'
+
+export function isReadCacheKey(key: QueryKey, scope: ProjectScope): boolean {
+ if (key[1] !== scope.host || key[2] !== scope.projectId) return false
+ if (key[0] === 'read-inbox') return key.length === 3
+ if (key[0] !== 'views') return false
+ const lengths: Record<string, number> = { insight: 7, web: 5, dashboard: 6 }
+ return key.length === lengths[String(key[3])]
+}
+
+export function cacheable(key: QueryKey, data: unknown, scope: ProjectScope): boolean {
+ if (!isReadCacheKey(key, scope)) return false
+ const value = asRecord(data)
+ if (!value) return false
+ if (key[0] === 'read-inbox') return Array.isArray(value.items) && typeof value.sourceUpdatedAt === 'number'
+ if (key[3] === 'insight')
+ return (
+ ['TrendsQuery', 'FunnelsQuery', 'RetentionQuery'].includes(String(value.queryKind)) &&
+ value.sqlTable === null &&
+ !rawQueryPayload(value.query)
+ )
+ if (key[3] === 'web') return Array.isArray(value.metrics)
+ return Array.isArray(asRecord(value.view)?.tiles)
+}
+
+function fields(value: Record<string, unknown>, names: readonly string[]): Record<string, unknown> {
+ return Object.fromEntries(names.filter((name) => name in value).map((name) => [name, value[name]]))
+}
+
+function rawQueryPayload(value: unknown, depth = 0): boolean {
+ if (depth > 16) return true
+ if (Array.isArray(value)) return value.some((item) => rawQueryPayload(item, depth + 1))
+ const record = asRecord(value)
+ return (
+ !!record &&
+ (['HogQLQuery', 'ActorsQuery', 'EventsQuery', 'PersonsNode'].includes(String(record.kind)) ||
+ Object.entries(record).some(
+ ([name, child]) =>
+ ['response', 'results', 'actors', 'persons'].includes(name) || rawQueryPayload(child, depth + 1)
+ ))
+ )
+}
+
+export function projectedData(key: QueryKey, data: unknown): unknown {
+ const value = asRecord(data)
+ if (!value) return null
+ if (key[0] === 'read-inbox')
+ return {
+ sourceUpdatedAt: value.sourceUpdatedAt,
+ signalCounts: value.signalCounts,
+ items: Array.isArray(value.items)
+ ? value.items.map((item) =>
+ fields(asRecord(item) ?? {}, [
+ 'id',
+ 'reportId',
+ 'title',
+ 'sourceProduct',
+ 'sourceLabel',
+ 'sources',
+ 'accent',
+ 'createdAt',
+ 'updatedAt',
+ 'modelScore',
+ 'reason',
+ 'state',
+ 'needsInput',
+ 'read',
+ 'agent',
+ 'pullRequestUrl',
+ 'pullRequestState',
+ ])
+ )
+ : [],
+ }
+ if (key[3] === 'dashboard') {
+ const view = asRecord(value.view) ?? {}
+ return {
+ readAt: value.readAt,
+ refreshFailed: value.refreshFailed,
+ restoredFromDevice: value.restoredFromDevice,
+ view: {
+ ...fields(view, ['id', 'name', 'description', 'savedRange', 'lastRefresh']),
+ tiles: Array.isArray(view.tiles)
+ ? view.tiles.map((tile) =>
+ fields(asRecord(tile) ?? {}, [
+ 'tileId',
+ 'kind',
+ 'insightId',
+ 'shortId',
+ 'name',
+ 'text',
+ 'usesOwnRange',
+ 'ignoresRangeOverride',
+ 'capabilities',
+ 'kindLabel',
+ 'seriesCount',
+ 'hasBreakdown',
+ ])
+ )
+ : [],
+ },
+ }
+ }
+ if (key[3] === 'web')
+ return fields(value, [
+ 'metrics',
+ 'resolvedRange',
+ 'timezone',
+ 'computed',
+ 'lastRefreshAt',
+ 'cacheTargetAge',
+ 'nextAllowedRefreshAt',
+ 'readAt',
+ 'dataReadAt',
+ 'refreshFailed',
+ 'restoredFromDevice',
+ ])
+ return fields(value, [
+ 'insightId',
+ 'shortId',
+ 'name',
+ 'description',
+ 'queryKind',
+ 'query',
+ 'resolvedRange',
+ 'timezone',
+ 'savedRange',
+ 'interval',
+ 'format',
+ 'value',
+ 'valueAt',
+ 'previous',
+ 'delta',
+ 'series',
+ 'allSeries',
+ 'chartKind',
+ 'funnel',
+ 'retention',
+ 'ranking',
+ 'sqlTable',
+ 'inProgressFrom',
+ 'usesOwnRange',
+ 'capabilities',
+ 'kindLabel',
+ 'computed',
+ 'createdBy',
+ 'createdAt',
+ 'lastRefreshAt',
+ 'cacheTargetAge',
+ 'nextAllowedRefreshAt',
+ 'readAt',
+ 'dataReadAt',
+ 'refreshFailed',
+ 'restoredFromDevice',
+ ])
+}
diff --git a/products/mobile/src/model/adapters/webOverview.ts b/products/mobile/src/model/adapters/webOverview.ts
index 256cb5183604..fd8e88d0ee75 100644
--- a/products/mobile/src/model/adapters/webOverview.ts
+++ b/products/mobile/src/model/adapters/webOverview.ts
@@ -70,11 +70,13 @@ export function webOverviewSnapshot(
nextAllowedRefreshAt: null,
readAt,
refreshFailed: failed,
+ dataReadAt: 0,
}
}
const range = response.resolved_date_range
return {
metrics: (response.results ?? []).map(metricOf),
+ dataReadAt: readAt,
resolvedRange: range?.date_from && range.date_to ? { from: range.date_from, to: range.date_to } : null,
timezone: response.timezone ?? null,
computed: response.is_cached === false,
diff --git a/products/mobile/src/model/views.ts b/products/mobile/src/model/views.ts
index 5de1b9dafa49..77f9a3cfcc27 100644
--- a/products/mobile/src/model/views.ts
+++ b/products/mobile/src/model/views.ts
@@ -66,6 +66,9 @@ export interface DeviceRecentEntry {
/** The refresh fields of one data item. They change only on a response with a result and no error. */
export interface Freshness {
+ restoredFromDevice?: boolean
+ /** Cache-only misses must not renew the age of the last successful result. */
+ dataReadAt?: number
lastRefreshAt: string | null
cacheTargetAge: string | null
nextAllowedRefreshAt: string | null