muya 2.4.5 → 2.4.7

package/esm/sqlite/create-sqlite.js

@@ -1 +1 @@
-import{STATE_SCHEDULER as l}from"../create";import{getId as m}from"../utils/id";import{createTable as d}from"./table/table";function D(u){let s;async function a(){if(!s){const{backend:e,...n}=u,t=e instanceof Promise?await e:e;s=await d({backend:t,...n})}return s}const i=m();l.add(i,{onScheduleDone(e){if(!e)return;const n=e,t={};for(const c of n)c.removedAll&&(t.removedAll=!0),c.mutations&&(t.mutations||(t.mutations=[]),t.mutations.push(...c.mutations));for(const c of r)c(t)}});function o(e){l.schedule(i,e)}const r=new Set;return{subscribe(e){return r.add(e),()=>r.delete(e)},clear(){s?.clear(),o({removedAll:!0})},async set(e){const t=await(await a()).set(e);return o({mutations:[t]}),t},async batchSet(e){const t=await(await a()).batchSet(e);return o({mutations:t}),t},async delete(e){const t=await(await a()).delete(e);return t&&o({mutations:[t]}),t},async deleteBy(e){const t=await(await a()).deleteBy(e);return o({mutations:t}),t},async get(e,n){return(await a()).get(e,n)},async*search(e={}){const n=await a();for await(const t of n.search(e))yield t},async count(e){return await(await a()).count(e)}}}export{D as createSqliteState};
+import{STATE_SCHEDULER as l}from"../create";import{getId as m}from"../utils/id";import{createTable as d}from"./table/table";function D(u){let s;async function a(){if(!s){const{backend:e,...n}=u,t=e instanceof Promise?await e:e;s=await d({backend:t,...n})}return s}const i=m();l.add(i,{onScheduleDone(e){if(!e)return;const n=e,t={};for(const c of n)c.removedAll&&(t.removedAll=!0),c.mutations&&(t.mutations||(t.mutations=[]),t.mutations.push(...c.mutations));for(const c of r)c(t)}});function o(e){l.schedule(i,e)}const r=new Set;return{subscribe(e){return r.add(e),()=>r.delete(e)},async clear(){const e=await a();return o({removedAll:!0}),e.clear()},async set(e){const t=await(await a()).set(e);return o({mutations:[t]}),t},async batchSet(e){const t=await(await a()).batchSet(e);return o({mutations:t}),t},async delete(e){const t=await(await a()).delete(e);return t&&o({mutations:[t]}),t},async deleteBy(e){const t=await(await a()).deleteBy(e);return o({mutations:t}),t},async get(e,n){return(await a()).get(e,n)},async*search(e={}){const n=await a();for await(const t of n.search(e))yield t},async count(e){return await(await a()).count(e)}}}export{D as createSqliteState};

package/esm/sqlite/table/table.js

