@livestore/livestore 0.1.0-dev.9 → 0.2.0-dev.0

package/src/reactiveQueries/sql.ts

@@ -1,226 +0,0 @@
-import { type Bindable, prepareBindValues, type QueryInfo, type QueryInfoNone } from '@livestore/common'
-import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
-
-import { globalReactivityGraph } from '../global-state.js'
-import type { Thunk } from '../reactive.js'
-import { NOT_REFRESHED_YET } from '../reactive.js'
-import type { RefreshReason } from '../store/store-types.js'
-import { getDurationMsFromSpan } from '../utils/otel.js'
-import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
-import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
-
-/**
- * NOTE `querySQL` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
- */
-export const querySQL = <TResultSchema, TResult = TResultSchema>(
-  query: string | ((get: GetAtomResult) => string),
-  options: {
-    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
-    map?: (rows: TResultSchema) => TResult
-    /**
-     * Can be provided explicitly to slightly speed up initial query performance
-     *
-     * NOTE In the future we want to do this automatically at build time
-     */
-    queriedTables?: Set<string>
-    bindValues?: Bindable
-    label?: string
-    reactivityGraph?: ReactivityGraph
-  },
-): LiveQuery<TResult, QueryInfoNone> =>
-  new LiveStoreSQLQuery<TResultSchema, TResult, QueryInfoNone>({
-    label: options?.label,
-    genQueryString: query,
-    queriedTables: options?.queriedTables,
-    bindValues: options?.bindValues,
-    reactivityGraph: options?.reactivityGraph,
-    map: options?.map,
-    schema: options.schema,
-    queryInfo: { _tag: 'None' },
-  })
-
-/* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<
-  TResultSchema,
-  TResult = TResultSchema,
-  TQueryInfo extends QueryInfo = QueryInfoNone,
-> extends LiveStoreQueryBase<TResult, TQueryInfo> {
-  _tag: 'sql' = 'sql'
-
-  /** A reactive thunk representing the query text */
-  queryString$: Thunk<string, QueryContext, RefreshReason> | undefined
-
-  /** A reactive thunk representing the query results */
-  results$: Thunk<TResult, QueryContext, RefreshReason>
-
-  label: string
-
-  protected reactivityGraph
-
-  /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
-  private execBeforeFirstRun
-
-  private mapResult: (rows: TResultSchema) => TResult
-  private schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
-
-  queryInfo: TQueryInfo
-
-  constructor({
-    genQueryString,
-    queriedTables,
-    bindValues,
-    label = genQueryString.toString(),
-    reactivityGraph,
-    schema,
-    map,
-    execBeforeFirstRun,
-    queryInfo,
-  }: {
-    label?: string
-    genQueryString: string | ((get: GetAtomResult, ctx: QueryContext) => string)
-    queriedTables?: Set<string>
-    bindValues?: Bindable
-    reactivityGraph?: ReactivityGraph
-    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
-    map?: (rows: TResultSchema) => TResult
-    execBeforeFirstRun?: (ctx: QueryContext) => void
-    queryInfo?: TQueryInfo
-  }) {
-    super()
-
-    this.label = `sql(${label})`
-    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
-    this.execBeforeFirstRun = execBeforeFirstRun
-    this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-
-    this.schema = schema
-    this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
-
-    let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
-    if (typeof genQueryString === 'function') {
-      queryString$OrQueryString = this.reactivityGraph.makeThunk(
-        (get, setDebugInfo, ctx, otelContext) => {
-          const startMs = performance.now()
-          const queryString = genQueryString(makeGetAtomResult(get, otelContext ?? ctx.rootOtelContext), ctx)
-          const durationMs = performance.now() - startMs
-          setDebugInfo({ _tag: 'computed', label: `${label}:queryString`, query: queryString, durationMs })
-          return queryString
-        },
-        {
-          label: `${label}:queryString`,
-          meta: { liveStoreThunkType: 'sqlQueryString' },
-          equal: (a, b) => a === b,
-        },
-      )
-
-      this.queryString$ = queryString$OrQueryString
-    } else {
-      queryString$OrQueryString = genQueryString
-    }
-
-    const queryLabel = `${label}:results`
-
-    const queriedTablesRef = { current: queriedTables }
-
-    const schemaEqual = Schema.equivalence(schema)
-    // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)
-    // This would mean dropping the `map` option
-    const equal =
-      map === undefined
-        ? (a: TResult, b: TResult) =>
-            a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : schemaEqual(a as any, b as any)
-        : undefined
-
-    const results$ = this.reactivityGraph.makeThunk<TResult>(
-      (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
-        otelTracer.startActiveSpan(
-          'sql:...', // NOTE span name will be overridden further down
-          {},
-          otelContext ?? rootOtelContext,
-          (span) => {
-            const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-            if (this.execBeforeFirstRun !== undefined) {
-              this.execBeforeFirstRun({ store, otelTracer, rootOtelContext, effectsWrapper: (run) => run() })
-              this.execBeforeFirstRun = undefined
-            }
-
-            const sqlString =
-              typeof queryString$OrQueryString === 'string'
-                ? queryString$OrQueryString
-                : get(queryString$OrQueryString, otelContext)
-
-            if (queriedTablesRef.current === undefined) {
-              queriedTablesRef.current = store.syncDbWrapper.getTablesUsed(sqlString)
-            }
-
-            // Establish a reactive dependency on the tables used in the query
-            for (const tableName of queriedTablesRef.current) {
-              const tableRef = store.tableRefs[tableName] ?? shouldNeverHappen(`No table ref found for ${tableName}`)
-              get(tableRef, otelContext)
-            }
-
-            span.setAttribute('sql.query', sqlString)
-            span.updateName(`sql:${sqlString.slice(0, 50)}`)
-
-            const rawResults = store.syncDbWrapper.select<any>(sqlString, {
-              queriedTables,
-              bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
-              otelContext,
-            })
-
-            span.setAttribute('sql.rowsCount', rawResults.length)
-
-            const parsedResult = Schema.decodeEither(this.schema)(rawResults)
-
-            if (parsedResult._tag === 'Left') {
-              const parseErrorStr = TreeFormatter.formatErrorSync(parsedResult.left)
-              const expectedSchemaStr = String(this.schema.ast)
-              const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
-
-              console.error(
-                `\
-Error parsing SQL query result.
-
-Query: ${sqlString}\
-${bindValuesStr}
-
-Expected schema: ${expectedSchemaStr}
-
-Error: ${parseErrorStr}
-
-Result:`,
-                rawResults,
-              )
-              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
-            }
-
-            const result = this.mapResult(parsedResult.right)
-
-            span.end()
-
-            const durationMs = getDurationMsFromSpan(span)
-
-            this.executionTimes.push(durationMs)
-
-            setDebugInfo({ _tag: 'sql', label, query: sqlString, durationMs })
-
-            return result
-          },
-        ),
-      { label: queryLabel, equal },
-    )
-
-    this.results$ = results$
-  }
-
-  destroy = () => {
-    if (this.queryString$ !== undefined) {
-      this.reactivityGraph.destroyNode(this.queryString$)
-    }
-
-    this.reactivityGraph.destroyNode(this.results$)
-  }
-}

