muya 2.4.92 → 2.4.93

package/esm/sqlite/use-sqlite.js

@@ -1 +1 @@
-import{useCallback as f,useLayoutEffect as P,useReducer as R,useRef as D}from"react";import{DEFAULT_PAGE_SIZE as O}from"./table";const T=1e4;function K(i,w={},k=[]){const{select:m,pageSize:q=O}=w,e=D(null),[,I]=R(c=>c+1,0),n=D(new Map),x=D(null),L=f(()=>{const{select:c,...l}=w;x.current=i.search({select:(o,a)=>({doc:o,meta:a}),...l})},[i,...k]),d=f(()=>{e.current=[],n.current.clear(),L()},[L]),y=f(async c=>{e.current===null&&(e.current=[]),c===!0&&d();const{current:l}=x;if(!l)return!0;let o=!1;for(let a=0;a<q;a++){const s=await l.next();if(s.done){x.current=null,o=!0;break}if(n.current.has(s.value.meta.key)){a+=-1;continue}e.current.push(m?m(s.value.doc):s.value.doc),n.current.set(s.value.meta.key,e.current.length-1)}return e.current=[...e.current],o},[]),p=f(async()=>{const c=await y(!1);return I(),c},[y]);P(()=>{const c=i.subscribe(async l=>{const{mutations:o,removedAll:a}=l;if(a&&d(),!o)return;const s=e.current?.length??0;let g=s,h=!1;const S=new Set;for(const u of o){const{key:r,op:b}=u;switch(b){case"insert":{g+=1;break}case"delete":{if(e.current&&e.current.length>0&&n.current.has(r)){const t=n.current.get(r);if(t===void 0)break;S.add(t),h=!0}break}case"update":{if(n.current.has(r)){const t=n.current.get(r);t!==void 0&&e.current&&(e.current[t]=await i.get(r,m),e.current=[...e.current],h=!0)}else{const t=await i.get(r,m);t&&(e.current=[...e.current??[],t],n.current.set(r,e.current.length-1),h=!0)}break}}}if(S.size>0&&e.current&&e.current.length>0){const u=new Map;e.current=e.current?.filter((b,t)=>!S.has(t));let r=0;for(const[b,t]of n.current)S.has(t)||(u.set(b,r),r++);n.current=u}const A=s!==g;if(A||h){if(A){await y(!0);let u=0;for(;(e.current?.length??0)<g&&u<T;)await y(!1),u++;u===T&&console.warn("Reached maximum iterations in fillNextPage loop. Possible duplicate or data issue.")}I()}});return()=>{c()}},[i]),P(()=>{d(),p()},k);const v=f(async()=>{d(),await p()},[p,d]);return[e.current,{nextPage:p,reset:v,keysIndex:n.current}]}export{K as useSqliteValue};
+import{useCallback as f,useLayoutEffect as P,useReducer as _,useRef as D}from"react";import{DEFAULT_PAGE_SIZE as C}from"./table";import{shallow as E}from"../utils/shallow";const T=1e4;function z(a,w={},I=[]){const{select:m,pageSize:q=C}=w,e=D(null),[,k]=_(c=>c+1,0),n=D(new Map),x=D(null),A=f(()=>{const{select:c,...i}=w;x.current=a.search({select:(u,l)=>({doc:u,meta:l}),...i})},[a,...I]),d=f(()=>{e.current=[],n.current.clear(),A()},[A]),y=f(async c=>{e.current===null&&(e.current=[]),c===!0&&d();const{current:i}=x;if(!i)return!0;let u=!1;for(let l=0;l<q;l++){const o=await i.next();if(o.done){x.current=null,u=!0;break}n.current.has(o.value.meta.key)||(e.current.push(m?m(o.value.doc):o.value.doc),n.current.set(o.value.meta.key,e.current.length-1))}return e.current=[...e.current],u},[]),p=f(async()=>{const c=await y(!1);return k(),c},[y]);P(()=>{const c=a.subscribe(async i=>{const{mutations:u,removedAll:l}=i;if(l&&d(),!u)return;const o=e.current?.length??0;let g=o,h=!1;const S=new Set;for(const s of u){const{key:r,op:b}=s;switch(b){case"insert":{g+=1;break}case"delete":{if(e.current&&e.current.length>0&&n.current.has(r)){const t=n.current.get(r);if(t===void 0)break;S.add(t),h=!0}break}case"update":{if(n.current.has(r)){const t=n.current.get(r);if(t!==void 0&&e.current){const v=await a.get(r,m),O=e.current[t];E(O,v)||(e.current[t]=v,e.current=[...e.current],h=!0)}}else{const t=await a.get(r,m);t&&(e.current=[...e.current??[],t],n.current.set(r,e.current.length-1),h=!0)}break}}}if(S.size>0&&e.current&&e.current.length>0){const s=new Map;e.current=e.current?.filter((b,t)=>!S.has(t));let r=0;for(const[b,t]of n.current)S.has(t)||(s.set(b,r),r++);n.current=s}const L=o!==g;if(L||h){if(L){await y(!0);let s=0;for(;(e.current?.length??0)<g&&s<T;)await y(!1),s++;s===T&&console.warn("Reached maximum iterations in fillNextPage loop. Possible duplicate or data issue.")}k()}});return()=>{c()}},[a]),P(()=>{d(),p()},I);const R=f(async()=>{d(),await p()},[p,d]);return[e.current,{nextPage:p,reset:R,keysIndex:n.current}]}export{z as useSqliteValue};

