muya 2.3.3 → 2.4.0

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

@@ -1 +1 @@
-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()})});
+import{bunMemoryBackend as l}from"../table/bun-backend";import{createTable as c}from"../table/table";describe("table",()=>{let i=l(),t,r;beforeEach(async()=>{i=l(),t=await c({backend:i,tableName:"TestTable",key:"name"}),r=await c({backend:i,tableName:"TestTableNested",key:"info.name",indexes:["info.age","info.city"]})}),it("should set and get items",async()=>{const e=await t.set({name:"Alice",age:30,city:"Paris"});expect(e.key).toBe("Alice"),expect(e.op).toBe("insert");const o=await t.get("Alice");expect(o).toEqual({name:"Alice",age:30,city:"Paris"});const a=await t.set({name:"Alice",age:31,city:"Paris"});expect(a.key).toBe("Alice"),expect(a.op).toBe("update");const n=await t.get("Alice");expect(n).toEqual({name:"Alice",age:31,city:"Paris"})}),it("should set and get nested key",async()=>{const e=await r.set({info:{name:"Bob",age:25,city:"London"}});expect(e.key).toBe("Bob"),expect(e.op).toBe("insert");const o=await r.get("Bob");expect(o).toEqual({info:{name:"Bob",age:25,city:"London"}});const a=await r.set({info:{name:"Bob",age:26,city:"London"}});expect(a.key).toBe("Bob"),expect(a.op).toBe("update");const n=await r.get("Bob");expect(n).toEqual({info:{name:"Bob",age:26,city:"London"}});const s=[];for await(const d of r.search({where:{info:{city:{like:"London"}}}}))s.push(d);expect(s.length).toBe(1)}),it("should count items and count with where",async()=>{await t.set({name:"Alice",age:30,city:"Paris"}),await t.set({name:"Bob",age:25,city:"London"}),expect(await t.count()).toBe(2),expect(await t.count({where:{city:"Paris"}})).toBe(1)}),it("should search with ordering, limit and offset",async()=>{const e=[{name:"Alice",age:30,city:"Paris"},{name:"Bob",age:25,city:"London"},{name:"Carol",age:35,city:"Berlin"}];for(const s of e)await t.set(s);const o=[];for await(const s of t.search({sortBy:"age",order:"asc"}))o.push(s);expect(o.map(s=>s.name)).toEqual(["Bob","Alice","Carol"]);const a=[];for await(const s of t.search({sortBy:"age",order:"asc",limit:2}))a.push(s);expect(a.map(s=>s.name)).toEqual(["Bob","Alice"]);const n=[];for await(const s of t.search({sortBy:"age",order:"asc",offset:1,limit:2}))n.push(s);expect(n.map(s=>s.name)).toEqual(["Alice","Carol"])}),it("should deleteBy where clause",async()=>{await t.set({name:"Dave",age:40,city:"NY"}),await t.set({name:"Eve",age:45,city:"NY"}),await t.set({name:"Frank",age:50,city:"LA"}),expect(await t.count()).toBe(3),await t.deleteBy({city:"NY"}),expect(await t.count()).toBe(1),expect(await t.get("Frank")).toEqual({name:"Frank",age:50,city:"LA"}),expect(await t.get("Dave")).toBeUndefined()}),it("should use selector in get and search",async()=>{await t.set({name:"Gary",age:60,city:"SF"});const e=await t.get("Gary",({age:a})=>a);expect(e).toBe(60);const o=[];for await(const a of t.search({select:({city:n})=>n}))o.push(a);expect(o).toEqual(["SF"])}),it("should delete items by key",async()=>{await t.set({name:"Helen",age:28,city:"Rome"}),expect(await t.get("Helen")).toBeDefined(),await t.delete("Helen"),expect(await t.get("Helen")).toBeUndefined()}),it("should test search with 1000 items",async()=>{const e=[];for(let a=0;a<1e3;a++)e.push({name:`Person${a}`,age:Math.floor(Math.random()*100),city:"City"+a%10});for(const a of e)await t.set(a);const o=[];for await(const a of t.search({sortBy:"age",order:"asc",limit:100}))o.push(a);expect(o.length).toBe(100)}),it("should handle operations on an empty table",async()=>{expect(await t.count()).toBe(0),expect(await t.get("NonExistent")).toBeUndefined();const e=[];for await(const o of t.search({sortBy:"age",order:"asc"}))e.push(o);expect(e.length).toBe(0)}),it("should handle duplicate keys gracefully",async()=>{await t.set({name:"Alice",age:30,city:"Paris"}),await t.set({name:"Alice",age:35,city:"Berlin"});const e=await t.get("Alice");expect(e).toEqual({name:"Alice",age:35,city:"Berlin"})}),it("should handle edge cases in selectors",async()=>{await t.set({name:"Charlie",age:40,city:"NY"});const e=await t.get("Charlie",()=>null);expect(e).toBeNull();const o=await t.get("Charlie",()=>{});expect(o).toBeUndefined()}),it("should clear the table",async()=>{await t.set({name:"Alice",age:30,city:"Paris"}),await t.set({name:"Bob",age:25,city:"London"}),expect(await t.count()).toBe(2),await t.clear(),expect(await t.count()).toBe(0)}),it("should use fts index",async()=>{const e=await c({backend:i,tableName:"TestTableFTS",key:"id",indexes:["fts:content"]});await e.set({id:"1",content:"The \u010Coho brown fox"}),await e.set({id:"2",content:"jumps over the lazy dog"}),await e.set({id:"3",content:"hello world"});const o=[];for await(const n of e.search({where:{content:{fts:["coho","fox"]}}}))o.push(n);expect(o.length).toBe(1),expect(o[0].id).toBe("1");const a=[];for await(const n of e.search({where:{content:{fts:["the"]}}}))a.push(n);expect(a.length).toBe(2)}),it("should use fts index with custom tokenizer options",async()=>{const e=await c({backend:i,tableName:"TestTableFTS2",key:"id",indexes:[{type:"fts",path:"content",tokenizer:{removeDiacritics:0,tokenChars:"abc",separators:"xyz"}}]});await e.set({id:"1",content:"abc xyz"}),await e.set({id:"2",content:"abc"}),await e.set({id:"3",content:"other"});const o=[];for await(const n of e.search({where:{content:{fts:["abc"]}}}))o.push(n);expect(o.length).toBe(2);const a=[];for await(const n of e.search({where:{content:{fts:["xyz"]}}}))a.push(n);expect(a.length).toBe(1),expect(a[0].id).toBe("1")}),it("should support multiple fts fields",async()=>{const e=await c({backend:i,tableName:"TestTableFTSMulti",key:"id",indexes:[{type:"fts",path:"title"},{type:"fts",path:"body"}]});await e.set({id:"1",title:"Hello",body:"World"}),await e.set({id:"2",title:"Foo",body:"Bar"}),await e.set({id:"3",title:"Hello",body:"Bar"});const o=[];for await(const n of e.search({where:{title:{fts:["Hello"]}}}))o.push(n);expect(o.length).toBe(2);const a=[];for await(const n of e.search({where:{body:{fts:["Bar"]}}}))a.push(n);expect(a.length).toBe(2)}),it("should handle fts search with no results",async()=>{const e=await c({backend:i,tableName:"TestTableFTSNone",key:"id",indexes:["fts:content"]});await e.set({id:"1",content:"foo bar"});const o=[];for await(const a of e.search({where:{content:{fts:["notfound"]}}}))o.push(a);expect(o.length).toBe(0)}),it("should  custom fn fts index",async()=>{const e=await c({backend:i,tableName:"TestTableFTS",key:"id",indexes:[{type:"fts",path:"content",tokenizer:{removeDiacritics:1}}]});await e.set({id:"1",content:"The \u010Coho brown fox"}),await e.set({id:"2",content:"jumps over the lazy dog"}),await e.set({id:"3",content:"hello world"});const o=[];for await(const n of e.search({where:{content:{fts:["coho","fox"]}}}))o.push(n);expect(o.length).toBe(1),expect(o[0].id).toBe("1");const a=[];for await(const n of e.search({where:{content:{fts:["the"]}}}))a.push(n);expect(a.length).toBe(2)}),it("should test fts index with nested fields",async()=>{const e=await c({backend:i,tableName:"TestTableFTSNested",key:"id",indexes:["fts:info.content"]});await e.set({id:"1",info:{content:"The quick brown fox"}}),await e.set({id:"2",info:{content:"jumps over the lazy dog"}}),await e.set({id:"3",info:{content:"hello world"}});const o=[];for await(const n of e.search({where:{info:{content:{fts:["quick","fox"]}}}}))o.push(n);expect(o.length).toBe(1),expect(o[0].id).toBe("1");const a=[];for await(const n of e.search({where:{info:{content:{fts:["the"]}}}}))a.push(n);expect(a.length).toBe(2)})});

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

