muya 2.4.1 → 2.4.3

package/esm/sqlite/create-sqlite.js

@@ -1 +1 @@
-import{STATE_SCHEDULER as f}from"../create";import{getId as P}from"../utils/id";import{shallow as v}from"../utils/shallow";import{selectSql as O}from"./select-sql";import{createTable as R,DEFAULT_STEP_SIZE as M}from"./table/table";function A(k){const g=P();function m(e){return`state-${g}-search-${e}`}let h;async function o(){if(!h){const{backend:e,...n}=k,t=e instanceof Promise?await e:e;h=await R({backend:t,...n})}return h}const c=new Map,d=new Map,y=new Map;async function p(e,n){const t=y.get(e),{options:a={}}=n,{stepSize:s=M}=a;if(!t)return!1;const r=[];for(let u=0;u<s;u++){const i=await t.next();if(i.done){y.delete(e);break}n.keys.has(String(i.value.key))||(r.push(i.value.document),n.keys.add(String(i.value.key)))}return r.length===0||v(n.items,r)?!1:(n.items=[...n.items,...r],!0)}function b(e){const n=d.get(e);n&&n()}async function x(e){const n=await o(),t=c.get(e);if(!t)return;const{options:a}=t,s=n.search({...a,select:(r,{rowId:u,key:i})=>({document:r,rowId:u,key:i})});y.set(e,s),t.keys=new Set,t.items=[],await p(e,t)}async function S(e){await x(e),b(e)}function T(e){const{key:n,op:t}=e,a=new Set;for(const[s,{keys:r}]of c)switch(t){case"delete":case"update":{r.has(String(n))&&a.add(s);break}case"insert":{a.add(s);break}}return a}async function l(e){const n=new Set;for(const t of e){const a=T(t);for(const s of a)n.add(s)}for(const t of n){const a=m(t);f.schedule(a,{searchId:t})}}const D=new Set;function w(e,n){c.has(e)||(c.set(e,{items:[],options:n,keys:new Set}),n&&S(e));const t=c.get(e);return n&&(t.options=n),t}const I={clear(e){c.delete(e)},async set(e){const t=await(await o()).set(e);return await l([t]),t},async batchSet(e){const t=await(await o()).batchSet(e);return await l(t),t},async delete(e){const t=await(await o()).delete(e);return t&&await l([t]),t},async deleteBy(e){const t=await(await o()).deleteBy(e);return await l(t),t},async get(e,n){return(await o()).get(e,n)},async*search(e={}){const n=await o();for await(const t of n.search(e))yield t},async count(e){return await(await o()).count(e)},updateSearchOptions(e,n){const t=w(e,n);t.options=n;const a=m(e);f.schedule(a,{searchId:e})},subscribe(e,n){const t=m(e),a=f.add(t,{onScheduleDone(){S(e)}});return D.add(a),d.has(e)||d.set(e,n),()=>{d.delete(e),a()}},getSnapshot(e){return w(e).items},refresh:S,destroy(){for(const e of D)e();c.clear(),d.clear()},async next(e){const n=c.get(e);if(n){const t=await p(e,n);return t&&b(e),t}return!1},select(e){return O(I,e)}};return I}export{A as createSqliteState};
+import{STATE_SCHEDULER as f}from"../create";import{getId as P}from"../utils/id";import{shallow as v}from"../utils/shallow";import{selectSql as M}from"./select-sql";import{createTable as O,DEFAULT_STEP_SIZE as R}from"./table/table";function q(g){const k=P();function m(e){return`state-${k}-search-${e}`}let h;async function s(){if(!h){const{backend:e,...n}=g,t=e instanceof Promise?await e:e;h=await O({backend:t,...n})}return h}const r=new Map,i=new Map,y=new Map;async function p(e,n){const t=y.get(e),{options:a={}}=n,{stepSize:c=R}=a;if(!t)return!1;const o=[];for(let u=0;u<c;u++){const d=await t.next();if(d.done){y.delete(e);break}n.keys.has(String(d.value.key))||(o.push(d.value.document),n.keys.add(String(d.value.key)))}return o.length===0||v(n.items,o)?!1:(n.items=[...n.items,...o],!0)}function b(e){const n=i.get(e);if(n)for(const[,t]of n)t()}async function x(e){const n=await s(),t=r.get(e);if(!t)return;const{options:a}=t,c=n.search({...a,select:(o,{rowId:u,key:d})=>({document:o,rowId:u,key:d})});y.set(e,c),t.keys=new Set,t.items=[],await p(e,t)}async function S(e){await x(e),b(e)}function T(e){const{key:n,op:t}=e,a=new Set;for(const[c,{keys:o}]of r)switch(t){case"delete":case"update":{o.has(String(n))&&a.add(c);break}case"insert":{a.add(c);break}}return a}async function l(e){const n=new Set;for(const t of e){const a=T(t);for(const c of a)n.add(c)}for(const t of n){const a=m(t);f.schedule(a,{searchId:t})}}const w=new Set;function D(e,n){r.has(e)||(r.set(e,{items:[],options:n,keys:new Set}),n&&S(e));const t=r.get(e);return n&&(t.options=n),t}const I={clear(e){r.delete(e)},async set(e){const t=await(await s()).set(e);return await l([t]),t},async batchSet(e){const t=await(await s()).batchSet(e);return await l(t),t},async delete(e){const t=await(await s()).delete(e);return t&&await l([t]),t},async deleteBy(e){const t=await(await s()).deleteBy(e);return await l(t),t},async get(e,n){return(await s()).get(e,n)},async*search(e={}){const n=await s();for await(const t of n.search(e))yield t},async count(e){return await(await s()).count(e)},updateSearchOptions(e,n){const t=D(e,n);t.options=n;const a=m(e);f.schedule(a,{searchId:e})},subscribe(e,n,t){const a=m(e),c=f.add(a,{onScheduleDone(){S(e)}});w.add(c),i.has(e)||i.set(e,new Map);const o=i.get(e);return o.set(n,t),()=>{o.delete(n),o.size===0&&i.delete(e),c()}},getSnapshot(e){return D(e).items},refresh:S,destroy(){for(const e of w)e();r.clear(),i.clear()},async next(e){const n=r.get(e);if(n){const t=await p(e,n);return t&&b(e),t}return!1},select(e){return M(I,e)}};return I}export{q as createSqliteState};

