muya 2.5.4 → 2.5.6

package/src/sqlite/table/table.ts

@@ -1,353 +0,0 @@
-/* eslint-disable prefer-destructuring */
-/* eslint-disable sonarjs/different-types-comparison */
-/* eslint-disable sonarjs/cognitive-complexity */
-/* eslint-disable @typescript-eslint/no-shadow */
-/* eslint-disable no-shadow */
-import type { Backend } from './backend'
-import type {
-  Table,
-  DbOptions,
-  DocType,
-  Key,
-  SearchOptions,
-  MutationResult,
-  GroupByResult,
-  GroupByOptions,
-  DotPath,
-  GetFieldType,
-} from './table.types'
-import { unicodeTokenizer, type FtsTokenizerOptions } from './tokenizer'
-import type { Where } from './where'
-import { getWhereQuery } from './where'
-
-const DELETE_IN_CHUNK = 500
-export const DEFAULT_PAGE_SIZE = 100
-
-/**
- * Convert a dot-separated path to a JSON path
- * @param dot The dot-separated path string
- * @returns The JSON path string
- */
-export function toJsonPath(dot: string) {
-  return '$.' + dot
-}
-
-/**
- * Get a nested value from an object using a dot-separated path
- * @param object The object to retrieve the value from
- * @param path The dot-separated path string
- * @returns The value at the specified path, or undefined if not found
- */
-export function getByPath<T extends object>(object: T, path: string): unknown {
-  if (!object || !path) return undefined
-  // eslint-disable-next-line unicorn/no-array-reduce
-  return path.split('.').reduce<unknown>((accumulator, key) => {
-    if (typeof accumulator === 'object' && accumulator !== null && key in (accumulator as Record<string, unknown>)) {
-      return (accumulator as Record<string, unknown>)[key]
-    }
-    return
-  }, object)
-}
-
-/**
- * Create and initialize a table in the database with the specified options
- * @param options The options for creating the table, including table name, indexes, backend, and key
- * @returns A promise that resolves to the created Table instance
- */
-export async function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>> {
-  const { backend, tableName, indexes, key, disablePragmaOptimization } = options
-  const hasUserKey = key !== undefined
-
-  if (!disablePragmaOptimization) {
-    await backend.execute(`PRAGMA journal_mode=WAL;`)
-    await backend.execute(`PRAGMA synchronous=NORMAL;`)
-    await backend.execute(`PRAGMA temp_store=MEMORY;`)
-    await backend.execute(`PRAGMA cache_size=-20000;`)
-  }
-
-  // Base JSON table
-  if (hasUserKey) {
-    await backend.execute(`
-      CREATE TABLE IF NOT EXISTS ${tableName} (
-        key TEXT PRIMARY KEY,
-        data TEXT NOT NULL
-      );
-    `)
-  } else {
-    await backend.execute(`
-      CREATE TABLE IF NOT EXISTS ${tableName} (
-        data TEXT NOT NULL
-      );
-    `)
-  }
-
-  // Track FTS fields and map dot paths to valid SQLite column names
-  let ftsTokenizer: string | undefined | FtsTokenizerOptions
-  const ftsFields: string[] = []
-  const ftsFieldMap: Record<string, string> = {} // dot path -> column name
-
-  for (const index of indexes ?? []) {
-    if (typeof index === 'string' && index.startsWith('fts:')) {
-      const path = index.slice(4)
-      const col = path.replaceAll('.', '_')
-      ftsFields.push(path)
-      ftsFieldMap[path] = col
-    } else if (typeof index === 'object' && index.type === 'fts') {
-      const path = index.path
-      const col = path.replaceAll('.', '_')
-      ftsFields.push(path)
-      ftsFieldMap[path] = col
-      if (index.tokenizer) {
-        if (!ftsTokenizer) {
-          ftsTokenizer = index.tokenizer
-        } else if (ftsTokenizer !== index.tokenizer) {
-          throw new Error(`Conflicting FTS tokenizers: already using "${ftsTokenizer}", got "${index.tokenizer}"`)
-        }
-      }
-    } else {
-      const idx = String(index)
-      await backend.execute(
-        `CREATE INDEX IF NOT EXISTS idx_${tableName}_${idx.replaceAll(/\W/g, '_')}
-       ON ${tableName} (json_extract(data, '${toJsonPath(idx)}'));`,
-      )
-    }
-  }
-
-  // Create FTS table + triggers
-  if (ftsFields.length > 0) {
-    let tokenizerSpec: string
-    if (typeof ftsTokenizer === 'object') {
-      tokenizerSpec = unicodeTokenizer(ftsTokenizer)
-    } else if (ftsTokenizer === undefined) {
-      tokenizerSpec = '"unicode61", "remove_diacritics=1"'
-    } else {
-      tokenizerSpec = ftsTokenizer
-    }
-    // Use mapped column names for FTS columns
-    const ftsColumns = ftsFields.map((f) => ftsFieldMap[f]).join(', ')
-    const query = `
-        CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName}_fts
-        USING fts5(${ftsColumns}, tokenize=${tokenizerSpec});
-`
-
-    await backend.execute(query)
-
-    // Insert trigger
-    await backend.execute(`
-      CREATE TRIGGER IF NOT EXISTS ${tableName}_ai
-      AFTER INSERT ON ${tableName}
-      BEGIN
-        INSERT INTO ${tableName}_fts(rowid, ${ftsColumns})
-        VALUES (
-          new.rowid,
-          ${ftsFields.map((f) => `json_extract(new.data, '${toJsonPath(f)}')`).join(', ')}
-        );
-      END;
-    `)
-
-    // Delete trigger
-    await backend.execute(`
-      CREATE TRIGGER IF NOT EXISTS ${tableName}_ad
-      AFTER DELETE ON ${tableName}
-      BEGIN
-        DELETE FROM ${tableName}_fts WHERE rowid = old.rowid;
-      END;
-    `)
-
-    // Update trigger
-    await backend.execute(`
-      CREATE TRIGGER IF NOT EXISTS ${tableName}_au
-      AFTER UPDATE ON ${tableName}
-      BEGIN
-        UPDATE ${tableName}_fts
-        SET ${ftsFields.map((f) => `${ftsFieldMap[f]}=json_extract(new.data, '${toJsonPath(f)}')`).join(', ')}
-        WHERE rowid = old.rowid;
-      END;
-    `)
-  }
-
-  /**
-   * Get the value of the configured key from a document
-   * @param document The document to extract the key from
-   * @returns The value of the key, or undefined if not found or no key is configured
-   */
-  function getKeyFromDocument(document: Document): Key | undefined {
-    if (!hasUserKey) return undefined
-    return getByPath(document, String(key)) as Key | undefined
-  }
-
-  const table: Table<Document> = {
-    backend,
-
-    async set(document, backendOverride) {
-      const db = backendOverride ?? backend
-      const json = JSON.stringify(document)
-
-      if (hasUserKey) {
-        const id = getKeyFromDocument(document)
-        if (id === undefined || id === null) {
-          throw new Error(`Document is missing the configured key "${String(key)}".`)
-        }
-
-        const existing = await db.select<Array<{ key: string }>>(`SELECT key FROM ${tableName} WHERE key = ?`, [id])
-
-        if (existing.length > 0) {
-          await db.execute(`UPDATE ${tableName} SET data = ? WHERE key = ?`, [json, id])
-          return { key: id, op: 'update', document }
-        } else {
-          await db.execute(`INSERT INTO ${tableName} (key, data) VALUES (?, ?)`, [id, json])
-          return { key: id, op: 'insert', document }
-        }
-      }
-
-      await db.execute(`INSERT INTO ${tableName} (data) VALUES (?)`, [json])
-      const rows = await db.select<Array<{ id: number }>>(`SELECT last_insert_rowid() AS id`)
-      const rowid = rows[0]?.id
-      if (typeof rowid !== 'number') throw new Error('Failed to retrieve last_insert_rowid()')
-      return { key: rowid, op: 'insert', document }
-    },
-
-    async get<Selected = Document>(
-      keyValue: Key,
-      selector: (document: Document, meta: { rowId: number; key: Key }) => Selected = (d) => d as unknown as Selected,
-    ) {
-      const whereKey = hasUserKey ? `key = ?` : `rowid = ?`
-      const result = await backend.select<Array<{ data: string; rowid: number }>>(
-        `SELECT rowid, data FROM ${tableName} WHERE ${whereKey}`,
-        [keyValue],
-      )
-      if (result.length === 0) return
-      const { data, rowid } = result[0]
-      const document = JSON.parse(data) as Document
-      const logicalKey = hasUserKey ? (getKeyFromDocument(document) ?? rowid) : rowid
-      return selector(document, { rowId: rowid, key: logicalKey }) as Selected
-    },
-
-    async delete(keyValue: Key, backendOverride?: Backend) {
-      const db = backendOverride ?? backend
-      const whereKey = hasUserKey ? `key = ?` : `rowid = ?`
-      await db.execute(`DELETE FROM ${tableName} WHERE ${whereKey}`, [keyValue])
-      const changed = await backend.select<Array<{ c: number }>>(`SELECT changes() AS c`)
-      if ((changed[0]?.c ?? 0) > 0) return { key: keyValue, op: 'delete' }
-      return
-    },
-
-    async *search<Selected = Document>(options: SearchOptions<Document, Selected> = {}): AsyncIterableIterator<Selected> {
-      const {
-        sortBy,
-        order = 'asc',
-        limit,
-        offset = 0,
-        where,
-        select = (document) => document as unknown as Selected,
-        pageSize = DEFAULT_PAGE_SIZE,
-      } = options
-
-      const whereSql = getWhereQuery<Document>(where, tableName)
-      const baseQuery = `SELECT rowid, data FROM ${tableName} ${whereSql}`
-
-      let yielded = 0
-      let currentOffset = offset
-      while (true) {
-        let query = baseQuery
-
-        if (sortBy) {
-          query += ` ORDER BY json_extract(data, '${toJsonPath(String(sortBy))}') COLLATE NOCASE ${order.toUpperCase()}`
-        } else {
-          query += hasUserKey ? ` ORDER BY key COLLATE NOCASE ${order.toUpperCase()}` : ` ORDER BY rowid ${order.toUpperCase()}`
-        }
-
-        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)
-        if (results.length === 0) break
-
-        for (const { rowid, data } of results) {
-          if (limit && yielded >= limit) return
-          const document = JSON.parse(data) as Document
-          const logicalKey = hasUserKey ? (getKeyFromDocument(document) ?? rowid) : rowid
-          // Pass both rowId and logicalKey
-          yield select(document, { rowId: rowid, key: logicalKey }) as Selected
-          yielded++
-        }
-
-        if (results.length < batchLimit || (limit && yielded >= limit)) break
-        currentOffset += results.length
-      }
-    },
-
-    async count(options: { where?: Where<Document> } = {}) {
-      const whereSql = getWhereQuery<Document>(options.where, tableName)
-      const query = `SELECT COUNT(*) as count FROM ${tableName} ${whereSql}`
-      const result = await backend.select<Array<{ count: number }>>(query)
-      return result[0]?.count ?? 0
-    },
-
-    async deleteBy(where: Where<Document>) {
-      const whereSql = getWhereQuery<Document>(where, tableName)
-      const keyCol = hasUserKey ? 'key' : 'rowid'
-      const results: MutationResult<Document>[] = []
-
-      await backend.transaction(async (tx) => {
-        const rows = await tx.select<Array<{ k: Key }>>(`SELECT ${keyCol} AS k FROM ${tableName} ${whereSql}`)
-        if (rows.length === 0) return
-
-        const allKeys = rows.map((r) => r.k)
-        for (let index = 0; index < allKeys.length; index += DELETE_IN_CHUNK) {
-          const chunk = allKeys.slice(index, index + DELETE_IN_CHUNK)
-          const placeholders = chunk.map(() => '?').join(',')
-          await tx.execute(`DELETE FROM ${tableName} WHERE ${keyCol} IN (${placeholders})`, chunk as unknown[])
-        }
-
-        for (const k of allKeys) results.push({ key: k, op: 'delete', document: undefined })
-      })
-
-      return results
-    },
-
-    async clear() {
-      await backend.execute(`DELETE FROM ${tableName}`)
-    },
-
-    async groupBy<Field extends DotPath<Document>>(
-      field: Field,
-      options: GroupByOptions<Document> = {},
-    ): Promise<Array<GroupByResult<GetFieldType<Document, Field>>>> {
-      const whereSql = getWhereQuery<Document>(options.where, tableName)
-      const jsonPath = toJsonPath(String(field))
-      const query = `
-        SELECT json_extract(data, '${jsonPath}') AS groupKey, COUNT(*) AS count
-        FROM ${tableName}
-        ${whereSql}
-        GROUP BY groupKey
-      `
-      type FieldType = GetFieldType<Document, Field>
-      const results = await backend.select<Array<{ groupKey: FieldType; count: number }>>(query)
-      return results.map((row) => ({ key: row.groupKey, count: row.count }))
-    },
-
-    async batchSet(documents: Document[]) {
-      const mutations: MutationResult<Document>[] = []
-      await backend.transaction(async (tx) => {
-        for (const document of documents) {
-          const m = await table.set(document, tx)
-          mutations.push(m)
-        }
-      })
-      return mutations
-    },
-    async batchDelete(keys: Key[]) {
-      const mutations: MutationResult<Document>[] = []
-      await backend.transaction(async (tx) => {
-        for (const key of keys) {
-          const m = await table.delete(key, tx)
-          if (m) mutations.push(m)
-        }
-      })
-      return mutations
-    },
-  }
-
-  return table
-}

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

