@livestore/livestore 0.0.12 → 0.0.15

package/src/backends/index.ts

@@ -1,98 +0,0 @@
-// A backend represents a raw SQLite database.
-// Examples include:
-// - A native SQLite process running in a Tauri Rust process
-// - A SQL.js WASM version of SQLite running in a web worker
-//
-// We can send commands to execute various kinds of queries,
-// and respond to various events from the database.
-
-import type * as otel from '@opentelemetry/api'
-
-import type { LiveStoreEvent } from '../events.js'
-import type { ActionDefinition } from '../schema.js'
-import type { ParamsObject } from '../util.js'
-import { casesHandled } from '../util.js'
-import type { BackendOptionsTauri } from './tauri.js'
-import type { BackendOptionsWeb } from './web.js'
-import { WebWorkerBackend } from './web.js'
-import type { BackendOptionsWebInMemory } from './web-in-memory.js'
-import { WebInMemoryBackend } from './web-in-memory.js'
-
-/* A location of a persistent writable SQLite file */
-export type WritableDatabaseLocation =
-  | {
-      type: 'opfs'
-      virtualFilename: string
-    }
-  | {
-      type: 'indexeddb'
-      virtualFilename: string
-    }
-  | {
-      type: 'filesystem'
-      directory: string
-      filename: string
-    }
-  | {
-      type: 'volatile-in-memory'
-    }
-
-export interface Backend {
-  // Select some data from the DB.
-  // This should only do reads, not writes, but we don't strongly enforce that.
-  select<T = any>(query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): Promise<SelectResponse<T>>
-
-  // Execute a query where you don't care about the result.
-  // Used for writes and configuration changes.
-  execute(query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): void
-
-  /** Apply an event to the backend */
-  applyEvent(event: LiveStoreEvent, eventDefiniton: ActionDefinition, parentSpan?: otel.Span): void
-
-  /** Return a snapshot of persisted data from the backend */
-  getPersistedData(parentSpan?: otel.Span): Promise<Uint8Array>
-}
-
-export type BackendType = 'tauri' | 'web' | 'web-in-memory'
-
-export const isBackendType = (type: string): type is BackendType => {
-  return type === 'tauri' || type === 'web' || type === 'web-in-memory'
-}
-
-export type SelectResponse<T = any> = {
-  results: T[]
-
-  // other perf stats metadata about how long the query took
-  [key: string]: any
-}
-
-export enum IndexType {
-  Basic = 'Basic',
-  FullText = 'FullText',
-}
-
-export type BackendOptions = BackendOptionsTauri | BackendOptionsWeb | BackendOptionsWebInMemory
-export type BackendOtelProps = {
-  otelTracer: otel.Tracer
-  parentSpan: otel.Span
-}
-
-export const createBackend = async (options: BackendOptions, otelProps: BackendOtelProps): Promise<Backend> => {
-  switch (options.type) {
-    case 'tauri': {
-      // NOTE Dynamic import is needed to avoid Tauri is a dependency of LiveStore (e.g. when used in the web)
-      const { TauriBackend } = await import('./tauri.js')
-      return await TauriBackend.load(options, otelProps)
-    }
-    case 'web': {
-      return WebWorkerBackend.load(options, otelProps)
-    }
-    // NOTE currently only needed for testing
-    case 'web-in-memory': {
-      return WebInMemoryBackend.load(options, otelProps)
-    }
-    default: {
-      casesHandled(options)
-    }
-  }
-}

package/src/backends/noop.ts

@@ -1,32 +0,0 @@
-import { makeNoopTracer } from '@livestore/utils'
-import type * as otel from '@opentelemetry/api'
-
-import type { ParamsObject } from '../util.js'
-import { BaseBackend } from './base.js'
-import type { SelectResponse } from './index.js'
-
-export type BackendOptionsNoop = {
-  type: 'noop'
-  /** Specifies where to persist data for this backend */
-  otelTracer?: otel.Tracer
-}
-
-export class NoopBackend extends BaseBackend {
-  constructor(readonly otelTracer: otel.Tracer) {
-    super()
-  }
-
-  static load = async (options: BackendOptionsNoop): Promise<NoopBackend> => {
-    return new NoopBackend(options.otelTracer ?? makeNoopTracer())
-  }
-
-  execute = (_query: string, _bindValues?: ParamsObject): void => {}
-
-  select = async <T>(_query: string, _bindValues?: ParamsObject): Promise<SelectResponse<T>> => {
-    return { results: [] }
-  }
-
-  getPersistedData = async (): Promise<Uint8Array> => {
-    return new Uint8Array()
-  }
-}

