muya 2.4.92 → 2.4.94

package/esm/sqlite/__tests__/where.test.js

@@ -0,0 +1 @@
+import{createTable as n}from"../table";import{bunMemoryBackend as c}from"../table/bun-backend";describe("where clauses",()=>{const a=c();it("should handle where where array of conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNestedOptional",key:"id",indexes:["content"]});await e.set({id:"1",content:"The quick brown fox"}),await e.set({id:"2",content:"The jumps over the lazy dog"}),await e.set({id:"3"});const t=[];for await(const i of e.search({where:{content:{like:["The%"]}}}))t.push(i);expect(t.length).toBe(2),expect(t[0].id).toBe("1")}),it("should create nested index for optional nested fields",async()=>{const e=await n({backend:a,tableName:"TestTableNestedOptional",key:"id",indexes:["fts:info.content"]});await e.set({id:"1",info:{content:"The quick brown fox"}}),await e.set({id:"2",info:{content:"jumps over the lazy dog"}}),await e.set({id:"3"});const t=[];for await(const s of e.search({where:{info:{content:{like:["The%"]}}}}))t.push(s);expect(t.length).toBe(1),expect(t[0].id).toBe("1");const i=[];for await(const s of e.search({where:{OR:[{info:{content:{like:["The%"]}}},{info:{content:{like:["jumps%"]}}}]}}))i.push(s);expect(i.length).toBe(2);const o=[];for await(const s of e.search({where:{info:{content:"nonexistent"}}}))o.push(s);expect(o.length).toBe(0)}),it("should handle FTS queries",async()=>{const e=await n({backend:a,tableName:"TestTableFts",key:"id",indexes:["fts:content"]});await e.set({id:"1",content:"The quick brown fox"}),await e.set({id:"2",content:"Jumps over the lazy dog"}),await e.set({id:"3",content:"Another document"});const t=[];for await(const i of e.search({where:{content:{fts:"quick"}}}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("1")}),it("should handle nested where conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNested",key:"id",indexes:["info.content"]});await e.set({id:"1",info:{content:"Nested quick brown fox"}}),await e.set({id:"2",info:{content:"Nested jumps over the lazy dog"}});const t=[];for await(const i of e.search({where:{info:{content:{like:"Nested%"}}}}))t.push(i);expect(t.length).toBe(2)}),it("should handle complex operators",async()=>{const e=await n({backend:a,tableName:"TestTableComplex",key:"id",indexes:["value"]});await e.set({id:"1",value:10}),await e.set({id:"2",value:20}),await e.set({id:"3",value:30});const t=[];for await(const i of e.search({where:{value:{gt:15,lt:25}},sortBy:"value"}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("2")}),it("should handle NOT conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNot",key:"id",indexes:["value"]});await e.set({id:"1",value:"apple"}),await e.set({id:"2",value:"banana"}),await e.set({id:"3",value:"cherry"});const t=[];for await(const i of e.search({where:{NOT:{value:"banana"}}}))t.push(i);expect(t.length).toBe(2),expect(t.map(i=>i.value)).toEqual(["apple","cherry"])}),it("should handle AND conditions",async()=>{const e=await n({backend:a,tableName:"TestTableAnd",key:"id",indexes:["category","price"]});await e.set({id:"1",category:"fruit",price:10}),await e.set({id:"2",category:"fruit",price:20}),await e.set({id:"3",category:"vegetable",price:15});const t=[];for await(const i of e.search({where:{AND:[{category:"fruit"},{price:{lt:15}}]}}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("1")}),it("should handle OR conditions",async()=>{const e=await n({backend:a,tableName:"TestTableOr",key:"id",indexes:["type"]});await e.set({id:"1",type:"A"}),await e.set({id:"2",type:"B"}),await e.set({id:"3",type:"C"});const t=[];for await(const i of e.search({where:{OR:[{type:"A"},{type:"C"}]}}))t.push(i);expect(t.length).toBe(2),expect(t.map(i=>i.type)).toEqual(["A","C"])}),it("should handle nested AND/OR/NOT conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNestedLogic",key:"id",indexes:["category","price"]});await e.set({id:"1",category:"fruit",price:10}),await e.set({id:"2",category:"fruit",price:20}),await e.set({id:"3",category:"fruit",price:15});const t={AND:[{category:{is:"fruit"}},{OR:[{price:{lt:15}},{price:{is:15}}]}]},i=[];for await(const s of e.search({}))i.push(s);expect(i.length).toBe(3);const o=[];for await(const s of e.search({where:t}))o.push(s);expect(o.length).toBe(2)})});

package/esm/sqlite/table/where.js