package/package.json

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

package/src/sqlite/__tests__/use-sqlite.more.test.tsx

@@ -4,6 +4,7 @@ import { useSqliteValue } from '../use-sqlite'
 import { waitFor } from '@testing-library/react'
 import { bunMemoryBackend } from '../table/bun-backend'
 import { StrictMode, Suspense } from 'react'
+import type { Key } from '../table'
 
 const backend = bunMemoryBackend()
 
@@ -428,4 +429,209 @@ describe('use-sqlite edge cases', () => {
       ])
     })
   })
+
+  it('should handle rapid consecutive updates without losing state', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'RaceState', key: 'id' })
+
+    // Insert initial document
+    await sql.set({ id: '1', name: 'Alice', age: 30 })
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice', age: 30 }])
+    })
+
+    // Now simulate fast consecutive updates to the same key
+    // These will hit the subscription handler while it's still awaiting `state.get`
+    await Promise.all([
+      sql.set({ id: '1', name: 'AliceV2', age: 31 }),
+      sql.set({ id: '1', name: 'AliceV3', age: 32 }),
+      sql.set({ id: '1', name: 'AliceV4', age: 33 }),
+    ])
+
+    // Wait for hook to stabilize
+    await waitFor(() => {
+      // eslint-disable-next-line prefer-destructuring, unicorn/prevent-abbreviations
+      const docs = result.current[0]
+      expect(docs?.length).toBe(1)
+      // Expect the *latest* update to win
+      expect(docs?.[0]).toEqual({ id: '1', name: 'AliceV4', age: 33 })
+    })
+  })
+
+  it('should not overwrite newer updates with stale state.get results', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'RaceFailState', key: 'id' })
+    await sql.set({ id: '1', name: 'Initial', age: 20 })
+
+    // Delay the first get call artificially to simulate slow DB
+    let callCount = 0
+    const originalGet = sql.get
+    // @ts-expect-error - We mocking the get method for testing
+    sql.get = async (key: Key, selector: ((document: Person) => Person) | undefined) => {
+      callCount++
+      if (callCount === 1) {
+        // Simulate slow resolution for first update
+        await new Promise((resolve) => setTimeout(resolve, 50))
+      }
+      return originalGet(key, selector)
+    }
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Initial', age: 20 }])
+    })
+
+    // Trigger two consecutive updates
+    await sql.set({ id: '1', name: 'AliceV1', age: 21 })
+    await sql.set({ id: '1', name: 'AliceV2', age: 22 })
+
+    // Wait for hook to stabilize
+    await waitFor(() => {
+      // eslint-disable-next-line prefer-destructuring, unicorn/prevent-abbreviations
+      const docs = result.current[0]
+      expect(docs?.length).toBe(1)
+      // 🔥 Correct behavior: should end with the *latest* version (AliceV2)
+      // ❌ Buggy behavior: may still show AliceV1 because the delayed get resolves last
+      expect(docs?.[0]).toEqual({ id: '1', name: 'AliceV2', age: 22 })
+    })
+  })
+  it('should reset correctly during pagination', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'ResetMid', key: 'id' })
+    const people = Array.from({ length: 200 }, (_, index) => ({ id: `${index + 1}`, name: `P${index + 1}`, age: index }))
+    await sql.batchSet(people)
+
+    const { result } = renderHook(() => useSqliteValue(sql, { pageSize: 50 }, []))
+
+    await waitFor(() => {
+      expect(result.current[0]?.length).toBe(50)
+    })
+
+    // Load next page
+    await act(async () => {
+      await result.current[1].nextPage()
+    })
+    expect(result.current[0]?.length).toBe(100)
+
+    // Reset
+    await act(async () => {
+      await result.current[1].reset()
+    })
+    await waitFor(() => {
+      // Should go back to first page only
+      expect(result.current[0]?.length).toBe(50)
+      expect(result.current[0]?.[0]?.id).toBe('1')
+    })
+  })
+  it('should overwrite duplicate keys instead of duplicating items', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'DupTest', key: 'id' })
+    await sql.set({ id: '1', name: 'Alice', age: 30 })
+    await sql.set({ id: '1', name: 'Alice2', age: 35 }) // overwrite
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice2', age: 35 }])
+    })
+  })
+  it('should not update after unmount', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'UnmountTest', key: 'id' })
+    const { unmount, result } = renderHook(() => useSqliteValue(sql, {}, []))
+
+    unmount()
+    await sql.set({ id: '1', name: 'ShouldNotAppear', age: 99 })
+
+    // wait briefly to give subscription a chance
+    await new Promise((r) => setTimeout(r, 20))
+
+    expect(result.current[0]).toBeNull() // no state change after unmount
+  })
+  it('should restart iterator when sortBy changes', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'SortChange', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'A', age: 40 },
+      { id: '2', name: 'B', age: 20 },
+    ])
+
+    const { result, rerender } = renderHook(({ sortBy }) => useSqliteValue(sql, { sortBy }, [sortBy]), {
+      initialProps: { sortBy: 'age' as keyof Person },
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]?.[0]?.age).toBe(20)
+    })
+
+    act(() => {
+      rerender({ sortBy: 'name' })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]?.[0]?.name).toBe('A') // sorted by name asc
+    })
+  })
+
+  it('should return done when nextPage is called on empty table', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'EmptyNext', key: 'id' })
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+
+    // @ts-expect-error - Testing internal method
+    const isDone = await act(result.current[1].nextPage)
+    expect(isDone).toBe(true)
+    expect(result.current[0]).toEqual([])
+  })
+
+  it('should handle deletion of non-visible item gracefully', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'DeleteNonVisible', key: 'id' })
+    const people = Array.from({ length: 200 }, (_, index) => ({ id: `${index + 1}`, name: `P${index + 1}`, age: index }))
+    await sql.batchSet(people)
+    let renderCount = 0
+    const { result } = renderHook(() => {
+      renderCount++
+      return useSqliteValue(sql, { pageSize: 50 }, [])
+    })
+    await waitFor(() => {
+      expect(renderCount).toBe(2) // initial + after load
+      expect(result.current[0]?.length).toBe(50)
+    })
+
+    // Delete item outside current page
+    await act(async () => {
+      await sql.delete('150')
+    })
+
+    await waitFor(() => {
+      expect(renderCount).toBe(2) // no re-render
+      expect(result.current[0]?.length).toBe(50) // unchanged page size
+    })
+  })
+  it('should not rerender when using select if the selected value does not change', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'SelectNoReRender', key: 'id' })
+    await sql.set({ id: '1', name: 'Alice', age: 30 })
+
+    let renders = 0
+    const { result } = renderHook(() => {
+      renders++
+      // Only project `name`
+      return useSqliteValue(sql, { select: (p) => p.name }, [])
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual(['Alice'])
+      expect(renders).toBe(2) // initial + after first load
+    })
+
+    // Update age (not part of select projection)
+    await act(async () => {
+      await sql.set({ id: '1', name: 'Alice', age: 31 })
+    })
+
+    // Wait a bit to let subscription flush
+    await new Promise((r) => setTimeout(r, 20))
+
+    // ❌ Buggy: renders increments again, even though "Alice" didn't change
+    // ✅ Expected: still 2 renders
+    expect(result.current[0]).toEqual(['Alice'])
+    expect(renders).toBe(2)
+  })
 })

