Feat/refactor sqlite

package.json

@@ -1,6 +1,6 @@
 {
   "name": "muya",
-  "version": "2.4.4",
+  "version": "2.4.5",
   "author": "samuel.gjabel@gmail.com",
   "repository": "https://github.com/samuelgjabel/muya",
   "main": "cjs/index.js",

packages/core/scheduler.ts

@@ -10,7 +10,7 @@ interface GlobalSchedulerItem<T> {
 
 export interface SchedulerOptions<T> {
   readonly onResolveItem?: (item: T) => void
-  readonly onScheduleDone: () => void | Promise<void>
+  readonly onScheduleDone: (values?: unknown[]) => void | Promise<void>
 }
 
 /**
@@ -59,13 +59,18 @@ export function createScheduler() {
     }
 
     const effectedListeners = new Set<ScheduleId>()
+    const valuesMap = new Map<ScheduleId, unknown[]>()
     for (const value of batches) {
       if (listeners.has(value.id)) {
         effectedListeners.add(value.id)
         const { onResolveItem } = listeners.get(value.id)!
         if (onResolveItem) {
           onResolveItem(value.value)
         }
+        if (!valuesMap.has(value.id)) {
+          valuesMap.set(value.id, [])
+        }
+        valuesMap.get(value.id)!.push(value.value)
       }
       batches.delete(value)
     }
@@ -76,7 +81,8 @@ export function createScheduler() {
     }
 
     for (const id of effectedListeners) {
-      listeners.get(id)?.onScheduleDone()
+      const values = valuesMap.get(id)
+      listeners.get(id)?.onScheduleDone(values)
     }
   }
 

packages/core/sqlite/__tests__/use-slite-count.test.tsx

@@ -0,0 +1,96 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+import { createSqliteState } from '../create-sqlite'
+import { useSqliteCount } from '../use-sqlite-count'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { waitFor } from '@testing-library/react'
+
+const backend = bunMemoryBackend()
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+describe('useSqliteCount', () => {
+  it('should count items in the table', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'CountTest1', key: 'id' })
+    const { result } = renderHook(() => useSqliteCount(sql))
+
+    await waitFor(() => {
+      expect(result.current).toBe(0)
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+      sql.set({ id: '2', name: 'Bob', age: 25 })
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(2)
+    })
+
+    act(() => {
+      sql.delete('1')
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(1)
+    })
+  })
+
+  it('should support filtering with where clause', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'CountTest2', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+
+    const { result } = renderHook(() => useSqliteCount(sql, { where: { age: { gt: 30 } } }))
+
+    await waitFor(() => {
+      expect(result.current).toBe(1)
+    })
+
+    act(() => {
+      sql.set({ id: '4', name: 'Dave', age: 35 })
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(2)
+    })
+
+    act(() => {
+      sql.delete('3')
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(1)
+    })
+  })
+
+  it('should react to dependency changes', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'CountTest3', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+
+    const { result, rerender } = renderHook(({ minAge }) => useSqliteCount(sql, { where: { age: { gt: minAge } } }, [minAge]), {
+      initialProps: { minAge: 20 },
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(3)
+    })
+
+    act(() => {
+      rerender({ minAge: 30 })
+    })
+
+    await waitFor(() => {
+      expect(result.current).toBe(1)
+    })
+  })
+})