@livestore/livestore 0.0.0-snapshot-df546e17f0470b8f4f9bd33aad8c4fca65ec6355 → 0.0.0-snapshot-3b921bf0919e38fd218b5ef2926920c8c4806157

package/src/reactiveQueries/base-class.ts

@@ -2,7 +2,8 @@ import type { QueryInfo, QueryInfoNone } from '@livestore/common'
 import type * as otel from '@opentelemetry/api'
 
 import { type Atom, type GetAtom, ReactiveGraph, throwContextNotSetError, type Thunk } from '../reactive.js'
-import type { QueryDebugInfo, RefreshReason, Store } from '../store.js'
+import type { Store } from '../store/store.js'
+import type { QueryDebugInfo, RefreshReason } from '../store/store-types.js'
 import type { StackInfo } from '../utils/stack-info.js'
 
 export type ReactivityGraph = ReactiveGraph<RefreshReason, QueryDebugInfo, QueryContext>
@@ -28,7 +29,7 @@ export type LiveQueryAny = LiveQuery<any, QueryInfo>
 
 export interface LiveQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> {
   id: number
-  _tag: 'js' | 'sql' | 'graphql'
+  _tag: 'computed' | 'sql' | 'graphql'
 
   /** This should only be used on a type-level and doesn't hold any value during runtime */
   '__result!': TResult
@@ -64,7 +65,7 @@ export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
 {
   '__result!'!: TResult
   id = queryIdCounter++
-  abstract _tag: 'js' | 'sql' | 'graphql'
+  abstract _tag: 'computed' | 'sql' | 'graphql'
 
   /** Human-readable label for the query for debugging */
   abstract label: string

package/src/reactiveQueries/{js.ts → computed.ts}

@@ -3,7 +3,7 @@ import * as otel from '@opentelemetry/api'
 
 import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } 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'
@@ -27,7 +27,7 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
   TResult,
   TQueryInfo
 > {
-  _tag: 'js' = 'js'
+  _tag: 'computed' = 'computed'
 
   /** A reactive thunk representing the query results */
   results$: Thunk<TResult, QueryContext, RefreshReason>
@@ -82,7 +82,7 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
 
           this.executionTimes.push(durationMs)
 
-          setDebugInfo({ _tag: 'js', label, query: fn.toString(), durationMs })
+          setDebugInfo({ _tag: 'computed', label, query: fn.toString(), durationMs })
 
           return res
         }),

package/src/reactiveQueries/graphql.ts

@@ -7,7 +7,8 @@ import * as graphql from 'graphql'
 
 import { globalReactivityGraph } from '../global-state.js'
 import { isThunk, type Thunk } from '../reactive.js'
