@livestore/livestore 0.3.2-dev.1 → 0.3.2-dev.11

package/src/store/store.ts

@@ -22,7 +22,18 @@ import type { LiveStoreSchema } from '@livestore/common/schema'
 import { getEventDef, LiveStoreEvent, SystemTables } from '@livestore/common/schema'
 import { assertNever, isDevEnv, notYetImplemented } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
-import { Cause, Effect, Fiber, Inspectable, Option, OtelTracer, Runtime, Schema, Stream } from '@livestore/utils/effect'
+import {
+  Cause,
+  Effect,
+  Exit,
+  Fiber,
+  Inspectable,
+  Option,
+  OtelTracer,
+  Runtime,
+  Schema,
+  Stream,
+} from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
@@ -54,7 +65,7 @@ if (isDevEnv()) {
   exposeDebugUtils()
 }
 
-export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}> extends Inspectable.Class {
+export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TContext = {}> extends Inspectable.Class {
   readonly storeId: string
   reactivityGraph: ReactivityGraph
   sqliteDbWrapper: SqliteDbWrapper
@@ -68,6 +79,9 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    */
   tableRefs: { [key: string]: Ref<null, ReactivityGraphContext, RefreshReason> }
 
+  /** Tracks whether the store has been shut down */
+  private isShutdown = false
+
   private effectContext: {
     runtime: Runtime.Runtime<Scope.Scope>
     lifetimeScope: Scope.Scope
@@ -282,6 +296,15 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
     return this.clientSession.clientId
   }
 
+  private checkShutdown = (operation: string): void => {
+    if (this.isShutdown) {
+      throw new UnexpectedError({
+        cause: `Store has been shut down (while performing "${operation}").`,
+        note: `You cannot perform this operation after the store has been shut down.`,
+      })
+    }
+  }
+
   /**
    * Subscribe to the results of a query
    * Returns a function to cancel the subscription.
@@ -309,8 +332,10 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       /** If provided, the stack info will be added to the `activeSubscriptions` set of the query */
       stackInfo?: StackInfo
     },
-  ): Unsubscribe =>
-    this.otel.tracer.startActiveSpan(
+  ): Unsubscribe => {
+    this.checkShutdown('subscribe')
+
+    return this.otel.tracer.startActiveSpan(
       `LiveStore.subscribe`,
       { attributes: { label: options?.label, queryLabel: isQueryBuilder(query) ? query.toString() : query.label } },
       options?.otelContext ?? this.otel.queriesSpanContext,
@@ -369,6 +394,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
         return unsubscribe
       },
     )