package/src/backends/web-in-memory.ts

@@ -1,65 +0,0 @@
-import type * as otel from '@opentelemetry/api'
-import type * as SqliteWasm from 'sqlite-esm'
-import sqlite3InitModule from 'sqlite-esm'
-
-import type { ParamsObject } from '../util.js'
-import { prepareBindValues } from '../util.js'
-import { BaseBackend } from './base.js'
-import type { BackendOtelProps, SelectResponse } from './index.js'
-
-export type BackendOptionsWebInMemory = {
-  type: 'web-in-memory'
-}
-
-declare type DatabaseWithCAPI = SqliteWasm.Database & { capi: SqliteWasm.CAPI }
-
-// NOTE: This backend is currently only used for testing
-export class WebInMemoryBackend extends BaseBackend {
-  constructor(
-    readonly otelTracer: otel.Tracer,
-    readonly db: DatabaseWithCAPI,
-  ) {
-    super()
-  }
-
-  static load = async (
-    _options: BackendOptionsWebInMemory,
-    { otelTracer }: BackendOtelProps,
-  ): Promise<WebInMemoryBackend> => {
-    const sqlite3 = await sqlite3InitModule({
-      print: (message) => console.log(`[sql-client] ${message}`),
-      printErr: (message) => console.error(`[sql-client] ${message}`),
-    })
-    const db = new sqlite3.oo1.DB({ filename: ':memory:', flags: 'c' }) as DatabaseWithCAPI
-    db.capi = sqlite3.capi
-
-    return new WebInMemoryBackend(otelTracer, db)
-  }
-
-  execute = (query: string, bindValues?: ParamsObject): void => {
-    this.db.exec({
-      sql: query,
-      bind: prepareBindValues(bindValues ?? {}, query) as TODO,
-      returnValue: 'resultRows',
-      rowMode: 'object',
-    })
-  }
-
-  select = async <T>(query: string, bindValues?: ParamsObject): Promise<SelectResponse<T>> => {
-    const resultRows: T[] = []
-
-    this.db.exec({
-      sql: query,
-      bind: prepareBindValues(bindValues ?? {}, query) as TODO,
-      rowMode: 'object',
-      resultRows,
-      // callback: (row: any) => console.log('select result', db.filename, query, row),
-    } as TODO)
-
-    return { results: resultRows }
-  }
-
-  getPersistedData = async (): Promise<Uint8Array> => {
-    return this.db.capi.sqlite3_js_db_export(this.db.pointer)
-  }
-}

package/src/backends/web.ts

