muya 2.5.4 → 2.5.6

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

@@ -1,264 +0,0 @@
-import { createSqliteState } from '../create-sqlite'
-import { bunMemoryBackend } from '../table/bun-backend'
-
-const backend = bunMemoryBackend()
-interface Person {
-  id: string
-  name: string
-  age: number
-}
-
-describe('create-sqlite-state', () => {
-  it('should batchSet and update multiple documents', 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 },
-    ])
-    const all = []
-    for await (const p of sql.search()) all.push(p)
-    expect(all).toHaveLength(2)
-    // update both
-    await sql.batchSet([
-      { id: '1', name: 'Alice2', age: 31 },
-      { id: '2', name: 'Bob2', age: 26 },
-    ])
-    const updated = []
-    for await (const p of sql.search()) updated.push(p)
-    expect(updated).toEqual([
-      { id: '1', name: 'Alice2', age: 31 },
-      { id: '2', name: 'Bob2', age: 26 },
-    ])
-  })
-
-  it('should deleteBy condition', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Alice', age: 30 },
-      { id: '2', name: 'Bob', age: 25 },
-      { id: '3', name: 'Carol', age: 40 },
-    ])
-    const deleted = await sql.deleteBy({ age: { gt: 30 } })
-    expect(deleted.length).toBe(1)
-    const all = []
-    for await (const p of sql.search()) all.push(p)
-    expect(all.map((p) => p.id)).toEqual(['1', '2'])
-  })
-
-  it('should get by key and with selector', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
-    await sql.set({ id: '1', name: 'Alice', age: 30 })
-    const doc = await sql.get('1')
-    expect(doc).toEqual({ id: '1', name: 'Alice', age: 30 })
-    const name = await sql.get('1', (d) => d.name)
-    expect(name).toBe('Alice')
-    const missing = await sql.get('999')
-    expect(missing).toBeUndefined()
-  })
-
-  it('should count documents with and without where', 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 },
-      { id: '3', name: 'Carol', age: 40 },
-    ])
-    expect(await sql.count()).toBe(3)
-    expect(await sql.count({ where: { age: { gt: 30 } } })).toBe(1)
-  })
-
-  it('should support search with options', async () => {
-    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Alice', age: 30 },
-      { id: '2', name: 'Bob', age: 25 },
-      { id: '3', name: 'Carol', age: 40 },
-    ])
-    const results = []
-    for await (const p of sql.search({ where: { age: { lt: 35 } } })) results.push(p)
-    expect(results.map((p) => p.id)).toEqual(['1', '2'])
-  })
-})
-
-interface Product {
-  id: string
-  name: string
-  category: string
-  price: number
-}
-
-describe('groupBy', () => {
-  it('should group by a simple field and count', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy1', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 2 },
-      { id: '3', name: 'Carrot', category: 'vegetable', price: 1 },
-      { id: '4', name: 'Orange', category: 'fruit', price: 3 },
-      { id: '5', name: 'Broccoli', category: 'vegetable', price: 2 },
-    ])
-
-    const grouped = await sql.groupBy('category')
-
-    expect(grouped).toHaveLength(2)
-    const fruitGroup = grouped.find((g) => g.key === 'fruit')
-    const vegetableGroup = grouped.find((g) => g.key === 'vegetable')
-    expect(fruitGroup?.count).toBe(3)
-    expect(vegetableGroup?.count).toBe(2)
-  })
-
-  it('should group by with where clause filter', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy2', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 5 },
-      { id: '3', name: 'Carrot', category: 'vegetable', price: 1 },
-      { id: '4', name: 'Orange', category: 'fruit', price: 3 },
-      { id: '5', name: 'Broccoli', category: 'vegetable', price: 6 },
-    ])
-
-    // Only group items with price > 2
-    const grouped = await sql.groupBy('category', { where: { price: { gt: 2 } } })
-
-    expect(grouped).toHaveLength(2)
-    const fruitGroup = grouped.find((g) => g.key === 'fruit')
-    const vegetableGroup = grouped.find((g) => g.key === 'vegetable')
-    expect(fruitGroup?.count).toBe(2) // Banana (5), Orange (3)
-    expect(vegetableGroup?.count).toBe(1) // Broccoli (6)
-  })
-
-  it('should group by numeric field', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy3', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 2 },
-      { id: '3', name: 'Carrot', category: 'vegetable', price: 1 },
-      { id: '4', name: 'Orange', category: 'fruit', price: 1 },
-    ])
-
-    const grouped = await sql.groupBy('price')
-
-    expect(grouped).toHaveLength(2)
-    const price1 = grouped.find((g) => g.key === 1)
-    const price2 = grouped.find((g) => g.key === 2)
-    expect(price1?.count).toBe(3)
-    expect(price2?.count).toBe(1)
-  })
-
-  it('should return empty array for empty table', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy4', key: 'id' })
-
-    const grouped = await sql.groupBy('category')
-
-    expect(grouped).toEqual([])
-  })
-
-  it('should handle null/undefined values in grouped field', async () => {
-    interface ItemWithOptional {
-      id: string
-      name: string
-      tag?: string
-    }
-    const sql = createSqliteState<ItemWithOptional>({ backend, tableName: 'GroupBy5', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'A', tag: 'red' },
-      { id: '2', name: 'B', tag: 'blue' },
-      { id: '3', name: 'C' }, // no tag
-      { id: '4', name: 'D', tag: 'red' },
-    ])
-
-    const grouped = await sql.groupBy('tag')
-
-    // Should have 3 groups: red, blue, and null/undefined
-    expect(grouped.length).toBeGreaterThanOrEqual(2)
-    const redGroup = grouped.find((g) => g.key === 'red')
-    const blueGroup = grouped.find((g) => g.key === 'blue')
-    expect(redGroup?.count).toBe(2)
-    expect(blueGroup?.count).toBe(1)
-  })
-
-  it('should verify count matches sum of grouped counts', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy6', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 2 },
-      { id: '3', name: 'Carrot', category: 'vegetable', price: 1 },
-      { id: '4', name: 'Orange', category: 'fruit', price: 3 },
-      { id: '5', name: 'Broccoli', category: 'vegetable', price: 2 },
-    ])
-
-    const totalCount = await sql.count()
-    const grouped = await sql.groupBy('category')
-    const sumOfCounts = grouped.reduce((sum, group) => sum + group.count, 0)
-
-    expect(totalCount).toBe(5)
-    expect(sumOfCounts).toBe(totalCount)
-  })
-
-  it('should verify count with where matches grouped count with same where', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy7', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 5 },
-      { id: '3', name: 'Carrot', category: 'vegetable', price: 1 },
-      { id: '4', name: 'Orange', category: 'fruit', price: 3 },
-      { id: '5', name: 'Broccoli', category: 'vegetable', price: 6 },
-    ])
-
-    const whereClause = { price: { gt: 2 } }
-    const filteredCount = await sql.count({ where: whereClause })
-    const grouped = await sql.groupBy('category', { where: whereClause })
-    const sumOfCounts = grouped.reduce((sum, group) => sum + group.count, 0)
-
-    expect(filteredCount).toBe(3) // Banana (5), Orange (3), Broccoli (6)
-    expect(sumOfCounts).toBe(filteredCount)
-  })
-
-  it('should have proper TypeScript inference for key type', async () => {
-    const sql = createSqliteState<Product>({ backend, tableName: 'GroupBy8', key: 'id' })
-    await sql.batchSet([
-      { id: '1', name: 'Apple', category: 'fruit', price: 1 },
-      { id: '2', name: 'Banana', category: 'fruit', price: 2 },
-    ])
-
-    // Group by string field - key should be string
-    const categoryGroups = await sql.groupBy('category')
-    const categoryKey: string = categoryGroups[0].key // TypeScript should infer string
-    expect(typeof categoryKey).toBe('string')
-
-    // Group by number field - key should be number
-    const priceGroups = await sql.groupBy('price')
-    const priceKey: number = priceGroups[0].key // TypeScript should infer number
-    expect(typeof priceKey).toBe('number')
-  })
-
-  it('should infer nested field types correctly', async () => {
-    interface NestedProduct {
-      id: string
-      details: {
-        category: string
-        info: {
-          rating: number
-        }
-      }
-    }
-    const sql = createSqliteState<NestedProduct>({ backend, tableName: 'GroupBy9', key: 'id' })
-    await sql.batchSet([
-      { id: '1', details: { category: 'A', info: { rating: 5 } } },
-      { id: '2', details: { category: 'A', info: { rating: 3 } } },
-      { id: '3', details: { category: 'B', info: { rating: 4 } } },
-    ])
-
-    // Group by nested string field
-    const categoryGroups = await sql.groupBy('details.category')
-    const nestedKey: string = categoryGroups[0].key
-    expect(typeof nestedKey).toBe('string')
-    expect(categoryGroups).toHaveLength(2)
-
-    // Group by deeply nested number field
-    const ratingGroups = await sql.groupBy('details.info.rating')
-    const ratingKey: number = ratingGroups[0].key
-    expect(typeof ratingKey).toBe('number')
-    expect(ratingGroups).toHaveLength(3)
-  })
-})