+  }
 
   subscribeStream = <TResult>(
     query$: LiveQueryDef<TResult>,
@@ -417,6 +443,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       | { query: string; bindValues: Bindable; schema?: Schema.Schema<TResult> },
     options?: { otelContext?: otel.Context; debugRefreshReason?: RefreshReason },
   ): TResult => {
+    this.checkShutdown('query')
+
     if (typeof query === 'object' && 'query' in query && 'bindValues' in query) {
       const res = this.sqliteDbWrapper.cachedSelect(query.query, prepareBindValues(query.bindValues, query.query), {
         otelContext: options?.otelContext,
@@ -438,6 +466,12 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
 
       const sqlRes = query.asSql()
       const schema = getResultSchema(query)
+
+      // Replace SessionIdSymbol in bind values before executing the query
+      if (sqlRes.bindValues) {
+        replaceSessionIdSymbol(sqlRes.bindValues, this.clientSession.sessionId)
+      }
+
       const rawRes = this.sqliteDbWrapper.cachedSelect(sqlRes.query, sqlRes.bindValues as any as PreparedBindValues, {
         otelContext: options?.otelContext,
         queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
@@ -473,6 +507,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * ```
    */
   setSignal = <T>(signalDef: SignalDef<T>, value: T | ((prev: T) => T)): void => {
+    this.checkShutdown('setSignal')
+
     const signalRef = signalDef.make(this.reactivityGraph.context!)
     const newValue: T = typeof value === 'function' ? (value as any)(signalRef.value.get()) : value
     signalRef.value.set(newValue)
@@ -557,6 +593,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       ) => void,
     ): void
   } = (firstEventOrTxnFnOrOptions: any, ...restEvents: any[]) => {
+    this.checkShutdown('commit')
+
     const { events, options } = this.getCommitArgs(firstEventOrTxnFnOrOptions, restEvents)
 
     for (const event of events) {
@@ -660,10 +698,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * ```
    */
   events = (_options?: StoreEventsOptions<TSchema>): AsyncIterable<LiveStoreEvent.ForSchema<TSchema>> => {
+    this.checkShutdown('events')
+
     return notYetImplemented(`store.events() is not yet implemented but planned soon`)
   }
 
   eventsStream = (_options?: StoreEventsOptions<TSchema>): Stream.Stream<LiveStoreEvent.ForSchema<TSchema>> => {
+    this.checkShutdown('eventsStream')
+
     return notYetImplemented(`store.eventsStream() is not yet implemented but planned soon`)
   }
 
@@ -672,6 +714,8 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * We might need a better solution for this. Let's see.
    */
   manualRefresh = (options?: { label?: string }) => {
+    this.checkShutdown('manualRefresh')
+
     const { label } = options ?? {}
     this.otel.tracer.startActiveSpan(
       'LiveStore:manualRefresh',
@@ -690,10 +734,25 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    *
    * This is called automatically when the store was created using the React or Effect API.
    */
-  shutdown = async (cause?: Cause.Cause<UnexpectedError>) => {
-    await this.clientSession
-      .shutdown(cause ?? Cause.fail(IntentionalShutdownCause.make({ reason: 'manual' })))
-      .pipe(this.runEffectFork, Fiber.join, Effect.runPromise)
+  shutdownPromise = async (cause?: UnexpectedError) => {
+    this.checkShutdown('shutdownPromise')
+
+    this.isShutdown = true
+    await this.shutdown(cause ? Cause.fail(cause) : undefined).pipe(this.runEffectFork, Fiber.join, Effect.runPromise)
+  }
+
+  /**
+   * Shuts down the store and closes the client session.
+   *
+   * This is called automatically when the store was created using the React or Effect API.
+   */
+  shutdown = (cause?: Cause.Cause<UnexpectedError>): Effect.Effect<void> => {
+    this.checkShutdown('shutdown')
+
+    this.isShutdown = true
+    return this.clientSession.shutdown(
+      cause ? Exit.failCause(cause) : Exit.succeed(IntentionalShutdownCause.make({ reason: 'manual' })),
+    )
   }
 
   /**

package/src/utils/dev.ts

@@ -1,4 +1,5 @@
-import { isDevEnv } from '@livestore/utils'
+import type { SqliteDb } from '@livestore/common'
+import { prettyBytes } from '@livestore/utils'
 import { Effect } from '@livestore/utils/effect'
 
 export const downloadBlob = (
@@ -26,11 +27,17 @@ export const downloadURL = (data: string, fileName: string) => {
 }
 
 export const exposeDebugUtils = () => {
-  if (isDevEnv()) {
-    globalThis.__debugLiveStoreUtils = {
-      downloadBlob,
-      runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
-      runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
-    }
+  globalThis.__debugLiveStoreUtils = {
+    downloadBlob,
+    runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
+    runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
+    dumpDb: (db: SqliteDb) => {
+      const tables = db.select<{ name: string }>(`SELECT name FROM sqlite_master WHERE type='table'`)
+      for (const table of tables) {
+        const rows = db.select<any>(`SELECT * FROM ${table.name}`)
+        console.log(`Table: ${table.name} (${prettyBytes(table.name.length)}, ${rows.length} rows)`)
+        console.table(rows)
+      }
+    },
   }
 }

package/src/utils/tests/fixture.ts

@@ -1,6 +1,6 @@
 import { makeInMemoryAdapter } from '@livestore/adapter-web'
 import { provideOtel } from '@livestore/common'
-import { createStore, makeSchema, State } from '@livestore/livestore'
+import { createStore, Events, makeSchema, State } from '@livestore/livestore'
 import { Effect, Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
@@ -37,8 +37,23 @@ export const app = State.SQLite.clientDocument({
 
 export const tables = { todos, app }
 
-export const state = State.SQLite.makeState({ tables, materializers: {} })
-export const schema = makeSchema({ state, events: {} })
+export const events = {
+  todoCreated: Events.synced({
+    name: 'todo.created',
+    schema: Schema.Struct({
+      id: Schema.String,
+      text: Schema.String,
+      completed: Schema.Boolean,
+    }),
+  }),
+}
+
+const materializers = State.SQLite.materializers(events, {
+  'todo.created': ({ id, text, completed }) => tables.todos.insert({ id, text, completed }),
+})
+
+export const state = State.SQLite.makeState({ tables, materializers })
+export const schema = makeSchema({ state, events })
 
 export const makeTodoMvc = ({
   otelTracer,