@@ -1 +1 @@
-function a(n){return typeof n=="string"?`'${n.replaceAll("'","''")}'`:typeof n=="number"?n.toString():typeof n=="boolean"?n?"1":"0":`'${String(n).replaceAll("'","''")}'`}function A(n,r,t){const e=t?`${t}.`:"";return n==="KEY"?`"${e}key"`:typeof r=="string"?`CAST(json_extract(${e}data, '$.${n}') AS TEXT)`:typeof r=="number"?`CAST(json_extract(${e}data, '$.${n}') AS NUMERIC)`:typeof r=="boolean"?`CAST(json_extract(${e}data, '$.${n}') AS INTEGER)`:`json_extract(${e}data, '$.${n}')`}const N=new Set(["is","isNot","gt","gte","lt","lte","in","notIn","like","fts"]);function p(n,r=""){const t={};for(const[e,c]of Object.entries(n)){if(e==="AND"||e==="OR"||e==="NOT"){t[e]=c;continue}const $=r?`${r}.${e}`:e;c&&typeof c=="object"&&!Array.isArray(c)&&!Object.keys(c).some(i=>N.has(i))?Object.assign(t,p(c,$)):t[$]=c}return t}function l(n,r,t){if(!n||typeof n!="object")return"";if(n.AND){const i=Array.isArray(n.AND)?n.AND.map(u=>l(u,r,t)).filter(Boolean):[];return i.length>0?`(${i.join(" AND ")})`:""}if(n.OR){const i=Array.isArray(n.OR)?n.OR.map(u=>l(u,r,t)).filter(Boolean):[];return i.length>0?`(${i.join(" OR ")})`:""}if(n.NOT){const i=l(n.NOT,r,t);return i?`(NOT ${i})`:""}const e=p(n);let c="",$=!1;for(const[i,u]of Object.entries(e)){if(u==null)continue;let T;typeof u!="object"||Array.isArray(u)?T=Array.isArray(u)?{in:u}:{is:u}:T=u;for(const s of Object.keys(T)){const d=T[s];if(d==null)continue;const y=Array.isArray(d)?d:[d];if(y.length!==0){if(s==="fts"){if(!t)throw new Error("FTS requires tableName for JOIN reference");const o=y.map(f=>`EXISTS (SELECT 1 FROM ${t}_fts f WHERE f.rowid = ${r??t}.rowid AND ${t}_fts MATCH ${a(f)})`).join(" AND ");c+=($?" AND ":"")+o,$=!0;continue}if(s==="is"||s==="isNot"||s==="in"||s==="notIn"){const o=A(i,y[0],r),f=y.map(a).join(","),g=s==="is"?y.length>1?`${o} IN (${f})`:`${o} = ${a(y[0])}`:s==="isNot"?y.length>1?`${o} NOT IN (${f})`:`${o} <> ${a(y[0])}`:s==="in"?`${o} IN (${f})`:`${o} NOT IN (${f})`;c+=($?" AND ":"")+g,$=!0;continue}for(const o of y){const f=A(i,o,r),g=s==="gt"?`${f} > ${a(o)}`:s==="gte"?`${f} >= ${a(o)}`:s==="lt"?`${f} < ${a(o)}`:s==="lte"?`${f} <= ${a(o)}`:`${f} LIKE ${a(o)}`;c+=($?" AND ":"")+g,$=!0}}}}return $?`(${c})`:""}function k(n,r){if(!n)return"";const t=l(n,void 0,r);return t?`WHERE ${t}`:""}export{l as getWhere,k as getWhereQuery};
+function $(n){return typeof n=="string"?`'${n.replaceAll("'","''")}'`:typeof n=="number"?n.toString():typeof n=="boolean"?n?"1":"0":`'${String(n).replaceAll("'","''")}'`}function A(n,r,t){const o=t?`${t}.`:"";return n==="KEY"?`"${o}key"`:typeof r=="string"?`CAST(json_extract(${o}data, '$.${n}') AS TEXT)`:typeof r=="number"?`CAST(json_extract(${o}data, '$.${n}') AS NUMERIC)`:typeof r=="boolean"?`CAST(json_extract(${o}data, '$.${n}') AS INTEGER)`:`json_extract(${o}data, '$.${n}')`}const p=new Set(["is","isNot","gt","gte","lt","lte","in","notIn","like","fts"]);function R(n,r=""){const t={};for(const[o,c]of Object.entries(n)){if(o==="AND"||o==="OR"||o==="NOT"){t[o]=c;continue}const a=r?`${r}.${o}`:o;c&&typeof c=="object"&&!Array.isArray(c)&&!Object.keys(c).some(i=>p.has(i))?Object.assign(t,R(c,a)):t[a]=c}return t}function T(n,r,t){if(!n||typeof n!="object")return"";if(n.AND){const i=Array.isArray(n.AND)?n.AND.map(u=>T(u,r,t)).filter(Boolean):[];return i.length>0?`(${i.join(" AND ")})`:""}if(n.OR){const i=Array.isArray(n.OR)?n.OR.map(u=>T(u,r,t)).filter(Boolean):[];return i.length>0?`(${i.join(" OR ")})`:""}if(n.NOT){const i=T(n.NOT,r,t);return i?`(NOT ${i})`:""}const o=R(n);let c="",a=!1;for(const[i,u]of Object.entries(o)){if(u==null)continue;let d;typeof u!="object"||Array.isArray(u)?d=Array.isArray(u)?{in:u}:{is:u}:d=u;for(const s of Object.keys(d)){const l=d[s];if(l==null)continue;const y=Array.isArray(l)?l:[l];if(y.length!==0){if(s==="fts"){if(!t)throw new Error("FTS requires tableName for JOIN reference");const e=y.map(f=>`EXISTS (SELECT 1 FROM ${t}_fts f WHERE f.rowid = ${r??t}.rowid AND ${t}_fts MATCH ${$(f)})`).join(" AND ");c+=(a?" AND ":"")+e,a=!0;continue}if(s==="is"||s==="isNot"||s==="in"||s==="notIn"){const e=A(i,y[0],r),f=y.map($).join(","),g=s==="is"?y.length>1?`${e} IN (${f})`:`${e} = ${$(y[0])}`:s==="isNot"?y.length>1?`${e} NOT IN (${f})`:`${e} <> ${$(y[0])}`:s==="in"?`${e} IN (${f})`:`${e} NOT IN (${f})`;c+=(a?" AND ":"")+g,a=!0;continue}for(const e of y){const f=A(i,e,r),g=s==="gt"?`${f} > ${$(e)}`:s==="gte"?`${f} >= ${$(e)}`:s==="lt"?`${f} < ${$(e)}`:s==="lte"?`${f} <= ${$(e)}`:`${f} LIKE ${$(e)}`;c+=(a?" AND ":"")+g,a=!0}}}}return a?`(${c})`:""}function k(n,r){if(!n)return"";const t=T(n,void 0,r);return t?`WHERE ${t}`:""}export{T as getWhere,k as getWhereQuery};

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.94",
   "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/__tests__/where.test.ts