package/src/sqlite/__tests__/map-deque.test.ts

@@ -1,61 +0,0 @@
-import { MapDeque } from '../table/map-deque'
-
-describe('MapDeque', () => {
-  it('should throw if maxSize <= 0', () => {
-    expect(() => new MapDeque(0)).toThrow(RangeError)
-    expect(() => new MapDeque(-1)).toThrow(RangeError)
-  })
-
-  it('should add items up to maxSize', () => {
-    const deque = new MapDeque<string, number>(2)
-    deque.set('a', 1)
-    deque.set('b', 2)
-    expect(deque.size).toBe(2)
-    expect(deque.get('a')).toBe(1)
-    expect(deque.get('b')).toBe(2)
-  })
-
-  it('should evict the oldest item when maxSize is exceeded', () => {
-    const deque = new MapDeque<string, number>(2)
-    deque.set('a', 1)
-    deque.set('b', 2)
-    deque.set('c', 3)
-    expect(deque.size).toBe(2)
-    expect(deque.has('a')).toBe(false)
-    expect(deque.get('b')).toBe(2)
-    expect(deque.get('c')).toBe(3)
-  })
-
-  it('should update value if key already exists and not evict', () => {
-    const deque = new MapDeque<string, number>(2)
-    deque.set('a', 1)
-    deque.set('b', 2)
-    // eslint-disable-next-line sonarjs/no-element-overwrite
-    deque.set('a', 42)
-    expect(deque.size).toBe(2)
-    expect(deque.get('a')).toBe(42)
-    expect(deque.get('b')).toBe(2)
-  })
-
-  it('should work with initial entries', () => {
-    const entries: Array<[string, number]> = [
-      ['x', 10],
-      ['y', 20],
-    ]
-    const deque = new MapDeque<string, number>(3, entries)
-    expect(deque.size).toBe(2)
-    expect(deque.get('x')).toBe(10)
-    expect(deque.get('y')).toBe(20)
-  })
-
-  it('should evict in insertion order, not key order', () => {
-    const deque = new MapDeque<string, number>(2)
-    deque.set('b', 1)
-    deque.set('a', 2)
-    deque.set('c', 3)
-    expect(deque.size).toBe(2)
-    expect(deque.has('b')).toBe(false)
-    expect(deque.has('a')).toBe(true)
-    expect(deque.has('c')).toBe(true)
-  })
-})

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