@@ -0,0 +1 @@
+import{unicodeTokenizer as t}from"../table/tokenizer";describe("tokenizer",()=>{const o=[{options:{},expected:'"unicode61"'},{options:{removeDiacritics:1},expected:'"unicode61", "remove_diacritics=1"'},{options:{tokenChars:"abc"},expected:`"unicode61", "tokenchars='abc'"`},{options:{separators:"xyz"},expected:`"unicode61", "separators='xyz'"`},{options:{removeDiacritics:2,tokenChars:"a-b",separators:"x,y"},expected:`"unicode61", "remove_diacritics=2", "tokenchars='a-b'", "separators='x,y'"`},{options:{tokenChars:"a'b",separators:"c'd"},expected:`"unicode61", "tokenchars='a''b'", "separators='c''d'"`},{options:{removeDiacritics:0,tokenChars:"",separators:""},expected:'"unicode61", "remove_diacritics=0"'},{options:{removeDiacritics:1,tokenChars:"abc",separators:"xyz"},expected:`"unicode61", "remove_diacritics=1", "tokenchars='abc'", "separators='xyz'"`}];for(const e of o)it(`returns expected tokenizer string for options: ${JSON.stringify(e.options)}`,()=>{expect(t(e.options)).toBe(e.expected)})});

package/esm/sqlite/table/index.js

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

