muya 2.1.2 → 2.2.0

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

@@ -0,0 +1 @@
+import{createSqliteState as o}from"../create-sqlite";import{bunMemoryBackend as s}from"../table/bun-backend";const n=s();describe("create-sqlite-state",()=>{it("should batchSet and update multiple documents",async()=>{const e=o({backend:n,tableName:"State2",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25}]);const a=[];for await(const i of e.search())a.push(i);expect(a).toHaveLength(2),await e.batchSet([{id:"1",name:"Alice2",age:31},{id:"2",name:"Bob2",age:26}]);const t=[];for await(const i of e.search())t.push(i);expect(t).toEqual([{id:"1",name:"Alice2",age:31},{id:"2",name:"Bob2",age:26}])}),it("should deleteBy condition",async()=>{const e=o({backend:n,tableName:"State3",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const a=await e.deleteBy({age:{gt:30}});expect(a.length).toBe(1);const t=[];for await(const i of e.search())t.push(i);expect(t.map(i=>i.id)).toEqual(["1","2"])}),it("should get by key and with selector",async()=>{const e=o({backend:n,tableName:"State4",key:"id"});await e.set({id:"1",name:"Alice",age:30});const a=await e.get("1");expect(a).toEqual({id:"1",name:"Alice",age:30});const t=await e.get("1",c=>c.name);expect(t).toBe("Alice");const i=await e.get("999");expect(i).toBeUndefined()}),it("should count documents with and without where",async()=>{const e=o({backend:n,tableName:"State5",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]),expect(await e.count()).toBe(3),expect(await e.count({where:{age:{gt:30}}})).toBe(1)}),it("should support search with options",async()=>{const e=o({backend:n,tableName:"State6",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const a=[];for await(const t of e.search({where:{age:{lt:35}}}))a.push(t);expect(a.map(t=>t.id)).toEqual(["1","2"])})});

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

@@ -0,0 +1 @@
+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(["Bob","Alice","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(["Bob","Alice"])}),s(()=>{n({order:"desc",limit:2})}),await o(()=>{expect(t.current[0].map(r=>r.name)).toEqual(["Carol","Alice"])}),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(20)}),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(["Bob","Alice","Carol"])})})});

package/esm/sqlite/create-sqlite.js

@@ -0,0 +1 @@
+import{createScheduler as P}from"../scheduler";import{shallow as R}from"../utils/shallow";import{selectSql as M}from"./select-sql";import{createTable as O,DEFAULT_STEP_SIZE as v}from"./table/table";const f=P();let C=0;function E(){return C++}function N(g){const T=E();function l(e){return`state-${T}-search-${e}`}let m;async function o(){return m||(m=await O(g)),m}const c=new Map,i=new Map,h=new Map;async function p(e,n){const t=h.get(e),{options:a={}}=n,{stepSize:s=v}=a;if(!t)return!1;const r=[];for(let d=0;d<s;d++){const y=await t.next();if(y.done){h.delete(e);break}r.push(y.value.document),n.keys.add(String(y.value.rowId))}return r.length===0||R(n.items,r)?!1:(n.items=[...n.items,...r],!0)}function b(e){const n=i.get(e);n&&n()}async function k(e){const n=await o(),t=c.get(e);if(!t)return;const{options:a}=t,s=n.search({...a,select:(r,{rowId:d})=>({document:r,rowId:d})});h.set(e,s),t.keys=new Set,t.items=[],await p(e,t)}async function S(e){await k(e),b(e)}function x(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 u(e){const n=new Set;for(const t of e){const a=x(t);for(const s of a)n.add(s)}for(const t of n){const a=l(t);f.schedule(a,{searchId:t})}}const w=new Set;function D(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={async set(e){const t=await(await o()).set(e);return await u([t]),t},async batchSet(e){const t=await(await o()).batchSet(e);return await u(t),t},async delete(e){const t=await(await o()).delete(e);return t&&await u([t]),t},async deleteBy(e){const t=await(await o()).deleteBy(e);return await u(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=D(e,n);t.options=n;const a=l(e);f.schedule(a,{searchId:e})},subscribe(e,n){const t=l(e),a=f.add(t,{onScheduleDone(){S(e)}});return w.add(a),i.has(e)||i.set(e,n),()=>{i.delete(e),a(),c.delete(e)}},getSnapshot(e){return D(e).items},refresh:S,destroy(){for(const e of w)e();c.clear(),i.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 M(I,e)}};return I}export{N as createSqliteState};

package/esm/sqlite/index.js

@@ -0,0 +1 @@
+export*from"./create-sqlite";export*from"./table";export*from"./select-sql";export*from"./use-sqlite";

package/esm/sqlite/select-sql.js

@@ -0,0 +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};

package/esm/sqlite/table/index.js

@@ -0,0 +1 @@
+export*from"./backend";export*from"./table.types";export*from"./where";export*from"./table";export*from"./map-deque";

package/esm/sqlite/use-sqlite.js

@@ -0,0 +1 @@
+import{useCallback as r,useDebugValue as S,useId as p,useLayoutEffect as a,useMemo as D}from"react";import{isError as f,isPromise as y}from"../utils/is";import{useSyncExternalStoreWithSelector as x}from"use-sync-external-store/shim/with-selector";function L(e,s={},u=[]){const{select:c}=s,t=p();a(()=>{e.updateSearchOptions(t,{...s,select:void 0})},u);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=x(d,i,i,l);if(S(n),y(n)||f(n))throw n;const m=D(()=>({next:()=>e.next(t),reset:()=>e.refresh(t)}),[t,e]);return[n,m]}export{L as useSqliteValue};

package/package.json

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

package/src/sqlite/__tests__/{create-sqlite-state.test.ts → create-sqlite.test.ts}

@@ -1,4 +1,4 @@
-import { createSqliteState } from '../create-sqlite-state'
+import { createSqliteState } from '../create-sqlite'
 import { bunMemoryBackend } from '../table/bun-backend'
 
 const backend = bunMemoryBackend()
@@ -10,7 +10,7 @@ interface Person {
 
 describe('create-sqlite-state', () => {
   it('should batchSet and update multiple documents', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -32,7 +32,7 @@ describe('create-sqlite-state', () => {
   })
 
   it('should deleteBy condition', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -46,7 +46,7 @@ describe('create-sqlite-state', () => {
   })
 
   it('should get by key and with selector', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
     await sql.set({ id: '1', name: 'Alice', age: 30 })
     const doc = await sql.get('1')
     expect(doc).toEqual({ id: '1', name: 'Alice', age: 30 })
@@ -57,7 +57,7 @@ describe('create-sqlite-state', () => {
   })
 
   it('should count documents with and without where', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -68,7 +68,7 @@ describe('create-sqlite-state', () => {
   })
 
   it('should support search with options', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },

package/src/sqlite/__tests__/{use-sqlite-state.test.ts → use-sqlite.test.ts}

@@ -1,6 +1,6 @@
 import { act, renderHook } from '@testing-library/react-hooks'
-import { createSqliteState } from '../create-sqlite-state'
-import { useSqliteValue } from '../use-sqlite-value'
+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'
@@ -15,7 +15,7 @@ interface Person {
 
 describe('use-sqlite-state', () => {
   it('should get basic value states', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
     let reRenders = 0
     const { result } = renderHook(() => {
       reRenders++
@@ -62,7 +62,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should use where clause changed via state', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -91,7 +91,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should support like in where clause and update results', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Alicia', age: 25 },
@@ -118,7 +118,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should update results when changing order and limit options', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -146,7 +146,7 @@ describe('use-sqlite-state', () => {
   })
 
   it('should support actions.next and actions.refresh', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
     await sql.batchSet([
       { id: '1', name: 'Alice', age: 30 },
       { id: '2', name: 'Bob', age: 25 },
@@ -161,7 +161,7 @@ describe('use-sqlite-state', () => {
     })
   })
   it('should handle thousands of records', async () => {
-    const sql = await createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
     const people: Person[] = []
     const ITEMS_COUNT = 1000
     for (let index = 1; index <= ITEMS_COUNT; index++) {
@@ -190,8 +190,47 @@ describe('use-sqlite-state', () => {
       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 = await createSqliteState<Person>({ backend, tableName: 'State7', key: 'id' })
+    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) })
@@ -210,4 +249,26 @@ describe('use-sqlite-state', () => {
       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(['Bob', 'Alice', 'Carol'])
+    })
+  })
 })

package/src/sqlite/{create-sqlite-state.ts → create-sqlite.ts}

@@ -3,6 +3,7 @@
 /* eslint-disable no-shadow */
 import { createScheduler } from '../scheduler'
 import { shallow } from '../utils/shallow'
+import { selectSql, type CreateState } from './select-sql'
 import { createTable, DEFAULT_STEP_SIZE } from './table/table'
 import type { DbOptions, DocType, Key, MutationResult, SearchOptions, Table } from './table/table.types'
 import type { Where } from './table/where'
@@ -14,6 +15,7 @@ let stateId = 0
 function getStateId() {
   return stateId++
 }
+
 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
@@ -31,6 +33,10 @@ export interface SyncTable<Document extends DocType> {
   readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
   readonly destroy: () => void
   readonly next: (searchId: SearchId) => Promise<boolean>
+
+  readonly select: <Params extends unknown[]>(
+    compute: (...args: Params) => SearchOptions<Document>,
+  ) => CreateState<Document, Params>
 }
 
 interface DataItems<Document extends DocType> {
@@ -39,7 +45,7 @@ interface DataItems<Document extends DocType> {
   options?: SearchOptions<Document, unknown>
 }
 
-export async function createSqliteState<Document extends DocType>(options: DbOptions<Document>): Promise<SyncTable<Document>> {
+export function createSqliteState<Document extends DocType>(options: DbOptions<Document>): SyncTable<Document> {
   // const table = await createTable<Document>(options)
 
   const id = getStateId()
@@ -66,7 +72,7 @@ export async function createSqliteState<Document extends DocType>(options: DbOpt
 
   async function next(searchId: SearchId, data: DataItems<Document>): Promise<boolean> {
     const iterator = iterators.get(searchId)
-    const { items, options = {} } = data
+    const { options = {} } = data
     const { stepSize = DEFAULT_STEP_SIZE } = options
     if (!iterator) return false
     const newItems: Document[] = []
@@ -81,9 +87,10 @@ export async function createSqliteState<Document extends DocType>(options: DbOpt
       data.keys.add(String(result.value.rowId))
     }
 
+    if (newItems.length === 0) return false
     if (shallow(data.items, newItems)) return false
-    data.items = [...items, ...newItems]
-    return newItems.length > 0
+    data.items = [...data.items, ...newItems]
+    return true
   }
 
   function notifyListeners(searchId: SearchId) {
@@ -164,7 +171,7 @@ export async function createSqliteState<Document extends DocType>(options: DbOpt
     return data
   }
 
-  return {
+  const state: SyncTable<Document> = {
     async set(document) {
       const table = await getTable()
       const changes = await table.set(document)
@@ -252,5 +259,11 @@ export async function createSqliteState<Document extends DocType>(options: DbOpt
       }
       return false
     },
+
+    select(compute) {
+      return selectSql(state, compute)
+    },
   }
+
+  return state
 }

package/src/sqlite/index.ts

@@ -0,0 +1,4 @@
+export * from './create-sqlite'
+export * from './table'
+export * from './select-sql'
+export * from './use-sqlite'

package/src/sqlite/select-sql.ts

@@ -0,0 +1,55 @@
+import { createState } from '../create-state'
+import type { GetState } from '../types'
+import type { SyncTable } from './create-sqlite'
+import type { DocType } from './table/table.types'
+import type { Where } from './table/where'
+
+export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>
+
+export interface SqlSeachOptions<Document extends DocType> {
+  readonly sorBy?: keyof Document
+  readonly order?: 'asc' | 'desc'
+  readonly limit?: number
+  readonly offset?: number
+  readonly where?: Where<Document>
+  readonly stepSize?: number
+}
+
+let stateId = 0
+function getStateId() {
+  stateId++
+  return `${stateId.toString(36)}-sql`
+}
+
+export function selectSql<Document extends DocType, Params extends unknown[] = []>(
+  state: SyncTable<Document>,
+  compute: (...args: Params) => SqlSeachOptions<Document>,
+): CreateState<Document, Params> {
+  const { subscribe, updateSearchOptions } = state
+
+  const result: CreateState<Document, Params> = (...params) => {
+    const searchId = getStateId()
+    const destroy = subscribe(searchId, () => {
+      getState.emitter.emit()
+    })
+
+    const options = compute(...params)
+    const getState = createState<Document[]>({
+      destroy() {
+        destroy()
+        getState.emitter.clear()
+        getState.cache.current = undefined
+      },
+      get() {
+        return state.getSnapshot(searchId)
+      },
+      getSnapshot() {
+        return state.getSnapshot(searchId)
+      },
+    })
+    updateSearchOptions<Document>(searchId, options)
+
+    return getState
+  }
+  return result
+}

package/src/sqlite/table/index.ts

@@ -0,0 +1,5 @@
+export * from './backend'
+export * from './table.types'
+export * from './where'
+export * from './table'
+export * from './map-deque'

package/src/sqlite/{use-sqlite-value.ts → use-sqlite.ts}

@@ -1,22 +1,16 @@
 import { useCallback, useDebugValue, useId, useLayoutEffect, useMemo, type DependencyList } from 'react'
-import type { SyncTable } from './create-sqlite-state'
+import type { SyncTable } from './create-sqlite'
 import type { DocType } from './table/table.types'
 import { isError, isPromise } from '../utils/is'
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'
-import type { Where } from './table/where'
+import type { SqlSeachOptions } from './select-sql'
 
 export interface SqLiteActions {
   readonly next: () => Promise<boolean>
   readonly reset: () => Promise<void>
 }
 
-export interface UseSearchOptions<Document extends DocType, Selected = Document> {
-  readonly sorBy?: keyof Document
-  readonly order?: 'asc' | 'desc'
-  readonly limit?: number
-  readonly offset?: number
-  readonly where?: Where<Document>
-  readonly stepSize?: number
+export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
   /**
    * Naive projection. Prefer specialized queries for heavy fan-out graphs.
    */

package/types/sqlite/{create-sqlite-state.d.ts → create-sqlite.d.ts}

@@ -1,3 +1,4 @@
+import { type CreateState } from './select-sql';
 import type { DbOptions, DocType, Key, MutationResult, SearchOptions } from './table/table.types';
 import type { Where } from './table/where';
 type SearchId = string;
@@ -17,6 +18,7 @@ export interface SyncTable<Document extends DocType> {
     readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
     readonly destroy: () => void;
     readonly next: (searchId: SearchId) => Promise<boolean>;
+    readonly select: <Params extends unknown[]>(compute: (...args: Params) => SearchOptions<Document>) => CreateState<Document, Params>;
 }
-export declare function createSqliteState<Document extends DocType>(options: DbOptions<Document>): Promise<SyncTable<Document>>;
+export declare function createSqliteState<Document extends DocType>(options: DbOptions<Document>): SyncTable<Document>;
 export {};

package/types/sqlite/index.d.ts

@@ -0,0 +1,4 @@
+export * from './create-sqlite';
+export * from './table';
+export * from './select-sql';
+export * from './use-sqlite';

package/types/sqlite/select-sql.d.ts

@@ -0,0 +1,14 @@
+import type { GetState } from '../types';
+import type { SyncTable } from './create-sqlite';
+import type { DocType } from './table/table.types';
+import type { Where } from './table/where';
+export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>;
+export interface SqlSeachOptions<Document extends DocType> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly where?: Where<Document>;
+    readonly stepSize?: number;
+}
+export declare function selectSql<Document extends DocType, Params extends unknown[] = []>(state: SyncTable<Document>, compute: (...args: Params) => SqlSeachOptions<Document>): CreateState<Document, Params>;

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

@@ -0,0 +1,5 @@
+export * from './backend';
+export * from './table.types';
+export * from './where';
+export * from './table';
+export * from './map-deque';

package/types/sqlite/{use-sqlite-value.d.ts → use-sqlite.d.ts}

@@ -1,18 +1,12 @@
 import { type DependencyList } from 'react';
-import type { SyncTable } from './create-sqlite-state';
+import type { SyncTable } from './create-sqlite';
 import type { DocType } from './table/table.types';
-import type { Where } from './table/where';
+import type { SqlSeachOptions } from './select-sql';
 export interface SqLiteActions {
     readonly next: () => Promise<boolean>;
     readonly reset: () => Promise<void>;
 }
-export interface UseSearchOptions<Document extends DocType, Selected = Document> {
-    readonly sorBy?: keyof Document;
-    readonly order?: 'asc' | 'desc';
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly where?: Where<Document>;
-    readonly stepSize?: number;
+export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
     /**
      * Naive projection. Prefer specialized queries for heavy fan-out graphs.
      */

package/esm/sqlite/__tests__/create-sqlite-state.test.js

@@ -1 +0,0 @@
-import{createSqliteState as o}from"../create-sqlite-state";import{bunMemoryBackend as s}from"../table/bun-backend";const n=s();describe("create-sqlite-state",()=>{it("should batchSet and update multiple documents",async()=>{const e=await o({backend:n,tableName:"State2",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25}]);const t=[];for await(const i of e.search())t.push(i);expect(t).toHaveLength(2),await e.batchSet([{id:"1",name:"Alice2",age:31},{id:"2",name:"Bob2",age:26}]);const a=[];for await(const i of e.search())a.push(i);expect(a).toEqual([{id:"1",name:"Alice2",age:31},{id:"2",name:"Bob2",age:26}])}),it("should deleteBy condition",async()=>{const e=await o({backend:n,tableName:"State3",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const t=await e.deleteBy({age:{gt:30}});expect(t.length).toBe(1);const a=[];for await(const i of e.search())a.push(i);expect(a.map(i=>i.id)).toEqual(["1","2"])}),it("should get by key and with selector",async()=>{const e=await o({backend:n,tableName:"State4",key:"id"});await e.set({id:"1",name:"Alice",age:30});const t=await e.get("1");expect(t).toEqual({id:"1",name:"Alice",age:30});const a=await e.get("1",c=>c.name);expect(a).toBe("Alice");const i=await e.get("999");expect(i).toBeUndefined()}),it("should count documents with and without where",async()=>{const e=await o({backend:n,tableName:"State5",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]),expect(await e.count()).toBe(3),expect(await e.count({where:{age:{gt:30}}})).toBe(1)}),it("should support search with options",async()=>{const e=await o({backend:n,tableName:"State6",key:"id"});await e.batchSet([{id:"1",name:"Alice",age:30},{id:"2",name:"Bob",age:25},{id:"3",name:"Carol",age:40}]);const t=[];for await(const a of e.search({where:{age:{lt:35}}}))t.push(a);expect(t.map(a=>a.id)).toEqual(["1","2"])})});

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

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

package/esm/sqlite/create-sqlite-state.js

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

package/esm/sqlite/use-sqlite-value.js

@@ -1 +0,0 @@
-import{useCallback as c,useDebugValue as a,useId as p,useLayoutEffect as y,useMemo as S}from"react";import{isError as f,isPromise as D}from"../utils/is";import{useSyncExternalStoreWithSelector as b}from"use-sync-external-store/shim/with-selector";function q(e,s={},u=[]){const{select:r}=s,t=p();y(()=>{e.updateSearchOptions(t,{...s,select:void 0})},u);const l=c(n=>r?n.map(r):n,[r]),d=c(n=>e.subscribe(t,n),[e,t]),i=c(()=>e.getSnapshot(t),[e,t]),o=b(d,i,i,l);if(a(o),D(o)||f(o))throw o;const m=S(()=>({next:()=>e.next(t),reset:()=>e.refresh(t)}),[t,e]);return[o,m]}export{q as useSqliteValue};