package/src/sqlite/use-sqlite.ts

@@ -3,6 +3,7 @@ import { useCallback, useLayoutEffect, useReducer, useRef, type DependencyList }
 import type { SyncTable } from './create-sqlite'
 import type { DocType, Key, SqlSeachOptions } from './table/table.types'
 import { DEFAULT_PAGE_SIZE } from './table'
+import { shallow } from '../utils/shallow'
 const MAX_ITERATIONS = 10_000
 
 export interface SqLiteActions {
@@ -54,7 +55,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [state, ...deps])
 
-  const reset = useCallback(() => {
+  const resetDataAndUpdateIterator = useCallback(() => {
     itemsRef.current = []
     keysIndex.current.clear()
     updateIterator()
@@ -65,7 +66,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
       itemsRef.current = []
     }
     if (shouldReset === true) {
-      reset()
+      resetDataAndUpdateIterator()
     }
 
     const { current: iterator } = iteratorRef
@@ -82,8 +83,6 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
         break
       }
       if (keysIndex.current.has(result.value.meta.key)) {
-        // eslint-disable-next-line sonarjs/updated-loop-counter
-        index += -1
         continue
       }
       itemsRef.current.push(select ? select(result.value.doc) : (result.value.doc as unknown as Selected))
@@ -104,7 +103,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
     const unsubscribe = state.subscribe(async (item) => {
       const { mutations, removedAll } = item
       if (removedAll) {
-        reset()
+        resetDataAndUpdateIterator()
       }
       if (!mutations) {
         return
@@ -134,9 +133,15 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
             if (keysIndex.current.has(key)) {
               const index = keysIndex.current.get(key)
               if (index !== undefined && itemsRef.current) {
-                itemsRef.current[index] = (await state.get(key, select)) as Selected
-                itemsRef.current = [...itemsRef.current]
-                hasUpdate = true
+                const newItem = (await state.get(key, select)) as Selected
+                const previousItem = itemsRef.current[index]
+
+                // 🆕 Only update & rerender if shallow comparison fails
+                if (!shallow(previousItem, newItem)) {
+                  itemsRef.current[index] = newItem
+                  itemsRef.current = [...itemsRef.current]
+                  hasUpdate = true
+                }
               }
             } else {
               // Handle updates to non-visible items
@@ -193,15 +198,15 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
   }, [state])
 
   useLayoutEffect(() => {
-    reset()
+    resetDataAndUpdateIterator()
     nextPage()
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps)
 
   const resetCb = useCallback(async () => {
-    reset()
+    resetDataAndUpdateIterator()
     await nextPage()
-  }, [nextPage, reset])
+  }, [nextPage, resetDataAndUpdateIterator])
 
   return [itemsRef.current, { nextPage, reset: resetCb, keysIndex: keysIndex.current }] as [
     (undefined extends Selected ? Document[] : Selected[]) | null,