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

package/src/reactiveQueries/sql.ts

@@ -6,7 +6,7 @@ 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.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'
@@ -79,7 +79,7 @@ export class LiveStoreSQLQuery<
     queryInfo,
   }: {
     label?: string
-    genQueryString: string | ((get: GetAtomResult) => string)
+    genQueryString: string | ((get: GetAtomResult, ctx: QueryContext) => string)
     queriedTables?: Set<string>
     bindValues?: Bindable
     reactivityGraph?: ReactivityGraph
@@ -101,11 +101,11 @@ export class LiveStoreSQLQuery<
     let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
     if (typeof genQueryString === 'function') {
       queryString$OrQueryString = this.reactivityGraph.makeThunk(
-        (get, setDebugInfo, { rootOtelContext }, otelContext) => {
+        (get, setDebugInfo, ctx, otelContext) => {
           const startMs = performance.now()
-          const queryString = genQueryString(makeGetAtomResult(get, otelContext ?? rootOtelContext))
+          const queryString = genQueryString(makeGetAtomResult(get, otelContext ?? ctx.rootOtelContext), ctx)
           const durationMs = performance.now() - startMs
-          setDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString, durationMs })
+          setDebugInfo({ _tag: 'computed', label: `${label}:queryString`, query: queryString, durationMs })
           return queryString
         },
         {

package/src/row-query.ts

@@ -1,16 +1,22 @@
 import type { QueryInfoCol, QueryInfoNone, QueryInfoRow } from '@livestore/common'
-import { sql } 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 { SqliteDsl } from 'effect-db-schema'
 
-import type { LiveQuery, LiveQueryAny, QueryContext, ReactivityGraph } from './reactiveQueries/base-class.js'
-import { computed } from './reactiveQueries/js.js'
+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.js'
+import type { Store } from './store/store.js'
 
 export type RowQueryOptions<TTableDef extends DbSchema.TableDef, TResult = RowResult<TTableDef>> = {
   otelContext?: otel.Context
@@ -46,7 +52,7 @@ export type MakeRowQuery = {
   >(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
-    id: string,
+    id: string | SessionIdSymbol,
     options?: RowQueryOptions<TTableDef, TResult> & RowQueryOptionsDefaulValues<TTableDef>,
   ): LiveQuery<TResult, QueryInfoRow<TTableDef>>
 }
@@ -54,15 +60,15 @@ export type MakeRowQuery = {
 // TODO also allow other where clauses and multiple rows
 export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   table: TTableDef,
-  idOrOptions?: string | RowQueryOptions<TTableDef, any>,
+  idOrOptions?: string | SessionIdSymbol | RowQueryOptions<TTableDef, any>,
   options_?: RowQueryOptions<TTableDef, any> & RowQueryOptionsDefaulValues<TTableDef>,
 ) => {
-  const id = typeof idOrOptions === 'string' ? idOrOptions : undefined
-  const options = typeof idOrOptions === 'string' ? options_ : idOrOptions
+  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) {
+  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`)
@@ -71,14 +77,21 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   const tableSchema = table.sqliteDef
   const tableName = tableSchema.name
 
-  const whereClause = id === undefined ? '' : `where id = '${id}'`
-  const queryStr = sql`select * from ${tableName} ${whereClause} limit 1`
+  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}`}`,
-    genQueryString: queryStr,
+    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
@@ -130,7 +143,7 @@ const makeExecBeforeFirstRun =
     otelContext: otelContext_,
     table,
   }: {
-    id?: string
+    id?: string | SessionIdSymbol
     defaultValues?: any
     skipInsertDefaultRow?: boolean
     otelContext?: otel.Context
@@ -158,12 +171,15 @@ const insertRowWithDefaultValuesOrIgnore = ({
   explicitDefaultValues,
 }: {
   store: Store
-  id: string
+  id: string | SessionIdSymbol
   table: DbSchema.TableDef
   otelContext: otel.Context
   explicitDefaultValues: Partial<RowResult<DbSchema.TableDef>> | undefined
 }) => {
-  const rowExists = store.syncDbWrapper.select(`select 1 from ${table.sqliteDef.name} where id = '${id}'`).length === 1
+  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)

package/src/store/create-store.ts

@@ -0,0 +1,214 @@
+import type {
+  Adapter,
+  BootStatus,
+  ClientSession,
+  EventId,
+  IntentionalShutdownCause,
+  StoreDevtoolsChannel,
+} from '@livestore/common'
+import { UnexpectedError } from '@livestore/common'
+import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import { makeNoopTracer } from '@livestore/utils'
+import {
+  Cause,
+  Deferred,
+  Duration,
+  Effect,
+  Exit,
+  FiberSet,
+  Layer,
+  Logger,
+  LogLevel,
+  MutableHashMap,
+  OtelTracer,
+  Queue,
+  Runtime,
+  Scope,
+} from '@livestore/utils/effect'
+import * as otel from '@opentelemetry/api'
+
+import { globalReactivityGraph } from '../global-state.js'
+import type { ReactivityGraph } from '../reactiveQueries/base-class.js'
+import { connectDevtoolsToStore } from './devtools.js'
+import { Store } from './store.js'
+import type { BaseGraphQLContext, GraphQLOptions, OtelOptions } from './store-types.js'
+
+export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
+  schema: TSchema
+  adapter: Adapter
+  storeId: string
+  reactivityGraph?: ReactivityGraph
+  graphQLOptions?: GraphQLOptions<TGraphQLContext>
+  otelOptions?: Partial<OtelOptions>
+  boot?: (
+    store: Store<TGraphQLContext, TSchema>,
+    parentSpan: otel.Span,
+  ) => void | Promise<void> | Effect.Effect<void, unknown, otel.Tracer>
+  batchUpdates?: (run: () => void) => void
+  disableDevtools?: boolean
+  onBootStatus?: (status: BootStatus) => void
+}
+
+/** Create a new LiveStore Store */
+export const createStorePromise = async <
+  TGraphQLContext extends BaseGraphQLContext,
+  TSchema extends LiveStoreSchema = LiveStoreSchema,
+>({
+  signal,
+  ...options
+}: CreateStoreOptions<TGraphQLContext, TSchema> & { signal?: AbortSignal }): Promise<Store<TGraphQLContext, TSchema>> =>
+  Effect.gen(function* () {
+    const scope = yield* Scope.make()
+    const runtime = yield* Effect.runtime()
+
+    if (signal !== undefined) {
+      signal.addEventListener('abort', () => {
+        Scope.close(scope, Exit.void).pipe(Effect.tapCauseLogPretty, Runtime.runFork(runtime))
+      })
+    }
+
+    return yield* FiberSet.make().pipe(
+      Effect.andThen((fiberSet) => createStore({ ...options, fiberSet })),
+      Scope.extend(scope),
+    )
+  }).pipe(
+    Effect.withSpan('createStore'),
+    Effect.tapCauseLogPretty,
+    Effect.annotateLogs({ thread: 'window' }),
+    Effect.provide(Logger.pretty),
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.runPromise,
+  )
+
+export const createStore = <
+  TGraphQLContext extends BaseGraphQLContext,
+  TSchema extends LiveStoreSchema = LiveStoreSchema,
+>({
+  schema,
+  adapter,
+  storeId,
+  graphQLOptions,
+  otelOptions,
+  boot,
+  reactivityGraph = globalReactivityGraph,
+  batchUpdates,
+  disableDevtools,
+  onBootStatus,
+  fiberSet,
+}: CreateStoreOptions<TGraphQLContext, TSchema> & { fiberSet: FiberSet.FiberSet }): Effect.Effect<
+  Store<TGraphQLContext, TSchema>,
+  UnexpectedError,
+  Scope.Scope
+> => {
+  const otelTracer = otelOptions?.tracer ?? makeNoopTracer()
+  const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active()
+
+  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+    Layer.provide(Layer.sync(OtelTracer.Tracer, () => otelTracer)),
+  )
+
+  return Effect.gen(function* () {
+    const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
+
+    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+    yield* Queue.take(bootStatusQueue).pipe(
+      Effect.tapSync((status) => onBootStatus?.(status)),
+      Effect.tap((status) => (status.stage === 'done' ? Queue.shutdown(bootStatusQueue) : Effect.void)),
+      Effect.forever,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    const storeDeferred = yield* Deferred.make<Store>()
+
+    const connectDevtoolsToStore_ = (storeDevtoolsChannel: StoreDevtoolsChannel) =>
+      Effect.gen(function* () {
+        const store = yield* Deferred.await(storeDeferred)
+        yield* connectDevtoolsToStore({ storeDevtoolsChannel, store })
+      })
+
+    const runtime = yield* Effect.runtime<Scope.Scope>()
+
+    // TODO close parent scope? (Needs refactor with Mike Arnaldi)
+    const shutdown = (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) =>
+      Effect.gen(function* () {
+        // NOTE we're calling `cause.toString()` here to avoid triggering a `console.error` in the grouped log
+        const logCause =
+          Cause.isFailType(cause) && cause.error._tag === 'LiveStore.IntentionalShutdownCause'
+            ? cause.toString()
+            : cause
+        yield* Effect.logDebug(`Shutting down LiveStore`, logCause)
+
+        FiberSet.clear(fiberSet).pipe(
+          Effect.andThen(() => FiberSet.run(fiberSet, Effect.failCause(cause))),
+          Effect.timeout(Duration.seconds(1)),
+          Effect.logWarnIfTakesLongerThan({ label: '@livestore/livestore:shutdown:clear-fiber-set', duration: 500 }),
+          Effect.catchTag('TimeoutException', (err) =>
+            Effect.logError('Store shutdown timed out. Forcing shutdown.', err).pipe(
+              Effect.andThen(FiberSet.run(fiberSet, Effect.failCause(cause))),
+            ),
+          ),
+          Runtime.runFork(runtime), // NOTE we need to fork this separately otherwise it will also be interrupted
+        )
+      }).pipe(Effect.withSpan('livestore:shutdown'))
+
+    const clientSession: ClientSession = yield* adapter({
+      schema,
+      storeId,
+      devtoolsEnabled: disableDevtools !== true,
+      bootStatusQueue,
+      shutdown,
+      connectDevtoolsToStore: connectDevtoolsToStore_,
+    }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'))
+
+    // TODO fill up with unsynced mutation events from the client session
+    const unsyncedMutationEvents = MutableHashMap.empty<EventId, MutationEvent.ForSchema<TSchema>>()
+
+    const store = Store.createStore<TGraphQLContext, TSchema>(
+      {
+        clientSession,
+        schema,
+        graphQLOptions,
+        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+        reactivityGraph,
+        disableDevtools,
+        unsyncedMutationEvents,
+        fiberSet,
+        runtime,
+        // NOTE during boot we're not yet executing mutations in a batched context
+        // but only set the provided `batchUpdates` function after boot
+        batchUpdates: (run) => run(),
+        storeId,
+      },
+      span,
+    )
+
+    if (boot !== undefined) {
+      // TODO also incorporate `boot` function progress into `bootStatusQueue`
+      yield* Effect.tryAll(() => boot(store, span)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('createStore:boot'),
+      )
+    }
+
+    // NOTE it's important to yield here to allow the forked Effect in the store constructor to run
+    yield* Effect.yieldNow()
+
+    if (batchUpdates !== undefined) {
+      // Replacing the default batchUpdates function with the provided one after boot
+      store.reactivityGraph.context!.effectsWrapper = batchUpdates
+    }
+
+    yield* Deferred.succeed(storeDeferred, store as any as Store)
+
+    return store
+  }).pipe(
+    Effect.withSpan('createStore', {
+      parent: otelOptions?.rootSpanContext
+        ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext)!)
+        : undefined,
+    }),
+    Effect.provide(TracingLive),
+  )
+}

package/src/{store-devtools.ts → store/devtools.ts}

@@ -1,17 +1,17 @@
-import type { DebugInfo, StoreAdapter } from '@livestore/common'
+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'
+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 = {
-  adapter: StoreAdapter
+  clientSession: ClientSession
   reactivityGraph: ReactivityGraph
   syncDbWrapper: SynchronousDatabaseWrapper
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
@@ -29,7 +29,7 @@ export const connectDevtoolsToStore = ({
   store: IStore
 }) =>
   Effect.gen(function* () {
-    const appHostId = store.adapter.coordinator.devtools.appHostId
+    const appHostId = store.clientSession.coordinator.devtools.appHostId
 
     const reactivityGraphSubcriptions: SubMap = new Map()
     const liveQueriesSubscriptions: SubMap = new Map()
@@ -49,7 +49,7 @@ export const connectDevtoolsToStore = ({
     const onMessage = (decodedMessage: typeof Devtools.MessageToAppHostStore.Type) => {
       // console.log('storeMessagePort message', decodedMessage)
 
-      if (decodedMessage.appHostId !== store.adapter.coordinator.devtools.appHostId) {
+      if (decodedMessage.appHostId !== store.clientSession.coordinator.devtools.appHostId) {
         // console.log(`Unknown message`, event)
         return
       }

package/src/store/store-types.ts

@@ -0,0 +1,110 @@
+import type { ClientSession, EventId, IntentionalShutdownCause, UnexpectedError } from '@livestore/common'
+import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import type { FiberSet, MutableHashMap, Runtime, Scope } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
+import type * as otel from '@opentelemetry/api'
+import type { GraphQLSchema } from 'graphql'
+
+import type { DebugRefreshReasonBase } from '../reactive.js'
+import type { ReactivityGraph } from '../reactiveQueries/base-class.js'
+import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
+import type { StackInfo } from '../utils/stack-info.js'
+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
+}
+
+export type BaseGraphQLContext = {
+  queriedTables: Set<string>
+  /** Needed by Pothos Otel plugin for resolver tracing to work */
+  otelContext?: otel.Context
+}
+
+export type GraphQLOptions<TContext> = {
+  schema: GraphQLSchema
+  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer, sessionId: string) => TContext
+}
+
+export type OtelOptions = {
+  tracer: otel.Tracer
+  rootSpanContext: otel.Context
+}
+
+export type StoreOptions<
+  TGraphQLContext extends BaseGraphQLContext,
+  TSchema extends LiveStoreSchema = LiveStoreSchema,
+> = {
+  clientSession: ClientSession
+  schema: TSchema
+  storeId: string
+  // TODO remove graphql-related stuff from store and move to GraphQL query directly
+  graphQLOptions?: GraphQLOptions<TGraphQLContext>
+  otelOptions: OtelOptions
+  reactivityGraph: ReactivityGraph
+  disableDevtools?: boolean
+  fiberSet: FiberSet.FiberSet
+  runtime: Runtime.Runtime<Scope.Scope>
+  batchUpdates: (runUpdates: () => void) => void
+  unsyncedMutationEvents: MutableHashMap.MutableHashMap<EventId, MutationEvent.ForSchema<TSchema>>
+}
+
+export type RefreshReason =
+  | DebugRefreshReasonBase
+  | {
+      _tag: 'mutate'
+      /** The mutations that were applied */
+      mutations: ReadonlyArray<MutationEvent.Any>
+
+      /** The tables that were written to by the event */
+      writeTables: ReadonlyArray<string>
+    }
+  | {
+      // TODO rename to a more appropriate name which is framework-agnostic
+      _tag: 'react'
+      api: string
+      label?: string
+      stackInfo?: StackInfo
+    }
+  | { _tag: 'manual'; label?: string }
+
+export type QueryDebugInfo = {
+  _tag: 'graphql' | 'sql' | 'computed' | 'unknown'
+  label: string
+  query: string
+  durationMs: number
+}
+
+export type StoreOtel = {
+  tracer: otel.Tracer
+  mutationsSpanContext: otel.Context
+  queriesSpanContext: otel.Context
+}
+
+export type StoreMutateOptions = {
+  label?: string
+  skipRefresh?: boolean
+  wasSyncMessage?: boolean
+  /**
+   * When set to `false` the mutation won't be persisted in the mutation log and sync server (but still synced).
+   * This can be useful e.g. for fine-granular update events (e.g. position updates during drag & drop)
+   *
+   * @default true
+   */
+  persisted?: boolean
+}