package/esm/sqlite/select-sql.js

@@ -1 +1 @@
-import{createState as p}from"../create-state";let n=0;function i(){return n++,`${n.toString(36)}-sql`}function S(r,o){const{subscribe:a,updateSearchOptions:s}=r;return(...c)=>{const e=i(),m=a(e,()=>{t.emitter.emit()}),u=o(...c),t=p({destroy(){m(),t.emitter.clear(),t.cache.current=void 0},get(){return r.getSnapshot(e)},getSnapshot(){return r.getSnapshot(e)}});return s(e,u),t}}export{S as selectSql};
+import{createState as l}from"../create-state";let n=0;function o(){return n++,`${n.toString(36)}-sql`}function S(r,a){const{subscribe:c,updateSearchOptions:s}=r,m=o();return(...u)=>{const e=o(),p=c(e,m,()=>{t.emitter.emit()}),i=a(...u),t=l({destroy(){p(),t.emitter.clear(),t.cache.current=void 0},get(){return r.getSnapshot(e)},getSnapshot(){return r.getSnapshot(e)}});return s(e,i),t}}export{S as selectSql};

package/esm/sqlite/use-sqlite.js

@@ -1 +1 @@
-import{useCallback as r,useDebugValue as S,useEffect as p,useId as a,useLayoutEffect as f,useMemo as D}from"react";import{isError as y,isPromise as x}from"../utils/is";import{useSyncExternalStoreWithSelector as b}from"use-sync-external-store/shim/with-selector";function O(e,s={},u=[]){const{select:c}=s,t=a();f(()=>{e.updateSearchOptions(t,{...s,select:void 0})},u),p(()=>()=>{e.clear(t)},[]);const l=r(o=>c?o.map(c):o,[c]),d=r(o=>e.subscribe(t,o),[e,t]),i=r(()=>e.getSnapshot(t),[e,t]),n=b(d,i,i,l);if(S(n),x(n)||y(n))throw n;const m=D(()=>({next:()=>e.next(t),reset:()=>e.refresh(t)}),[t,e]);return[n,m]}export{O as useSqliteValue};
+import{useCallback as f,useDebugValue as p,useEffect as a,useId as y,useLayoutEffect as D,useMemo as S}from"react";import{isError as h,isPromise as x}from"../utils/is";import{useSyncExternalStoreWithSelector as b}from"use-sync-external-store/shim/with-selector";function q(t){const{limit:o,offset:s,order:c,sortBy:e,where:i,stepSize:u,select:d}=t;let n="";return o!==void 0&&(n+=`l${o}`),s!==void 0&&(n+=`o${s}`),c!==void 0&&(n+=`r${c}`),e!==void 0&&(n+=`s${e}`),i!==void 0&&(n+=`w${JSON.stringify(i)}`),u!==void 0&&(n+=`t${u}`),d!==void 0&&(n+=`f${d.toString()}`),n}function w(t,o={},s=[]){const{select:c}=o,e=S(()=>q({...o,select:void 0}),[o]),i=y();D(()=>{t.updateSearchOptions(e,{...o,select:void 0})},s),a(()=>()=>{t.clear(e)},[]);const u=f(l=>c?l.map(c):l,[c]),d=f(l=>t.subscribe(e,i,l),[t,e,i]),n=f(()=>t.getSnapshot(e),[t,e]),r=b(d,n,n,u);if(p(r),x(r)||h(r))throw r;const m=S(()=>({next:()=>t.next(e),reset:()=>t.refresh(e)}),[e,t]);return[r,m]}export{w as useSqliteValue};