@@ -0,0 +1,234 @@
+import { createTable } from '../table'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { type Where } from '../table/where'
+
+describe('where clauses', () => {
+  const backend = bunMemoryBackend()
+
+  it('should handle where where array of conditions', async () => {
+    const tableNestedOptional = await createTable<{ id: string; content?: string }>({
+      backend,
+      tableName: 'TestTableNestedOptional',
+      key: 'id',
+      indexes: ['content'],
+    })
+
+    await tableNestedOptional.set({ id: '1', content: 'The quick brown fox' })
+    await tableNestedOptional.set({ id: '2', content: 'The jumps over the lazy dog' })
+    await tableNestedOptional.set({ id: '3' }) // No `content` field
+
+    const results: { id: string; content?: string }[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { content: { like: ['The%'] } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results[0].id).toBe('1')
+  })
+  it('should create nested index for optional nested fields', async () => {
+    type TestDoc = { id: string; info?: { content?: string } }
+    const tableNestedOptional = await createTable<TestDoc>({
+      backend,
+      tableName: 'TestTableNestedOptional',
+      key: 'id',
+      indexes: ['fts:info.content'],
+    })
+
+    await tableNestedOptional.set({ id: '1', info: { content: 'The quick brown fox' } })
+    await tableNestedOptional.set({ id: '2', info: { content: 'jumps over the lazy dog' } })
+    await tableNestedOptional.set({ id: '3' }) // No `info` field
+
+    const results: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { info: { content: { like: ['The%'] } } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+
+    const results2: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { OR: [{ info: { content: { like: ['The%'] } } }, { info: { content: { like: ['jumps%'] } } }] },
+    })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+
+    const results3: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { info: { content: 'nonexistent' } },
+    })) {
+      results3.push(doc)
+    }
+    expect(results3.length).toBe(0)
+  })
+  it('should handle FTS queries', async () => {
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFts',
+      key: 'id',
+      indexes: ['fts:content'],
+    })
+
+    await tableFts.set({ id: '1', content: 'The quick brown fox' })
+    await tableFts.set({ id: '2', content: 'Jumps over the lazy dog' })
+    await tableFts.set({ id: '3', content: 'Another document' })
+
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({
+      where: { content: { fts: 'quick' } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+  })
+
+  it('should handle nested where conditions', async () => {
+    const tableNested = await createTable<{ id: string; info: { content: string } }>({
+      backend,
+      tableName: 'TestTableNested',
+      key: 'id',
+      indexes: ['info.content'],
+    })
+
+    await tableNested.set({ id: '1', info: { content: 'Nested quick brown fox' } })
+    await tableNested.set({ id: '2', info: { content: 'Nested jumps over the lazy dog' } })
+
+    const results: { id: string; info: { content: string } }[] = []
+    for await (const doc of tableNested.search({
+      where: { info: { content: { like: 'Nested%' } } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+  })
+
+  it('should handle complex operators', async () => {
+    const tableComplex = await createTable<{ id: string; value: number }>({
+      backend,
+      tableName: 'TestTableComplex',
+      key: 'id',
+      indexes: ['value'],
+    })
+
+    await tableComplex.set({ id: '1', value: 10 })
+    await tableComplex.set({ id: '2', value: 20 })
+    await tableComplex.set({ id: '3', value: 30 })
+
+    const results: { id: string; value: number }[] = []
+    for await (const doc of tableComplex.search({
+      where: { value: { gt: 15, lt: 25 } },
+      sortBy: 'value',
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('2')
+  })
+
+  it('should handle NOT conditions', async () => {
+    const tableNot = await createTable<{ id: string; value: string }>({
+      backend,
+      tableName: 'TestTableNot',
+      key: 'id',
+      indexes: ['value'],
+    })
+
+    await tableNot.set({ id: '1', value: 'apple' })
+    await tableNot.set({ id: '2', value: 'banana' })
+    await tableNot.set({ id: '3', value: 'cherry' })
+
+    const results: { id: string; value: string }[] = []
+    for await (const doc of tableNot.search({
+      where: { NOT: { value: 'banana' } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results.map((doc) => doc.value)).toEqual(['apple', 'cherry'])
+  })
+
+  it('should handle AND conditions', async () => {
+    const tableAnd = await createTable<{ id: string; category: string; price: number }>({
+      backend,
+      tableName: 'TestTableAnd',
+      key: 'id',
+      indexes: ['category', 'price'],
+    })
+
+    await tableAnd.set({ id: '1', category: 'fruit', price: 10 })
+    await tableAnd.set({ id: '2', category: 'fruit', price: 20 })
+    await tableAnd.set({ id: '3', category: 'vegetable', price: 15 })
+
+    const results: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableAnd.search({
+      where: { AND: [{ category: 'fruit' }, { price: { lt: 15 } }] },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+  })
+
+  it('should handle OR conditions', async () => {
+    const tableOr = await createTable<{ id: string; type: string }>({
+      backend,
+      tableName: 'TestTableOr',
+      key: 'id',
+      indexes: ['type'],
+    })
+
+    await tableOr.set({ id: '1', type: 'A' })
+    await tableOr.set({ id: '2', type: 'B' })
+    await tableOr.set({ id: '3', type: 'C' })
+
+    const results: { id: string; type: string }[] = []
+    for await (const doc of tableOr.search({
+      where: { OR: [{ type: 'A' }, { type: 'C' }] },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results.map((doc) => doc.type)).toEqual(['A', 'C'])
+  })
+
+  it('should handle nested AND/OR/NOT conditions', async () => {
+    const tableNestedLogic = await createTable<{ id: string; category: string; price: number }>({
+      backend,
+      tableName: 'TestTableNestedLogic',
+      key: 'id',
+      indexes: ['category', 'price'],
+    })
+
+    await tableNestedLogic.set({ id: '1', category: 'fruit', price: 10 })
+    await tableNestedLogic.set({ id: '2', category: 'fruit', price: 20 })
+    await tableNestedLogic.set({ id: '3', category: 'fruit', price: 15 })
+
+    const whereClause: Where<{ category: string; price: number }> = {
+      AND: [
+        { category: { is: 'fruit' } },
+        {
+          OR: [{ price: { lt: 15 } }, { price: { is: 15 } }],
+        },
+      ],
+    }
+
+    const allData: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableNestedLogic.search({})) {
+      allData.push(doc)
+    }
+    expect(allData.length).toBe(3)
+
+    const results: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableNestedLogic.search({
+      where: whereClause,
+    })) {
+      results.push(doc)
+    }
+
+    expect(results.length).toBe(2)
+  })
+})

package/src/sqlite/table/table.types.ts

@@ -20,14 +20,16 @@ export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`
 
 type Previous = [never, 0, 1, 2, 3, 4, 5]
 
-export type DotPath<T, D extends number = 5> = [D] extends [never]
+type DotPathRaw<T, D extends number = 5> = [D] extends [never]
   ? never
   : T extends object
     ? {
-        [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPath<T[K], Previous[D]>}` : K
+        [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPathRaw<T[K], Previous[D]>}` : K
       }[Extract<keyof T, string>]
     : never
 
+export type DotPath<T> = DotPathRaw<MakeAllFieldAsRequired<T>>
+
 // Built-in FTS5 tokenizers
 export type FtsTokenizer =
   | 'porter' // English stemming
@@ -81,3 +83,7 @@ export interface Table<Document extends DocType> extends DbNotGeneric {
   readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
   readonly clear: () => Promise<void>
 }
+
+export type MakeAllFieldAsRequired<T> = {
+  [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K]
+}

package/src/sqlite/table/where.ts

@@ -4,6 +4,8 @@
 /* eslint-disable sonarjs/no-nested-conditional */
 /* eslint-disable sonarjs/cognitive-complexity */
 
+import type { MakeAllFieldAsRequired } from './table.types'
+
 // -------------------------------------------------------------
 // Condition operators for each field
 // -------------------------------------------------------------
@@ -20,21 +22,22 @@ interface Condition<T> {
   readonly fts?: string | string[] // 🔥 NEW
 }
 
-// -------------------------------------------------------------
-// Where type: recursive object with operators or nested fields
-// -------------------------------------------------------------
-export type Where<T extends Record<string, unknown>> =
+type WhereRaw<T extends Record<string, unknown>> =
   | {
       [K in keyof T]?: T[K] extends Record<string, unknown>
-        ? Where<T[K]> // nested object
+        ? WhereRaw<T[K]> // nested object
         : Condition<T[K]> | T[K] | T[K][]
     }
   | {
-      readonly AND?: Array<Where<T>>
-      readonly OR?: Array<Where<T>>
-      readonly NOT?: Where<T>
+      readonly AND?: Array<WhereRaw<T>>
+      readonly OR?: Array<WhereRaw<T>>
+      readonly NOT?: WhereRaw<T>
     }
 
+// -------------------------------------------------------------
+// Where type: recursive object with operators or nested fields
+// -------------------------------------------------------------
+export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>
 /**
  * Inline a value for SQL query, with proper escaping for strings
  * @param value The value to inline

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,

package/types/sqlite/table/table.types.d.ts

@@ -15,9 +15,10 @@ export interface SqlSeachOptions<Document extends DocType> {
 }
 export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`;
 type Previous = [never, 0, 1, 2, 3, 4, 5];
-export type DotPath<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
-    [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPath<T[K], Previous[D]>}` : K;
+type DotPathRaw<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPathRaw<T[K], Previous[D]>}` : K;
 }[Extract<keyof T, string>] : never;
+export type DotPath<T> = DotPathRaw<MakeAllFieldAsRequired<T>>;
 export type FtsTokenizer = 'porter' | 'simple' | 'icu' | 'unicode61' | FtsTokenizerOptions;
 export interface FtsType<Document extends DocType> {
     readonly type: 'fts';
@@ -59,4 +60,7 @@ export interface Table<Document extends DocType> extends DbNotGeneric {
     readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
     readonly clear: () => Promise<void>;
 }
+export type MakeAllFieldAsRequired<T> = {
+    [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K];
+};
 export {};

package/types/sqlite/table/where.d.ts

@@ -1,3 +1,4 @@
+import type { MakeAllFieldAsRequired } from './table.types';
 interface Condition<T> {
     readonly is?: T | T[];
     readonly isNot?: T | T[];
@@ -10,13 +11,14 @@ interface Condition<T> {
     readonly like?: T | T[];
     readonly fts?: string | string[];
 }
-export type Where<T extends Record<string, unknown>> = {
-    [K in keyof T]?: T[K] extends Record<string, unknown> ? Where<T[K]> : Condition<T[K]> | T[K] | T[K][];
+type WhereRaw<T extends Record<string, unknown>> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? WhereRaw<T[K]> : Condition<T[K]> | T[K] | T[K][];
 } | {
-    readonly AND?: Array<Where<T>>;
-    readonly OR?: Array<Where<T>>;
-    readonly NOT?: Where<T>;
+    readonly AND?: Array<WhereRaw<T>>;
+    readonly OR?: Array<WhereRaw<T>>;
+    readonly NOT?: WhereRaw<T>;
 };
+export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>;
 /**
  * Write SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions