muya 2.2.1 → 2.2.3

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

@@ -1 +1 @@
-import{bunMemoryBackend as c}from"../table/bun-backend";import{createTable as r}from"../table/table";describe("table",()=>{let n=c(),e;beforeEach(async()=>{n=c(),e=await r({backend:n,tableName:"TestTable",key:"name"})}),it("should set and get items",async()=>{const a=await e.set({name:"Alice",age:30,city:"Paris"});expect(a.key).toBe("Alice"),expect(a.op).toBe("insert");const i=await e.get("Alice");expect(i).toEqual({name:"Alice",age:30,city:"Paris"});const t=await e.set({name:"Alice",age:31,city:"Paris"});expect(t.key).toBe("Alice"),expect(t.op).toBe("update");const s=await e.get("Alice");expect(s).toEqual({name:"Alice",age:31,city:"Paris"})}),it("should count items and count with where",async()=>{await e.set({name:"Alice",age:30,city:"Paris"}),await e.set({name:"Bob",age:25,city:"London"}),expect(await e.count()).toBe(2),expect(await e.count({where:{city:"Paris"}})).toBe(1)}),it("should search with ordering, limit and offset",async()=>{const a=[{name:"Alice",age:30,city:"Paris"},{name:"Bob",age:25,city:"London"},{name:"Carol",age:35,city:"Berlin"}];for(const o of a)await e.set(o);const i=[];for await(const o of e.search({sortBy:"age",order:"asc"}))i.push(o);expect(i.map(o=>o.name)).toEqual(["Bob","Alice","Carol"]);const t=[];for await(const o of e.search({sortBy:"age",order:"asc",limit:2}))t.push(o);expect(t.map(o=>o.name)).toEqual(["Bob","Alice"]);const s=[];for await(const o of e.search({sortBy:"age",order:"asc",offset:1,limit:2}))s.push(o);expect(s.map(o=>o.name)).toEqual(["Alice","Carol"])}),it("should deleteBy where clause",async()=>{await e.set({name:"Dave",age:40,city:"NY"}),await e.set({name:"Eve",age:45,city:"NY"}),await e.set({name:"Frank",age:50,city:"LA"}),expect(await e.count()).toBe(3),await e.deleteBy({city:"NY"}),expect(await e.count()).toBe(1),expect(await e.get("Frank")).toEqual({name:"Frank",age:50,city:"LA"}),expect(await e.get("Dave")).toBeUndefined()}),it("should use selector in get and search",async()=>{await e.set({name:"Gary",age:60,city:"SF"});const a=await e.get("Gary",({age:t})=>t);expect(a).toBe(60);const i=[];for await(const t of e.search({select:({city:s})=>s}))i.push(t);expect(i).toEqual(["SF"])}),it("should delete items by key",async()=>{await e.set({name:"Helen",age:28,city:"Rome"}),expect(await e.get("Helen")).toBeDefined(),await e.delete("Helen"),expect(await e.get("Helen")).toBeUndefined()}),it("should test search with 1000 items",async()=>{const a=[];for(let t=0;t<1e3;t++)a.push({name:`Person${t}`,age:Math.floor(Math.random()*100),city:"City"+t%10});for(const t of a)await e.set(t);const i=[];for await(const t of e.search({sortBy:"age",order:"asc",limit:100}))i.push(t);expect(i.length).toBe(100)}),it("should handle operations on an empty table",async()=>{expect(await e.count()).toBe(0),expect(await e.get("NonExistent")).toBeUndefined();const a=[];for await(const i of e.search({sortBy:"age",order:"asc"}))a.push(i);expect(a.length).toBe(0)}),it("should handle duplicate keys gracefully",async()=>{await e.set({name:"Alice",age:30,city:"Paris"}),await e.set({name:"Alice",age:35,city:"Berlin"});const a=await e.get("Alice");expect(a).toEqual({name:"Alice",age:35,city:"Berlin"})}),it("should handle edge cases in selectors",async()=>{await e.set({name:"Charlie",age:40,city:"NY"});const a=await e.get("Charlie",()=>null);expect(a).toBeNull();const i=await e.get("Charlie",()=>{});expect(i).toBeUndefined()})});
+import{bunMemoryBackend as r}from"../table/bun-backend";import{createTable as l}from"../table/table";describe("table",()=>{let c=r(),e,s;beforeEach(async()=>{c=r(),e=await l({backend:c,tableName:"TestTable",key:"name"}),s=await l({backend:c,tableName:"TestTableNested",key:"info.name",indexes:["info.age","info.city"]})}),it("should set and get items",async()=>{const a=await e.set({name:"Alice",age:30,city:"Paris"});expect(a.key).toBe("Alice"),expect(a.op).toBe("insert");const o=await e.get("Alice");expect(o).toEqual({name:"Alice",age:30,city:"Paris"});const t=await e.set({name:"Alice",age:31,city:"Paris"});expect(t.key).toBe("Alice"),expect(t.op).toBe("update");const i=await e.get("Alice");expect(i).toEqual({name:"Alice",age:31,city:"Paris"})}),it("should set and get nested key",async()=>{const a=await s.set({info:{name:"Bob",age:25,city:"London"}});expect(a.key).toBe("Bob"),expect(a.op).toBe("insert");const o=await s.get("Bob");expect(o).toEqual({info:{name:"Bob",age:25,city:"London"}});const t=await s.set({info:{name:"Bob",age:26,city:"London"}});expect(t.key).toBe("Bob"),expect(t.op).toBe("update");const i=await s.get("Bob");expect(i).toEqual({info:{name:"Bob",age:26,city:"London"}});const n=[];for await(const d of s.search({where:{info:{city:{like:"London"}}}}))n.push(d);expect(n.length).toBe(1)}),it("should count items and count with where",async()=>{await e.set({name:"Alice",age:30,city:"Paris"}),await e.set({name:"Bob",age:25,city:"London"}),expect(await e.count()).toBe(2),expect(await e.count({where:{city:"Paris"}})).toBe(1)}),it("should search with ordering, limit and offset",async()=>{const a=[{name:"Alice",age:30,city:"Paris"},{name:"Bob",age:25,city:"London"},{name:"Carol",age:35,city:"Berlin"}];for(const n of a)await e.set(n);const o=[];for await(const n of e.search({sortBy:"age",order:"asc"}))o.push(n);expect(o.map(n=>n.name)).toEqual(["Bob","Alice","Carol"]);const t=[];for await(const n of e.search({sortBy:"age",order:"asc",limit:2}))t.push(n);expect(t.map(n=>n.name)).toEqual(["Bob","Alice"]);const i=[];for await(const n of e.search({sortBy:"age",order:"asc",offset:1,limit:2}))i.push(n);expect(i.map(n=>n.name)).toEqual(["Alice","Carol"])}),it("should deleteBy where clause",async()=>{await e.set({name:"Dave",age:40,city:"NY"}),await e.set({name:"Eve",age:45,city:"NY"}),await e.set({name:"Frank",age:50,city:"LA"}),expect(await e.count()).toBe(3),await e.deleteBy({city:"NY"}),expect(await e.count()).toBe(1),expect(await e.get("Frank")).toEqual({name:"Frank",age:50,city:"LA"}),expect(await e.get("Dave")).toBeUndefined()}),it("should use selector in get and search",async()=>{await e.set({name:"Gary",age:60,city:"SF"});const a=await e.get("Gary",({age:t})=>t);expect(a).toBe(60);const o=[];for await(const t of e.search({select:({city:i})=>i}))o.push(t);expect(o).toEqual(["SF"])}),it("should delete items by key",async()=>{await e.set({name:"Helen",age:28,city:"Rome"}),expect(await e.get("Helen")).toBeDefined(),await e.delete("Helen"),expect(await e.get("Helen")).toBeUndefined()}),it("should test search with 1000 items",async()=>{const a=[];for(let t=0;t<1e3;t++)a.push({name:`Person${t}`,age:Math.floor(Math.random()*100),city:"City"+t%10});for(const t of a)await e.set(t);const o=[];for await(const t of e.search({sortBy:"age",order:"asc",limit:100}))o.push(t);expect(o.length).toBe(100)}),it("should handle operations on an empty table",async()=>{expect(await e.count()).toBe(0),expect(await e.get("NonExistent")).toBeUndefined();const a=[];for await(const o of e.search({sortBy:"age",order:"asc"}))a.push(o);expect(a.length).toBe(0)}),it("should handle duplicate keys gracefully",async()=>{await e.set({name:"Alice",age:30,city:"Paris"}),await e.set({name:"Alice",age:35,city:"Berlin"});const a=await e.get("Alice");expect(a).toEqual({name:"Alice",age:35,city:"Berlin"})}),it("should handle edge cases in selectors",async()=>{await e.set({name:"Charlie",age:40,city:"NY"});const a=await e.get("Charlie",()=>null);expect(a).toBeNull();const o=await e.get("Charlie",()=>{});expect(o).toBeUndefined()})});

