muya 2.1.1 → 2.1.3

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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,142 @@
+/* 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'
+
+interface Person {
+  name: string
+  age: number
+  city: string
+}
+describe('table', () => {
+  let backend = bunMemoryBackend()
+  let table: ReturnType<typeof createTable<Person>> extends Promise<infer T> ? T : never
+
+  beforeEach(async () => {
+    backend = bunMemoryBackend()
+    table = await createTable<Person>({
+      backend,
+      tableName: 'TestTable',
+      key: 'name',
+    })
+  })
+
+  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 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({ sorBy: '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({ sorBy: '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({ sorBy: '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({ sorBy: '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({ sorBy: '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()
+  })
+})

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

@@ -0,0 +1,274 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+import { createSqliteState } from '../create-sqlite'
+import { useSqliteValue } from '../use-sqlite'
+import { waitFor } from '@testing-library/react'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { useState } from 'react'
+import { DEFAULT_STEP_SIZE } from '../table/table'
+
+const backend = bunMemoryBackend()
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+describe('use-sqlite-state', () => {
+  it('should get basic value states', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
+    let reRenders = 0
+    const { result } = renderHook(() => {
+      reRenders++
+      return useSqliteValue(sql, {}, [])
+    })
+    // expect(result.current).toEqual([])
+
+    expect(reRenders).toBe(1)
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice', age: 30 }])
+      expect(reRenders).toBe(3)
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice2', age: 30 })
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice2', age: 30 }])
+      expect(reRenders).toBe(4)
+    })
+
+    // delete item
+    act(() => {
+      sql.delete('1')
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([])
+      expect(reRenders).toBe(5)
+    })
+
+    // add two items
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+      sql.set({ id: '2', name: 'Bob', age: 25 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(2)
+      expect(reRenders).toBe(6)
+    })
+  })
+
+  it('should use where clause changed via state', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+    let reRenders = 0
+    const { result } = renderHook(() => {
+      reRenders++
+      const [minAge, setMinAge] = useState(20)
+      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sorBy: 'age' }, [minAge]), setMinAge] as const
+    })
+
+    await waitFor(() => {
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
+      expect(reRenders).toBe(2)
+    })
+
+    // // change minAge to 29
+    act(() => {
+      result.current[1](29)
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Carol'])
+      expect(reRenders).toBe(4)
+    })
+  })
+
+  it('should support like in where clause and update results', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Alicia', age: 25 },
+      { id: '3', name: 'Bob', age: 40 },
+    ])
+    let reRenders = 0
+    const { result, rerender } = renderHook(
+      ({ like }) => {
+        reRenders++
+        return useSqliteValue(sql, { where: { name: { like } } }, [like])
+      },
+      { initialProps: { like: '%Ali%' } },
+    )
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Alicia'])
+    })
+    act(() => {
+      rerender({ like: '%Bob%' })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob'])
+    })
+    expect(reRenders).toBeGreaterThanOrEqual(2)
+  })
+
+  it('should update results when changing order and limit options', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+    const { result, rerender } = renderHook(
+      ({ order, limit }) => useSqliteValue(sql, { sorBy: 'age', order, limit }, [order, limit]),
+      { initialProps: { order: 'asc' as 'asc' | 'desc', limit: 2 } },
+    )
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob', 'Alice'])
+    })
+    act(() => {
+      rerender({ order: 'desc', limit: 2 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol', 'Alice'])
+    })
+    act(() => {
+      rerender({ order: 'desc', limit: 1 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol'])
+    })
+  })
+
+  it('should support actions.next and actions.refresh', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+    // actions.next and actions.refresh should be functions
+    await waitFor(() => {
+      expect(typeof result.current[1].next).toBe('function')
+      expect(typeof result.current[1].reset).toBe('function')
+      expect(result.current[1].reset()).resolves.toBeUndefined()
+      expect(result.current[1].next()).resolves.toBeFalsy()
+    })
+  })
+  it('should handle thousands of records', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const people: Person[] = []
+    const ITEMS_COUNT = 1000
+    for (let index = 1; index <= ITEMS_COUNT; index++) {
+      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
+    }
+    await sql.batchSet(people)
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
+    })
+
+    // loop until we have all ITEMS_COUNT items
+    for (let index = 0; index < ITEMS_COUNT / DEFAULT_STEP_SIZE; index++) {
+      act(() => {
+        result.current[1].next()
+      })
+      await waitFor(() => {
+        expect(result.current[0].length).toBe(Math.min(DEFAULT_STEP_SIZE * (index + 2), ITEMS_COUNT))
+      })
+    }
+
+    act(() => {
+      result.current[1].reset()
+    })
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
+    })
+  })
+
+  it('should handle thousands of records with single update', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const people: Person[] = []
+    const ITEMS_COUNT = 10_000
+    const stepSize = 5000
+    for (let index = 1; index <= ITEMS_COUNT; index++) {
+      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
+    }
+    await sql.batchSet(people)
+    let reRenders = 0
+    const { result } = renderHook(() => {
+      reRenders++
+      return useSqliteValue(sql, { stepSize }, [])
+    })
+    await waitFor(() => {
+      expect(reRenders).toBe(2)
+      expect(result.current[0].length).toBe(stepSize)
+    })
+
+    act(() => {
+      for (let index = 0; index < ITEMS_COUNT / stepSize; index++) {
+        result.current[1].next()
+      }
+    })
+
+    await waitFor(() => {
+      expect(reRenders).toBe(4)
+      expect(result.current[0].length).toBe(ITEMS_COUNT)
+    })
+
+    act(() => {
+      result.current[1].reset()
+    })
+    await waitFor(() => {
+      expect(reRenders).toBe(5)
+      expect(result.current[0].length).toBe(stepSize)
+    })
+  })
+  it('should change ordering', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State7', key: 'id', indexes: ['age'] })
+    const people: Person[] = []
+    for (let index = 1; index <= 100; index++) {
+      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
+    }
+    await sql.batchSet(people)
+    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sorBy: 'age', order }, [order]), {
+      initialProps: { order: 'asc' as 'asc' | 'desc' },
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].age).toBe(20)
+    })
+    act(() => {
+      rerender({ order: 'desc' })
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].age).toBe(69)
+    })
+  })
+
+  it('should support selector in options', async () => {
+    const sql = createSqliteState<Person>({ backend, tableName: 'State8', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+    const { result } = renderHook(() =>
+      useSqliteValue(
+        sql,
+        {
+          sorBy: 'age',
+          select: (d) => d.name,
+        },
+        [],
+      ),
+    )
+    await waitFor(() => {
+      expect(result.current[0]).toEqual(['Bob', 'Alice', 'Carol'])
+    })
+  })
+})