@@ -1,129 +0,0 @@
-import type { Backend } from './backend'
-import type { FtsTokenizerOptions } from './tokenizer'
-import type { Where } from './where'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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}`
-
-type Previous = [never, 0, 1, 2, 3, 4, 5]
-
-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>>
-
-/**
- * Extract the value type at a given dot path
- * e.g., GetFieldType<{ user: { name: string } }, 'user.name'> = string
- */
-export type GetFieldType<T, Path extends string> = Path extends `${infer First}.${infer Rest}`
-  ? First extends keyof T
-    ? GetFieldType<T[First], Rest>
-    : never
-  : Path extends keyof T
-    ? T[Path]
-    : never
-
-// Built-in FTS5 tokenizers
-export type FtsTokenizer =
-  | 'porter' // English stemming
-  | 'simple' // basic ASCII tokenizer
-  | 'icu' // requires SQLite compiled with ICU extension
-  | 'unicode61' // Unicode-aware tokenizer with diacritic removal and custom token chars
-  | FtsTokenizerOptions
-
-export interface FtsType<Document extends DocType> {
-  readonly type: 'fts'
-  readonly path: DotPath<Document>
-  readonly tokenizer?: FtsTokenizer
-}
-export type IndexDeclaration<Document extends DocType> =
-  | DotPath<Document> // normal JSON path index
-  | `fts:${DotPath<Document>}` // full-text index
-  | FtsType<Document> // full-text index with options
-
-export interface DbOptions<Document extends DocType> {
-  readonly tableName: string
-  readonly indexes?: Array<IndexDeclaration<Document>>
-  readonly backend: Backend
-  readonly key?: DotPath<Document>
-  readonly disablePragmaOptimization?: boolean
-}
-
-export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
-  readonly select?: (document: Document, meta: { rowId: number; key: Key }) => Selected
-}
-
-interface DbNotGeneric {
-  readonly backend: Backend
-}
-
-export type Key = string | number
-
-export type MutationOp = 'insert' | 'update' | 'delete'
-
-interface MutationResultBase<T> {
-  key: Key
-  op: MutationOp
-  document?: T
-}
-interface MutationResultDelete<T> extends MutationResultBase<T> {
-  key: Key
-  op: 'delete'
-}
-
-interface MutationResultUpdateInsert<T> extends MutationResultBase<T> {
-  key: Key
-  op: 'update' | 'insert'
-  document: T
-}
-
-export type MutationResult<T> = MutationResultDelete<T> | MutationResultUpdateInsert<T>
-
-export interface GroupByResult<K> {
-  readonly key: K
-  readonly count: number
-}
-
-export interface GroupByOptions<Document extends DocType> {
-  readonly where?: Where<Document>
-}
-
-export interface Table<Document extends DocType> extends DbNotGeneric {
-  readonly set: (document: Document, backendOverride?: Backend) => 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, backendOverride?: Backend) => 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>>>>
-}
-
-export type MakeAllFieldAsRequired<T> = {
-  [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K]
-}

package/src/sqlite/table/tokenizer.ts

@@ -1,35 +0,0 @@
-export interface FtsTokenizerOptions {
-  readonly removeDiacritics?: 0 | 1 | 2
-  readonly tokenChars?: string
-  readonly separators?: string
-}
-
-/**
- * Create a custom FTS5 tokenizer string based on the provided options
- * @param options Options to customize the tokenizer
- * @returns A string representing the FTS5 tokenizer configuration
- */
-export function unicodeTokenizer(options: FtsTokenizerOptions = {}): string {
-  const { removeDiacritics, tokenChars, separators } = options
-  const parts: string[] = []
-
-  if (removeDiacritics !== undefined) {
-    parts.push(`"remove_diacritics=${removeDiacritics}"`)
-  }
-  if (tokenChars && tokenChars.length > 0) {
-    parts.push(`"tokenchars='${tokenChars.replaceAll("'", "''")}'"`)
-  }
-  if (separators && separators.length > 0) {
-    parts.push(`"separators='${separators.replaceAll("'", "''")}'"`)
-  }
-
-  // 👉 return correct SQLite syntax
-  if (parts.length === 0) {
-    return '"unicode61"'
-  }
-  const hasParts = parts.length > 0
-  if (!hasParts) {
-    return '"unicode61"'
-  }
-  return `"unicode61", ${parts.join(', ')}`
-}