package/src/row-query.ts

@@ -1,196 +0,0 @@
-import type { QueryInfoCol, QueryInfoNone, QueryInfoRow } from '@livestore/common'
-import { SessionIdSymbol, sql } from '@livestore/common'
-import { DbSchema } from '@livestore/common/schema'
-import type { SqliteDsl } from '@livestore/db-schema'
-import type { GetValForKey } from '@livestore/utils'
-import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
-import type * as otel from '@opentelemetry/api'
-
-import type {
-  GetAtomResult,
-  LiveQuery,
-  LiveQueryAny,
-  QueryContext,
-  ReactivityGraph,
-} from './reactiveQueries/base-class.js'
-import { computed } from './reactiveQueries/computed.js'
-import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
-import type { Store } from './store/store.js'
-
-export type RowQueryOptions<TTableDef extends DbSchema.TableDef, TResult = RowResult<TTableDef>> = {
-  otelContext?: otel.Context
-  skipInsertDefaultRow?: boolean
-  reactivityGraph?: ReactivityGraph
-  map?: (result: RowResult<TTableDef>) => TResult
-  label?: string
-}
-
-export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
-  defaultValues?: Partial<RowResult<TTableDef>>
-}
-
-export type MakeRowQuery = {
-  <
-    TTableDef extends DbSchema.TableDef<
-      DbSchema.DefaultSqliteTableDef,
-      boolean,
-      DbSchema.TableOptions & { isSingleton: true }
-    >,
-    TResult = RowResult<TTableDef>,
-  >(
-    table: TTableDef,
-    options?: RowQueryOptions<TTableDef, TResult>,
-  ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
-  <
-    TTableDef extends DbSchema.TableDef<
-      DbSchema.DefaultSqliteTableDef,
-      boolean,
-      DbSchema.TableOptions & { isSingleton: false }
-    >,
-    TResult = RowResult<TTableDef>,
-  >(
-    table: TTableDef,
-    // TODO adjust so it works with arbitrary primary keys or unique constraints
-    id: string | SessionIdSymbol,
-    options?: RowQueryOptions<TTableDef, TResult> & RowQueryOptionsDefaulValues<TTableDef>,
-  ): LiveQuery<TResult, QueryInfoRow<TTableDef>>
-}
-
-// TODO also allow other where clauses and multiple rows
-export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
-  table: TTableDef,
-  idOrOptions?: string | SessionIdSymbol | RowQueryOptions<TTableDef, any>,
-  options_?: RowQueryOptions<TTableDef, any> & RowQueryOptionsDefaulValues<TTableDef>,
-) => {
-  const id = typeof idOrOptions === 'string' || idOrOptions === SessionIdSymbol ? idOrOptions : undefined
-  const options = typeof idOrOptions === 'string' || idOrOptions === SessionIdSymbol ? options_ : idOrOptions
-  const defaultValues: Partial<RowResult<TTableDef>> | undefined = (options as any)?.defaultValues ?? {}
-
-  // Validate query args
-  if (table.options.isSingleton === true && id !== undefined && id !== SessionIdSymbol) {
-    shouldNeverHappen(`Cannot query state table ${table.sqliteDef.name} with id "${id}" as it is a singleton`)
-  } else if (table.options.isSingleton !== true && id === undefined) {
-    shouldNeverHappen(`Cannot query state table ${table.sqliteDef.name} without id`)
-  }
-
-  const tableSchema = table.sqliteDef
-  const tableName = tableSchema.name
-
-  const makeQueryString = (id: string | undefined) =>
-    sql`select * from ${tableName} ${id === undefined ? '' : `where id = '${id}'`} limit 1`
-
-  const genQueryString =
-    id === SessionIdSymbol
-      ? (_: GetAtomResult, ctx: QueryContext) => makeQueryString(ctx.store.sessionId)
-      : makeQueryString(id)
-
-  const rowSchema = table.isSingleColumn === true ? table.schema.pipe(Schema.pluck('value' as any)) : table.schema
-
-  return new LiveStoreSQLQuery({
-    label:
-      options?.label ??
-      `rowQuery:query:${tableSchema.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`,
-    genQueryString,
-    queriedTables: new Set([tableName]),
-    reactivityGraph: options?.reactivityGraph,
-    // While this code-path is not needed for singleton tables, it's still needed for `useRow` with non-existing rows for a given ID
-    execBeforeFirstRun: makeExecBeforeFirstRun({
-      otelContext: options?.otelContext,
-      table,
-      defaultValues,
-      id,
-      skipInsertDefaultRow: options?.skipInsertDefaultRow,
-    }),
-    schema: rowSchema.pipe(Schema.Array, Schema.headOrElse()),
-    map: options?.map,
-    queryInfo: { _tag: 'Row', table, id: id ?? 'singleton' },
-  })
-}
-
-export type RowResult<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
-  ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
-  : SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
-
-export type RowResultEncoded<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
-  ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>, 'value'>
-  : SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>
-
-export const deriveColQuery: {
-  <TQuery extends LiveQuery<any, QueryInfoNone>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
-    colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfoNone>
-  <TQuery extends LiveQuery<any, QueryInfoRow<any>>, TCol extends keyof TQuery['__result!'] & string>(
-    query$: TQuery,
-    colName: TCol,
-  ): LiveQuery<TQuery['__result!'][TCol], QueryInfoCol<TQuery['queryInfo']['table'], TCol>>
-} = (query$: LiveQueryAny, colName: string) => {
-  return computed((get) => get(query$)[colName], {
-    label: `deriveColQuery:${query$.label}:${colName}`,
-    queryInfo:
-      query$.queryInfo._tag === 'Row'
-        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
-        : undefined,
-  }) as any
-}
-
-const makeExecBeforeFirstRun =
-  ({
-    id,
-    defaultValues,
-    skipInsertDefaultRow,
-    otelContext: otelContext_,
-    table,
-  }: {
-    id?: string | SessionIdSymbol
-    defaultValues?: any
-    skipInsertDefaultRow?: boolean
-    otelContext?: otel.Context
-    table: DbSchema.TableDef
-  }) =>
-  ({ store }: QueryContext) => {
-    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
-
-    if (skipInsertDefaultRow !== true && table.options.isSingleton === false) {
-      insertRowWithDefaultValuesOrIgnore({
-        store,
-        id: id!,
-        table,
-        otelContext,
-        explicitDefaultValues: defaultValues,
-      })
-    }
-  }
-
-const insertRowWithDefaultValuesOrIgnore = ({
-  store,
-  id,
-  table,
-  otelContext,
-  explicitDefaultValues,
-}: {
-  store: Store
-  id: string | SessionIdSymbol
-  table: DbSchema.TableDef
-  otelContext: otel.Context
-  explicitDefaultValues: Partial<RowResult<DbSchema.TableDef>> | undefined
-}) => {
-  const idStr = id === SessionIdSymbol ? store.sessionId : id
-  const rowExists =
-    store.syncDbWrapper.select(`select 1 from ${table.sqliteDef.name} where id = '${idStr}'`).length === 1
-
-  if (rowExists) return
-
-  // const mutationDef = deriveCreateMutationDef(table)
-  if (DbSchema.tableHasDerivedMutations(table) === false) {
-    return shouldNeverHappen(
-      `Cannot insert row for table "${table.sqliteDef.name}" which does not have 'deriveMutations: true' set`,
-    )
-  }
-  // NOTE It's important that we only mutate and don't refresh here, as this function is called during a render
-  store.mutateWithoutRefresh(table.insert({ id, ...explicitDefaultValues }), {
-    otelContext,
-    coordinatorMode: 'default',
-  })
-}