@@ -1,38 +1,38 @@
-import{unicodeTokenizer as C}from"./tokenizer";import{getWhereQuery as k}from"./where";const L=500,M=100;function R(l){return"$."+l}function U(l,a){if(!(!l||!a))return a.split(".").reduce((t,y)=>{if(typeof t=="object"&&t!==null&&y in t)return t[y]},l)}async function P(l){const{backend:a,tableName:t,indexes:y,key:A,disablePragmaOptimization:x}=l,u=A!==void 0;x||(await a.execute("PRAGMA journal_mode=WAL;"),await a.execute("PRAGMA synchronous=NORMAL;"),await a.execute("PRAGMA temp_store=MEMORY;"),await a.execute("PRAGMA cache_size=-20000;")),u?await a.execute(`
+import{unicodeTokenizer as _}from"./tokenizer";import{getWhereQuery as g}from"./where";const x=500,C=100;function m(l){return"$."+l}function M(l,s){if(!(!l||!s))return s.split(".").reduce((t,y)=>{if(typeof t=="object"&&t!==null&&y in t)return t[y]},l)}async function G(l){const{backend:s,tableName:t,indexes:y,key:$,disablePragmaOptimization:L}=l,u=$!==void 0;L||(await s.execute("PRAGMA journal_mode=WAL;"),await s.execute("PRAGMA synchronous=NORMAL;"),await s.execute("PRAGMA temp_store=MEMORY;"),await s.execute("PRAGMA cache_size=-20000;")),u?await s.execute(`
       CREATE TABLE IF NOT EXISTS ${t} (
         key TEXT PRIMARY KEY,
         data TEXT NOT NULL
       );
-    `):await a.execute(`
+    `):await s.execute(`
       CREATE TABLE IF NOT EXISTS ${t} (
         data TEXT NOT NULL
       );
-    `);let d;const T=[],f={};for(const e of y??[])if(typeof e=="string"&&e.startsWith("fts:")){const n=e.slice(4),r=n.replaceAll(".","_");T.push(n),f[n]=r}else if(typeof e=="object"&&e.type==="fts"){const n=e.path,r=n.replaceAll(".","_");if(T.push(n),f[n]=r,e.tokenizer){if(!d)d=e.tokenizer;else if(d!==e.tokenizer)throw new Error(`Conflicting FTS tokenizers: already using "${d}", got "${e.tokenizer}"`)}}else{const n=String(e);await a.execute(`CREATE INDEX IF NOT EXISTS idx_${t}_${n.replaceAll(/\W/g,"_")}
-       ON ${t} (json_extract(data, '${R(n)}'));`)}if(T.length>0){let e;typeof d=="object"?e=C(d):d===void 0?e='"unicode61", "remove_diacritics=1"':e=d;const n=T.map(o=>f[o]).join(", "),r=`
+    `);let d;const T=[],f={};for(const e of y??[])if(typeof e=="string"&&e.startsWith("fts:")){const n=e.slice(4),o=n.replaceAll(".","_");T.push(n),f[n]=o}else if(typeof e=="object"&&e.type==="fts"){const n=e.path,o=n.replaceAll(".","_");if(T.push(n),f[n]=o,e.tokenizer){if(!d)d=e.tokenizer;else if(d!==e.tokenizer)throw new Error(`Conflicting FTS tokenizers: already using "${d}", got "${e.tokenizer}"`)}}else{const n=String(e);await s.execute(`CREATE INDEX IF NOT EXISTS idx_${t}_${n.replaceAll(/\W/g,"_")}
+       ON ${t} (json_extract(data, '${m(n)}'));`)}if(T.length>0){let e;typeof d=="object"?e=_(d):d===void 0?e='"unicode61", "remove_diacritics=1"':e=d;const n=T.map(r=>f[r]).join(", "),o=`
         CREATE VIRTUAL TABLE IF NOT EXISTS ${t}_fts
         USING fts5(${n}, tokenize=${e});
-`;await a.execute(r),await a.execute(`
+`;await s.execute(o),await s.execute(`
       CREATE TRIGGER IF NOT EXISTS ${t}_ai
       AFTER INSERT ON ${t}
       BEGIN
         INSERT INTO ${t}_fts(rowid, ${n})
         VALUES (
           new.rowid,
-          ${T.map(o=>`json_extract(new.data, '${R(o)}')`).join(", ")}
+          ${T.map(r=>`json_extract(new.data, '${m(r)}')`).join(", ")}
         );
       END;
-    `),await a.execute(`
+    `),await s.execute(`
       CREATE TRIGGER IF NOT EXISTS ${t}_ad
       AFTER DELETE ON ${t}
       BEGIN
         DELETE FROM ${t}_fts WHERE rowid = old.rowid;
       END;
-    `),await a.execute(`
+    `),await s.execute(`
       CREATE TRIGGER IF NOT EXISTS ${t}_au
       AFTER UPDATE ON ${t}
       BEGIN
         UPDATE ${t}_fts
-        SET ${T.map(o=>`${f[o]}=json_extract(new.data, '${R(o)}')`).join(", ")}
+        SET ${T.map(r=>`${f[r]}=json_extract(new.data, '${m(r)}')`).join(", ")}
         WHERE rowid = old.rowid;
       END;
-    `)}function $(e){if(u)return U(e,String(A))}async function b(e){return(await e.select("SELECT changes() AS c"))[0]?.c??0}const g={backend:a,async set(e,n){const r=n??a,o=JSON.stringify(e);if(u){const s=$(e);if(s==null)throw new Error(`Document is missing the configured key "${String(A)}".`);if(await r.execute(`UPDATE ${t} SET data = ? WHERE key = ?`,[o,s]),await b(r)===1)return{key:s,op:"update"};try{return await r.execute(`INSERT INTO ${t} (key, data) VALUES (?, ?)`,[s,o]),{key:s,op:"insert"}}catch{return await r.execute(`UPDATE ${t} SET data = ? WHERE key = ?`,[o,s]),{key:s,op:"update"}}}await r.execute(`INSERT INTO ${t} (data) VALUES (?)`,[o]);const c=(await r.select("SELECT last_insert_rowid() AS id"))[0]?.id;if(typeof c!="number")throw new Error("Failed to retrieve last_insert_rowid()");return{key:c,op:"insert"}},async get(e,n=r=>r){const r=u?"key = ?":"rowid = ?",o=await a.select(`SELECT rowid, data FROM ${t} WHERE ${r}`,[e]);if(o.length===0)return;const{data:E,rowid:c}=o[0],s=JSON.parse(E),i=u?$(s)??c:c;return n(s,{rowId:c,key:i})},async delete(e){const n=u?"key = ?":"rowid = ?";if(await a.execute(`DELETE FROM ${t} WHERE ${n}`,[e]),((await a.select("SELECT changes() AS c"))[0]?.c??0)>0)return{key:e,op:"delete"}},async*search(e={}){const{sortBy:n,order:r="asc",limit:o,offset:E=0,where:c,select:s=w=>w,pageSize:i=M}=e,p=k(c,t),h=`SELECT rowid, data FROM ${t} ${p}`;let S=0,D=E;for(;;){let w=h;n?w+=` ORDER BY json_extract(data, '${R(String(n))}') COLLATE NOCASE ${r.toUpperCase()}`:w+=u?` ORDER BY key COLLATE NOCASE ${r.toUpperCase()}`:` ORDER BY rowid ${r.toUpperCase()}`;const I=o?Math.min(i,o-S):i;w+=` LIMIT ${I} OFFSET ${D}`;const m=await a.select(w);if(m.length===0)break;for(const{rowid:O,data:F}of m){if(o&&S>=o)return;const N=JSON.parse(F),_=u?$(N)??O:O;yield s(N,{rowId:O,key:_}),S++}if(m.length<I||o&&S>=o)break;D+=m.length}},async count(e={}){const n=k(e.where,t),r=`SELECT COUNT(*) as count FROM ${t} ${n}`;return(await a.select(r))[0]?.count??0},async deleteBy(e){const n=k(e,t),r=u?"key":"rowid",o=[];return await a.transaction(async E=>{const c=await E.select(`SELECT ${r} AS k FROM ${t} ${n}`);if(c.length===0)return;const s=c.map(i=>i.k);for(let i=0;i<s.length;i+=L){const p=s.slice(i,i+L),h=p.map(()=>"?").join(",");await E.execute(`DELETE FROM ${t} WHERE ${r} IN (${h})`,p)}for(const i of s)o.push({key:i,op:"delete"})}),o},async clear(){await a.execute(`DELETE FROM ${t}`)},async batchSet(e){const n=[];return await a.transaction(async r=>{for(const o of e){const E=await g.set(o,r);n.push(E)}}),n}};return g}export{M as DEFAULT_PAGE_SIZE,P as createTable,U as getByPath,R as toJsonPath};
+    `)}function A(e){if(u)return M(e,String($))}const k={backend:s,async set(e,n){const o=n??s,r=JSON.stringify(e);if(u){const a=A(e);if(a==null)throw new Error(`Document is missing the configured key "${String($)}".`);return(await o.select(`SELECT key FROM ${t} WHERE key = ?`,[a])).length>0?(await o.execute(`UPDATE ${t} SET data = ? WHERE key = ?`,[r,a]),{key:a,op:"update"}):(await o.execute(`INSERT INTO ${t} (key, data) VALUES (?, ?)`,[a,r]),{key:a,op:"insert"})}await o.execute(`INSERT INTO ${t} (data) VALUES (?)`,[r]);const c=(await o.select("SELECT last_insert_rowid() AS id"))[0]?.id;if(typeof c!="number")throw new Error("Failed to retrieve last_insert_rowid()");return{key:c,op:"insert"}},async get(e,n=o=>o){const o=u?"key = ?":"rowid = ?",r=await s.select(`SELECT rowid, data FROM ${t} WHERE ${o}`,[e]);if(r.length===0)return;const{data:E,rowid:c}=r[0],a=JSON.parse(E),i=u?A(a)??c:c;return n(a,{rowId:c,key:i})},async delete(e){const n=u?"key = ?":"rowid = ?";if(await s.execute(`DELETE FROM ${t} WHERE ${n}`,[e]),((await s.select("SELECT changes() AS c"))[0]?.c??0)>0)return{key:e,op:"delete"}},async*search(e={}){const{sortBy:n,order:o="asc",limit:r,offset:E=0,where:c,select:a=w=>w,pageSize:i=C}=e,S=g(c,t),h=`SELECT rowid, data FROM ${t} ${S}`;let p=0,I=E;for(;;){let w=h;n?w+=` ORDER BY json_extract(data, '${m(String(n))}') COLLATE NOCASE ${o.toUpperCase()}`:w+=u?` ORDER BY key COLLATE NOCASE ${o.toUpperCase()}`:` ORDER BY rowid ${o.toUpperCase()}`;const N=r?Math.min(i,r-p):i;w+=` LIMIT ${N} OFFSET ${I}`;const R=await s.select(w);if(R.length===0)break;for(const{rowid:O,data:F}of R){if(r&&p>=r)return;const D=JSON.parse(F),b=u?A(D)??O:O;yield a(D,{rowId:O,key:b}),p++}if(R.length<N||r&&p>=r)break;I+=R.length}},async count(e={}){const n=g(e.where,t),o=`SELECT COUNT(*) as count FROM ${t} ${n}`;return(await s.select(o))[0]?.count??0},async deleteBy(e){const n=g(e,t),o=u?"key":"rowid",r=[];return await s.transaction(async E=>{const c=await E.select(`SELECT ${o} AS k FROM ${t} ${n}`);if(c.length===0)return;const a=c.map(i=>i.k);for(let i=0;i<a.length;i+=x){const S=a.slice(i,i+x),h=S.map(()=>"?").join(",");await E.execute(`DELETE FROM ${t} WHERE ${o} IN (${h})`,S)}for(const i of a)r.push({key:i,op:"delete"})}),r},async clear(){await s.execute(`DELETE FROM ${t}`)},async batchSet(e){const n=[];return await s.transaction(async o=>{for(const r of e){const E=await k.set(r,o);n.push(E)}}),n}};return k}export{C as DEFAULT_PAGE_SIZE,G as createTable,M as getByPath,m as toJsonPath};

