cleanup live queries

Author: samwillis

packages/db-collection-e2e/src/suites/accumulated-data.suite.ts

@@ -29,6 +29,8 @@ export function createAccumulatedDataTestSuite(
 
         // Test structure: Delete a record, verify it's removed
         expect(query.size).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
     })
 
@@ -52,6 +54,8 @@ export function createAccumulatedDataTestSuite(
         results.forEach((u) => {
           expect(u.deletedAt).toBeNull()
         })
+
+        await query.cleanup()
       })
 
       it(`should include soft-deleted records when not filtered`, async () => {
@@ -71,6 +75,8 @@ export function createAccumulatedDataTestSuite(
 
         expect(hasNotDeleted).toBe(true)
         // May or may not have deleted records depending on seed data
+
+        await query.cleanup()
       })
     })
 
@@ -89,6 +95,8 @@ export function createAccumulatedDataTestSuite(
         // Test structure: Update a record in database
         // Query should receive update reactively
         expect(query.size).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
     })
   })

packages/db-collection-e2e/src/suites/collation.suite.ts

@@ -29,6 +29,8 @@ export function createCollationTestSuite(
 
         const results = Array.from(query.state.values())
         expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
 
       it(`should handle case-sensitive comparisons by default`, async () => {
@@ -48,6 +50,8 @@ export function createCollationTestSuite(
         const results = Array.from(query.state.values())
         // Should match lowercase variant from seed data
         expect(results.length).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
     })
 
@@ -66,6 +70,8 @@ export function createCollationTestSuite(
         await query.preload()
 
         expect(query.compareOptions.stringSort).toBe(`lexical`)
+
+        await query.cleanup()
       })
 
       it(`should support locale-based collation`, async () => {
@@ -86,6 +92,8 @@ export function createCollationTestSuite(
         if (query.compareOptions.stringSort === `locale`) {
           expect(query.compareOptions.locale).toBe(`de-DE`)
         }
+
+        await query.cleanup()
       })
     })
 
@@ -103,6 +111,8 @@ export function createCollationTestSuite(
         await query.preload()
 
         expect(query.compareOptions.stringSort).toBe(`lexical`)
+
+        await query.cleanup()
       })
     })
 
@@ -128,6 +138,8 @@ export function createCollationTestSuite(
           // Just verify it's sorted, regardless of collation
           expect(results[i - 1]!.name).toBeTruthy()
         }
+
+        await query.cleanup()
       })
     })
   })

packages/db-collection-e2e/src/suites/deduplication.suite.ts

@@ -37,6 +37,8 @@ export function createDeduplicationTestSuite(
         // Both should have same results
         expect(query1.size).toBe(query2.size)
         expect(query1.size).toBeGreaterThanOrEqual(0)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
 
       it(`should deduplicate multiple identical queries`, async () => {
@@ -61,6 +63,8 @@ export function createDeduplicationTestSuite(
         queries.forEach((q) => {
           expect(q.size).toBe(firstSize!)
         })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
       })
     })
 