@@ -1,351 +0,0 @@
-/* eslint-disable @typescript-eslint/no-shadow */
-/* eslint-disable no-shadow */
-/* eslint-disable sonarjs/pseudo-random */
-import { bunMemoryBackend } from '../table/bun-backend'
-import { createTable } from '../table/table'
-
-interface Person {
-  name: string
-  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>({
-      backend,
-      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 () => {
-    const mutation = await table.set({ name: 'Alice', age: 30, city: 'Paris' })
-    expect(mutation.key).toBe('Alice')
-    expect(mutation.op).toBe('insert')
-    const result = await table.get('Alice')
-    expect(result).toEqual({ name: 'Alice', age: 30, city: 'Paris' })
-
-    const updateMutation = await table.set({ name: 'Alice', age: 31, city: 'Paris' })
-    expect(updateMutation.key).toBe('Alice')
-    expect(updateMutation.op).toBe('update')
-    const updatedResult = await table.get('Alice')
-    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' })
-    expect(await table.count()).toBe(2)
-    expect(await table.count({ where: { city: 'Paris' } })).toBe(1)
-  })
-
-  it('should search with ordering, limit and offset', async () => {
-    const people: Person[] = [
-      { name: 'Alice', age: 30, city: 'Paris' },
-      { name: 'Bob', age: 25, city: 'London' },
-      { name: 'Carol', age: 35, city: 'Berlin' },
-    ]
-    for (const p of people) {
-      await table.set(p)
-    }
-    // sort by age ascending
-    const asc = [] as Person[]
-    for await (const p of table.search({ sortBy: 'age', order: 'asc' })) asc.push(p)
-    expect(asc.map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
-    // limit and offset
-    const limited = [] as Person[]
-    for await (const p of table.search({ sortBy: 'age', order: 'asc', limit: 2 })) limited.push(p)
-    expect(limited.map((p) => p.name)).toEqual(['Bob', 'Alice'])
-    const offsetted = [] as Person[]
-    for await (const p of table.search({ sortBy: 'age', order: 'asc', offset: 1, limit: 2 })) offsetted.push(p)
-    expect(offsetted.map((p) => p.name)).toEqual(['Alice', 'Carol'])
-  })
-
-  it('should deleteBy where clause', async () => {
-    await table.set({ name: 'Dave', age: 40, city: 'NY' })
-    await table.set({ name: 'Eve', age: 45, city: 'NY' })
-    await table.set({ name: 'Frank', age: 50, city: 'LA' })
-    expect(await table.count()).toBe(3)
-    await table.deleteBy({ city: 'NY' })
-    expect(await table.count()).toBe(1)
-    expect(await table.get('Frank')).toEqual({ name: 'Frank', age: 50, city: 'LA' })
-    expect(await table.get('Dave')).toBeUndefined()
-  })
-
-  it('should use selector in get and search', async () => {
-    await table.set({ name: 'Gary', age: 60, city: 'SF' })
-    // selector in get
-    const ageOnly = await table.get('Gary', ({ age }) => age)
-    expect(ageOnly).toBe(60)
-    // selector in search
-    const cities: string[] = []
-    for await (const city of table.search({ select: ({ city }) => city })) cities.push(city)
-    expect(cities).toEqual(['SF'])
-  })
-
-  it('should delete items by key', async () => {
-    await table.set({ name: 'Helen', age: 28, city: 'Rome' })
-    expect(await table.get('Helen')).toBeDefined()
-    await table.delete('Helen')
-    expect(await table.get('Helen')).toBeUndefined()
-  })
-  it('should test search with 1000 items', async () => {
-    const people: Person[] = []
-    for (let index = 0; index < 1000; index++) {
-      people.push({
-        name: `Person${index}`,
-        age: Math.floor(Math.random() * 100),
-        city: 'City' + (index % 10),
-      })
-    }
-    for (const p of people) {
-      await table.set(p)
-    }
-    const results: Person[] = []
-    for await (const person of table.search({ sortBy: 'age', order: 'asc', limit: 100 })) {
-      results.push(person)
-    }
-    expect(results.length).toBe(100)
-  })
-
-  it('should handle operations on an empty table', async () => {
-    expect(await table.count()).toBe(0)
-    expect(await table.get('NonExistent')).toBeUndefined()
-    const results: Person[] = []
-    for await (const person of table.search({ sortBy: 'age', order: 'asc' })) {
-      results.push(person)
-    }
-    expect(results.length).toBe(0)
-  })
-
-  it('should handle duplicate keys gracefully', async () => {
-    await table.set({ name: 'Alice', age: 30, city: 'Paris' })
-    await table.set({ name: 'Alice', age: 35, city: 'Berlin' })
-    const result = await table.get('Alice')
-    expect(result).toEqual({ name: 'Alice', age: 35, city: 'Berlin' })
-  })
-
-  it('should handle edge cases in selectors', async () => {
-    await table.set({ name: 'Charlie', age: 40, city: 'NY' })
-    const nullSelector = await table.get('Charlie', () => null)
-    expect(nullSelector).toBeNull()
-    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)
-  })
-})