package/esm/sqlite/table/table.js

@@ -1,10 +1,11 @@
-import{getWhereQuery as S}from"./where";const p=500,g=100;async function x(A){const{backend:o,tableName:s,indexes:O,key:m,disablePragmaOptimization:R}=A,d=m!==void 0;R||(await o.execute("PRAGMA journal_mode=WAL;"),await o.execute("PRAGMA synchronous=NORMAL;"),await o.execute("PRAGMA temp_store=MEMORY;"),await o.execute("PRAGMA cache_size=-20000;")),d?await o.execute(`
-      CREATE TABLE IF NOT EXISTS ${s} (
+import{getWhereQuery as h}from"./where";const O=500,N=100;function D(l){return"$."+l}function I(l,r){if(!(!l||!r))return r.split(".").reduce((o,y)=>{if(typeof o=="object"&&o!==null&&y in o)return o[y]},l)}async function M(l){const{backend:r,tableName:o,indexes:y,key:S,disablePragmaOptimization:k}=l,d=S!==void 0;k||(await r.execute("PRAGMA journal_mode=WAL;"),await r.execute("PRAGMA synchronous=NORMAL;"),await r.execute("PRAGMA temp_store=MEMORY;"),await r.execute("PRAGMA cache_size=-20000;")),d?await r.execute(`
+      CREATE TABLE IF NOT EXISTS ${o} (
         key TEXT PRIMARY KEY,
         data TEXT NOT NULL
       );
-    `):await o.execute(`
-      CREATE TABLE IF NOT EXISTS ${s} (
+    `):await r.execute(`
+      CREATE TABLE IF NOT EXISTS ${o} (
         data TEXT NOT NULL
       );
-    `);for(const n of O??[]){const r=String(n);await o.execute(`CREATE INDEX IF NOT EXISTS idx_${s}_${r} ON ${s} (json_extract(data, '$.${r}'));`)}function k(n){return d?n[m]:void 0}async function D(n){return(await n.select("SELECT changes() AS c"))[0]?.c??0}const f={backend:o,async set(n,r){const e=r??o,a=JSON.stringify(n);if(d){const t=k(n);if(t==null)throw new Error(`Document is missing the configured key "${String(m)}". Provide it or create the table without "key".`);if(await e.execute(`UPDATE ${s} SET data = ? WHERE key = ?`,[a,t]),await D(e)===1)return{key:t,op:"update"};try{return await e.execute(`INSERT INTO ${s} (key, data) VALUES (?, ?)`,[t,a]),{key:t,op:"insert"}}catch{return await e.execute(`UPDATE ${s} SET data = ? WHERE key = ?`,[a,t]),{key:t,op:"update"}}}await e.execute(`INSERT INTO ${s} (data) VALUES (?)`,[a]);const c=(await e.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(n,r=(e,a)=>e){const e=d?"key = ?":"rowid = ?",a=await o.select(`SELECT rowid, data FROM ${s} WHERE ${e}`,[n]);if(a.length===0)return;const[i]=a,{data:c,rowid:u}=i,t=JSON.parse(c);return r(t,{rowid:u})},async delete(n){const r=d?"key = ?":"rowid = ?";if(await o.execute(`DELETE FROM ${s} WHERE ${r}`,[n]),((await o.select("SELECT changes() AS c"))[0]?.c??0)>0)return{key:n,op:"delete"}},async*search(n={}){const{sortBy:r,order:e="asc",limit:a,offset:i=0,where:c,select:u=(y,T)=>y,stepSize:t=g}=n;let l=`SELECT rowid, data FROM ${s}`;c&&(l+=" "+S(c));let E=0,h=i;for(;;){let y=l;r?y+=` ORDER BY json_extract(data, '$.${String(r)}') COLLATE NOCASE ${e.toUpperCase()}`:y+=d?` ORDER BY key COLLATE NOCASE ${e.toUpperCase()}`:` ORDER BY rowid ${e.toUpperCase()}`;const T=a?Math.min(t,a-E):t;y+=` LIMIT ${T} OFFSET ${h}`;const w=await o.select(y);if(w.length===0)break;for(const{rowid:$,data:b}of w){if(a&&E>=a)return;const L=JSON.parse(b);yield u(L,{rowId:$}),E++}if(w.length<T||a&&E>=a)break;h+=w.length}},async count(n={}){const{where:r}=n;let e=`SELECT COUNT(*) as count FROM ${s}`;return r&&(e+=" "+S(r)),(await o.select(e))[0]?.count??0},async deleteBy(n){const r=S(n),e=d?"key":"rowid",a=[];return await o.transaction(async i=>{const c=await i.select(`SELECT ${e} AS k, rowid FROM ${s} ${r}`);if(c.length===0)return;const u=c.map(t=>t.k);for(let t=0;t<u.length;t+=p){const l=u.slice(t,t+p),E=l.map(()=>"?").join(",");await i.execute(`DELETE FROM ${s} WHERE ${e} IN (${E})`,l)}for(const t of u)a.push({key:t,op:"delete"})}),a},async batchSet(n){const r=[];return await o.transaction(async e=>{for(const a of n){const i=await f.set(a,e);r.push(i)}}),r}};return f}export{g as DEFAULT_STEP_SIZE,x as createTable};
+    `);for(const t of y??[]){const a=String(t);await r.execute(`CREATE INDEX IF NOT EXISTS idx_${o}_${a.replaceAll(/\W/g,"_")}
+       ON ${o} (json_extract(data, '${D(a)}'));`)}function $(t){if(d)return I(t,String(S))}async function g(t){return(await t.select("SELECT changes() AS c"))[0]?.c??0}const p={backend:r,async set(t,a){const e=a??r,n=JSON.stringify(t);if(d){const s=$(t);if(s==null)throw new Error(`Document is missing the configured key "${String(S)}". Provide it or create the table without "key".`);if(await e.execute(`UPDATE ${o} SET data = ? WHERE key = ?`,[n,s]),await g(e)===1)return{key:s,op:"update"};try{return await e.execute(`INSERT INTO ${o} (key, data) VALUES (?, ?)`,[s,n]),{key:s,op:"insert"}}catch{return await e.execute(`UPDATE ${o} SET data = ? WHERE key = ?`,[n,s]),{key:s,op:"update"}}}await e.execute(`INSERT INTO ${o} (data) VALUES (?)`,[n]);const u=(await e.select("SELECT last_insert_rowid() AS id"))[0]?.id;if(typeof u!="number")throw new Error("Failed to retrieve last_insert_rowid()");return{key:u,op:"insert"}},async get(t,a=e=>e){const e=d?"key = ?":"rowid = ?",n=await r.select(`SELECT rowid, data FROM ${o} WHERE ${e}`,[t]);if(n.length===0)return;const{data:i,rowid:u}=n[0],s=JSON.parse(i);return a(s,{rowId:u})},async delete(t){const a=d?"key = ?":"rowid = ?";if(await r.execute(`DELETE FROM ${o} WHERE ${a}`,[t]),((await r.select("SELECT changes() AS c"))[0]?.c??0)>0)return{key:t,op:"delete"}},async*search(t={}){const{sortBy:a,order:e="asc",limit:n,offset:i=0,where:u,select:s=E=>E,stepSize:c=N}=t,w=h(u),f=`SELECT rowid, data FROM ${o} ${w}`;let T=0,A=i;for(;;){let E=f;a?E+=` ORDER BY json_extract(data, '${D(String(a))}') COLLATE NOCASE ${e.toUpperCase()}`:E+=d?` ORDER BY key COLLATE NOCASE ${e.toUpperCase()}`:` ORDER BY rowid ${e.toUpperCase()}`;const R=n?Math.min(c,n-T):c;E+=` LIMIT ${R} OFFSET ${A}`;const m=await r.select(E);if(m.length===0)break;for(const{rowid:b,data:L}of m){if(n&&T>=n)return;const x=JSON.parse(L);yield s(x,{rowId:b}),T++}if(m.length<R||n&&T>=n)break;A+=m.length}},async count(t={}){const a=h(t.where),e=`SELECT COUNT(*) as count FROM ${o} ${a}`;return(await r.select(e))[0]?.count??0},async deleteBy(t){const a=h(t),e=d?"key":"rowid",n=[];return await r.transaction(async i=>{const u=await i.select(`SELECT ${e} AS k FROM ${o} ${a}`);if(u.length===0)return;const s=u.map(c=>c.k);for(let c=0;c<s.length;c+=O){const w=s.slice(c,c+O),f=w.map(()=>"?").join(",");await i.execute(`DELETE FROM ${o} WHERE ${e} IN (${f})`,w)}for(const c of s)n.push({key:c,op:"delete"})}),n},async batchSet(t){const a=[];return await r.transaction(async e=>{for(const n of t){const i=await p.set(n,e);a.push(i)}}),a}};return p}export{N as DEFAULT_STEP_SIZE,M as createTable,I as getByPath};

package/esm/sqlite/table/where.js

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

package/package.json

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

package/src/sqlite/__tests__/table.test.ts

@@ -12,10 +12,20 @@ interface Person {
   age: number
   city: string
 }
+
+interface PersonNested {
+  info: {
+    name: string
+    age: number
+    city: string
+  }
+}
 describe('table', () => {
   let backend = bunMemoryBackend()
   let table: ReturnType<typeof createTable<Person>> extends Promise<infer T> ? T : never
 
+  let tableNested: ReturnType<typeof createTable<PersonNested>> extends Promise<infer T> ? T : never
+
   beforeEach(async () => {
     backend = bunMemoryBackend()
     table = await createTable<Person>({
@@ -23,6 +33,12 @@ describe('table', () => {
       tableName: 'TestTable',
       key: 'name',
     })
+    tableNested = await createTable<PersonNested>({
+      backend,
+      tableName: 'TestTableNested',
+      key: 'info.name',
+      indexes: ['info.age', 'info.city'],
+    })
   })
 
   it('should set and get items', async () => {
@@ -39,6 +55,29 @@ describe('table', () => {
     expect(updatedResult).toEqual({ name: 'Alice', age: 31, city: 'Paris' })
   })
 
+  it('should set and get nested key', async () => {
+    const mutation = await tableNested.set({ info: { name: 'Bob', age: 25, city: 'London' } })
+    expect(mutation.key).toBe('Bob')
+    expect(mutation.op).toBe('insert')
+    const result = await tableNested.get('Bob')
+    expect(result).toEqual({ info: { name: 'Bob', age: 25, city: 'London' } })
+
+    const updateMutation = await tableNested.set({ info: { name: 'Bob', age: 26, city: 'London' } })
+    expect(updateMutation.key).toBe('Bob')
+    expect(updateMutation.op).toBe('update')
+    const updatedResult = await tableNested.get('Bob')
+    expect(updatedResult).toEqual({ info: { name: 'Bob', age: 26, city: 'London' } })
+
+    // nested where query
+    const results: PersonNested[] = []
+    for await (const person of tableNested.search({
+      where: { info: { city: { like: 'London' } } },
+    })) {
+      results.push(person)
+    }
+    expect(results.length).toBe(1)
+  })
+
   it('should count items and count with where', async () => {
     await table.set({ name: 'Alice', age: 30, city: 'Paris' })
     await table.set({ name: 'Bob', age: 25, city: 'London' })

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

@@ -0,0 +1,280 @@
+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 { Suspense, useState } from 'react'
+import { DEFAULT_STEP_SIZE } from '../table/table'
+
+const backend = bunMemoryBackend()
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+function Wrapper({ children }: Readonly<{ children: React.ReactNode }>) {
+  return <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+}
+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++
+        const aha = useSqliteValue(sql, {}, [])
+        return aha
+      },
+      { wrapper: Wrapper },
+    )
+
+    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'])
+    })
+  })
+})

package/src/sqlite/table/table.ts

@@ -1,19 +1,37 @@
-// table.ts
+/* eslint-disable prefer-destructuring */
 /* eslint-disable sonarjs/different-types-comparison */
 /* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable @typescript-eslint/no-shadow */
 /* eslint-disable no-shadow */
+
 import type { Table, DbOptions, DocType, Key, SearchOptions, MutationResult } from './table.types'
-import { getWhereQuery, type Where } from './where'
+import type { Where } from './where'
+import { getWhereQuery } from './where'
 
 const DELETE_IN_CHUNK = 500 // keep well below SQLite's default 999 parameter limit
 export const DEFAULT_STEP_SIZE = 100
+
+// --- Helpers for JSON dot paths ---
+function toJsonPath(dot: string) {
+  return '$.' + dot
+}
+
+export function getByPath<T extends object>(object: T, path: string): unknown {
+  if (!object || !path) return undefined
+  // eslint-disable-next-line unicorn/no-array-reduce
+  return path.split('.').reduce<unknown>((accumulator, key) => {
+    if (typeof accumulator === 'object' && accumulator !== null && key in (accumulator as Record<string, unknown>)) {
+      return (accumulator as Record<string, unknown>)[key]
+    }
+    return
+  }, object)
+}
+
 export async function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>> {
   const { backend, tableName, indexes, key, disablePragmaOptimization } = options
   const hasUserKey = key !== undefined
 
   // --- Apply performance PRAGMAs unless explicitly disabled ---
-  // These significantly speed up write-heavy workloads on SQLite.
   if (!disablePragmaOptimization) {
     await backend.execute(`PRAGMA journal_mode=WAL;`)
     await backend.execute(`PRAGMA synchronous=NORMAL;`)
@@ -37,14 +55,18 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     `)
   }
 
-  // JSON expression indexes for fields under data
+  // JSON expression indexes
   for (const index of indexes ?? []) {
     const idx = String(index)
-    await backend.execute(`CREATE INDEX IF NOT EXISTS idx_${tableName}_${idx} ON ${tableName} (json_extract(data, '$.${idx}'));`)
+    await backend.execute(
+      `CREATE INDEX IF NOT EXISTS idx_${tableName}_${idx.replaceAll(/\W/g, '_')}
+       ON ${tableName} (json_extract(data, '${toJsonPath(idx)}'));`,
+    )
   }
 
   function getKeyFromDocument(document: Document): Key | undefined {
-    return hasUserKey ? (document[key as keyof Document] as unknown as Key | undefined) : undefined
+    if (!hasUserKey) return undefined
+    return getByPath(document, String(key)) as Key | undefined
   }
 
   async function getChanges(conn: typeof backend): Promise<number> {
@@ -87,14 +109,13 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
       const rows = await db.select<Array<{ id: number }>>(`SELECT last_insert_rowid() AS id`)
       const rowid = rows[0]?.id
       if (typeof rowid !== 'number') throw new Error('Failed to retrieve last_insert_rowid()')
-      const result: MutationResult = { key: rowid, op: 'insert' }
-      return result
+      return { key: rowid, op: 'insert' }
     },
 
-    // --- FIXED: include rowid ---
     async get<Selected = Document>(
       keyValue: Key,
-      selector: (document: Document, meta: { rowid: number }) => Selected = (d, _m) => d as unknown as Selected,
+      // keep meta available and consistent with search() { rowId }
+      selector: (document: Document, meta: { rowId: number }) => Selected = (d) => d as unknown as Selected,
     ) {
       const whereKey = hasUserKey ? `key = ?` : `rowid = ?`
       const result = await backend.select<Array<{ data: string; rowid: number }>>(
@@ -102,23 +123,19 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         [keyValue],
       )
       if (result.length === 0) return
-      const [item] = result
-      const { data, rowid } = item
+      const { data, rowid } = result[0]
       const document = JSON.parse(data) as Document
-      return selector(document, { rowid }) as Selected
+      return selector(document, { rowId: rowid }) as Selected
     },
 
     async delete(keyValue: Key) {
       const whereKey = hasUserKey ? `key = ?` : `rowid = ?`
       await backend.execute(`DELETE FROM ${tableName} WHERE ${whereKey}`, [keyValue])
       const changed = await backend.select<Array<{ c: number }>>(`SELECT changes() AS c`)
-      if ((changed[0]?.c ?? 0) > 0) {
-        return { key: keyValue, op: 'delete' }
-      }
+      if ((changed[0]?.c ?? 0) > 0) return { key: keyValue, op: 'delete' }
       return
     },
 
-    // --- FIXED: include rowid in search ---
     async *search<Selected = Document>(options: SearchOptions<Document, Selected> = {}): AsyncIterableIterator<Selected> {
       const {
         sortBy,
@@ -126,12 +143,12 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         limit,
         offset = 0,
         where,
-        select = (document, _meta) => document as unknown as Selected,
+        select = (document) => document as unknown as Selected,
         stepSize = DEFAULT_STEP_SIZE,
       } = options
 
-      let baseQuery = `SELECT rowid, data FROM ${tableName}`
-      if (where) baseQuery += ' ' + getWhereQuery(where)
+      const whereSql = getWhereQuery<Document>(where)
+      const baseQuery = `SELECT rowid, data FROM ${tableName} ${whereSql}`
 
       let yielded = 0
       let currentOffset = offset
@@ -139,7 +156,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         let query = baseQuery
 
         if (sortBy) {
-          query += ` ORDER BY json_extract(data, '$.${String(sortBy)}') COLLATE NOCASE ${order.toUpperCase()}`
+          query += ` ORDER BY json_extract(data, '${toJsonPath(String(sortBy))}') COLLATE NOCASE ${order.toUpperCase()}`
         } else {
           query += hasUserKey ? ` ORDER BY key COLLATE NOCASE ${order.toUpperCase()}` : ` ORDER BY rowid ${order.toUpperCase()}`
         }
@@ -163,28 +180,26 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     },
 
     async count(options: { where?: Where<Document> } = {}) {
-      const { where } = options
-      let query = `SELECT COUNT(*) as count FROM ${tableName}`
-      if (where) query += ' ' + getWhereQuery(where)
+      const whereSql = getWhereQuery<Document>(options.where)
+      const query = `SELECT COUNT(*) as count FROM ${tableName} ${whereSql}`
       const result = await backend.select<Array<{ count: number }>>(query)
       return result[0]?.count ?? 0
     },
 
     async deleteBy(where: Where<Document>) {
-      const whereQuery = getWhereQuery(where)
+      const whereSql = getWhereQuery<Document>(where)
       const keyCol = hasUserKey ? 'key' : 'rowid'
-
       const results: MutationResult[] = []
+
       await backend.transaction(async (tx) => {
-        const rows = await tx.select<Array<{ k: Key }>>(`SELECT ${keyCol} AS k, rowid FROM ${tableName} ${whereQuery}`)
+        const rows = await tx.select<Array<{ k: Key }>>(`SELECT ${keyCol} AS k FROM ${tableName} ${whereSql}`)
         if (rows.length === 0) return
 
         const allKeys = rows.map((r) => r.k)
-
         for (let index = 0; index < allKeys.length; index += DELETE_IN_CHUNK) {
           const chunk = allKeys.slice(index, index + DELETE_IN_CHUNK)
           const placeholders = chunk.map(() => '?').join(',')
-          await tx.execute(`DELETE FROM ${tableName} WHERE ${keyCol} IN (${placeholders})`, chunk as unknown as unknown[])
+          await tx.execute(`DELETE FROM ${tableName} WHERE ${keyCol} IN (${placeholders})`, chunk as unknown[])
         }
 
         for (const k of allKeys) results.push({ key: k, op: 'delete' })

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

@@ -6,36 +6,41 @@ import type { Where } from './where'
 export type DocType = { [key: string]: any }
 export type KeyTypeAvailable = 'string' | 'number'
 
+// Expand all nested keys into dot-paths
+export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`
+
+type Previous = [never, 0, 1, 2, 3, 4, 5]
+
+export type DotPath<T, D extends number = 5> = [D] extends [never]
+  ? never
+  : T extends object
+    ? {
+        [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPath<T[K], Previous[D]>}` : K
+      }[Extract<keyof T, string>]
+    : never
+// Replace keyof Document with DotPath<Document>
 export interface DbOptions<Document extends DocType> {
-  readonly sorBy?: keyof Document
-  readonly order?: 'asc' | 'desc'
   readonly tableName: string
-  readonly indexes?: Array<keyof Document>
+  readonly indexes?: Array<DotPath<Document>>
   readonly backend: Backend
-  /**
-   * Optional key. If omitted, the table uses implicit SQLite ROWID as the key.
-   */
-  readonly key?: keyof Document
+  readonly key?: DotPath<Document>
   readonly disablePragmaOptimization?: boolean
 }
 
-interface DbNotGeneric {
-  readonly backend: Backend
-}
-
 export interface SearchOptions<Document extends DocType, Selected = Document> {
-  readonly sortBy?: keyof Document
+  readonly sortBy?: DotPath<Document>
   readonly order?: 'asc' | 'desc'
   readonly limit?: number
   readonly offset?: number
   readonly where?: Where<Document>
   readonly stepSize?: number
-  /**
-   * Naive projection. Prefer specialized queries for heavy fan-out graphs.
-   */
   readonly select?: (document: Document, meta: { rowId: number }) => Selected
 }
 
+interface DbNotGeneric {
+  readonly backend: Backend
+}
+
 export type Key = string | number
 
 export type MutationOp = 'insert' | 'update' | 'delete'

package/src/sqlite/table/where.ts

@@ -1,267 +1,182 @@
+/* eslint-disable unicorn/no-array-callback-reference */
+/* eslint-disable unicorn/no-nested-ternary */
+/* eslint-disable no-nested-ternary */
 /* eslint-disable sonarjs/no-nested-conditional */
 /* eslint-disable sonarjs/cognitive-complexity */
+
 // -------------------------------------------------------------
-// Simplified `Where` type: each field may be a `Condition`
-// *or* directly a `Document[K]`/`Document[K][]`, shorthand for "is"/"in".
-// We also allow the special literal "KEY" to filter by the primary‐key column.
+// Condition operators for each field
 // -------------------------------------------------------------
-
-export interface Field {
-  readonly table: string
-  readonly field: string
+interface Condition<T> {
+  readonly is?: T | T[]
+  readonly isNot?: T | T[]
+  readonly gt?: T
+  readonly gte?: T
+  readonly lt?: T
+  readonly lte?: T
+  readonly in?: T[]
+  readonly notIn?: T[]
+  readonly like?: T | T[]
 }
 
-interface Condition<Document extends Record<string, unknown>, K extends keyof Document = keyof Document> {
-  readonly is?: Document[K] | Array<Document[K]>
-  readonly isNot?: Document[K] | Array<Document[K]>
-  readonly gt?: Document[K] | Array<Document[K]>
-  readonly gte?: Document[K] | Array<Document[K]>
-  readonly lt?: Document[K] | Array<Document[K]>
-  readonly lte?: Document[K] | Array<Document[K]>
-  readonly in?: Document[K] | Array<Document[K]>
-  readonly notIn?: Document[K] | Array<Document[K]>
-  readonly like?: Document[K] | Array<Document[K]>
-}
-
-/**
- * We extend `keyof Document` by the special literal "KEY".
- * That means users can write `{ KEY: ... }` in addition to `{ someField: ... }`.
- *
- * - If K extends keyof Document, then primitive values must match Document[K].
- * - If K === "KEY", then primitive values are treated as strings/Array<string>.
- */
-export type Where<Document extends Record<string, unknown>> =
+// -------------------------------------------------------------
+// Where type: recursive object with operators or nested fields
+// -------------------------------------------------------------
+export type Where<T extends Record<string, unknown>> =
   | {
-      [K in keyof Document | 'KEY']?:
-        | Condition<Document, K extends keyof Document ? K : keyof Document>
-        | (K extends keyof Document ? Document[K] : string)
-        | (K extends keyof Document ? Array<Document[K]> : string[])
+      [K in keyof T]?: T[K] extends Record<string, unknown>
+        ? Where<T[K]> // nested object
+        : Condition<T[K]> | T[K] | T[K][]
     }
   | {
-      readonly AND?: Array<Where<Document>>
-      readonly OR?: Array<Where<Document>>
-      readonly NOT?: Where<Document>
+      readonly AND?: Array<Where<T>>
+      readonly OR?: Array<Where<T>>
+      readonly NOT?: Where<T>
     }
 
 // -------------------------------------------------------------
-// A tiny helper to escape/inline a single primitive into SQL.
+// Tiny helpers
 // -------------------------------------------------------------
 function inlineValue(value: unknown): string {
-  if (typeof value === 'string') {
-    return `'${(value as string).split("'").join("''")}'`
-  }
-  if (typeof value === 'number') {
-    return (value as number).toString()
-  }
-  if (typeof value === 'boolean') {
-    return (value as boolean) ? '1' : '0'
-  }
-  return `'${String(value).split("'").join("''")}'`
+  if (typeof value === 'string') return `'${value.replaceAll("'", "''")}'`
+  if (typeof value === 'number') return value.toString()
+  if (typeof value === 'boolean') return value ? '1' : '0'
+  return `'${String(value).replaceAll("'", "''")}'`
 }
 
-// -------------------------------------------------------------
-// Build the expression for a given field.
-// If field === "KEY", refer directly to the primary‐key column (`key`).
-// Otherwise, extract from JSON `data`.
-// -------------------------------------------------------------
 function getFieldExpr(field: string, value: unknown, tableAlias?: string): string {
   const prefix = tableAlias ? `${tableAlias}.` : ''
   if (field === 'KEY') {
-    // Use double‐quotes around key to avoid conflicts with reserved words
     return `"${prefix}key"`
   }
-
-  // Otherwise, treat as JSON field under "data"
-  if (typeof value === 'string') {
-    return `CAST(json_extract(${prefix}data, '$.${field}') AS TEXT)`
-  }
-  if (typeof value === 'boolean') {
-    return `CAST(json_extract(${prefix}data, '$.${field}') AS INTEGER)`
-  }
-  if (typeof value === 'number') {
-    return `CAST(json_extract(${prefix}data, '$.${field}') AS NUMERIC)`
-  }
+  if (typeof value === 'string') return `CAST(json_extract(${prefix}data, '$.${field}') AS TEXT)`
+  if (typeof value === 'number') return `CAST(json_extract(${prefix}data, '$.${field}') AS NUMERIC)`
+  if (typeof value === 'boolean') return `CAST(json_extract(${prefix}data, '$.${field}') AS INTEGER)`
   return `json_extract(${prefix}data, '$.${field}')`
 }
 
+const OPS_SET: ReadonlySet<string> = new Set(['is', 'isNot', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'like'])
+
 // -------------------------------------------------------------
-// Valid operators set (for quick membership checks).
+// Flatten nested objects to dot-paths
 // -------------------------------------------------------------
-const OPS_SET: ReadonlySet<string> = new Set(['is', 'isNot', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'like'])
+function flattenWhere(object: Record<string, unknown>, prefix = ''): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
 
-function isUndefined(value: unknown): value is undefined {
-  return value === undefined
+  for (const [k, v] of Object.entries(object)) {
+    if (k === 'AND' || k === 'OR' || k === 'NOT') {
+      result[k] = v
+      continue
+    }
+
+    const path = prefix ? `${prefix}.${k}` : k
+
+    if (v && typeof v === 'object' && !Array.isArray(v) && !Object.keys(v).some((kk) => OPS_SET.has(kk))) {
+      Object.assign(result, flattenWhere(v as Record<string, unknown>, path))
+    } else {
+      result[path] = v
+    }
+  }
+
+  return result
 }
 
 // -------------------------------------------------------------
-// Main recursive parser: turn a `Where<Document>` into a SQL clause
-// (without the leading "WHERE").
+// Main recursive builder
 // -------------------------------------------------------------
-export function getWhere<Document extends Record<string, unknown>>(where: Where<Document>, tableAlias?: string): string {
-  if (!where || typeof where !== 'object') {
-    return ''
-  }
+export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string): string {
+  if (!where || typeof where !== 'object') return ''
 
-  // ----- Logical branches: AND / OR / NOT -----
-  if (!isUndefined(where.AND)) {
-    const array = where.AND as Array<Where<Document>>
-    if (Array.isArray(array) && array.length > 0) {
-      let combined = ''
-      let firstAdded = false
-      for (const sub of array) {
-        const clause = getWhere(sub, tableAlias)
-        if (!clause) continue
-        if (firstAdded) combined += ' AND '
-        combined += clause
-        firstAdded = true
-      }
-      return firstAdded ? `(${combined})` : ''
-    }
-    return ''
+  // ----- Logical branches -----
+  if (where.AND) {
+    const clauses = Array.isArray(where.AND) ? where.AND.map((w) => getWhere(w, tableAlias)).filter(Boolean) : []
+    return clauses.length > 0 ? `(${clauses.join(' AND ')})` : ''
   }
 
-  if (!isUndefined(where.OR)) {
-    const array = where.OR as Array<Where<Document>>
-    if (Array.isArray(array) && array.length > 0) {
-      let combined = ''
-      let firstAdded = false
-      for (const sub of array) {
-        const clause = getWhere(sub, tableAlias)
-        if (!clause) continue
-        if (firstAdded) combined += ' OR '
-        combined += clause
-        firstAdded = true
-      }
-      return firstAdded ? `(${combined})` : ''
-    }
-    return ''
+  if (where.OR) {
+    const clauses = Array.isArray(where.OR) ? where.OR.map((w) => getWhere(w, tableAlias)).filter(Boolean) : []
+    return clauses.length > 0 ? `(${clauses.join(' OR ')})` : ''
   }
 
-  if (!isUndefined(where.NOT)) {
-    const sub = where.NOT as Where<Document>
-    if (sub && typeof sub === 'object') {
-      const clause = getWhere(sub, tableAlias)
-      return clause ? `(NOT ${clause})` : ''
-    }
-    return ''
+  if (where.NOT) {
+    const clause = getWhere(where.NOT, tableAlias)
+    return clause ? `(NOT ${clause})` : ''
   }
 
-  // ----- Field‐based conditions: default is AND across fields -----
+  // ----- Field conditions -----
+  const flat = flattenWhere(where as Record<string, unknown>)
   let fieldClauses = ''
-  let anyFieldClause = false
+  let anyField = false
 
-  for (const key in where as Record<string, unknown>) {
-    if (key === 'AND' || key === 'OR' || key === 'NOT') continue
-
-    const rawValue = (where as Record<string, unknown>)[key]
+  for (const [key, rawValue] of Object.entries(flat)) {
     if (rawValue == null) continue
 
-    // If the user provided a primitive or an array, coerce it to a Condition:
-    //  - single primitive → { is: rawVal }
-    //  - array           → { in: rawVal }
-    let cond: Condition<Document, typeof key>
+    // coerce primitive/array into Condition
+    let cond: Condition<unknown>
     if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
-      cond = Array.isArray(rawValue) ? { in: rawValue } : ({ is: rawValue } as Condition<Document, typeof key>)
+      cond = Array.isArray(rawValue) ? { in: rawValue } : { is: rawValue }
     } else {
-      cond = rawValue as Condition<Document, typeof key>
+      cond = rawValue as Condition<unknown>
     }
 
-    // Iterate only over real operator keys that exist on this `cond`
-    for (const opKey of Object.keys(cond) as Array<keyof typeof cond>) {
-      if (!OPS_SET.has(opKey as string)) continue
-      const rawOpValue = cond[opKey]
-      if (rawOpValue == null) continue
+    for (const opKey of Object.keys(cond)) {
+      if (!OPS_SET.has(opKey)) continue
+      const opValue = cond[opKey as keyof Condition<unknown>]
+      if (opValue == null) continue
 
-      // Always treat it as an array for uniformity:
-      const array = Array.isArray(rawOpValue) ? (rawOpValue as unknown[]) : [rawOpValue]
-      if (array.length === 0) continue
+      const values = Array.isArray(opValue) ? opValue : [opValue]
+      if (values.length === 0) continue
 
-      // Handle `is` / `isNot` / `in` / `notIn`
+      // is / isNot / in / notIn
       if (opKey === 'is' || opKey === 'isNot' || opKey === 'in' || opKey === 'notIn') {
-        const [firstValue] = array
-        const fieldExpr = getFieldExpr(key, firstValue, tableAlias)
-
-        // Build comma‐separated list without using `.map()`
-        let inList = ''
-        if (array.length > 1) {
-          for (const [index, elt] of array.entries()) {
-            if (index > 0) inList += ','
-            inList += inlineValue(elt)
-          }
-        }
-
-        switch (opKey) {
-          case 'is': {
-            fieldClauses +=
-              array.length > 1
-                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inList})`
-                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} = ${inlineValue(array[0])}`
-            break
-          }
-          case 'isNot': {
-            fieldClauses +=
-              array.length > 1
-                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inList})`
-                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} <> ${inlineValue(array[0])}`
-            break
-          }
-          case 'in': {
-            fieldClauses +=
-              array.length > 1
-                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inList})`
-                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inlineValue(array[0])})`
-            break
-          }
-          case 'notIn': {
-            fieldClauses +=
-              array.length > 1
-                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inList})`
-                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inlineValue(array[0])})`
-            break
-          }
-        }
-
-        anyFieldClause = true
+        const fieldExpr = getFieldExpr(key, values[0], tableAlias)
+        const inList = values.map(inlineValue).join(',')
+
+        const clause =
+          opKey === 'is'
+            ? values.length > 1
+              ? `${fieldExpr} IN (${inList})`
+              : `${fieldExpr} = ${inlineValue(values[0])}`
+            : opKey === 'isNot'
+              ? values.length > 1
+                ? `${fieldExpr} NOT IN (${inList})`
+                : `${fieldExpr} <> ${inlineValue(values[0])}`
+              : opKey === 'in'
+                ? `${fieldExpr} IN (${inList})`
+                : `${fieldExpr} NOT IN (${inList})`
+
+        fieldClauses += (anyField ? ' AND ' : '') + clause
+        anyField = true
         continue
       }
 
-      // Handle comparisons: gt, gte, lt, lte, like
-      for (const v of array) {
+      // gt / gte / lt / lte / like
+      for (const v of values) {
         const fieldExpr = getFieldExpr(key, v, tableAlias)
-        switch (opKey) {
-          case 'gt': {
-            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} > ${inlineValue(v)}`
-            break
-          }
-          case 'gte': {
-            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} >= ${inlineValue(v)}`
-            break
-          }
-          case 'lt': {
-            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} < ${inlineValue(v)}`
-            break
-          }
-          case 'lte': {
-            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} <= ${inlineValue(v)}`
-            break
-          }
-          case 'like': {
-            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} LIKE ${inlineValue(v)}`
-            break
-          }
-        }
-        anyFieldClause = true
+        const clause =
+          opKey === 'gt'
+            ? `${fieldExpr} > ${inlineValue(v)}`
+            : opKey === 'gte'
+              ? `${fieldExpr} >= ${inlineValue(v)}`
+              : opKey === 'lt'
+                ? `${fieldExpr} < ${inlineValue(v)}`
+                : opKey === 'lte'
+                  ? `${fieldExpr} <= ${inlineValue(v)}`
+                  : `${fieldExpr} LIKE ${inlineValue(v)}`
+        fieldClauses += (anyField ? ' AND ' : '') + clause
+        anyField = true
       }
     }
   }
 
-  return anyFieldClause ? `(${fieldClauses})` : ''
+  return anyField ? `(${fieldClauses})` : ''
 }
 
 // -------------------------------------------------------------
-// Wrap `parse(...)` in "WHERE (…)". If empty, return "".
+// Public wrapper: adds "WHERE" if needed
 // -------------------------------------------------------------
-export function getWhereQuery<Document extends Record<string, unknown>>(where: Where<Document>): string {
+export function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>): string {
+  if (!where) return ''
   const clause = getWhere(where)
   return clause ? `WHERE ${clause}` : ''
 }

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

@@ -1,3 +1,4 @@
 import type { Table, DbOptions, DocType } from './table.types';
 export declare const DEFAULT_STEP_SIZE = 100;
+export declare function getByPath<T extends object>(object: T, path: string): unknown;
 export declare function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>>;

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

@@ -4,35 +4,32 @@ export type DocType = {
     [key: string]: any;
 };
 export type KeyTypeAvailable = 'string' | 'number';
+export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`;
+type Previous = [never, 0, 1, 2, 3, 4, 5];
+export type DotPath<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPath<T[K], Previous[D]>}` : K;
+}[Extract<keyof T, string>] : never;
 export interface DbOptions<Document extends DocType> {
-    readonly sorBy?: keyof Document;
-    readonly order?: 'asc' | 'desc';
     readonly tableName: string;
-    readonly indexes?: Array<keyof Document>;
+    readonly indexes?: Array<DotPath<Document>>;
     readonly backend: Backend;
-    /**
-     * Optional key. If omitted, the table uses implicit SQLite ROWID as the key.
-     */
-    readonly key?: keyof Document;
+    readonly key?: DotPath<Document>;
     readonly disablePragmaOptimization?: boolean;
 }
-interface DbNotGeneric {
-    readonly backend: Backend;
-}
 export interface SearchOptions<Document extends DocType, Selected = Document> {
-    readonly sortBy?: keyof Document;
+    readonly sortBy?: DotPath<Document>;
     readonly order?: 'asc' | 'desc';
     readonly limit?: number;
     readonly offset?: number;
     readonly where?: Where<Document>;
     readonly stepSize?: number;
-    /**
-     * Naive projection. Prefer specialized queries for heavy fan-out graphs.
-     */
     readonly select?: (document: Document, meta: {
         rowId: number;
     }) => Selected;
 }
+interface DbNotGeneric {
+    readonly backend: Backend;
+}
 export type Key = string | number;
 export type MutationOp = 'insert' | 'update' | 'delete';
 export interface MutationResult {

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

@@ -1,32 +1,21 @@
-export interface Field {
-    readonly table: string;
-    readonly field: string;
+interface Condition<T> {
+    readonly is?: T | T[];
+    readonly isNot?: T | T[];
+    readonly gt?: T;
+    readonly gte?: T;
+    readonly lt?: T;
+    readonly lte?: T;
+    readonly in?: T[];
+    readonly notIn?: T[];
+    readonly like?: T | T[];
 }
-interface Condition<Document extends Record<string, unknown>, K extends keyof Document = keyof Document> {
-    readonly is?: Document[K] | Array<Document[K]>;
-    readonly isNot?: Document[K] | Array<Document[K]>;
-    readonly gt?: Document[K] | Array<Document[K]>;
-    readonly gte?: Document[K] | Array<Document[K]>;
-    readonly lt?: Document[K] | Array<Document[K]>;
-    readonly lte?: Document[K] | Array<Document[K]>;
-    readonly in?: Document[K] | Array<Document[K]>;
-    readonly notIn?: Document[K] | Array<Document[K]>;
-    readonly like?: Document[K] | Array<Document[K]>;
-}
-/**
- * We extend `keyof Document` by the special literal "KEY".
- * That means users can write `{ KEY: ... }` in addition to `{ someField: ... }`.
- *
- * - If K extends keyof Document, then primitive values must match Document[K].
- * - If K === "KEY", then primitive values are treated as strings/Array<string>.
- */
-export type Where<Document extends Record<string, unknown>> = {
-    [K in keyof Document | 'KEY']?: Condition<Document, K extends keyof Document ? K : keyof Document> | (K extends keyof Document ? Document[K] : string) | (K extends keyof Document ? Array<Document[K]> : string[]);
+export type Where<T extends Record<string, unknown>> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? Where<T[K]> : Condition<T[K]> | T[K] | T[K][];
 } | {
-    readonly AND?: Array<Where<Document>>;
-    readonly OR?: Array<Where<Document>>;
-    readonly NOT?: Where<Document>;
+    readonly AND?: Array<Where<T>>;
+    readonly OR?: Array<Where<T>>;
+    readonly NOT?: Where<T>;
 };
-export declare function getWhere<Document extends Record<string, unknown>>(where: Where<Document>, tableAlias?: string): string;
-export declare function getWhereQuery<Document extends Record<string, unknown>>(where: Where<Document>): string;
+export declare function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string): string;
+export declare function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>): string;
 export {};