@livestore/livestore 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/row-query.ts

@@ -0,0 +1,200 @@
+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/js.js'
+import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
+import type { Store } from './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 === SessionIdSymbol ? 'sessionId' : (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',
+  })
+}

package/src/store-context.ts

@@ -0,0 +1,23 @@
+import type { IntentionalShutdownCause, UnexpectedError } from '@livestore/common'
+import { Schema } from '@livestore/utils/effect'
+
+import type { Store } from './store.js'
+
+export type LiveStoreContext =
+  | LiveStoreContextRunning
+  | {
+      stage: 'error'
+      error: UnexpectedError | unknown
+    }
+  | {
+      stage: 'shutdown'
+      cause: IntentionalShutdownCause | StoreAbort
+    }
+
+export class StoreAbort extends Schema.TaggedError<StoreAbort>()('LiveStore.StoreAbort', {}) {}
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {}) {}
+
+export type LiveStoreContextRunning = {
+  stage: 'running'
+  store: Store
+}

package/src/store-devtools.ts

@@ -0,0 +1,217 @@
+import type { ClientSession, DebugInfo } from '@livestore/common'
+import { Devtools, liveStoreVersion, UnexpectedError } from '@livestore/common'
+import { throttle } from '@livestore/utils'
+import type { WebChannel } from '@livestore/utils/effect'
+import { Effect, Stream } from '@livestore/utils/effect'
+
+import { NOT_REFRESHED_YET } from './reactive.js'
+import type { LiveQuery, ReactivityGraph } from './reactiveQueries/base-class.js'
+import type { SynchronousDatabaseWrapper } from './SynchronousDatabaseWrapper.js'
+import { emptyDebugInfo as makeEmptyDebugInfo } from './SynchronousDatabaseWrapper.js'
+import type { ReferenceCountedSet } from './utils/data-structures.js'
+
+type IStore = {
+  clientSession: ClientSession
+  reactivityGraph: ReactivityGraph
+  syncDbWrapper: SynchronousDatabaseWrapper
+  activeQueries: ReferenceCountedSet<LiveQuery<any>>
+}
+
+type Unsub = () => void
+type RequestId = string
+type SubMap = Map<RequestId, Unsub>
+
+export const connectDevtoolsToStore = ({
+  storeDevtoolsChannel,
+  store,
+}: {
+  storeDevtoolsChannel: WebChannel.WebChannel<Devtools.MessageToAppHostStore, Devtools.MessageFromAppHostStore>
+  store: IStore
+}) =>
+  Effect.gen(function* () {
+    const appHostId = store.clientSession.coordinator.devtools.appHostId
+
+    const reactivityGraphSubcriptions: SubMap = new Map()
+    const liveQueriesSubscriptions: SubMap = new Map()
+    const debugInfoHistorySubscriptions: SubMap = new Map()
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        reactivityGraphSubcriptions.forEach((unsub) => unsub())
+        liveQueriesSubscriptions.forEach((unsub) => unsub())
+        debugInfoHistorySubscriptions.forEach((unsub) => unsub())
+      }),
+    )
+
+    const sendToDevtools = (message: Devtools.MessageFromAppHostStore) =>
+      storeDevtoolsChannel.send(message).pipe(Effect.tapCauseLogPretty, Effect.runSync)
+
+    const onMessage = (decodedMessage: typeof Devtools.MessageToAppHostStore.Type) => {
+      // console.log('storeMessagePort message', decodedMessage)
+
+      if (decodedMessage.appHostId !== store.clientSession.coordinator.devtools.appHostId) {
+        // console.log(`Unknown message`, event)
+        return
+      }
+
+      const requestId = decodedMessage.requestId
+
+      const requestIdleCallback = globalThis.requestIdleCallback ?? ((cb: () => void) => cb())
+
+      switch (decodedMessage._tag) {
+        case 'LSD.ReactivityGraphSubscribe': {
+          const includeResults = decodedMessage.includeResults
+
+          const send = () =>
+            // In order to not add more work to the current tick, we use requestIdleCallback
+            // to send the reactivity graph updates to the devtools
+            requestIdleCallback(
+              () =>
+                sendToDevtools(
+                  Devtools.ReactivityGraphRes.make({
+                    reactivityGraph: store.reactivityGraph.getSnapshot({ includeResults }),
+                    requestId,
+                    appHostId,
+                    liveStoreVersion,
+                  }),
+                ),
+              { timeout: 500 },
+            )
+
+          send()
+
+          // In some cases, there can be A LOT of reactivity graph updates in a short period of time
+          // so we throttle the updates to avoid sending too much data
+          // This might need to be tweaked further and possibly be exposed to the user in some way.
+          const throttledSend = throttle(send, 20)
+
+          reactivityGraphSubcriptions.set(requestId, store.reactivityGraph.subscribeToRefresh(throttledSend))
+
+          break
+        }
+        case 'LSD.DebugInfoReq': {
+          sendToDevtools(
+            Devtools.DebugInfoRes.make({
+              debugInfo: store.syncDbWrapper.debugInfo,
+              requestId,
+              appHostId,
+              liveStoreVersion,
+            }),
+          )
+          break
+        }
+        case 'LSD.DebugInfoHistorySubscribe': {
+          const buffer: DebugInfo[] = []
+          let hasStopped = false
+          let rafHandle: number | undefined
+
+          const tick = () => {
+            buffer.push(store.syncDbWrapper.debugInfo)
+
+            // NOTE this resets the debug info, so all other "readers" e.g. in other `requestAnimationFrame` loops,
+            // will get the empty debug info
+            // TODO We need to come up with a more graceful way to do store. Probably via a single global
+            // `requestAnimationFrame` loop that is passed in somehow.
+            store.syncDbWrapper.debugInfo = makeEmptyDebugInfo()
+
+            if (buffer.length > 10) {
+              sendToDevtools(
+                Devtools.DebugInfoHistoryRes.make({
+                  debugInfoHistory: buffer,
+                  requestId,
+                  appHostId,
+                  liveStoreVersion,
+                }),
+              )
+              buffer.length = 0
+            }
+
+            if (hasStopped === false) {
+              rafHandle = requestAnimationFrame(tick)
+            }
+          }
+
+          rafHandle = requestAnimationFrame(tick)
+
+          const unsub = () => {
+            hasStopped = true
+            if (rafHandle !== undefined) {
+              cancelAnimationFrame(rafHandle)
+            }
+          }
+
+          debugInfoHistorySubscriptions.set(requestId, unsub)
+
+          break
+        }
+        case 'LSD.DebugInfoHistoryUnsubscribe': {
+          debugInfoHistorySubscriptions.get(requestId)!()
+          debugInfoHistorySubscriptions.delete(requestId)
+          break
+        }
+        case 'LSD.DebugInfoResetReq': {
+          store.syncDbWrapper.debugInfo.slowQueries.clear()
+          sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, appHostId, liveStoreVersion }))
+          break
+        }
+        case 'LSD.DebugInfoRerunQueryReq': {
+          const { queryStr, bindValues, queriedTables } = decodedMessage
+          store.syncDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
+          sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, appHostId, liveStoreVersion }))
+          break
+        }
+        case 'LSD.ReactivityGraphUnsubscribe': {
+          reactivityGraphSubcriptions.get(requestId)!()
+          break
+        }
+        case 'LSD.LiveQueriesSubscribe': {
+          const send = () =>
+            requestIdleCallback(
+              () =>
+                sendToDevtools(
+                  Devtools.LiveQueriesRes.make({
+                    liveQueries: [...store.activeQueries].map((q) => ({
+                      _tag: q._tag,
+                      id: q.id,
+                      label: q.label,
+                      runs: q.runs,
+                      executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
+                      lastestResult:
+                        q.results$.previousResult === NOT_REFRESHED_YET
+                          ? 'SYMBOL_NOT_REFRESHED_YET'
+                          : q.results$.previousResult,
+                      activeSubscriptions: Array.from(q.activeSubscriptions),
+                    })),
+                    requestId,
+                    liveStoreVersion,
+                    appHostId,
+                  }),
+                ),
+              { timeout: 500 },
+            )
+
+          send()
+
+          // Same as in the reactivity graph subscription case above, we need to throttle the updates
+          const throttledSend = throttle(send, 20)
+
+          liveQueriesSubscriptions.set(requestId, store.reactivityGraph.subscribeToRefresh(throttledSend))
+
+          break
+        }
+        case 'LSD.LiveQueriesUnsubscribe': {
+          liveQueriesSubscriptions.get(requestId)!()
+          liveQueriesSubscriptions.delete(requestId)
+          break
+        }
+        // No default
+      }
+    }
+
+    yield* storeDevtoolsChannel.listen.pipe(
+      Stream.flatten(),
+      Stream.tapSync((message) => onMessage(message)),
+      Stream.runDrain,
+      Effect.withSpan('LSD.devtools.onMessage'),
+    )
+  }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('LSD.devtools.connectStoreToDevtools'))