package/esm/sqlite/use-sqlite.js

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

package/package.json

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

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

@@ -0,0 +1,431 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+import { createSqliteState } from '../create-sqlite'
+import { useSqliteValue } from '../use-sqlite'
+import { waitFor } from '@testing-library/react'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { StrictMode, Suspense } from 'react'
+
+const backend = bunMemoryBackend()
+
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+/**
+ * Wrapper component to provide necessary React context for testing.
+ * @param props - The props object containing children.
+ * @param props.children - The children to render inside the wrapper.
+ * @returns The wrapped children with React context.
+ */
+function Wrapper({ children }: Readonly<{ children: React.ReactNode }>) {
+  return (
+    <StrictMode>
+      <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+    </StrictMode>
+  )
+}
+
+describe('use-sqlite edge cases', () => {
+  it('should remove an item and verify it is removed', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'RemoveTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+      expect(result.current[1].keysIndex).toEqual(
+        new Map([
+          ['1', 0],
+          ['2', 1],
+        ]),
+      )
+    })
+
+    act(() => {
+      sql.delete('1')
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '2', name: 'Bob', age: 25 }])
+      expect(result.current[1].keysIndex).toEqual(new Map([['2', 0]]))
+    })
+
+    act(() => {
+      sql.delete('2')
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([])
+    })
+  })
+  it('should handle deleting a non-existent item gracefully', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'EdgeCaseTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.delete('3') // Attempt to delete a non-existent item
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ]) // State should remain unchanged
+    })
+  })
+
+  it('should handle deleting all items', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'DeleteAllTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.delete('1')
+      sql.delete('2')
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([]) // All items should be removed
+    })
+  })
+
+  it('should handle concurrent operations', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'ConcurrentOpsTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.delete('1')
+      sql.set({ id: '3', name: 'Carol', age: 40 })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '2', name: 'Bob', age: 25 },
+        { id: '3', name: 'Carol', age: 40 },
+      ]) // State should reflect both operations
+    })
+  })
+
+  it('should handle repeated updates, removals, and insertions in a loop', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'LoopTest', key: 'id' })
+    sql.clear()
+    // Initial batch set
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    // Perform updates, removals, and insertions in a loop
+    act(() => {
+      for (let index = 0; index < 10; index++) {
+        sql.set({ id: `new-${index}`, name: `Person ${index}`, age: 20 + index }) // Insert new item
+        sql.delete('1') // Remove an existing item
+        sql.set({ id: '2', name: `Updated Bob ${index}`, age: 25 + index }) // Update an existing item
+      }
+      // fetch next
+      result.current[1].nextPage()
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '2', name: 'Updated Bob 9', age: 34 },
+        { id: 'new-0', name: 'Person 0', age: 20 },
+        { id: 'new-1', name: 'Person 1', age: 21 },
+        { id: 'new-2', name: 'Person 2', age: 22 },
+        { id: 'new-3', name: 'Person 3', age: 23 },
+        { id: 'new-4', name: 'Person 4', age: 24 },
+        { id: 'new-5', name: 'Person 5', age: 25 },
+        { id: 'new-6', name: 'Person 6', age: 26 },
+        { id: 'new-7', name: 'Person 7', age: 27 },
+        { id: 'new-8', name: 'Person 8', age: 28 },
+        { id: 'new-9', name: 'Person 9', age: 29 },
+      ])
+    })
+  })
+  it('should handle concurrent insertions and deletions', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'ConcurrentInsertDeleteTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.set({ id: '3', name: 'Carol', age: 40 })
+      sql.delete('1')
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '2', name: 'Bob', age: 25 },
+        { id: '3', name: 'Carol', age: 40 },
+      ])
+    })
+  })
+
+  it('should handle pagination with empty pages', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'EmptyPaginationTest', key: 'id' })
+    sql.clear()
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([])
+    })
+
+    act(() => {
+      result.current[1].nextPage()
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([]) // Still empty
+    })
+  })
+
+  it('should handle duplicate key insertions gracefully', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'DuplicateKeyTest', key: 'id' })
+    await sql.batchSet([{ id: '1', name: 'Alice', age: 30 }])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice', age: 30 }])
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Updated Alice', age: 35 })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Updated Alice', age: 35 }])
+    })
+  })
+
+  it('should handle reset during pagination', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'ResetDuringPaginationTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      result.current[1].reset()
+      result.current[1].nextPage()
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+  })
+
+  it('should handle invalid key deletion gracefully', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'InvalidKeyDeletionTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.delete('non-existent-key')
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+  })
+  it('should update a visible document', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'UpdateVisibleTest', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Updated Alice', age: 35 })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Updated Alice', age: 35 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+  })
+
+  it('should update a non-visible document', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'UpdateNonVisibleTest', 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(() => useSqliteValue(sql, { pageSize: 2 }, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      sql.set({ id: '3', name: 'Updated Carol', age: 45 })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ]) // No change in visible items
+    })
+
+    act(() => {
+      result.current[1].nextPage()
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+        { id: '3', name: 'Updated Carol', age: 45 },
+      ])
+    })
+  })
+
+  it('should handle updates during pagination', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'UpdateDuringPaginationTest', 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(() => useSqliteValue(sql, { pageSize: 2 }, []), { wrapper: Wrapper })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+      ])
+    })
+
+    act(() => {
+      result.current[1].nextPage()
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Bob', age: 25 },
+        { id: '3', name: 'Carol', age: 40 },
+      ])
+    })
+
+    act(() => {
+      sql.set({ id: '2', name: 'Updated Bob', age: 35 })
+    })
+
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([
+        { id: '1', name: 'Alice', age: 30 },
+        { id: '2', name: 'Updated Bob', age: 35 },
+        { id: '3', name: 'Carol', age: 40 },
+      ])
+    })
+  })
+})