-import type { BaseGraphQLContext, RefreshReason, Store } from '../store.js'
+import type { Store } from '../store/store.js'
+import type { BaseGraphQLContext, 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'

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'
@@ -105,7 +105,7 @@ export class LiveStoreSQLQuery<
           const startMs = performance.now()
           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

@@ -14,9 +14,9 @@ import type {
   QueryContext,
   ReactivityGraph,
 } from './reactiveQueries/base-class.js'
-import { computed } from './reactiveQueries/js.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

package/src/store/create-store.ts

@@ -0,0 +1,296 @@
+import type {
+  Adapter,
+  BootDb,
+  BootStatus,
+  ClientSession,
+  EventId,
+  IntentionalShutdownCause,
+  PreparedBindValues,
+  StoreDevtoolsChannel,
+} from '@livestore/common'
+import { getExecArgsFromMutation, replaceSessionIdSymbol, UnexpectedError } from '@livestore/common'
+import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import { makeMutationEventSchemaMemo } from '@livestore/common/schema'
+import { makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
+import {
+  Cause,
+  Data,
+  Deferred,
+  Duration,
+  Effect,
+  Exit,
+  FiberSet,
+  Layer,
+  Logger,
+  LogLevel,
+  MutableHashMap,
+  OtelTracer,
+  Queue,
+  Runtime,
+  Schema,
+  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?: (db: BootDb, 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,
+  )
+
+// #region createStore
+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>()
+
+    const runEffectFork = (effect: Effect.Effect<any, any, never>) =>
+      effect.pipe(Effect.tapCauseLogPretty, FiberSet.run(fiberSet), Runtime.runFork(runtime))
+
+    // TODO close parent scope? (Needs refactor with Mike A)
+    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'))
+
+    const mutationEventSchema = makeMutationEventSchemaMemo(schema)
+
+    // TODO get rid of this
+    // const __processedMutationIds = new Set<number>()
+
+    const currentMutationEventIdRef = { current: yield* clientSession.coordinator.getCurrentMutationEventId }
+
+    // TODO fill up with unsynced mutation events from the coordinator
+    const unsyncedMutationEvents = MutableHashMap.empty<EventId, MutationEvent.ForSchema<TSchema>>()
+
+    // TODO consider moving booting into the clientSession
+    if (boot !== undefined) {
+      let isInTxn = false
+      let txnExecuteStmnts: [string, PreparedBindValues | undefined][] = []
+
+      const bootDbImpl: BootDb = {
+        _tag: 'BootDb',
+        execute: (queryStr, bindValues) => {
+          const stmt = clientSession.syncDb.prepare(queryStr)
+          stmt.execute(bindValues)
+
+          if (isInTxn === true) {
+            txnExecuteStmnts.push([queryStr, bindValues])
+          } else {
+            clientSession.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
+          }
+        },
+        mutate: (...list) => {
+          for (const mutationEventDecoded_ of list) {
+            const mutationDef =
+              schema.mutations.get(mutationEventDecoded_.mutation) ??
+              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
+
+            const { id, parentId } = clientSession.coordinator
+              .nextMutationEventIdPair({ localOnly: mutationDef.options.localOnly })
+              .pipe(Effect.runSync)
+
+            currentMutationEventIdRef.current = id
+
+            const mutationEventDecoded = { ...mutationEventDecoded_, id, parentId }
+
+            replaceSessionIdSymbol(mutationEventDecoded.args, clientSession.coordinator.sessionId)
+
+            MutableHashMap.set(unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
+
+            // __processedMutationIds.add(mutationEventDecoded.id.global)
+
+            const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+            // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+            for (const { statementSql, bindValues } of execArgsArr) {
+              clientSession.syncDb.execute(statementSql, bindValues)
+            }
+
+            const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded)
+
+            clientSession.coordinator
+              .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: true })
+              .pipe(runEffectFork)
+          }
+        },
+        select: (queryStr, bindValues) => {
+          const stmt = clientSession.syncDb.prepare(queryStr)
+          return stmt.select(bindValues)
+        },
+        txn: (callback) => {
+          try {
+            isInTxn = true
+            // clientSession.syncDb.execute('BEGIN TRANSACTION', undefined)
+
+            callback()
+
+            // clientSession.syncDb.execute('COMMIT', undefined)
+
+            // clientSession.coordinator.execute('BEGIN', undefined, undefined)
+            for (const [queryStr, bindValues] of txnExecuteStmnts) {
+              clientSession.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
+            }
+            // clientSession.coordinator.execute('COMMIT', undefined, undefined)
+          } catch (e: any) {
+            // clientSession.syncDb.execute('ROLLBACK', undefined)
+            throw e
+          } finally {
+            isInTxn = false
+            txnExecuteStmnts = []
+          }
+        },
+      }
+
+      yield* Effect.tryAll(() => boot(bootDbImpl, span)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('createStore:boot'),
+      )
+    }
+
+    const store = Store.createStore<TGraphQLContext, TSchema>(
+      {
+        clientSession,
+        schema,
+        graphQLOptions,
+        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+        reactivityGraph,
+        disableDevtools,
+        currentMutationEventIdRef,
+        unsyncedMutationEvents,
+        fiberSet,
+        runtime,
+        batchUpdates: batchUpdates ?? ((run) => run()),
+        storeId,
+      },
+      span,
+    )
+
+    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),
+  )
+}
+// #endregion createStore

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

@@ -4,11 +4,11 @@ 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 = {
   clientSession: ClientSession

package/src/store/store-types.ts

@@ -0,0 +1,111 @@
+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
+  currentMutationEventIdRef: { current: EventId }
+  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
+}