muya 2.4.93 → 2.4.94

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

@@ -0,0 +1 @@
+import{createTable as n}from"../table";import{bunMemoryBackend as c}from"../table/bun-backend";describe("where clauses",()=>{const a=c();it("should handle where where array of conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNestedOptional",key:"id",indexes:["content"]});await e.set({id:"1",content:"The quick brown fox"}),await e.set({id:"2",content:"The jumps over the lazy dog"}),await e.set({id:"3"});const t=[];for await(const i of e.search({where:{content:{like:["The%"]}}}))t.push(i);expect(t.length).toBe(2),expect(t[0].id).toBe("1")}),it("should create nested index for optional nested fields",async()=>{const e=await n({backend:a,tableName:"TestTableNestedOptional",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"});const t=[];for await(const s of e.search({where:{info:{content:{like:["The%"]}}}}))t.push(s);expect(t.length).toBe(1),expect(t[0].id).toBe("1");const i=[];for await(const s of e.search({where:{OR:[{info:{content:{like:["The%"]}}},{info:{content:{like:["jumps%"]}}}]}}))i.push(s);expect(i.length).toBe(2);const o=[];for await(const s of e.search({where:{info:{content:"nonexistent"}}}))o.push(s);expect(o.length).toBe(0)}),it("should handle FTS queries",async()=>{const e=await n({backend:a,tableName:"TestTableFts",key:"id",indexes:["fts:content"]});await e.set({id:"1",content:"The quick brown fox"}),await e.set({id:"2",content:"Jumps over the lazy dog"}),await e.set({id:"3",content:"Another document"});const t=[];for await(const i of e.search({where:{content:{fts:"quick"}}}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("1")}),it("should handle nested where conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNested",key:"id",indexes:["info.content"]});await e.set({id:"1",info:{content:"Nested quick brown fox"}}),await e.set({id:"2",info:{content:"Nested jumps over the lazy dog"}});const t=[];for await(const i of e.search({where:{info:{content:{like:"Nested%"}}}}))t.push(i);expect(t.length).toBe(2)}),it("should handle complex operators",async()=>{const e=await n({backend:a,tableName:"TestTableComplex",key:"id",indexes:["value"]});await e.set({id:"1",value:10}),await e.set({id:"2",value:20}),await e.set({id:"3",value:30});const t=[];for await(const i of e.search({where:{value:{gt:15,lt:25}},sortBy:"value"}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("2")}),it("should handle NOT conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNot",key:"id",indexes:["value"]});await e.set({id:"1",value:"apple"}),await e.set({id:"2",value:"banana"}),await e.set({id:"3",value:"cherry"});const t=[];for await(const i of e.search({where:{NOT:{value:"banana"}}}))t.push(i);expect(t.length).toBe(2),expect(t.map(i=>i.value)).toEqual(["apple","cherry"])}),it("should handle AND conditions",async()=>{const e=await n({backend:a,tableName:"TestTableAnd",key:"id",indexes:["category","price"]});await e.set({id:"1",category:"fruit",price:10}),await e.set({id:"2",category:"fruit",price:20}),await e.set({id:"3",category:"vegetable",price:15});const t=[];for await(const i of e.search({where:{AND:[{category:"fruit"},{price:{lt:15}}]}}))t.push(i);expect(t.length).toBe(1),expect(t[0].id).toBe("1")}),it("should handle OR conditions",async()=>{const e=await n({backend:a,tableName:"TestTableOr",key:"id",indexes:["type"]});await e.set({id:"1",type:"A"}),await e.set({id:"2",type:"B"}),await e.set({id:"3",type:"C"});const t=[];for await(const i of e.search({where:{OR:[{type:"A"},{type:"C"}]}}))t.push(i);expect(t.length).toBe(2),expect(t.map(i=>i.type)).toEqual(["A","C"])}),it("should handle nested AND/OR/NOT conditions",async()=>{const e=await n({backend:a,tableName:"TestTableNestedLogic",key:"id",indexes:["category","price"]});await e.set({id:"1",category:"fruit",price:10}),await e.set({id:"2",category:"fruit",price:20}),await e.set({id:"3",category:"fruit",price:15});const t={AND:[{category:{is:"fruit"}},{OR:[{price:{lt:15}},{price:{is:15}}]}]},i=[];for await(const s of e.search({}))i.push(s);expect(i.length).toBe(3);const o=[];for await(const s of e.search({where:t}))o.push(s);expect(o.length).toBe(2)})});

package/esm/sqlite/table/where.js

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

package/package.json

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

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

@@ -0,0 +1,234 @@
+import { createTable } from '../table'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { type Where } from '../table/where'
+
+describe('where clauses', () => {
+  const backend = bunMemoryBackend()
+
+  it('should handle where where array of conditions', async () => {
+    const tableNestedOptional = await createTable<{ id: string; content?: string }>({
+      backend,
+      tableName: 'TestTableNestedOptional',
+      key: 'id',
+      indexes: ['content'],
+    })
+
+    await tableNestedOptional.set({ id: '1', content: 'The quick brown fox' })
+    await tableNestedOptional.set({ id: '2', content: 'The jumps over the lazy dog' })
+    await tableNestedOptional.set({ id: '3' }) // No `content` field
+
+    const results: { id: string; content?: string }[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { content: { like: ['The%'] } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results[0].id).toBe('1')
+  })
+  it('should create nested index for optional nested fields', async () => {
+    type TestDoc = { id: string; info?: { content?: string } }
+    const tableNestedOptional = await createTable<TestDoc>({
+      backend,
+      tableName: 'TestTableNestedOptional',
+      key: 'id',
+      indexes: ['fts:info.content'],
+    })
+
+    await tableNestedOptional.set({ id: '1', info: { content: 'The quick brown fox' } })
+    await tableNestedOptional.set({ id: '2', info: { content: 'jumps over the lazy dog' } })
+    await tableNestedOptional.set({ id: '3' }) // No `info` field
+
+    const results: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { info: { content: { like: ['The%'] } } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+
+    const results2: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { OR: [{ info: { content: { like: ['The%'] } } }, { info: { content: { like: ['jumps%'] } } }] },
+    })) {
+      results2.push(doc)
+    }
+    expect(results2.length).toBe(2)
+
+    const results3: TestDoc[] = []
+    for await (const doc of tableNestedOptional.search({
+      where: { info: { content: 'nonexistent' } },
+    })) {
+      results3.push(doc)
+    }
+    expect(results3.length).toBe(0)
+  })
+  it('should handle FTS queries', async () => {
+    const tableFts = await createTable<{ id: string; content: string }>({
+      backend,
+      tableName: 'TestTableFts',
+      key: 'id',
+      indexes: ['fts:content'],
+    })
+
+    await tableFts.set({ id: '1', content: 'The quick brown fox' })
+    await tableFts.set({ id: '2', content: 'Jumps over the lazy dog' })
+    await tableFts.set({ id: '3', content: 'Another document' })
+
+    const results: { id: string; content: string }[] = []
+    for await (const doc of tableFts.search({
+      where: { content: { fts: 'quick' } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+  })
+
+  it('should handle nested where conditions', async () => {
+    const tableNested = await createTable<{ id: string; info: { content: string } }>({
+      backend,
+      tableName: 'TestTableNested',
+      key: 'id',
+      indexes: ['info.content'],
+    })
+
+    await tableNested.set({ id: '1', info: { content: 'Nested quick brown fox' } })
+    await tableNested.set({ id: '2', info: { content: 'Nested jumps over the lazy dog' } })
+
+    const results: { id: string; info: { content: string } }[] = []
+    for await (const doc of tableNested.search({
+      where: { info: { content: { like: 'Nested%' } } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+  })
+
+  it('should handle complex operators', async () => {
+    const tableComplex = await createTable<{ id: string; value: number }>({
+      backend,
+      tableName: 'TestTableComplex',
+      key: 'id',
+      indexes: ['value'],
+    })
+
+    await tableComplex.set({ id: '1', value: 10 })
+    await tableComplex.set({ id: '2', value: 20 })
+    await tableComplex.set({ id: '3', value: 30 })
+
+    const results: { id: string; value: number }[] = []
+    for await (const doc of tableComplex.search({
+      where: { value: { gt: 15, lt: 25 } },
+      sortBy: 'value',
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('2')
+  })
+
+  it('should handle NOT conditions', async () => {
+    const tableNot = await createTable<{ id: string; value: string }>({
+      backend,
+      tableName: 'TestTableNot',
+      key: 'id',
+      indexes: ['value'],
+    })
+
+    await tableNot.set({ id: '1', value: 'apple' })
+    await tableNot.set({ id: '2', value: 'banana' })
+    await tableNot.set({ id: '3', value: 'cherry' })
+
+    const results: { id: string; value: string }[] = []
+    for await (const doc of tableNot.search({
+      where: { NOT: { value: 'banana' } },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results.map((doc) => doc.value)).toEqual(['apple', 'cherry'])
+  })
+
+  it('should handle AND conditions', async () => {
+    const tableAnd = await createTable<{ id: string; category: string; price: number }>({
+      backend,
+      tableName: 'TestTableAnd',
+      key: 'id',
+      indexes: ['category', 'price'],
+    })
+
+    await tableAnd.set({ id: '1', category: 'fruit', price: 10 })
+    await tableAnd.set({ id: '2', category: 'fruit', price: 20 })
+    await tableAnd.set({ id: '3', category: 'vegetable', price: 15 })
+
+    const results: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableAnd.search({
+      where: { AND: [{ category: 'fruit' }, { price: { lt: 15 } }] },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(1)
+    expect(results[0].id).toBe('1')
+  })
+
+  it('should handle OR conditions', async () => {
+    const tableOr = await createTable<{ id: string; type: string }>({
+      backend,
+      tableName: 'TestTableOr',
+      key: 'id',
+      indexes: ['type'],
+    })
+
+    await tableOr.set({ id: '1', type: 'A' })
+    await tableOr.set({ id: '2', type: 'B' })
+    await tableOr.set({ id: '3', type: 'C' })
+
+    const results: { id: string; type: string }[] = []
+    for await (const doc of tableOr.search({
+      where: { OR: [{ type: 'A' }, { type: 'C' }] },
+    })) {
+      results.push(doc)
+    }
+    expect(results.length).toBe(2)
+    expect(results.map((doc) => doc.type)).toEqual(['A', 'C'])
+  })
+
+  it('should handle nested AND/OR/NOT conditions', async () => {
+    const tableNestedLogic = await createTable<{ id: string; category: string; price: number }>({
+      backend,
+      tableName: 'TestTableNestedLogic',
+      key: 'id',
+      indexes: ['category', 'price'],
+    })
+
+    await tableNestedLogic.set({ id: '1', category: 'fruit', price: 10 })
+    await tableNestedLogic.set({ id: '2', category: 'fruit', price: 20 })
+    await tableNestedLogic.set({ id: '3', category: 'fruit', price: 15 })
+
+    const whereClause: Where<{ category: string; price: number }> = {
+      AND: [
+        { category: { is: 'fruit' } },
+        {
+          OR: [{ price: { lt: 15 } }, { price: { is: 15 } }],
+        },
+      ],
+    }
+
+    const allData: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableNestedLogic.search({})) {
+      allData.push(doc)
+    }
+    expect(allData.length).toBe(3)
+
+    const results: { id: string; category: string; price: number }[] = []
+    for await (const doc of tableNestedLogic.search({
+      where: whereClause,
+    })) {
+      results.push(doc)
+    }
+
+    expect(results.length).toBe(2)
+  })
+})

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

@@ -20,14 +20,16 @@ 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]
+type DotPathRaw<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
+        [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPathRaw<T[K], Previous[D]>}` : K
       }[Extract<keyof T, string>]
     : never
 
+export type DotPath<T> = DotPathRaw<MakeAllFieldAsRequired<T>>
+
 // Built-in FTS5 tokenizers
 export type FtsTokenizer =
   | 'porter' // English stemming
@@ -81,3 +83,7 @@ export interface Table<Document extends DocType> extends DbNotGeneric {
   readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
   readonly clear: () => Promise<void>
 }
+
+export type MakeAllFieldAsRequired<T> = {
+  [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K]
+}

package/src/sqlite/table/where.ts

@@ -4,6 +4,8 @@
 /* eslint-disable sonarjs/no-nested-conditional */
 /* eslint-disable sonarjs/cognitive-complexity */
 
+import type { MakeAllFieldAsRequired } from './table.types'
+
 // -------------------------------------------------------------
 // Condition operators for each field
 // -------------------------------------------------------------
@@ -20,21 +22,22 @@ interface Condition<T> {
   readonly fts?: string | string[] // 🔥 NEW
 }
 
-// -------------------------------------------------------------
-// Where type: recursive object with operators or nested fields
-// -------------------------------------------------------------
-export type Where<T extends Record<string, unknown>> =
+type WhereRaw<T extends Record<string, unknown>> =
   | {
       [K in keyof T]?: T[K] extends Record<string, unknown>
-        ? Where<T[K]> // nested object
+        ? WhereRaw<T[K]> // nested object
         : Condition<T[K]> | T[K] | T[K][]
     }
   | {
-      readonly AND?: Array<Where<T>>
-      readonly OR?: Array<Where<T>>
-      readonly NOT?: Where<T>
+      readonly AND?: Array<WhereRaw<T>>
+      readonly OR?: Array<WhereRaw<T>>
+      readonly NOT?: WhereRaw<T>
     }
 
+// -------------------------------------------------------------
+// Where type: recursive object with operators or nested fields
+// -------------------------------------------------------------
+export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>
 /**
  * Inline a value for SQL query, with proper escaping for strings
  * @param value The value to inline

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

@@ -15,9 +15,10 @@ export interface SqlSeachOptions<Document extends DocType> {
 }
 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;
+type DotPathRaw<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPathRaw<T[K], Previous[D]>}` : K;
 }[Extract<keyof T, string>] : never;
+export type DotPath<T> = DotPathRaw<MakeAllFieldAsRequired<T>>;
 export type FtsTokenizer = 'porter' | 'simple' | 'icu' | 'unicode61' | FtsTokenizerOptions;
 export interface FtsType<Document extends DocType> {
     readonly type: 'fts';
@@ -59,4 +60,7 @@ export interface Table<Document extends DocType> extends DbNotGeneric {
     readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
     readonly clear: () => Promise<void>;
 }
+export type MakeAllFieldAsRequired<T> = {
+    [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K];
+};
 export {};

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

@@ -1,3 +1,4 @@
+import type { MakeAllFieldAsRequired } from './table.types';
 interface Condition<T> {
     readonly is?: T | T[];
     readonly isNot?: T | T[];
@@ -10,13 +11,14 @@ interface Condition<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][];
+type WhereRaw<T extends Record<string, unknown>> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? WhereRaw<T[K]> : Condition<T[K]> | T[K] | T[K][];
 } | {
-    readonly AND?: Array<Where<T>>;
-    readonly OR?: Array<Where<T>>;
-    readonly NOT?: Where<T>;
+    readonly AND?: Array<WhereRaw<T>>;
+    readonly OR?: Array<WhereRaw<T>>;
+    readonly NOT?: WhereRaw<T>;
 };
+export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>;
 /**
  * Write SQL WHERE clause from a Where object
  * @param where The Where object defining the conditions