package/esm/sqlite/table/table.js

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

package/esm/sqlite/table/tokenizer.js

@@ -0,0 +1 @@
+function o(i={}){const{removeDiacritics:t,tokenChars:r,separators:n}=i,e=[];return t!==void 0&&e.push(`"remove_diacritics=${t}"`),r&&r.length>0&&e.push(`"tokenchars='${r.replaceAll("'","''")}'"`),n&&n.length>0&&e.push(`"separators='${n.replaceAll("'","''")}'"`),e.length===0||!(e.length>0)?'"unicode61"':`"unicode61", ${e.join(", ")}`}export{o as unicodeTokenizer};

package/esm/sqlite/table/where.js

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

package/package.json

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

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

@@ -1,9 +1,6 @@
 /* eslint-disable @typescript-eslint/no-shadow */
 /* eslint-disable no-shadow */
 /* eslint-disable sonarjs/pseudo-random */
-// /* eslint-disable sonarjs/no-unused-vars */
-// /* eslint-disable unicorn/prevent-abbreviations */
-
 import { bunMemoryBackend } from '../table/bun-backend'
 import { createTable } from '../table/table'
 
@@ -178,4 +175,177 @@ describe('table', () => {
     const undefinedSelector = await table.get('Charlie', () => void 0)
     expect(undefinedSelector).toBeUndefined()
   })
