muya 2.5.4 → 2.5.5

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

@@ -1,234 +0,0 @@
-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/create-sqlite.ts

@@ -1,164 +0,0 @@
-import { STATE_SCHEDULER } from '../create'
-import { getId } from '../utils/id'
-import type { Backend } from './table'
-import { createTable } from './table/table'
-import type {
-  DbOptions,
-  DocType,
-  DotPath,
-  GetFieldType,
-  GroupByOptions,
-  GroupByResult,
-  Key,
-  MutationResult,
-  SearchOptions,
-  Table,
-} from './table/table.types'
-import type { Where } from './table/where'
-
-export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOptions<Document>, 'backend'> {
-  readonly backend: Backend | Promise<Backend>
-}
-
-export interface MutationItems<Doc> {
-  mutations?: MutationResult<Doc>[]
-  removedAll?: boolean
-}
-
-export interface SyncTable<Document extends DocType> {
-  readonly subscribe: (listener: (mutation: MutationItems<Document>) => void) => () => void
-  readonly set: (document: Document) => Promise<MutationResult<Document>>
-  readonly batchSet: (documents: Document[]) => Promise<MutationResult<Document>[]>
-  readonly batchDelete: (keys: Key[]) => Promise<MutationResult<Document>[]>
-  readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>
-
-  readonly delete: (key: Key) => Promise<MutationResult<Document> | undefined>
-  readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>
-  readonly count: (options?: { where?: Where<Document> }) => Promise<number>
-  readonly deleteBy: (where: Where<Document>) => Promise<MutationResult<Document>[]>
-  readonly clear: () => Promise<void>
-  readonly groupBy: <Field extends DotPath<Document>>(
-    field: Field,
-    options?: GroupByOptions<Document>,
-  ) => Promise<Array<GroupByResult<GetFieldType<Document, Field>>>>
-}
-
-/**
- * Create a SyncTable that wraps a Table and provides reactive capabilities
- * @param options Options to create the SyncTable, including the backend and table name
- * @returns A SyncTable instance with methods to interact with the underlying Table and manage reactive searches
- */
-export function createSqliteState<Document extends DocType>(options: CreateSqliteOptions<Document>): SyncTable<Document> {
-  let cachedTable: Table<Document> | undefined
-  /**
-   * Get or create the underlying table
-   * @returns The Table instance
-   */
-  async function getTable() {
-    if (!cachedTable) {
-      const { backend, ...rest } = options
-      const resolvedBackend = backend instanceof Promise ? await backend : backend
-      cachedTable = await createTable<Document>({ backend: resolvedBackend, ...rest })
-    }
-    return cachedTable
-  }
-
-  const id = getId()
-  STATE_SCHEDULER.add(id, {
-    onScheduleDone(unknownItems) {
-      if (!unknownItems) {
-        return
-      }
-      const items = unknownItems as MutationItems<Document>[]
-      const merged: MutationItems<Document> = {}
-      for (const item of items) {
-        if (item.removedAll) {
-          merged.removedAll = true
-        }
-        if (item.mutations) {
-          if (!merged.mutations) {
-            merged.mutations = []
-          }
-          merged.mutations.push(...item.mutations)
-        }
-      }
-      for (const listener of listeners) {
-        listener(merged)
-      }
-    },
-  })
-
-  /**
-   * Notify all subscribers of changes
-   * @param item The mutation items to notify subscribers about
-   */
-  function handleChanges(item: MutationItems<Document>) {
-    STATE_SCHEDULER.schedule(id, item)
-  }
-
-  const listeners = new Set<(mutation: MutationItems<Document>) => void>()
-
-  const state: SyncTable<Document> = {
-    subscribe(listener) {
-      listeners.add(listener)
-      return () => listeners.delete(listener)
-    },
-    async clear() {
-      const table = await getTable()
-      handleChanges({ removedAll: true })
-      return table.clear()
-    },
-    async set(document) {
-      const table = await getTable()
-      const changes = await table.set(document)
-      handleChanges({ mutations: [changes] })
-      return changes
-    },
-    async batchSet(documents) {
-      const table = await getTable()
-      const changes = await table.batchSet(documents)
-      handleChanges({ mutations: changes })
-      return changes
-    },
-    async batchDelete(keys) {
-      const table = await getTable()
-      const changes = await table.batchDelete(keys)
-      handleChanges({ mutations: changes })
-      return changes
-    },
-    async delete(key) {
-      const table = await getTable()
-      const changes = await table.delete(key)
-      if (changes) {
-        handleChanges({ mutations: [changes] })
-      }
-      return changes
-    },
-    async deleteBy(where) {
-      const table = await getTable()
-      const changes = await table.deleteBy(where)
-      handleChanges({ mutations: changes })
-      return changes
-    },
-    async get(key, selector) {
-      const table = await getTable()
-      return table.get(key, selector)
-    },
-    async *search(searchOptions = {}) {
-      const table = await getTable()
-      for await (const item of table.search(searchOptions)) {
-        yield item
-      }
-    },
-    async count(countOptions) {
-      const table = await getTable()
-      return await table.count(countOptions)
-    },
-    async groupBy(field, groupByOptions) {
-      const table = await getTable()
-      return await table.groupBy(field, groupByOptions)
-    },
-  }
-
-  return state
-}

