muya 2.4.4 → 2.4.5

package/src/sqlite/create-sqlite.ts

@@ -1,26 +1,21 @@
-/* eslint-disable sonarjs/redundant-type-aliases */
 import { STATE_SCHEDULER } from '../create'
 import { getId } from '../utils/id'
-import { shallow } from '../utils/shallow'
-import { selectSql, type CreateState } from './select-sql'
 import type { Backend } from './table'
-import { createTable, DEFAULT_STEP_SIZE } from './table/table'
+import { createTable } from './table/table'
 import type { DbOptions, DocType, Key, MutationResult, SearchOptions, Table } from './table/table.types'
 import type { Where } from './table/where'
 
-type SearchId = string
-
 export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOptions<Document>, 'backend'> {
   readonly backend: Backend | Promise<Backend>
 }
 
-export interface SyncTable<Document extends DocType> {
-  // readonly registerSearch: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => () => void
-  readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void
-  readonly subscribe: (searchId: SearchId, componentId: string, listener: () => void) => () => void
-  readonly getSnapshot: (searchId: SearchId) => Document[]
-  readonly refresh: (searchId: SearchId) => Promise<void>
+export interface MutationItems {
+  mutations?: MutationResult[]
+  removedAll?: boolean
+}
 
+export interface SyncTable<Document extends DocType> {
+  readonly subscribe: (listener: (mutation: MutationItems) => void) => () => void
   readonly set: (document: Document) => Promise<MutationResult>
   readonly batchSet: (documents: Document[]) => Promise<MutationResult[]>
   readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>
@@ -29,21 +24,7 @@ export interface SyncTable<Document extends DocType> {
   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[]>
-  readonly destroy: () => void
-  readonly next: (searchId: SearchId) => Promise<boolean>
-  readonly clear: (searchId: SearchId) => void
-  readonly load: (searchId: SearchId) => void
-
-  readonly select: <Params extends unknown[]>(
-    compute: (...args: Params) => SearchOptions<Document>,
-  ) => CreateState<Document, Params>
-}
-
-interface CachedItem<Document extends DocType> {
-  items: Document[]
-  keys: Set<Key>
-  options?: SearchOptions<Document, unknown>
-  wasInitialized: boolean
+  readonly clear: () => void
 }
 
 /**
@@ -52,17 +33,6 @@ interface CachedItem<Document extends DocType> {
  * @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> {
-  const id = getId()
-
-  /**
-   * Get a unique schedule ID for a search ID
-   * @param searchId The search ID
-   * @returns The unique schedule ID
-   */
-  function getScheduleId(searchId: SearchId) {
-    return `state-${id}-search-${searchId}`
-  }
-
   let cachedTable: Table<Document> | undefined
   /**
    * Get or create the underlying table
@@ -77,213 +47,74 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
     return cachedTable
   }
 
-  interface NextResult {
-    document: Document
-    key: Key
-  }
-  // const emitter = createEmitter<Table<Document>>()
-  const cachedData = new Map<SearchId, CachedItem<Document>>()
-  const listeners = new Map<SearchId, Map<string, () => void>>()
-  const iterators = new Map<SearchId, AsyncIterableIterator<NextResult>>()
-
-  interface GetNextBase {
-    readonly newItems?: Document[]
-    readonly isOk: boolean
-    readonly isDone?: boolean
-  }
-
-  interface GetNextTrue extends GetNextBase {
-    readonly isOk: true
-    readonly newItems: Document[]
-  }
-  interface GetNextFalse extends GetNextBase {
-    readonly isOk: false
-  }
-  type GetNext = GetNextTrue | GetNextFalse
-  /**
-   * Next step in the iterator
-   * @param searchId The search ID
-   * @param data The data items to process
-   * @param shouldReset Whether to reset the items
-   * @returns boolean indicating if new items were added
-   */
-  async function getNext(searchId: SearchId, data: CachedItem<Document>, shouldReset: boolean): Promise<GetNext> {
-    const iterator = iterators.get(searchId)
-    const { options: nextOptions = {} } = data
-    const { stepSize = DEFAULT_STEP_SIZE } = nextOptions
-    if (!iterator) return { isOk: false }
-    const newItems: Document[] = []
-    if (shouldReset) {
-      data.keys.clear()
-    }
-
-    for (let index = 0; index < stepSize; index++) {
-      const result = await iterator.next()
-      if (result.done) {
-        iterators.delete(searchId)
-        break
-      }
-
-      if (!data.keys.has(String(result.value.key))) {
-        newItems.push(result.value.document)
-        data.keys.add(String(result.value.key))
-      }
-    }
-
-    if (newItems.length === 0) return { isOk: true, newItems: shouldReset ? [] : data.items, isDone: true }
-    if (shallow(data.items, newItems)) return { isOk: false }
-    if (shouldReset) return { isOk: true, newItems }
-    return { newItems: [...data.items, ...newItems], isOk: true }
-  }
-
-  /**
-   * Notify listeners of up dates
-   * @param searchId The search ID to notify
-   */
-  function notifyListeners(searchId: SearchId) {
-    const searchListeners = listeners.get(searchId)
-    if (searchListeners) {
-      for (const [, listener] of searchListeners) {
-        listener()
+  const id = getId()
+  STATE_SCHEDULER.add(id, {
+    onScheduleDone(unknownItems) {
+      if (!unknownItems) {
+        return
       }
-    }
-  }
-
-  /**
-   * Refresh the cache for a search ID
-   * @param searchId The search ID to refresh
-   */
-  async function refreshCache(searchId: SearchId) {
-    const table = await getTable()
-    const data = cachedData.get(searchId)
-    if (!data) return
-    const { options: refreshOptions } = data
-    const iterator = table.search({ ...refreshOptions, select: (document, { rowId, key }) => ({ document, rowId, key }) })
-    iterators.set(searchId, iterator)
-    const { isOk, newItems } = await getNext(searchId, data, true)
-    if (isOk) {
-      data.items = newItems
-    }
-  }
-  /**
-   * Refresh the data and notify listeners
-   * @param searchId The search ID to refresh
-   */
-  async function refresh(searchId: SearchId) {
-    await refreshCache(searchId)
-    notifyListeners(searchId)
-  }
-
-  /**
-   * Handle changes to the data
-   * @param mutationResult The mutation result
-   * @returns A set of search IDs that need to be updated
-   */
-  function getChangedKeys(mutationResult: MutationResult) {
-    const { key, op } = mutationResult
-    // find all cached data with key
-    const searchIds = new Set<SearchId>()
-    for (const [searchId, { keys }] of cachedData) {
-      switch (op) {
-        case 'delete':
-        case 'update': {
-          if (keys.has(String(key))) {
-            searchIds.add(searchId)
-          }
-          break
+      const items = unknownItems as MutationItems[]
+      const merged: MutationItems = {}
+      for (const item of items) {
+        if (item.removedAll) {
+          merged.removedAll = true
         }
-        case 'insert': {
-          // we do not know about the key
-          searchIds.add(searchId)
-          break
+        if (item.mutations) {
+          if (!merged.mutations) {
+            merged.mutations = []
+          }
+          merged.mutations.push(...item.mutations)
         }
       }
-    }
-    return searchIds
-  }
-
-  /**
-   * Handle multiple changes
-   * @param mutationResults The array of mutation results
-   */
-  async function handleChanges(mutationResults: MutationResult[]) {
-    const updateSearchIds = new Set<SearchId>()
-    for (const mutationResult of mutationResults) {
-      const searchIds = getChangedKeys(mutationResult)
-      for (const searchId of searchIds) {
-        updateSearchIds.add(searchId)
+      for (const listener of listeners) {
+        listener(merged)
       }
-    }
-
-    for (const searchId of updateSearchIds) {
-      const scheduleId = getScheduleId(searchId)
-      STATE_SCHEDULER.schedule(scheduleId, {})
-    }
-  }
-
-  const clearSchedulers = new Set<() => void>()
+    },
+  })
 
   /**
-   * Register data for a search ID
-   * @param searchId The search ID
-   * @param registerDataOptions Optional search options
-   * @returns The data items for the search ID
+   * Notify all subscribers of changes
+   * @param item The mutation items to notify subscribers about
    */
-  function registerData(searchId: SearchId, registerDataOptions?: SearchOptions<Document, unknown>) {
-    if (!cachedData.has(searchId)) {
-      const cachedItem: CachedItem<Document> = {
-        items: [],
-        options: registerDataOptions,
-        keys: new Set(),
-        wasInitialized: false,
-      }
-      cachedData.set(searchId, cachedItem)
-    }
-    const cachedItem = cachedData.get(searchId)!
-
-    if (registerDataOptions) {
-      cachedItem.options = registerDataOptions
-    }
-    return cachedItem
+  function handleChanges(item: MutationItems) {
+    STATE_SCHEDULER.schedule(id, item)
   }
 
+  const listeners = new Set<(mutation: MutationItems) => void>()
+
   const state: SyncTable<Document> = {
-    load(searchId: SearchId) {
-      const cachedItem = cachedData.get(searchId)
-      if (!cachedItem) return
-      if (!cachedItem.wasInitialized) {
-        cachedItem.wasInitialized = true
-        const scheduleId = getScheduleId(searchId)
-        STATE_SCHEDULER.schedule(scheduleId, { searchId })
-      }
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
     },
-    clear(searchId: SearchId) {
-      cachedData.delete(searchId)
+    clear() {
+      cachedTable?.clear()
+      handleChanges({ removedAll: true })
     },
     async set(document) {
       const table = await getTable()
       const changes = await table.set(document)
-      await handleChanges([changes])
+      handleChanges({ mutations: [changes] })
       return changes
     },
     async batchSet(documents) {
       const table = await getTable()
       const changes = await table.batchSet(documents)
-      await handleChanges(changes)
+      handleChanges({ mutations: changes })
       return changes
     },
     async delete(key) {
       const table = await getTable()
       const changes = await table.delete(key)
       if (changes) {
-        await handleChanges([changes])
+        handleChanges({ mutations: [changes] })
       }
       return changes
     },
     async deleteBy(where) {
       const table = await getTable()
       const changes = await table.deleteBy(where)
-      await handleChanges(changes)
+      handleChanges({ mutations: changes })
       return changes
     },
     async get(key, selector) {
@@ -300,65 +131,6 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       const table = await getTable()
       return await table.count(countOptions)
     },
-
-    updateSearchOptions(searchId, updateSearchOptions) {
-      const data = registerData(searchId, updateSearchOptions)
-      data.options = updateSearchOptions
-      const scheduleId = getScheduleId(searchId)
-      STATE_SCHEDULER.schedule(scheduleId, { searchId })
-    },
-
-    subscribe(searchId, componentId, listener) {
-      const scheduleId = getScheduleId(searchId)
-      const clearScheduler = STATE_SCHEDULER.add(scheduleId, {
-        onScheduleDone() {
-          refresh(searchId)
-        },
-      })
-      // console.log('Subscribing to searchId:', searchId)
-      this.load(searchId)
-      clearSchedulers.add(clearScheduler)
-
-      if (!listeners.has(searchId)) {
-        listeners.set(searchId, new Map())
-      }
-      const searchListeners = listeners.get(searchId)!
-      searchListeners.set(componentId, listener)
-
-      return () => {
-        searchListeners.delete(componentId)
-        if (searchListeners.size === 0) {
-          listeners.delete(searchId)
-        }
-        clearScheduler()
-      }
-    },
-    getSnapshot(searchId) {
-      const data = registerData(searchId)
-      return data.items
-    },
-    refresh,
-    destroy() {
-      for (const clear of clearSchedulers) clear()
-      cachedData.clear()
-      listeners.clear()
-    },
-    async next(searchId) {
-      const data = cachedData.get(searchId)
-      if (data) {
-        const hasNext = await getNext(searchId, data, false)
-        if (hasNext.isOk) {
-          data.items = hasNext.newItems
-          notifyListeners(searchId)
-        }
-        return hasNext.isDone ?? false
-      }
-      return false
-    },
-
-    select(compute) {
-      return selectSql(state, compute)
-    },
   }
 
   return state

package/src/sqlite/index.ts

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

package/src/sqlite/table/table.ts

@@ -9,7 +9,7 @@ import type { Where } from './where'
 import { getWhereQuery } from './where'
 
 const DELETE_IN_CHUNK = 500
-export const DEFAULT_STEP_SIZE = 100
+export const DEFAULT_PAGE_SIZE = 100
 
 /**
  * Convert a dot-separated path to a JSON path
@@ -239,7 +239,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
         offset = 0,
         where,
         select = (document) => document as unknown as Selected,
-        stepSize = DEFAULT_STEP_SIZE,
+        pageSize = DEFAULT_PAGE_SIZE,
       } = options
 
       const whereSql = getWhereQuery<Document>(where, tableName)
@@ -256,7 +256,7 @@ export async function createTable<Document extends DocType>(options: DbOptions<D
           query += hasUserKey ? ` ORDER BY key COLLATE NOCASE ${order.toUpperCase()}` : ` ORDER BY rowid ${order.toUpperCase()}`
         }
 
-        const batchLimit = limit ? Math.min(stepSize, limit - yielded) : stepSize
+        const batchLimit = limit ? Math.min(pageSize, limit - yielded) : pageSize
         query += ` LIMIT ${batchLimit} OFFSET ${currentOffset}`
 
         const results = await backend.select<Array<{ rowid: number; data: string }>>(query)

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

@@ -1,4 +1,3 @@
-import type { SqlSeachOptions } from '../select-sql'
 import type { Backend } from './backend'
 import type { FtsTokenizerOptions } from './tokenizer'
 import type { Where } from './where'
@@ -7,6 +6,15 @@ import type { Where } from './where'
 export type DocType = { [key: string]: any }
 export type KeyTypeAvailable = 'string' | 'number'
 
+export interface SqlSeachOptions<Document extends DocType> {
+  readonly sortBy?: DotPath<Document>
+  readonly order?: 'asc' | 'desc'
+  readonly limit?: number
+  readonly offset?: number
+  readonly where?: Where<Document>
+  readonly pageSize?: number
+}
+
 // Expand all nested keys into dot-paths
 export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`
 

package/src/sqlite/use-sqlite-count.ts

@@ -0,0 +1,69 @@
+import { useCallback, useEffect, useLayoutEffect, useReducer, useRef, type DependencyList } from 'react'
+import type { SyncTable } from './create-sqlite'
+import type { DocType } from './table/table.types'
+import type { Where } from './table/where'
+
+/**
+ * A React hook to count the number of items in a SyncTable reactively.
+ * It updates the count when items are inserted or deleted, but ignores updates.
+ * Supports filtering the count using a `where` clause.
+ * @param state The SyncTable instance to observe.
+ * @param options Optional filtering options.
+ * @param options.where A `where` clause to filter the count.
+ * @param deps Dependency list to control when to re-run the effect.
+ * @returns The current count of items in the table.
+ */
+export function useSqliteCount<Document extends DocType>(
+  state: SyncTable<Document>,
+  options: { where?: Where<Document> } = {},
+  deps: DependencyList = [],
+): number {
+  const countRef = useRef(0)
+  const [, rerender] = useReducer((c: number) => c + 1, 0)
+
+  const updateCount = useCallback(async () => {
+    const newCount = await state.count(options)
+    countRef.current = newCount
+    rerender()
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, deps)
+
+  useEffect(() => {
+    updateCount()
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, deps)
+
+  useLayoutEffect(() => {
+    const unsubscribe = state.subscribe((item) => {
+      const { mutations, removedAll } = item
+      if (removedAll) {
+        countRef.current = 0
+        rerender()
+        return
+      }
+      if (!mutations) {
+        return
+      }
+
+      let shouldUpdate = false
+      for (const mutation of mutations) {
+        const { op } = mutation
+        if (op === 'insert' || op === 'delete') {
+          shouldUpdate = true
+          break
+        }
+      }
+
+      if (shouldUpdate) {
+        updateCount()
+      }
+    })
+
+    return () => {
+      unsubscribe()
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [state])
+
+  return countRef.current
+}