@@ -1,97 +0,0 @@
-import type * as otel from '@opentelemetry/api'
-import * as Comlink from 'comlink'
-
-import type { ParamsObject } from '../util.js'
-import { prepareBindValues } from '../util.js'
-import { BaseBackend } from './base.js'
-import type { BackendOtelProps, SelectResponse, WritableDatabaseLocation } from './index.js'
-import type { WrappedWorker } from './web-worker.js'
-
-export type BackendOptionsWeb = {
-  type: 'web'
-  /** Specifies where to persist data for this backend */
-  persistentDatabaseLocation: WritableDatabaseLocation
-}
-
-export class WebWorkerBackend extends BaseBackend {
-  worker: Comlink.Remote<WrappedWorker>
-  persistentDatabaseLocation: WritableDatabaseLocation
-  otelTracer: otel.Tracer
-
-  executionBacklog: { query: string; bindValues?: ParamsObject }[] = []
-  executionPromise: Promise<void> | undefined = undefined
-
-  private constructor({
-    worker,
-    persistentDatabaseLocation,
-    otelTracer,
-  }: {
-    worker: Comlink.Remote<WrappedWorker>
-    persistentDatabaseLocation: WritableDatabaseLocation
-    otelTracer: otel.Tracer
-  }) {
-    super()
-    this.worker = worker
-    this.persistentDatabaseLocation = persistentDatabaseLocation
-    this.otelTracer = otelTracer
-  }
-
-  static load = async (
-    { persistentDatabaseLocation }: BackendOptionsWeb,
-    { otelTracer }: BackendOtelProps,
-  ): Promise<WebWorkerBackend> => {
-    // TODO: Importing the worker like this only works with Vite;
-    // should this really be inside the LiveStore library?
-    // Doesn't work with Firefox right now during dev https://bugzilla.mozilla.org/show_bug.cgi?id=1247687
-    const worker = new Worker(new URL('./web-worker.js', import.meta.url), {
-      type: 'module',
-    })
-    const wrappedWorker = Comlink.wrap<WrappedWorker>(worker)
-
-    await wrappedWorker.initialize({ persistentDatabaseLocation })
-
-    return new WebWorkerBackend({
-      worker: wrappedWorker,
-      persistentDatabaseLocation,
-      otelTracer,
-    })
-  }
-
-  execute = (query: string, bindValues_?: ParamsObject) => {
-    const bindValues = prepareBindValues(bindValues_ ?? {}, query)
-    this.executionBacklog.push({ query, bindValues })
-
-    // Instead of sending the queries to the worker immediately, we wait a bit and batch them up (which reduces the number of messages sent to the worker)
-    if (this.executionPromise === undefined) {
-      this.executionPromise = new Promise((resolve) => {
-        setTimeout(() => {
-          void this.worker.executeBulk(this.executionBacklog)
-          this.executionBacklog = []
-          this.executionPromise = undefined
-
-          resolve()
-        }, 10)
-      })
-    }
-  }
-
-  select = async <T>(query: string, bindValues?: ParamsObject): Promise<SelectResponse<T>> => {
-    // NOTE we need to wait for the executionBacklog to be worked off, before we run the select query (as it might depend on the previous execution queries)
-    await this.executionPromise
-
-    try {
-      const response = (await this.worker.select(query, bindValues)) as SelectResponse<T>
-      return response
-    } catch (e) {
-      console.error(`Error while executing query via "select": ${query}`)
-      throw e
-    }
-  }
-
-  getPersistedData = async (_parentSpan?: otel.Span): Promise<Uint8Array> => {
-    // NOTE we need to wait for the executionBacklog to be worked off
-    await this.executionPromise
-
-    return this.worker.getPersistedData()
-  }
-}

package/src/react/useGlobalQuery.ts

@@ -1,40 +0,0 @@
-import { useEffect, useState } from 'react'
-
-import { labelForKey } from '../componentKey.js'
-import { TODO_REMOVE_trackLongRunningSpan } from '../otel.js'
-import type { LiveStoreQuery, QueryResult } from '../store.js'
-
-export const useGlobalQuery = <Q extends LiveStoreQuery>(query: Q): QueryResult<Q> => {
-  // We know the query has a result by the time we use it; so we can synchronously populate a default state
-  const [value, setValue] = useState<QueryResult<Q>>(query.results$.result)
-
-  // Subscribe to future updates for this query
-  useEffect(() => {
-    return query.store.otel.tracer.startActiveSpan(
-      `LiveStore:useGlobalQuery:${labelForKey(query.componentKey)}:${query.label}`,
-      {},
-      query.store.otel.queriesSpanContext,
-      (span) => {
-        TODO_REMOVE_trackLongRunningSpan(span)
-
-        const cancel = query.store.subscribe(
-          query,
-          (v) => {
-            // NOTE: we return a reference to the result object within LiveStore;
-            // this implies that app code must not mutate the results, or else
-            // there may be weird reactivity bugs.
-            return setValue(v)
-          },
-          undefined,
-          { label: query.label },
-        )
-        return () => {
-          cancel()
-          span.end()
-        }
-      },
-    )
-  }, [query])
-
-  return value
-}