package/src/sqlite/index.ts

@@ -1,4 +0,0 @@
-export * from './create-sqlite'
-export * from './table'
-export * from './use-sqlite-count'
-export * from './use-sqlite'

package/src/sqlite/table/backend.ts

@@ -1,21 +0,0 @@
-export const IN_MEMORY_DB = ':memory:'
-
-export interface QueryResult {
-  /** The number of rows affected by the query. */
-  rowsAffected: number
-  /**
-   * The last inserted `id`.
-   *
-   * This value is not set for Postgres databases. If the
-   * last inserted id is required on Postgres, the `select` function
-   * must be used, with a `RETURNING` clause
-   * (`INSERT INTO todos (title) VALUES ($1) RETURNING id`).
-   */
-  lastInsertId?: number
-}
-export interface Backend {
-  execute: (query: string, bindValues?: unknown[]) => Promise<QueryResult>
-  select: <T>(query: string, bindValues?: unknown[]) => Promise<T>
-  transaction: (callback: (tx: Backend) => Promise<void>) => Promise<void>
-  path: string
-}

package/src/sqlite/table/bun-backend.ts

@@ -1,47 +0,0 @@
-import { Database, type Statement } from 'bun:sqlite'
-import type { Backend } from './backend'
-import { MapDeque } from './map-deque'
-
-/**
- * Create an in-memory SQLite backend using Bun's SQLite implementation
- * @returns A Backend instance for in-memory SQLite operations
- */
-export function bunMemoryBackend(): Backend {
-  const db = Database.open(':memory:')
-  const prepares = new MapDeque<string, Statement>(100)
-  /**
-   * Get or prepare a SQLite statement, caching it for future use
-   * @param query The SQL query string
-   * @returns The prepared SQLite statement
-   */
-  function getStatement(query: string): Statement {
-    if (prepares.has(query)) {
-      return prepares.get(query)!
-    }
-    const stmt = db.prepare(query)
-    prepares.set(query, stmt)
-    return stmt
-  }
-
-  const backend: Backend = {
-    execute: async (query, params = []) => {
-      const q = getStatement(query)
-      const result = q.run(...(params as never[]))
-      return {
-        rowsAffected: result.changes,
-        changes: result.changes,
-      }
-    },
-    transaction: async (callback) => {
-      return db.transaction(() => callback(backend))()
-    },
-    path: db.filename,
-    select: async (query, params = []) => {
-      const q = getStatement(query)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const result = q.all(...(params as never[])) as Array<Record<string, any>>
-      return result as never
-    },
-  }
-  return backend
-}

package/src/sqlite/table/index.ts

@@ -1,6 +0,0 @@
-export * from './backend'
-export * from './table.types'
-export * from './where'
-export * from './table'
-export * from './map-deque'
-export * from './tokenizer'

package/src/sqlite/table/map-deque.ts

@@ -1,29 +0,0 @@
-export class MapDeque<K, V> extends Map<K, V> {
-  constructor(
-    private maxSize: number,
-    entries?: ReadonlyArray<readonly [K, V]> | null,
-  ) {
-    super(entries)
-    if (this.maxSize <= 0) {
-      throw new RangeError('maxSize must be greater than 0')
-    }
-  }
-
-  override set(key: K, value: V): this {
-    if (this.has(key)) {
-      super.set(key, value)
-      return this
-    }
-
-    if (this.size >= this.maxSize) {
-      const firstKey = this.keys().next().value
-      if (firstKey !== undefined) {
-        this.delete(firstKey)
-      }
-    }
-
-    super.set(key, value)
-
-    return this
-  }
-}