@@ -88,6 +92,8 @@ export function createDeduplicationTestSuite(
 
         // Query 2 results should be subset of Query 1
         expect(query2.size).toBeLessThanOrEqual(query1.size)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
 
       it(`should handle non-overlapping predicates correctly`, async () => {
@@ -114,6 +120,8 @@ export function createDeduplicationTestSuite(
         // Both should execute independently
         expect(query1.size).toBeGreaterThanOrEqual(0)
         expect(query2.size).toBeGreaterThanOrEqual(0)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
     })
 
@@ -123,21 +131,23 @@ export function createDeduplicationTestSuite(
         const usersCollection = config.collections.onDemand.users
 
         // Start first query
-        const query1Promise = createLiveQueryCollection((q) =>
+        const query1 = createLiveQueryCollection((q) =>
           q
             .from({ user: usersCollection })
             .where(({ user }) => eq(user.isActive, true))
-        ).preload()
+        )
 
         // Immediately start identical second query
-        const query2Promise = createLiveQueryCollection((q) =>
+        const query2 = createLiveQueryCollection((q) =>
           q
             .from({ user: usersCollection })
             .where(({ user }) => eq(user.isActive, true))
-        ).preload()
+        )
 
         // Both should complete successfully
-        await Promise.all([query1Promise, query2Promise])
+        await Promise.all([query1.preload(), query2.preload()])
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
 
       it(`should handle query arriving mid-flight with different predicate`, async () => {
@@ -160,6 +170,8 @@ export function createDeduplicationTestSuite(
 
         // Both execute correctly
         expect(query1.size).toBeGreaterThanOrEqual(query2.size)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
     })
 
@@ -190,6 +202,8 @@ export function createDeduplicationTestSuite(
 
         expect(query1.size).toBe(query2.size)
         expect(query1.size).toBe(10)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
 
       it(`should handle queries with different limits`, async () => {
@@ -216,6 +230,8 @@ export function createDeduplicationTestSuite(
 
         expect(query1.size).toBe(10)
         expect(query2.size).toBe(20)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
 
       it(`should handle queries with different offsets`, async () => {
@@ -249,6 +265,8 @@ export function createDeduplicationTestSuite(
         const ids1 = Array.from(query1.state.values()).map((u) => u.id)
         const ids2 = Array.from(query2.state.values()).map((u) => u.id)
         expect(ids1).not.toEqual(ids2)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
     })
 
@@ -275,6 +293,8 @@ export function createDeduplicationTestSuite(
         queries.forEach((q) => {
           expect(q.size).toBe(firstSize!)
         })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
       })
 
       it(`should not corrupt data with concurrent queries`, async () => {
@@ -311,6 +331,8 @@ export function createDeduplicationTestSuite(
         queries.forEach((q) => {
           expect(q.size).toBeGreaterThanOrEqual(0)
         })
+
+        await Promise.all(queries.map((q) => q.cleanup()))
       })
     })
   })

packages/db-collection-e2e/src/suites/joins.suite.ts

@@ -37,6 +37,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         expect(results.length).toBeGreaterThan(0)
         expect(results[0]!).toHaveProperty(`userName`)
         expect(results[0]!).toHaveProperty(`postTitle`)
+
+        await query.cleanup()
       })
 
       it(`should join with predicates on both collections`, async () => {
@@ -67,6 +69,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         results.forEach((r) => {
           expect(r.viewCount).toBeGreaterThan(10)
         })
+
+        await query.cleanup()
       })
 
       it(`should join with one eager, one on-demand`, async () => {
@@ -94,6 +98,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
 
         const results = Array.from(query.state.values())
         expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
 
       it(`should join with ordering across collections`, async () => {
@@ -141,6 +147,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
           const currCount = results[i]!.viewCount
           expect(prevCount).toBeGreaterThanOrEqual(currCount)
         }
+
+        await query.cleanup()
       })
 
       it(`should join with pagination`, async () => {
@@ -167,6 +175,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         await query.preload()
 
         expect(query.size).toBeLessThanOrEqual(10)
+
+        await query.cleanup()
       })
     })
 
@@ -198,6 +208,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         expect(results[0]!).toHaveProperty(`userName`)
         expect(results[0]!).toHaveProperty(`postTitle`)
         expect(results[0]!).toHaveProperty(`commentText`)
+
+        await query.cleanup()
       })
 
       it(`should handle predicates on all three collections`, async () => {
@@ -227,6 +239,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         const results = Array.from(query.state.values())
         // All results should match all predicates
         expect(results.length).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
 
       it(`should handle mixed syncModes in 3-way join`, async () => {
@@ -259,6 +273,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
 
         const results = Array.from(query.state.values())
         expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
     })
 
@@ -287,6 +303,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         results.forEach((r) => {
           expect(r.viewCount).toBeGreaterThan(50)
         })
+
+        await query.cleanup()
       })
 
       it(`should not over-fetch in joined collections`, async () => {
@@ -313,6 +331,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
         results.forEach((r) => {
           expect(r.userAge).toBeGreaterThan(30)
         })
+
+        await query.cleanup()
       })
     })
 
@@ -339,6 +359,8 @@ export function createJoinsTestSuite(getConfig: () => Promise<E2ETestConfig>) {
 
         const results = Array.from(query.state.values())
         expect(results.length).toBeGreaterThan(0)
+
+        await query.cleanup()
       })
     })
   })

packages/db-collection-e2e/src/suites/live-updates.suite.ts

@@ -28,6 +28,8 @@ export function createLiveUpdatesTestSuite(
 
         // Test structure: After backend insert/update, query should update reactively
         expect(initialSize).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
 
       it(`should add new records that match query predicate`, async () => {
@@ -45,6 +47,8 @@ export function createLiveUpdatesTestSuite(
         // Test structure: Insert record with age=35 in database
         // Should appear in query results reactively
         expect(query.size).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
 
       it(`should remove records that no longer match predicate`, async () => {
@@ -62,6 +66,8 @@ export function createLiveUpdatesTestSuite(
         // Test structure: Update backend record from age=35 to age=25
         // Should be removed from query results
         expect(query.size).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
     })
 
@@ -85,6 +91,8 @@ export function createLiveUpdatesTestSuite(
         expect(changeCount).toBeGreaterThanOrEqual(0)
 
         subscription.unsubscribe()
+
+        await query.cleanup()
       })
     })
 
@@ -110,6 +118,8 @@ export function createLiveUpdatesTestSuite(
         // Both queries should work independently
         expect(query1.size).toBeGreaterThanOrEqual(0)
         expect(query2.size).toBeGreaterThanOrEqual(0)
+
+        await Promise.all([query1.cleanup(), query2.cleanup()])
       })
     })
   })

packages/db-collection-e2e/src/suites/mutations.suite.ts

@@ -28,6 +28,8 @@ export function createMutationsTestSuite(
         // Note: Actual insert would use collection.insert()
         // This test structure is ready for when mutation APIs are available
         expect(initialSize).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
 
       it(`should handle insert appearing in matching queries`, async () => {
@@ -44,6 +46,8 @@ export function createMutationsTestSuite(
 
         // Test structure ready for insert testing
         expect(query.size).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
     })
 
@@ -64,6 +68,8 @@ export function createMutationsTestSuite(
         // Test structure: Update a user from age=25 to age=35
         // Should appear in query results
         expect(initialSize).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
 
       it(`should handle update that makes record unmatch predicate`, async () => {
@@ -81,6 +87,8 @@ export function createMutationsTestSuite(
         // Test structure: Update a user from age=35 to age=25
         // Should be removed from query results
         expect(query.size).toBeGreaterThanOrEqual(0)
+
+        await query.cleanup()
       })
     })
 
@@ -101,6 +109,8 @@ export function createMutationsTestSuite(
 
         // Test structure: Mutations should maintain pagination state
         expect(query.size).toBeLessThanOrEqual(10)
+
+        await query.cleanup()
       })
     })
   })