package/package.json

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

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

@@ -110,7 +110,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should support like in where clause and update results', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State3Hook', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Alicia', age: 25 },
@@ -136,8 +136,8 @@ describe('use-sqlite-state', () => {
     expect(reRenders).toBeGreaterThanOrEqual(2)
   })
 
-  it('should update results when changing order and limit options', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
+  it('should update results when changing order and limit options 1', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State44Hook', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -165,7 +165,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should support actions.next and actions.refresh', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State5Hook', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -180,7 +180,7 @@ describe('use-sqlite-state', () => {
     })
   })
   it('should handle thousands of records', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6Hook', key: 'id' })
     const people: Person[] = []
     const ITEMS_COUNT = 1000
     for (let index = 1; index <= ITEMS_COUNT; index++) {
@@ -211,7 +211,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should handle thousands of records with single update', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6Hook', key: 'id' })
     const people: Person[] = []
     const ITEMS_COUNT = 10_000
     const stepSize = 5000
@@ -373,4 +373,37 @@ describe('use-sqlite-state', () => {
 
     // add another item
   })
+  it('should test reset', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State11', key: 'id' })
+    let reRenders = 0
+
+    await sql.set({ id: 'initial', name: 'initial', age: 1 })
+    const { result } = renderHook(() => {
+      reRenders++
+      // eslint-disable-next-line unicorn/prevent-abbreviations
+      const res = useSqliteValue(sql, {}, [])
+      return res
+    })
+
+    await waitFor(() => {
+      expect(reRenders).toBe(2)
+      expect(result.current[0].length).toBe(1)
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+    })
+    await waitFor(() => {
+      expect(reRenders).toBe(3)
+      expect(result.current[0].length).toBe(2)
+    })
+
+    act(() => {
+      result.current[1].reset()
+    })
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(2)
+      expect(reRenders).toBe(4)
+    })
+  })
 })