package/src/sqlite/create-sqlite.ts

@@ -24,7 +24,7 @@ export interface SyncTable<Document extends DocType> {
   readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>
   readonly count: (options?: { where?: Where<Document> }) => Promise<number>
   readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
-  readonly clear: () => void
+  readonly clear: () => Promise<void>
 }
 
 /**
@@ -87,9 +87,10 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       listeners.add(listener)
       return () => listeners.delete(listener)
     },
-    clear() {
-      cachedTable?.clear()
+    async clear() {
+      const table = await getTable()
       handleChanges({ removedAll: true })
+      return table.clear()
     },
     async set(document) {
       const table = await getTable()

package/src/sqlite/table/table.ts

@@ -164,16 +164,6 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     return getByPath(document, String(key)) as Key | undefined
   }
 
-  /**
-   * Get the number of rows changed by the last operation on the given connection
-   * @param conn The database connection to check for changes
-   * @returns A promise that resolves to the number of changed rows
-   */
-  async function getChanges(conn: typeof backend): Promise<number> {
-    const r = await conn.select<Array<{ c: number }>>(`SELECT changes() AS c`)
-    return r[0]?.c ?? 0
-  }
-
   const table: Table<Document> = {
     backend,
 
@@ -187,16 +177,14 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
           throw new Error(`Document is missing the configured key "${String(key)}".`)
         }
 
