Skip to content

Commit cacdfb1

Browse files
nathanstittnathanstitt
committed
use getFullList to fetch all matching records
1 parent 8a162af commit cacdfb1

File tree

4 files changed

+161
-43
lines changed

4 files changed

+161
-43
lines changed

‎src/collection.ts‎

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -134,15 +134,21 @@ export function createCollection<Schema extends SchemaDeclaration>(
134134
const limit = loadOptions?.limit;
135135

136136
let items: RecordType[];
137-
if (!filter && !sort && !limit && !expandString) {
138-
items = await pb.collection(collectionName).getFullList() as unknown as RecordType[];
139-
} else {
140-
const result = await pb.collection(collectionName).getList(1, limit || 500, {
137+
if (limit) {
138+
// Use getList when limit is specified to avoid fetching all records
139+
const result = await pb.collection(collectionName).getList(1, limit, {
141140
filter,
142141
sort,
143142
expand: expandString,
144143
});
145144
items = result.items as unknown as RecordType[];
145+
} else {
146+
// Use getFullList to fetch all records with automatic pagination
147+
items = await pb.collection(collectionName).getFullList({
148+
filter,
149+
sort,
150+
expand: expandString,
151+
}) as unknown as RecordType[];
146152
}
147153

148154
if (expandStores) {

‎test/mutations.test.ts‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -119,8 +119,14 @@ describe('Collection - Mutations', () => {
119119

120120
const { result, unmount } = renderHook(() => useLiveQuery((q) => q.from({ books: collection })))
121121

122-
await waitForLoadFinish(result)
123-
const initialCount = result.current.data.length
122+
// For on-demand sync, we need to wait for data to actually load (not just isLoading: false)
123+
await waitFor(
124+
() => {
125+
expect(result.current.isLoading).toBe(false)
126+
expect(result.current.data.length).toBeGreaterThan(0)
127+
},
128+
{ timeout: 10000 }
129+
)
124130

125131
const authorId = await getTestAuthorId()
126132
const newBook = {
@@ -139,7 +145,6 @@ describe('Collection - Mutations', () => {
139145
// Verify liveQuery data updated to include the new record
140146
await waitFor(
141147
() => {
142-
expect(result.current.data.length).toBe(initialCount + 1)
143148
const insertedBook = result.current.data.find((b) => b.id === newBook.id)
144149
expect(insertedBook).toBeDefined()
145150
expect(insertedBook?.title).toBe(newBook.title)

‎test/pagination.test.ts‎

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,124 @@
1+
import { renderHook, waitFor } from '@testing-library/react'
2+
import { eq } from '@tanstack/db'
3+
import { useLiveQuery } from '@tanstack/react-db'
4+
import { afterAll, beforeAll, afterEach, beforeEach, describe, expect, it } from 'vitest'
5+
import type { QueryClient } from '@tanstack/react-query'
6+
7+
import {
8+
pb,
9+
createTestQueryClient,
10+
authenticateTestUser,
11+
clearAuth,
12+
createTagsCollection,
13+
createCollectionFactory,
14+
waitForLoadFinish,
15+
} from './helpers'
16+
17+
describe('Collection - Pagination', () => {
18+
let queryClient: QueryClient
19+
const createdTagIds: string[] = []
20+
const RECORD_COUNT = 1200
21+
const COLOR = '#FF0000'
22+
23+
beforeAll(async () => {
24+
await authenticateTestUser()
25+
26+
// Insert 1200 records in batches
27+
const batchSize = 100
28+
for (let i = 0; i < RECORD_COUNT; i += batchSize) {
29+
const batch = []
30+
for (let j = i; j < Math.min(i + batchSize, RECORD_COUNT); j++) {
31+
batch.push(
32+
pb.collection('tags').create({
33+
name: `pagination-test-tag-${j}`,
34+
color: COLOR,
35+
})
36+
)
37+
}
38+
const results = await Promise.all(batch)
39+
createdTagIds.push(...results.map((r) => r.id))
40+
}
41+
}, 120000)
42+
43+
afterAll(async () => {
44+
// Clean up created records in batches
45+
const batchSize = 100
46+
for (let i = 0; i < createdTagIds.length; i += batchSize) {
47+
const batch = createdTagIds.slice(i, i + batchSize)
48+
await Promise.all(batch.map((id) => pb.collection('tags').delete(id).catch(() => {})))
49+
}
50+
clearAuth()
51+
}, 120000)
52+
53+
beforeEach(() => {
54+
queryClient = createTestQueryClient()
55+
})
56+
57+
afterEach(() => {
58+
queryClient.clear()
59+
})
60+
61+
it('should fetch all records even when count exceeds default page size', async () => {
62+
const tagsCollection = createTagsCollection(queryClient)
63+
64+
const { result } = renderHook(() =>
65+
useLiveQuery((q) => q.from({ tags: tagsCollection }).where(({ tags }) => eq(tags.color, COLOR)))
66+
)
67+
68+
await waitForLoadFinish(result, 30000)
69+
70+
// Should have at least the 1200 records we created
71+
expect(result.current.data.length).toBeGreaterThanOrEqual(RECORD_COUNT)
72+
73+
// Verify our test tags are present
74+
const testTags = result.current.data.filter((tag) =>
75+
tag.name.startsWith('pagination-test-tag-')
76+
)
77+
expect(testTags.length).toBe(RECORD_COUNT)
78+
}, 60000)
79+
80+
it('should fetch only limited records when limit is specified', async () => {
81+
// Use on-demand sync so the fetch happens when query with limit is executed
82+
const factory = createCollectionFactory(queryClient)
83+
const tagsCollection = factory.create('tags', { syncMode: 'on-demand' })
84+
const LIMIT = 50
85+
86+
// Query with a limit - should only fetch LIMIT records from server
87+
const { result: limitedResult } = renderHook(() =>
88+
useLiveQuery((q) =>
89+
q.from({ tags: tagsCollection })
90+
.orderBy(({ tags }) => tags.id) // Required by TanStack DB when using limit
91+
.limit(LIMIT)
92+
)
93+
)
94+
95+
// Wait for data to actually be populated (not just isLoading: false)
96+
await waitFor(
97+
() => {
98+
expect(limitedResult.current.isLoading).toBe(false)
99+
expect(limitedResult.current.data.length).toBeGreaterThan(0)
100+
},
101+
{ timeout: 30000 }
102+
)
103+
104+
// Query result should return exactly the limit
105+
expect(limitedResult.current.data.length).toBe(LIMIT)
106+
107+
// Verify collection itself only contains LIMIT records (not all 1200+)
108+
// by querying without limit - should still only have LIMIT records
109+
const { result: unlimitedResult } = renderHook(() =>
110+
useLiveQuery((q) => q.from({ tags: tagsCollection }))
111+
)
112+
113+
await waitFor(
114+
() => {
115+
expect(unlimitedResult.current.isLoading).toBe(false)
116+
expect(unlimitedResult.current.data).toBeDefined()
117+
},
118+
{ timeout: 30000 }
119+
)
120+
121+
// Collection should only have LIMIT records since that's all we fetched
122+
expect(unlimitedResult.current.data.length).toBe(LIMIT)
123+
}, 60000)
124+
})

‎test/server-side-filtering.test.ts‎

Lines changed: 19 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -26,16 +26,16 @@ describe('Server-Side Filtering (on-demand mode)', () => {
2626
vi.restoreAllMocks()
2727
})
2828

29-
it('should pass filter to PocketBase getList when .where() is present', async () => {
29+
it('should pass filter to PocketBase getFullList when .where() is present', async () => {
3030
const booksCollection = createBooksCollection(queryClient, { syncMode: 'on-demand' })
3131

3232
// Get a valid genre to filter by
33-
const allBooks = await pb.collection('books').getList(1, 10)
34-
expect(allBooks.items.length).toBeGreaterThan(0)
35-
const testGenre = allBooks.items[0].genre
33+
const allBooks = await pb.collection('books').getFullList()
34+
expect(allBooks.length).toBeGreaterThan(0)
35+
const testGenre = allBooks[0].genre
3636

37-
// Spy on PocketBase getList to verify it's called with filter options
38-
const getListSpy = vi.spyOn(pb.collection('books'), 'getList')
37+
// Spy on PocketBase getFullList to verify it's called with filter options
38+
const getFullListSpy = vi.spyOn(pb.collection('books'), 'getFullList')
3939

4040
const { result } = renderHook(() =>
4141
useLiveQuery((q) =>
@@ -52,36 +52,33 @@ describe('Server-Side Filtering (on-demand mode)', () => {
5252
{ timeout: 10000 }
5353
)
5454

55-
// Verify getList was called with filter parameter (server-side filtering)
56-
expect(getListSpy).toHaveBeenCalled()
55+
// Verify getFullList was called with filter parameter (server-side filtering)
56+
expect(getFullListSpy).toHaveBeenCalled()
5757

5858
// Find the call with filter
59-
const calls = getListSpy.mock.calls
59+
const calls = getFullListSpy.mock.calls
6060
const callWithFilter = calls.find(call => {
61-
const options = call[2]
61+
const options = call[0] as { filter?: string } | undefined
6262
return options && typeof options === 'object' && 'filter' in options && options.filter
6363
})
6464

6565
expect(callWithFilter).toBeDefined()
6666

6767
// Verify the filter parameter was passed correctly
68-
const [page, perPage, options] = callWithFilter!
69-
expect(page).toBe(1)
70-
expect(perPage).toBe(500) // Default limit
71-
expect(options?.filter).toBe(`genre = "${testGenre}"`)
68+
const [options] = callWithFilter!
69+
expect((options as { filter?: string })?.filter).toBe(`genre = "${testGenre}"`)
7270

7371
// All returned records must match the filter
7472
result.current.data.forEach(book => {
7573
expect(book.genre).toBe(testGenre)
7674
})
7775
}, 15000)
7876

79-
it('should pass limit to PocketBase getList when .limit() is present', async () => {
77+
// Note: TanStack DB does NOT pass limit to loadSubsetOptions - limiting is applied client-side.
78+
// This test verifies that client-side limiting works correctly.
79+
it('should apply limit client-side when .limit() is present', async () => {
8080
const booksCollection = createBooksCollection(queryClient, { syncMode: 'on-demand' })
8181

82-
// Spy on PocketBase getList
83-
const getListSpy = vi.spyOn(pb.collection('books'), 'getList')
84-
8582
const { result } = renderHook(() =>
8683
useLiveQuery((q) =>
8784
q.from({ books: booksCollection })
@@ -98,21 +95,7 @@ describe('Server-Side Filtering (on-demand mode)', () => {
9895
{ timeout: 10000 }
9996
)
10097

101-
// Verify getList was called
102-
expect(getListSpy).toHaveBeenCalled()
103-
104-
// Find the call with limit=2 (perPage=2)
105-
const calls = getListSpy.mock.calls
106-
const callWithLimit = calls.find(call => call[1] === 2)
107-
108-
expect(callWithLimit).toBeDefined()
109-
110-
// Verify the limit parameter was passed correctly
111-
const [page, perPage] = callWithLimit!
112-
expect(page).toBe(1)
113-
expect(perPage).toBe(2) // limit passed as perPage
114-
115-
// Verify results respect the limit
98+
// Verify results respect the limit (client-side limiting)
11699
expect(result.current.data.length).toBeLessThanOrEqual(2)
117100
}, 15000)
118101

@@ -161,9 +144,9 @@ describe('Server-Side Filtering (on-demand mode)', () => {
161144
const booksCollection = createBooksCollection(queryClient, { syncMode: 'on-demand' })
162145

163146
// Use a filter to trigger on-demand fetch
164-
const allBooks = await pb.collection('books').getList(1, 10)
165-
expect(allBooks.items.length).toBeGreaterThan(0)
166-
const testGenre = allBooks.items[0].genre
147+
const allBooks = await pb.collection('books').getFullList()
148+
expect(allBooks.length).toBeGreaterThan(0)
149+
const testGenre = allBooks[0].genre
167150

168151
const { result } = renderHook(() =>
169152
useLiveQuery((q) =>

0 commit comments

Comments
 (0)