package/src/sqlite/create-sqlite.ts

@@ -17,7 +17,7 @@ export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOp
 export interface SyncTable<Document extends DocType> {
   // readonly registerSearch: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => () => void
   readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void
-  readonly subscribe: (searchId: SearchId, listener: () => void) => () => void
+  readonly subscribe: (searchId: SearchId, componentId: string, listener: () => void) => () => void
   readonly getSnapshot: (searchId: SearchId) => Document[]
   readonly refresh: (searchId: SearchId) => Promise<void>
 
@@ -81,7 +81,7 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
   }
   // const emitter = createEmitter<Table<Document>>()
   const cachedData = new Map<SearchId, DataItems<Document>>()
-  const listeners = new Map<SearchId, () => void>()
+  const listeners = new Map<SearchId, Map<string, () => void>>()
   const iterators = new Map<SearchId, AsyncIterableIterator<NextResult>>()
 
   /**
@@ -123,7 +123,9 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
   function notifyListeners(searchId: SearchId) {
     const searchListeners = listeners.get(searchId)
     if (searchListeners) {
-      searchListeners()
+      for (const [, listener] of searchListeners) {
+        listener()
+      }
     }
   }
 
@@ -273,7 +275,7 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       STATE_SCHEDULER.schedule(scheduleId, { searchId })
     },
 
-    subscribe(searchId, listener) {
+    subscribe(searchId, componentId, listener) {
       const scheduleId = getScheduleId(searchId)
       const clearScheduler = STATE_SCHEDULER.add(scheduleId, {
         onScheduleDone() {
@@ -283,10 +285,15 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       clearSchedulers.add(clearScheduler)
 
       if (!listeners.has(searchId)) {
-        listeners.set(searchId, listener)
+        listeners.set(searchId, new Map())
       }
+      const searchListeners = listeners.get(searchId)!
+      searchListeners.set(componentId, listener)
       return () => {
-        listeners.delete(searchId)
+        searchListeners.delete(componentId)
+        if (searchListeners.size === 0) {
+          listeners.delete(searchId)
+        }
         clearScheduler()
       }
     },

package/src/sqlite/select-sql.ts

@@ -36,10 +36,10 @@ export function selectSql<Document extends DocType, Params extends unknown[] = [
   compute: (...args: Params) => SqlSeachOptions<Document>,
 ): CreateState<Document, Params> {
   const { subscribe, updateSearchOptions } = state
-
+  const componentId = getStateId()
   const result: CreateState<Document, Params> = (...params) => {
     const searchId = getStateId()
-    const destroy = subscribe(searchId, () => {
+    const destroy = subscribe(searchId, componentId, () => {
       getState.emitter.emit()
     })
 

package/src/sqlite/use-sqlite.ts

@@ -17,6 +17,38 @@ export interface UseSearchOptions<Document extends DocType, Selected = Document>
   readonly select?: (document: Document) => Selected
 }
 
+/**
+ * Generate a cache key based on the search options to uniquely identify the query
+ * @param options The search options to generate the key from
+ * @returns A string representing the unique cache key for the given search options
+ */
+function generateCacheKey(options: UseSearchOptions<DocType, unknown>): string {
+  const { limit, offset, order, sortBy, where, stepSize, select } = options
+  let key = ''
+  if (limit !== undefined) {
+    key += `l${limit}`
+  }
+  if (offset !== undefined) {
+    key += `o${offset}`
+  }
+  if (order !== undefined) {
+    key += `r${order}`
+  }
+  if (sortBy !== undefined) {
+    key += `s${sortBy}`
+  }
+  if (where !== undefined) {
+    key += `w${JSON.stringify(where)}`
+  }
+  if (stepSize !== undefined) {
+    key += `t${stepSize}`
+  }
+  if (select !== undefined) {
+    key += `f${select.toString()}`
+  }
+  return key
+}
+
 /**
  * React hook to subscribe to a SyncTable and get its current snapshot, with optional search options and selector for derived state
  * @param state The SyncTable to subscribe to
@@ -32,16 +64,17 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
 ): [undefined extends Selected ? Document[] : Selected[], SqLiteActions] {
   const { select } = options
 
-  const id = useId()
+  const searchId = useMemo(() => generateCacheKey({ ...options, select: undefined }), [options])
+  const componentId = useId()
 
   useLayoutEffect(() => {
-    state.updateSearchOptions(id, { ...options, select: undefined })
+    state.updateSearchOptions(searchId, { ...options, select: undefined })
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps)
 
   useEffect(() => {
     return () => {
-      state.clear(id)
+      state.clear(searchId)
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
@@ -56,14 +89,14 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
 
   const subscribe = useCallback(
     (onStorageChange: () => void) => {
-      return state.subscribe(id, onStorageChange)
+      return state.subscribe(searchId, componentId, onStorageChange)
     },
-    [state, id],
+    [state, searchId, componentId],
   )
 
   const getSnapshot = useCallback(() => {
-    return state.getSnapshot(id)
-  }, [state, id])
+    return state.getSnapshot(searchId)
+  }, [state, searchId])
 
   const value = useSyncExternalStoreWithSelector<Document[], Selected[]>(subscribe, getSnapshot, getSnapshot, selector)
 
@@ -77,9 +110,9 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
 
   const actions = useMemo((): SqLiteActions => {
     return {
-      next: () => state.next(id),
-      reset: () => state.refresh(id),
+      next: () => state.next(searchId),
+      reset: () => state.refresh(searchId),
     }
-  }, [id, state])
+  }, [searchId, state])
   return [value as undefined extends Selected ? Document[] : Selected[], actions]
 }

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

@@ -8,7 +8,7 @@ export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOp
 }
 export interface SyncTable<Document extends DocType> {
     readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void;
-    readonly subscribe: (searchId: SearchId, listener: () => void) => () => void;
+    readonly subscribe: (searchId: SearchId, componentId: string, listener: () => void) => () => void;
     readonly getSnapshot: (searchId: SearchId) => Document[];
     readonly refresh: (searchId: SearchId) => Promise<void>;
     readonly set: (document: Document) => Promise<MutationResult>;

package/esm/sqlite/__tests__/use-sqlite.test.js

@@ -1 +0,0 @@
-import{act as s,renderHook as c}from"@testing-library/react-hooks";import{createSqliteState as i}from"../create-sqlite";import{useSqliteValue as l}from"../use-sqlite";import{waitFor as o}from"@testing-library/react";import{bunMemoryBackend as g}from"../table/bun-backend";import{useState as x}from"react";import{DEFAULT_STEP_SIZE as m}from"../table/table";const u=g();describe("use-sqlite-state",()=>{it("should get basic value states",async()=>{const a=i({backend:u,tableName:"State1",key:"id"});let t=0;const{result:n}=c(()=>(t++,l(a,{},[])));expect(t).toBe(1),s(()=>{a.set({id:"1",name:"Alice",age:30})}),await o(()=>{expect(n.current[0]).toEqual([{id:"1",name:"Alice",age:30}]),expect(t).toBe(3)}),s(()=>{a.set({id:"1",name:"Alice2",age:30})}),await o(()=>{expect(n.current[0]).toEqual([{id:"1",name:"Alice2",age:30}]),expect(t).toBe(4)}),s(()=>{a.delete("1")}),await o(()=>{expect(n.current[0]).toEqual([]),expect(t).toBe(5)}),s(()=>{a.set({id:"1",name:"Alice",age:30}),a.set({id:"2",name:"Bob",age:25})}),await o(()=>{expect(n.current[0].length).toBe(2),expect(t).toBe(6)})}),it("should use where clause changed via state",async()=>{const a=i({backend:u,tableName:"State2",key:"id"});await a.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);let t=0;const{result:n}=c(()=>{t++;const[r,e]=x(20);return[l(a,{where:{age:{gt:r}},sorBy:"age"},[r]),e]});await o(()=>{expect(n.current[0][0].map(r=>r.name)).toEqual(["Alice","Bob","Carol"]),expect(t).toBe(2)}),s(()=>{n.current[1](29)}),await o(()=>{expect(n.current[0][0].map(r=>r.name)).toEqual(["Alice","Carol"]),expect(t).toBe(4)})}),it("should support like in where clause and update results",async()=>{const a=i({backend:u,tableName:"State3",key:"id"});await a.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Alicia",age:25},{id:"3",name:"Bob",age:40}]);let t=0;const{result:n,rerender:r}=c(({like:e})=>(t++,l(a,{where:{name:{like:e}}},[e])),{initialProps:{like:"%Ali%"}});await o(()=>{expect(n.current[0].map(e=>e.name)).toEqual(["Alice","Alicia"])}),s(()=>{r({like:"%Bob%"})}),await o(()=>{expect(n.current[0].map(e=>e.name)).toEqual(["Bob"])}),expect(t).toBeGreaterThanOrEqual(2)}),it("should update results when changing order and limit options",async()=>{const a=i({backend:u,tableName:"State4",key:"id"});await a.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const{result:t,rerender:n}=c(({order:r,limit:e})=>l(a,{sorBy:"age",order:r,limit:e},[r,e]),{initialProps:{order:"asc",limit:2}});await o(()=>{expect(t.current[0].map(r=>r.name)).toEqual(["Alice","Bob"])}),s(()=>{n({order:"desc",limit:2})}),await o(()=>{expect(t.current[0].map(r=>r.name)).toEqual(["Alice","Bob"])}),s(()=>{n({order:"desc",limit:1})}),await o(()=>{expect(t.current[0].map(r=>r.name)).toEqual(["Carol"])})}),it("should support actions.next and actions.refresh",async()=>{const a=i({backend:u,tableName:"State5",key:"id"});await a.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25}]);const{result:t}=c(()=>l(a,{},[]));await o(()=>{expect(typeof t.current[1].next).toBe("function"),expect(typeof t.current[1].reset).toBe("function"),expect(t.current[1].reset()).resolves.toBeUndefined(),expect(t.current[1].next()).resolves.toBeFalsy()})}),it("should handle thousands of records",async()=>{const a=i({backend:u,tableName:"State6",key:"id"}),t=[],n=1e3;for(let e=1;e<=n;e++)t.push({id:e.toString(),name:`Person${e}`,age:20+e%50});await a.batchSet(t);const{result:r}=c(()=>l(a,{},[]));await o(()=>{expect(r.current[0].length).toBe(m)});for(let e=0;e<n/m;e++)s(()=>{r.current[1].next()}),await o(()=>{expect(r.current[0].length).toBe(Math.min(m*(e+2),n))});s(()=>{r.current[1].reset()}),await o(()=>{expect(r.current[0].length).toBe(m)})}),it("should handle thousands of records with single update",async()=>{const a=i({backend:u,tableName:"State6",key:"id"}),t=[],n=1e4,r=5e3;for(let d=1;d<=n;d++)t.push({id:d.toString(),name:`Person${d}`,age:20+d%50});await a.batchSet(t);let e=0;const{result:p}=c(()=>(e++,l(a,{stepSize:r},[])));await o(()=>{expect(e).toBe(2),expect(p.current[0].length).toBe(r)}),s(()=>{for(let d=0;d<n/r;d++)p.current[1].next()}),await o(()=>{expect(e).toBe(4),expect(p.current[0].length).toBe(n)}),s(()=>{p.current[1].reset()}),await o(()=>{expect(e).toBe(5),expect(p.current[0].length).toBe(r)})}),it("should change ordering",async()=>{const a=i({backend:u,tableName:"State7",key:"id",indexes:["age"]}),t=[];for(let e=1;e<=100;e++)t.push({id:e.toString(),name:`Person${e}`,age:20+e%50});await a.batchSet(t);const{result:n,rerender:r}=c(({order:e})=>l(a,{sorBy:"age",order:e},[e]),{initialProps:{order:"asc"}});await o(()=>{expect(n.current[0][0].age).toBe(21)}),s(()=>{r({order:"desc"})}),await o(()=>{expect(n.current[0][0].age).toBe(69)})}),it("should support selector in options",async()=>{const a=i({backend:u,tableName:"State8",key:"id"});await a.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const{result:t}=c(()=>l(a,{sorBy:"age",select:n=>n.name},[]));await o(()=>{expect(t.current[0]).toEqual(["Alice","Bob","Carol"])})})});

package/src/sqlite/__tests__/use-sqlite.test.ts

@@ -1,274 +0,0 @@
-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 { useState } from 'react'
-import { DEFAULT_STEP_SIZE } from '../table/table'
-
-const backend = bunMemoryBackend()
-interface Person {
-  id: string
-  name: string
-  age: number
-}
-
-describe('use-sqlite-state', () => {
-  it('should get basic value states', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
-    let reRenders = 0
-    const { result } = renderHook(() => {
-      reRenders++
-      return useSqliteValue(sql, {}, [])
-    })
-    // expect(result.current).toEqual([])
-
-    expect(reRenders).toBe(1)
-
-    act(() => {
-      sql.set({ id: '1', name: 'Alice', age: 30 })
-    })
-    await waitFor(() => {
-      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice', age: 30 }])
-      expect(reRenders).toBe(3)
-    })
-
-    act(() => {
-      sql.set({ id: '1', name: 'Alice2', age: 30 })
-    })
-    await waitFor(() => {
-      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice2', age: 30 }])
-      expect(reRenders).toBe(4)
-    })
-
-    // delete item
-    act(() => {
-      sql.delete('1')
-    })
-    await waitFor(() => {
-      expect(result.current[0]).toEqual([])
-      expect(reRenders).toBe(5)
-    })
-
-    // add two items
-    act(() => {
-      sql.set({ id: '1', name: 'Alice', age: 30 })
-      sql.set({ id: '2', name: 'Bob', age: 25 })
-    })
-    await waitFor(() => {
-      expect(result.current[0].length).toBe(2)
-      expect(reRenders).toBe(6)
-    })
-  })
-
-  it('should use where clause changed via state', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Alice', age: 30 },
-      { id: '2', name: 'Bob', age: 25 },
-      { id: '3', name: 'Carol', age: 40 },
-    ])
-    let reRenders = 0
-    const { result } = renderHook(() => {
-      reRenders++
-      const [minAge, setMinAge] = useState(20)
-      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sorBy: 'age' }, [minAge]), setMinAge] as const
-    })
-
-    await waitFor(() => {
-      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Bob', 'Carol'])
-      expect(reRenders).toBe(2)
-    })
-
-    // // change minAge to 29
-    act(() => {
-      result.current[1](29)
-    })
-    await waitFor(() => {
-      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Carol'])
-      expect(reRenders).toBe(4)
-    })
-  })
-
-  it('should support like in where clause and update results', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Alice', age: 30 },
-      { id: '2', name: 'Alicia', age: 25 },
-      { id: '3', name: 'Bob', age: 40 },
-    ])
-    let reRenders = 0
-    const { result, rerender } = renderHook(
-      ({ like }) => {
-        reRenders++
-        return useSqliteValue(sql, { where: { name: { like } } }, [like])
-      },
-      { initialProps: { like: '%Ali%' } },
-    )
-    await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Alicia'])
-    })
-    act(() => {
-      rerender({ like: '%Bob%' })
-    })
-    await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Bob'])
-    })
-    expect(reRenders).toBeGreaterThanOrEqual(2)
-  })
-
-  it('should update results when changing order and limit options', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State4', 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(
-      ({ order, limit }) => useSqliteValue(sql, { sorBy: 'age', order, limit }, [order, limit]),
-      { initialProps: { order: 'asc' as 'asc' | 'desc', limit: 2 } },
-    )
-    await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
-    })
-    act(() => {
-      rerender({ order: 'desc', limit: 2 })
-    })
-    await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
-    })
-    act(() => {
-      rerender({ order: 'desc', limit: 1 })
-    })
-    await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Carol'])
-    })
-  })
-
-  it('should support actions.next and actions.refresh', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Alice', age: 30 },
-      { id: '2', name: 'Bob', age: 25 },
-    ])
-    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
-    // actions.next and actions.refresh should be functions
-    await waitFor(() => {
-      expect(typeof result.current[1].next).toBe('function')
-      expect(typeof result.current[1].reset).toBe('function')
-      expect(result.current[1].reset()).resolves.toBeUndefined()
-      expect(result.current[1].next()).resolves.toBeFalsy()
-    })
-  })
-  it('should handle thousands of records', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
-    const people: Person[] = []
-    const ITEMS_COUNT = 1000
-    for (let index = 1; index <= ITEMS_COUNT; index++) {
-      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
-    }
-    await sql.batchSet(people)
-    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
-    await waitFor(() => {
-      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
-    })
-
-    // loop until we have all ITEMS_COUNT items
-    for (let index = 0; index < ITEMS_COUNT / DEFAULT_STEP_SIZE; index++) {
-      act(() => {
-        result.current[1].next()
-      })
-      await waitFor(() => {
-        expect(result.current[0].length).toBe(Math.min(DEFAULT_STEP_SIZE * (index + 2), ITEMS_COUNT))
-      })
-    }
-
-    act(() => {
-      result.current[1].reset()
-    })
-    await waitFor(() => {
-      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
-    })
-  })
-
-  it('should handle thousands of records with single update', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
-    const people: Person[] = []
-    const ITEMS_COUNT = 10_000
-    const stepSize = 5000
-    for (let index = 1; index <= ITEMS_COUNT; index++) {
-      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
-    }
-    await sql.batchSet(people)
-    let reRenders = 0
-    const { result } = renderHook(() => {
-      reRenders++
-      return useSqliteValue(sql, { stepSize }, [])
-    })
-    await waitFor(() => {
-      expect(reRenders).toBe(2)
-      expect(result.current[0].length).toBe(stepSize)
-    })
-
-    act(() => {
-      for (let index = 0; index < ITEMS_COUNT / stepSize; index++) {
-        result.current[1].next()
-      }
-    })
-
-    await waitFor(() => {
-      expect(reRenders).toBe(4)
-      expect(result.current[0].length).toBe(ITEMS_COUNT)
-    })
-
-    act(() => {
-      result.current[1].reset()
-    })
-    await waitFor(() => {
-      expect(reRenders).toBe(5)
-      expect(result.current[0].length).toBe(stepSize)
-    })
-  })
-  it('should change ordering', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State7', key: 'id', indexes: ['age'] })
-    const people: Person[] = []
-    for (let index = 1; index <= 100; index++) {
-      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
-    }
-    await sql.batchSet(people)
-    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sorBy: 'age', order }, [order]), {
-      initialProps: { order: 'asc' as 'asc' | 'desc' },
-    })
-    await waitFor(() => {
-      expect(result.current[0][0].age).toBe(21)
-    })
-    act(() => {
-      rerender({ order: 'desc' })
-    })
-    await waitFor(() => {
-      expect(result.current[0][0].age).toBe(69)
-    })
-  })
-
-  it('should support selector in options', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State8', 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,
-        {
-          sorBy: 'age',
-          select: (d) => d.name,
-        },
-        [],
-      ),
-    )
-    await waitFor(() => {
-      expect(result.current[0]).toEqual(['Alice', 'Bob', 'Carol'])
-    })
-  })
-})