+
+  it('should clear the table', async () => {
+    await table.set({ name: 'Alice', age: 30, city: 'Paris' })
+    await table.set({ name: 'Bob', age: 25, city: 'London' })
+    expect(await table.count()).toBe(2)
+    await table.clear()
+    expect(await table.count()).toBe(0)
+  })
+  it('should use fts index', async () => {
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFTS',
+      key: 'id',
+      indexes: ['fts:content'],
+    })
+    await tableFts.set({ id: '1', content: 'The Čoho brown fox' })
+    await tableFts.set({ id: '2', content: 'jumps over the lazy dog' })
+    await tableFts.set({ id: '3', content: 'hello world' })
+
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['coho', 'fox'] } } })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+
+    const results2: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['the'] } } })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+  })
+
+  it('should use fts index with custom tokenizer options', async () => {
+    // Use only ASCII letters for tokenchars/separators to avoid SQLite errors
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFTS2',
+      key: 'id',
+      indexes: [
+        {
+          type: 'fts',
+          path: 'content',
+          tokenizer: { removeDiacritics: 0, tokenChars: 'abc', separators: 'xyz' },
+        },
+      ],
+    })
+    await tableFts.set({ id: '1', content: 'abc xyz' })
+    await tableFts.set({ id: '2', content: 'abc' })
+    await tableFts.set({ id: '3', content: 'other' })
+
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['abc'] } } })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+
+    const results2: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['xyz'] } } })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(1)
+    expect(results2[0].id).toBe('1')
+  })
+
+  it('should support multiple fts fields', async () => {
+    // Use a single FTS index with multiple fields (title, body) in one index
+    const tableFts = await createTable<{ id: string; title: string; body: string }>({
+      backend,
+      tableName: 'TestTableFTSMulti',
+      key: 'id',
+      indexes: [
+        { type: 'fts', path: 'title' },
+        { type: 'fts', path: 'body' },
+      ],
+    })
+    await tableFts.set({ id: '1', title: 'Hello', body: 'World' })
+    await tableFts.set({ id: '2', title: 'Foo', body: 'Bar' })
+    await tableFts.set({ id: '3', title: 'Hello', body: 'Bar' })
+
+    // FTS search on title
+    const results: { id: string; title: string; body: string }[] = []
+    for await (const doc of tableFts.search({ where: { title: { fts: ['Hello'] } } })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+
+    // FTS search on body
+    const results2: { id: string; title: string; body: string }[] = []
+    for await (const doc of tableFts.search({ where: { body: { fts: ['Bar'] } } })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+  })
+
+  it('should handle fts search with no results', async () => {
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFTSNone',
+      key: 'id',
+      indexes: ['fts:content'],
+    })
+    await tableFts.set({ id: '1', content: 'foo bar' })
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['notfound'] } } })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(0)
+  })
+
+  it('should  custom fn fts index', async () => {
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFTS',
+      key: 'id',
+      indexes: [
+        {
+          type: 'fts',
+          path: 'content',
+          tokenizer: {
+            removeDiacritics: 1,
+          },
+        },
+      ],
+    })
+    await tableFts.set({ id: '1', content: 'The Čoho brown fox' })
+    await tableFts.set({ id: '2', content: 'jumps over the lazy dog' })
+    await tableFts.set({ id: '3', content: 'hello world' })
+
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['coho', 'fox'] } } })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+
+    const results2: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({ where: { content: { fts: ['the'] } } })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+  })
+
+  it('should test fts index with nested fields', async () => {
+    const tableFts = await createTable<{ id: string; info: { content: string } }>({
+      backend,
+      tableName: 'TestTableFTSNested',
+      key: 'id',
+      indexes: ['fts:info.content'],
+    })
+    await tableFts.set({ id: '1', info: { content: 'The quick brown fox' } })
+    await tableFts.set({ id: '2', info: { content: 'jumps over the lazy dog' } })
+    await tableFts.set({ id: '3', info: { content: 'hello world' } })
+
+    const results: { id: string; info: { content: string } }[] = []
+    for await (const doc of tableFts.search({
+      where: {
+        info: {
+          content: { fts: ['quick', 'fox'] },
+        },
+      },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+
+    const results2: { id: string; info: { content: string } }[] = []
+    for await (const doc of tableFts.search({ where: { info: { content: { fts: ['the'] } } } })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+  })
 })

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

@@ -0,0 +1,43 @@
+import { unicodeTokenizer, type FtsTokenizerOptions } from '../table/tokenizer'
+
+describe('tokenizer', () => {
+  const items: {
+    options: FtsTokenizerOptions
+    expected: string
+  }[] = [
+    { options: {}, expected: '"unicode61"' },
+    {
+      options: { removeDiacritics: 1 },
+      expected: '"unicode61", "remove_diacritics=1"',
+    },
+    {
+      options: { tokenChars: 'abc' },
+      expected: '"unicode61", "tokenchars=\'abc\'"',
+    },
+    {
+      options: { separators: 'xyz' },
+      expected: '"unicode61", "separators=\'xyz\'"',
+    },
+    {
+      options: { removeDiacritics: 2, tokenChars: 'a-b', separators: 'x,y' },
+      expected: '"unicode61", "remove_diacritics=2", "tokenchars=\'a-b\'", "separators=\'x,y\'"',
+    },
+    {
+      options: { tokenChars: "a'b", separators: "c'd" },
+      expected: "\"unicode61\", \"tokenchars='a''b'\", \"separators='c''d'\"",
+    },
+    {
+      options: { removeDiacritics: 0, tokenChars: '', separators: '' },
+      expected: '"unicode61", "remove_diacritics=0"',
+    },
+    {
+      options: { removeDiacritics: 1, tokenChars: 'abc', separators: 'xyz' },
+      expected: '"unicode61", "remove_diacritics=1", "tokenchars=\'abc\'", "separators=\'xyz\'"',
+    },
+  ]
+  for (const item of items) {
+    it(`returns expected tokenizer string for options: ${JSON.stringify(item.options)}`, () => {
+      expect(unicodeTokenizer(item.options)).toBe(item.expected)
+    })
+  }
+})

package/src/sqlite/table/index.ts

@@ -3,3 +3,4 @@ export * from './table.types'
 export * from './where'
 export * from './table'
 export * from './map-deque'
+export * from './tokenizer'

package/src/sqlite/table/table.ts

@@ -3,18 +3,18 @@
 /* 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 { unicodeTokenizer, type FtsTokenizerOptions } from './tokenizer'
 import type { Where } from './where'
 import { getWhereQuery } from './where'
 
-const DELETE_IN_CHUNK = 500 // keep well below SQLite's default 999 parameter limit
+const DELETE_IN_CHUNK = 500
 export const DEFAULT_STEP_SIZE = 100
 
 /**
  * Convert a dot-separated path to a JSON path
- * @param dot The dot-separated path
- * @returns The JSON path
+ * @param dot The dot-separated path string
+ * @returns The JSON path string
  */
 export function toJsonPath(dot: string) {
   return '$.' + dot
@@ -22,8 +22,8 @@ export function toJsonPath(dot: string) {
 
 /**
  * Get a nested value from an object using a dot-separated path
- * @param object The object to get the value from
- * @param path The dot-separated path to the value
+ * @param object The object to retrieve the value from
+ * @param path The dot-separated path string
  * @returns The value at the specified path, or undefined if not found
  */
 export function getByPath<T extends object>(object: T, path: string): unknown {
@@ -38,15 +38,14 @@ export function getByPath<T extends object>(object: T, path: string): unknown {
 }
 
 /**
- * Create a new table in the database with the given options
- * @param options The options for creating the table
- * @returns The created table
+ * Create and initialize a table in the database with the specified options
+ * @param options The options for creating the table, including table name, indexes, backend, and key
+ * @returns A promise that resolves to the created Table instance
  */
 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 ---
   if (!disablePragmaOptimization) {
     await backend.execute(`PRAGMA journal_mode=WAL;`)
     await backend.execute(`PRAGMA synchronous=NORMAL;`)
@@ -54,7 +53,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     await backend.execute(`PRAGMA cache_size=-20000;`)
   }
 
-  // Schema
+  // Base JSON table
   if (hasUserKey) {
     await backend.execute(`
       CREATE TABLE IF NOT EXISTS ${tableName} (
@@ -70,19 +69,95 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     `)
   }
 
-  // JSON expression indexes
+  // Track FTS fields and map dot paths to valid SQLite column names
+  let ftsTokenizer: string | undefined | FtsTokenizerOptions
+  const ftsFields: string[] = []
+  const ftsFieldMap: Record<string, string> = {} // dot path -> column name
+
   for (const index of indexes ?? []) {
-    const idx = String(index)
-    await backend.execute(
-      `CREATE INDEX IF NOT EXISTS idx_${tableName}_${idx.replaceAll(/\W/g, '_')}
+    if (typeof index === 'string' && index.startsWith('fts:')) {
+      const path = index.slice(4)
+      const col = path.replaceAll('.', '_')
+      ftsFields.push(path)
+      ftsFieldMap[path] = col
+    } else if (typeof index === 'object' && index.type === 'fts') {
+      const path = index.path
+      const col = path.replaceAll('.', '_')
+      ftsFields.push(path)
+      ftsFieldMap[path] = col
+      if (index.tokenizer) {
+        if (!ftsTokenizer) {
+          ftsTokenizer = index.tokenizer
+        } else if (ftsTokenizer !== index.tokenizer) {
+          throw new Error(`Conflicting FTS tokenizers: already using "${ftsTokenizer}", got "${index.tokenizer}"`)
+        }
+      }
+    } else {
+      const idx = String(index)
+      await backend.execute(
+        `CREATE INDEX IF NOT EXISTS idx_${tableName}_${idx.replaceAll(/\W/g, '_')}
        ON ${tableName} (json_extract(data, '${toJsonPath(idx)}'));`,
-    )
+      )
+    }
+  }
+
+  // Create FTS table + triggers
+  if (ftsFields.length > 0) {
+    let tokenizerSpec: string
+    if (typeof ftsTokenizer === 'object') {
+      tokenizerSpec = unicodeTokenizer(ftsTokenizer)
+    } else if (ftsTokenizer === undefined) {
+      tokenizerSpec = '"unicode61", "remove_diacritics=1"'
+    } else {
+      tokenizerSpec = ftsTokenizer
+    }
+    // Use mapped column names for FTS columns
+    const ftsColumns = ftsFields.map((f) => ftsFieldMap[f]).join(', ')
+    const query = `
+        CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName}_fts
+        USING fts5(${ftsColumns}, tokenize=${tokenizerSpec});
+`
+
+    await backend.execute(query)
+
+    // Insert trigger
+    await backend.execute(`
+      CREATE TRIGGER IF NOT EXISTS ${tableName}_ai
+      AFTER INSERT ON ${tableName}
+      BEGIN
+        INSERT INTO ${tableName}_fts(rowid, ${ftsColumns})
+        VALUES (
+          new.rowid,
+          ${ftsFields.map((f) => `json_extract(new.data, '${toJsonPath(f)}')`).join(', ')}
+        );
+      END;
+    `)
+
+    // Delete trigger
+    await backend.execute(`
+      CREATE TRIGGER IF NOT EXISTS ${tableName}_ad
+      AFTER DELETE ON ${tableName}
+      BEGIN
+        DELETE FROM ${tableName}_fts WHERE rowid = old.rowid;
+      END;
+    `)
+
+    // Update trigger
+    await backend.execute(`
+      CREATE TRIGGER IF NOT EXISTS ${tableName}_au
+      AFTER UPDATE ON ${tableName}
+      BEGIN
+        UPDATE ${tableName}_fts
+        SET ${ftsFields.map((f) => `${ftsFieldMap[f]}=json_extract(new.data, '${toJsonPath(f)}')`).join(', ')}
+        WHERE rowid = old.rowid;
+      END;
+    `)
   }
 
   /**
-   * Get the key value from a document
+   * Get the value of the configured key from a document
    * @param document The document to extract the key from
-   * @returns The key value or undefined if no user key is configured
+   * @returns The value of the key, or undefined if not found or no key is configured
    */
   function getKeyFromDocument(document: Document): Key | undefined {
     if (!hasUserKey) return undefined
@@ -90,9 +165,9 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
   }
 
   /**
-   * Get the number of rows changed by the last operation
-   * @param conn The database connection
-   * @returns The number of rows changed
+   * Get the number of rows changed by the last operation on the given connection
+   * @param conn The database connection to check for changes
+   * @returns A promise that resolves to the number of changed rows
    */
   async function getChanges(conn: typeof backend): Promise<number> {
     const r = await conn.select<Array<{ c: number }>>(`SELECT changes() AS c`)
@@ -109,17 +184,13 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
       if (hasUserKey) {
         const id = getKeyFromDocument(document)
         if (id === undefined || id === null) {
-          throw new Error(
-            `Document is missing the configured key "${String(key)}". Provide it or create the table without "key".`,
-          )
+          throw new Error(`Document is missing the configured key "${String(key)}".`)
         }
 
-        // Fast path: UPDATE first
         await db.execute(`UPDATE ${tableName} SET data = ? WHERE key = ?`, [json, id])
         const updated = await getChanges(db)
         if (updated === 1) return { key: id, op: 'update' }
 
-        // No row updated => try INSERT
         try {
           await db.execute(`INSERT INTO ${tableName} (key, data) VALUES (?, ?)`, [id, json])
           return { key: id, op: 'insert' }
@@ -129,7 +200,6 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         }
       }
 
-      // ROWID mode
       await db.execute(`INSERT INTO ${tableName} (data) VALUES (?)`, [json])
       const rows = await db.select<Array<{ id: number }>>(`SELECT last_insert_rowid() AS id`)
       const rowid = rows[0]?.id
@@ -139,7 +209,6 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
 
     async get<Selected = Document>(
       keyValue: Key,
-      // 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 = ?`
@@ -172,7 +241,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         stepSize = DEFAULT_STEP_SIZE,
       } = options
 
-      const whereSql = getWhereQuery<Document>(where)
+      const whereSql = getWhereQuery<Document>(where, tableName)
       const baseQuery = `SELECT rowid, data FROM ${tableName} ${whereSql}`
 
       let yielded = 0
@@ -205,14 +274,14 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     },
 
     async count(options: { where?: Where<Document> } = {}) {
-      const whereSql = getWhereQuery<Document>(options.where)
+      const whereSql = getWhereQuery<Document>(options.where, tableName)
       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 whereSql = getWhereQuery<Document>(where)
+      const whereSql = getWhereQuery<Document>(where, tableName)
       const keyCol = hasUserKey ? 'key' : 'rowid'
       const results: MutationResult[] = []
 
@@ -236,6 +305,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
     async clear() {
       await backend.execute(`DELETE FROM ${tableName}`)
     },
+
     async batchSet(documents: Document[]) {
       const mutations: MutationResult[] = []
       await backend.transaction(async (tx) => {

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

@@ -1,6 +1,6 @@
-// table.types.ts
 import type { SqlSeachOptions } from '../select-sql'
 import type { Backend } from './backend'
+import type { FtsTokenizerOptions } from './tokenizer'
 import type { Where } from './where'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -19,10 +19,28 @@ export type DotPath<T, D extends number = 5> = [D] extends [never]
         [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>
+
+// Built-in FTS5 tokenizers
+export type FtsTokenizer =
+  | 'porter' // English stemming
+  | 'simple' // basic ASCII tokenizer
+  | 'icu' // requires SQLite compiled with ICU extension
+  | 'unicode61' // Unicode-aware tokenizer with diacritic removal and custom token chars
+  | FtsTokenizerOptions
+
+export interface FtsType<Document extends DocType> {
+  readonly type: 'fts'
+  readonly path: DotPath<Document>
+  readonly tokenizer?: FtsTokenizer
+}
+export type IndexDeclaration<Document extends DocType> =
+  | DotPath<Document> // normal JSON path index
+  | `fts:${DotPath<Document>}` // full-text index
+  | FtsType<Document> // full-text index with options
+
 export interface DbOptions<Document extends DocType> {
   readonly tableName: string
-  readonly indexes?: Array<DotPath<Document>>
+  readonly indexes?: Array<IndexDeclaration<Document>>
   readonly backend: Backend
   readonly key?: DotPath<Document>
   readonly disablePragmaOptimization?: boolean

package/src/sqlite/table/tokenizer.ts

@@ -0,0 +1,35 @@
+export interface FtsTokenizerOptions {
+  readonly removeDiacritics?: 0 | 1 | 2
+  readonly tokenChars?: string
+  readonly separators?: string
+}
+
+/**
+ * Create a custom FTS5 tokenizer string based on the provided options
+ * @param options Options to customize the tokenizer
+ * @returns A string representing the FTS5 tokenizer configuration
+ */
+export function unicodeTokenizer(options: FtsTokenizerOptions = {}): string {
+  const { removeDiacritics, tokenChars, separators } = options
+  const parts: string[] = []
+
+  if (removeDiacritics !== undefined) {
+    parts.push(`"remove_diacritics=${removeDiacritics}"`)
+  }
+  if (tokenChars && tokenChars.length > 0) {
+    parts.push(`"tokenchars='${tokenChars.replaceAll("'", "''")}'"`)
+  }
+  if (separators && separators.length > 0) {
+    parts.push(`"separators='${separators.replaceAll("'", "''")}'"`)
+  }
+
+  // 👉 return correct SQLite syntax
+  if (parts.length === 0) {
+    return '"unicode61"'
+  }
+  const hasParts = parts.length > 0
+  if (!hasParts) {
+    return '"unicode61"'
+  }
+  return `"unicode61", ${parts.join(', ')}`
+}

package/src/sqlite/table/where.ts

@@ -17,6 +17,7 @@ interface Condition<T> {
   readonly in?: T[]
   readonly notIn?: T[]
   readonly like?: T | T[]
+  readonly fts?: string | string[] // 🔥 NEW
 }
 
 // -------------------------------------------------------------
@@ -55,16 +56,13 @@ function inlineValue(value: unknown): string {
  */
 function getFieldExpr(field: string, value: unknown, tableAlias?: string): string {
   const prefix = tableAlias ? `${tableAlias}.` : ''
-  if (field === 'KEY') {
-    return `"${prefix}key"`
-  }
+  if (field === 'KEY') return `"${prefix}key"`
   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'])
+const OPS_SET: ReadonlySet<string> = new Set(['is', 'isNot', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'like', 'fts'])
 
 /**
  * Flatten a nested Where object into a single-level object with dot-separated keys
@@ -97,28 +95,27 @@ function flattenWhere(object: Record<string, unknown>, prefix = ''): Record<stri
  * Write SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions
  * @param tableAlias Optional table alias to prefix field names
+ * @param tableName Optional table name (required for FTS conditions)
  * @returns The SQL WHERE clause string (without the "WHERE" keyword)
  */
-export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string): string {
+export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string, tableName?: string): string {
   if (!where || typeof where !== 'object') return ''
 
-  // ----- Logical branches -----
   if (where.AND) {
-    const clauses = Array.isArray(where.AND) ? where.AND.map((w) => getWhere(w, tableAlias)).filter(Boolean) : []
+    const clauses = Array.isArray(where.AND) ? where.AND.map((w) => getWhere(w, tableAlias, tableName)).filter(Boolean) : []
     return clauses.length > 0 ? `(${clauses.join(' AND ')})` : ''
   }
 
   if (where.OR) {
-    const clauses = Array.isArray(where.OR) ? where.OR.map((w) => getWhere(w, tableAlias)).filter(Boolean) : []
+    const clauses = Array.isArray(where.OR) ? where.OR.map((w) => getWhere(w, tableAlias, tableName)).filter(Boolean) : []
     return clauses.length > 0 ? `(${clauses.join(' OR ')})` : ''
   }
 
   if (where.NOT) {
-    const clause = getWhere(where.NOT, tableAlias)
+    const clause = getWhere(where.NOT, tableAlias, tableName)
     return clause ? `(NOT ${clause})` : ''
   }
 
-  // ----- Field conditions -----
   const flat = flattenWhere(where as Record<string, unknown>)
   let fieldClauses = ''
   let anyField = false
@@ -126,7 +123,6 @@ export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tab
   for (const [key, rawValue] of Object.entries(flat)) {
     if (rawValue == null) continue
 
-    // coerce primitive/array into Condition
     let cond: Condition<unknown>
     if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
       cond = Array.isArray(rawValue) ? { in: rawValue } : { is: rawValue }
@@ -135,18 +131,28 @@ export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tab
     }
 
     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
 
       const values = Array.isArray(opValue) ? opValue : [opValue]
       if (values.length === 0) continue
 
-      // is / isNot / in / notIn
+      if (opKey === 'fts') {
+        if (!tableName) throw new Error('FTS requires tableName for JOIN reference')
+        const clause = values
+          .map(
+            (v) =>
+              `EXISTS (SELECT 1 FROM ${tableName}_fts f WHERE f.rowid = ${tableAlias ?? tableName}.rowid AND ${tableName}_fts MATCH ${inlineValue(v)})`,
+          )
+          .join(' AND ')
+        fieldClauses += (anyField ? ' AND ' : '') + clause
+        anyField = true
+        continue
+      }
+
       if (opKey === 'is' || opKey === 'isNot' || opKey === 'in' || opKey === 'notIn') {
         const fieldExpr = getFieldExpr(key, values[0], tableAlias)
         const inList = values.map(inlineValue).join(',')
-
         const clause =
           opKey === 'is'
             ? values.length > 1
@@ -159,13 +165,11 @@ export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tab
               : opKey === 'in'
                 ? `${fieldExpr} IN (${inList})`
                 : `${fieldExpr} NOT IN (${inList})`
-
         fieldClauses += (anyField ? ' AND ' : '') + clause
         anyField = true
         continue
       }
 
-      // gt / gte / lt / lte / like
       for (const v of values) {
         const fieldExpr = getFieldExpr(key, v, tableAlias)
         const clause =
@@ -190,10 +194,11 @@ export function getWhere<T extends Record<string, unknown>>(where: Where<T>, tab
 /**
  * Get SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions
+ * @param tableName Optional table name (required for FTS conditions)
  * @returns The SQL WHERE clause string (without the "WHERE" keyword)
  */
-export function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>): string {
+export function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>, tableName?: string): string {
   if (!where) return ''
-  const clause = getWhere(where)
+  const clause = getWhere(where, undefined, tableName)
   return clause ? `WHERE ${clause}` : ''
 }

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

@@ -3,3 +3,4 @@ export * from './table.types';
 export * from './where';
 export * from './table';
 export * from './map-deque';
+export * from './tokenizer';

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

@@ -2,20 +2,20 @@ import type { Table, DbOptions, DocType } from './table.types';
 export declare const DEFAULT_STEP_SIZE = 100;
 /**
  * Convert a dot-separated path to a JSON path
- * @param dot The dot-separated path
- * @returns The JSON path
+ * @param dot The dot-separated path string
+ * @returns The JSON path string
  */
 export declare function toJsonPath(dot: string): string;
 /**
  * Get a nested value from an object using a dot-separated path
- * @param object The object to get the value from
- * @param path The dot-separated path to the value
+ * @param object The object to retrieve the value from
+ * @param path The dot-separated path string
  * @returns The value at the specified path, or undefined if not found
  */
 export declare function getByPath<T extends object>(object: T, path: string): unknown;
 /**
- * Create a new table in the database with the given options
- * @param options The options for creating the table
- * @returns The created table
+ * Create and initialize a table in the database with the specified options
+ * @param options The options for creating the table, including table name, indexes, backend, and key
+ * @returns A promise that resolves to the created Table instance
  */
 export declare function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>>;

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

@@ -1,5 +1,6 @@
 import type { SqlSeachOptions } from '../select-sql';
 import type { Backend } from './backend';
+import type { FtsTokenizerOptions } from './tokenizer';
 import type { Where } from './where';
 export type DocType = {
     [key: string]: any;
@@ -10,9 +11,16 @@ 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 type FtsTokenizer = 'porter' | 'simple' | 'icu' | 'unicode61' | FtsTokenizerOptions;
+export interface FtsType<Document extends DocType> {
+    readonly type: 'fts';
+    readonly path: DotPath<Document>;
+    readonly tokenizer?: FtsTokenizer;
+}
+export type IndexDeclaration<Document extends DocType> = DotPath<Document> | `fts:${DotPath<Document>}` | FtsType<Document>;
 export interface DbOptions<Document extends DocType> {
     readonly tableName: string;
-    readonly indexes?: Array<DotPath<Document>>;
+    readonly indexes?: Array<IndexDeclaration<Document>>;
     readonly backend: Backend;
     readonly key?: DotPath<Document>;
     readonly disablePragmaOptimization?: boolean;

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

@@ -0,0 +1,11 @@
+export interface FtsTokenizerOptions {
+    readonly removeDiacritics?: 0 | 1 | 2;
+    readonly tokenChars?: string;
+    readonly separators?: string;
+}
+/**
+ * Create a custom FTS5 tokenizer string based on the provided options
+ * @param options Options to customize the tokenizer
+ * @returns A string representing the FTS5 tokenizer configuration
+ */
+export declare function unicodeTokenizer(options?: FtsTokenizerOptions): string;

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

@@ -8,6 +8,7 @@ interface Condition<T> {
     readonly in?: T[];
     readonly notIn?: T[];
     readonly like?: T | T[];
+    readonly fts?: string | string[];
 }
 export type Where<T extends Record<string, unknown>> = {
     [K in keyof T]?: T[K] extends Record<string, unknown> ? Where<T[K]> : Condition<T[K]> | T[K] | T[K][];
@@ -20,13 +21,15 @@ export type Where<T extends Record<string, unknown>> = {
  * Write SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions
  * @param tableAlias Optional table alias to prefix field names
+ * @param tableName Optional table name (required for FTS conditions)
  * @returns The SQL WHERE clause string (without the "WHERE" keyword)
  */
-export declare function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string): string;
+export declare function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string, tableName?: string): string;
 /**
  * Get SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions
+ * @param tableName Optional table name (required for FTS conditions)
  * @returns The SQL WHERE clause string (without the "WHERE" keyword)
  */
-export declare function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>): string;
+export declare function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>, tableName?: string): string;
 export {};