-        await db.execute(`UPDATE ${tableName} SET data = ? WHERE key = ?`, [json, id])
-        const updated = await getChanges(db)
-        if (updated === 1) return { key: id, op: 'update' }
+        const existing = await db.select<Array<{ key: string }>>(`SELECT key FROM ${tableName} WHERE key = ?`, [id])
 
-        try {
-          await db.execute(`INSERT INTO ${tableName} (key, data) VALUES (?, ?)`, [id, json])
-          return { key: id, op: 'insert' }
-        } catch {
+        if (existing.length > 0) {
           await db.execute(`UPDATE ${tableName} SET data = ? WHERE key = ?`, [json, id])
           return { key: id, op: 'update' }
+        } else {
+          await db.execute(`INSERT INTO ${tableName} (key, data) VALUES (?, ?)`, [id, json])
+          return { key: id, op: 'insert' }
         }
       }
 

package/src/sqlite/use-sqlite.ts

@@ -17,6 +17,7 @@ export interface SqLiteActions {
    */
   readonly reset: () => Promise<void>
   readonly keysIndex: Map<Key, number>
+  readonly isResetting?: boolean
 }
 
 export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
@@ -72,6 +73,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
       return true
     }
     let isDone = false
+
     for (let index = 0; index < pageSize; index++) {
       const result = await iterator.next()
       if (result.done) {
@@ -87,6 +89,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
       itemsRef.current.push(select ? select(result.value.doc) : (result.value.doc as unknown as Selected))
       keysIndex.current.set(result.value.meta.key, itemsRef.current.length - 1)
     }
+    itemsRef.current = [...itemsRef.current]
     return isDone
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
@@ -110,6 +113,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
       const oldLength = itemsRef.current?.length ?? 0
       let newLength = oldLength
       let hasUpdate = false
+      const removeIndexes = new Set<number>()
       for (const mutation of mutations) {
         const { key, op } = mutation
         switch (op) {
@@ -118,35 +122,57 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
             break
           }
           case 'delete': {
-            if (itemsRef.current && keysIndex.current.has(key)) {
+            if (itemsRef.current && itemsRef.current.length > 0 && keysIndex.current.has(key)) {
               const index = keysIndex.current.get(key)
               if (index === undefined) break
-              itemsRef.current.splice(index, 1)
-              keysIndex.current.delete(key)
+              removeIndexes.add(index)
               hasUpdate = true
             }
             break
           }
           case 'update': {
-            if (itemsRef.current && keysIndex.current.has(key)) {
+            if (keysIndex.current.has(key)) {
               const index = keysIndex.current.get(key)
-              if (index === undefined) break
-              itemsRef.current[index] = (await state.get(key, select)) as Selected
-              hasUpdate = true
+              if (index !== undefined && itemsRef.current) {
+                itemsRef.current[index] = (await state.get(key, select)) as Selected
+                itemsRef.current = [...itemsRef.current]
+                hasUpdate = true
+              }
+            } else {
+              // Handle updates to non-visible items
+              const updatedItem = await state.get(key, select)
+              if (updatedItem) {
+                itemsRef.current = [...(itemsRef.current ?? []), updatedItem]
+                keysIndex.current.set(key, itemsRef.current.length - 1)
+                hasUpdate = true
+              }
             }
             break
           }
         }
       }
 
+      if (removeIndexes.size > 0 && itemsRef.current && itemsRef.current.length > 0) {
+        const newIndex = new Map<Key, number>()
+        itemsRef.current = itemsRef.current?.filter((_, index) => {
+          return !removeIndexes.has(index)
+        })
+        let newIdx = 0
+        for (const [key, index] of keysIndex.current) {
+          if (removeIndexes.has(index)) {
+            continue
+          }
+          newIndex.set(key, newIdx)
+          newIdx++
+        }
+        keysIndex.current = newIndex
+      }
+
       const isLengthChanged = oldLength !== newLength
       const isChanged = isLengthChanged || hasUpdate
       if (!isChanged) return
       if (isLengthChanged) {
         await fillNextPage(true)
-
-        // here we ensure that if the length changed, we fill the next page
-
         let iterations = 0
         while ((itemsRef.current?.length ?? 0) < newLength && iterations < MAX_ITERATIONS) {
           await fillNextPage(false)
@@ -167,9 +193,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
   }, [state])
 
   useLayoutEffect(() => {
-    updateIterator()
-    itemsRef.current = undefined
-    keysIndex.current.clear()
+    reset()
     nextPage()
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps)

package/types/sqlite/create-sqlite.d.ts

@@ -19,7 +19,7 @@ export interface SyncTable<Document extends DocType> {
         where?: Where<Document>;
     }) => Promise<number>;
     readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
-    readonly clear: () => void;
+    readonly clear: () => Promise<void>;
 }
 /**
  * Create a SyncTable that wraps a Table and provides reactive capabilities

package/types/sqlite/use-sqlite.d.ts

@@ -13,6 +13,7 @@ export interface SqLiteActions {
      */
     readonly reset: () => Promise<void>;
     readonly keysIndex: Map<Key, number>;
+    readonly isResetting?: boolean;
 }
 export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
     /**