@livestore/livestore 0.0.0-snapshot-6788a4cf00171a177a3a1e59cefc10f5bad71049 → 0.0.0-snapshot-783e1b05c962636b7bb28308b34f6cd9baf596e1

package/src/live-queries/__snapshots__/db-query.test.ts.snap

@@ -1,92 +1,5 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`otel > QueryBuilder subscription - async iterator 1`] = `
-{
-  "_name": "createStore",
-  "attributes": {
-    "debugInstanceId": "test",
-    "storeId": "default",
-  },
-  "children": [
-    {
-      "_name": "livestore.in-memory-db:execute",
-      "attributes": {
-        "sql.query": "
-      PRAGMA page_size=32768;
-      PRAGMA cache_size=10000;
-      PRAGMA synchronous='OFF';
-      PRAGMA temp_store='MEMORY';
-      PRAGMA foreign_keys='ON'; -- we want foreign key constraints to be enforced
-    ",
-      },
-    },
-    {
-      "_name": "@livestore/common:LeaderSyncProcessor:push",
-      "attributes": {
-        "batch": "undefined",
-        "batchSize": 1,
-      },
-    },
-    {
-      "_name": "client-session-sync-processor:pull",
-      "attributes": {
-        "code.stacktrace": "<STACKTRACE>",
-        "span.label": "⚠︎ Interrupted",
-        "status.interrupted": true,
-      },
-    },
-    {
-      "_name": "LiveStore:sync",
-    },
-    {
-      "_name": "LiveStore:commits",
-    },
-    {
-      "_name": "LiveStore:queries",
-    },
-  ],
-}
-`;
-
-exports[`otel > QueryBuilder subscription - async iterator 2`] = `
-[
-  {
-    "_name": "LiveStore:commit",
-    "attributes": {
-      "livestore.eventTags": "[
-  "todo.created"
-]",
-      "livestore.eventsCount": 1,
-    },
-    "children": [
-      {
-        "_name": "client-session-sync-processor:push",
-        "attributes": {
-          "batchSize": 1,
-          "eventCounts": "{
-  "todo.created": 1
-}",
-          "mergeResultTag": "advance",
-        },
-        "children": [
-          {
-            "_name": "client-session-sync-processor:materialize-event",
-            "children": [
-              {
-                "_name": "livestore.in-memory-db:execute",
-                "attributes": {
-                  "sql.query": "INSERT INTO 'todos' (id, text, completed) VALUES (?, ?, ?)",
-                },
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  },
-]
-`;
-
 exports[`otel > QueryBuilder subscription - basic functionality 1`] = `
 {
   "_name": "createStore",

package/src/live-queries/db-query.test.ts

@@ -289,53 +289,6 @@ Vitest.describe('otel', () => {
     ),
   )
 
-  Vitest.scopedLive('QueryBuilder subscription - async iterator', () =>
-    Effect.gen(function* () {
-      const { store, exporter, span, provider } = yield* makeQuery
-
-      const defaultTodo = { id: '', text: '', completed: false }
-
-      const queryBuilder = tables.todos
-        .where({ completed: false })
-        .first({ behaviour: 'fallback', fallback: () => defaultTodo })
-
-      yield* Effect.promise(async () => {
-        const iterator = store.subscribe(queryBuilder)
-
-        const initial = await iterator.next()
-        expect(initial.done).toBe(false)
-        expect(initial.value).toMatchObject(defaultTodo)
-
-        store.commit(events.todoCreated({ id: 't-async', text: 'write tests', completed: false }))
-
-        const update = await iterator.next()
-        expect(update.done).toBe(false)
-        expect(update.value).toMatchObject({
-          id: 't-async',
-          text: 'write tests',
-          completed: false,
-        })
-
-        const doneResult = await iterator.return()
-        expect(doneResult.done).toBe(true)
-      })
-
-      span.end()
-
-      return { exporter, provider }
-    }).pipe(
-      Effect.scoped,
-      Effect.tap(({ exporter, provider }) =>
-        Effect.promise(async () => {
-          await provider.forceFlush()
-          expect(getSimplifiedRootSpan(exporter, 'createStore', mapAttributes)).toMatchSnapshot()
-          expect(getAllSimplifiedRootSpans(exporter, 'LiveStore:commit', mapAttributes)).toMatchSnapshot()
-          await provider.shutdown()
-        }),
-      ),
-    ),
-  )
-
   Vitest.scopedLive('QueryBuilder subscription - direct table subscription', () =>
     Effect.gen(function* () {
       const { store, exporter, span, provider } = yield* makeQuery

package/src/mod.ts

@@ -37,13 +37,7 @@ export {
 export { emptyDebugInfo, SqliteDbWrapper } from './SqliteDbWrapper.ts'
 export { type CreateStoreOptions, createStore, createStorePromise } from './store/create-store.ts'
 export { Store } from './store/store.ts'
-export type {
-  OtelOptions,
-  QueryDebugInfo,
-  RefreshReason,
-  SubscribeOptions,
-  Unsubscribe,
-} from './store/store-types.ts'
+export type { OtelOptions, QueryDebugInfo, RefreshReason, Unsubscribe } from './store/store-types.ts'
 export {
   type LiveStoreContext,
   type LiveStoreContextRunning,

package/src/store/store-types.ts

@@ -14,7 +14,6 @@ import type { Effect, Runtime, Scope } from '@livestore/utils/effect'
 import { Deferred } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
-import type { LiveQuery } from '../live-queries/base-class.ts'
 import type { DebugRefreshReasonBase } from '../reactive.ts'
 import type { StackInfo } from '../utils/stack-info.ts'
 import type { Store } from './store.ts'
@@ -136,12 +135,3 @@ export type StoreEventsOptions<TSchema extends LiveStoreSchema> = {
 }
 
 export type Unsubscribe = () => void
-
-export type SubscribeOptions<TResult> = {
-  onSubscribe?: (query$: LiveQuery<TResult>) => void
-  onUnsubsubscribe?: () => void
-  label?: string
-  skipInitialRun?: boolean
-  otelContext?: otel.Context
-  stackInfo?: StackInfo
-}

package/src/store/store.ts

@@ -20,7 +20,7 @@ import {
   UnexpectedError,
 } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import { EventSequenceNumber, LiveStoreEvent, resolveEventDef, SystemTables } from '@livestore/common/schema'
+import { LiveStoreEvent, resolveEventDef, SystemTables } from '@livestore/common/schema'
 import { assertNever, isDevEnv, notYetImplemented, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
 import {
@@ -52,21 +52,16 @@ import type { Ref } from '../reactive.ts'
 import { SqliteDbWrapper } from '../SqliteDbWrapper.ts'
 import { ReferenceCountedSet } from '../utils/data-structures.ts'
 import { downloadBlob, exposeDebugUtils } from '../utils/dev.ts'
+import type { StackInfo } from '../utils/stack-info.ts'
 import type {
   RefreshReason,
   StoreCommitOptions,
   StoreEventsOptions,
   StoreOptions,
   StoreOtel,
-  SubscribeOptions,
   Unsubscribe,
 } from './store-types.ts'
 
-type SubscribeQuery<TResult> =
-  | LiveQueryDef<TResult, 'def' | 'signal-def'>
-  | LiveQuery<TResult>
-  | QueryBuilder<TResult, any, any>
-
 if (isDevEnv()) {
   exposeDebugUtils()
 }
@@ -354,125 +349,98 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
   }
 
   /**
-   * Subscribe to the results of a query.
-   *
-   * - When providing an `onUpdate` callback it returns an {@link Unsubscribe} function.
-   * - Without a callback it returns an {@link AsyncIterable} that yields query results.
+   * Subscribe to the results of a query
+   * Returns a function to cancel the subscription.
    *
    * @example
    * ```ts
    * const unsubscribe = store.subscribe(query$, (result) => console.log(result))
    * ```
-   *
-   * @example
-   * ```ts
-   * for await (const result of store.subscribe(query$)) {
-   *   console.log(result)
-   * }
-   * ```
    */
-  subscribe: {
-    <TResult>(
-      query: SubscribeQuery<TResult>,
-      onUpdate: (value: TResult) => void,
-      options?: SubscribeOptions<TResult>,
-    ): Unsubscribe
-    <TResult>(query: SubscribeQuery<TResult>, options?: SubscribeOptions<TResult>): AsyncIterableIterator<TResult>
-  } = <TResult>(
-    query: SubscribeQuery<TResult>,
-    onUpdateOrOptions?: ((value: TResult) => void) | SubscribeOptions<TResult>,
-    maybeOptions?: SubscribeOptions<TResult>,
-  ): Unsubscribe | AsyncIterableIterator<TResult> => {
-    if (typeof onUpdateOrOptions === 'function') {
-      const onUpdate = onUpdateOrOptions
-      const options = maybeOptions
-
-      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,
-        (span) => {
-          // console.debug('store sub', query$.id, query$.label)
-          const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-          const queryRcRef = isQueryBuilder(query)
-            ? queryDb(query).make(this.reactivityGraph.context!)
-            : query._tag === 'def' || query._tag === 'signal-def'
-              ? query.make(this.reactivityGraph.context!)
-              : {
-                  value: query as LiveQuery<TResult>,
-                  deref: () => {},
-                }
-          const query$ = queryRcRef.value
+  subscribe = <TResult>(
+    query: LiveQueryDef<TResult, 'def' | 'signal-def'> | LiveQuery<TResult> | QueryBuilder<TResult, any, any>,
+    /** Called when the query result has changed */
+    onUpdate: (value: TResult) => void,
+    options?: {
+      onSubscribe?: (query$: LiveQuery<TResult>) => void
+      /** Gets called after the query subscription has been removed */
+      onUnsubsubscribe?: () => void
+      label?: string
+      /**
+       * Skips the initial `onUpdate` callback
+       * @default false
+       */
+      skipInitialRun?: boolean
+      otelContext?: otel.Context
+      /** If provided, the stack info will be added to the `activeSubscriptions` set of the query */
+      stackInfo?: StackInfo
+    },
+  ): Unsubscribe => {
+    this.checkShutdown('subscribe')
 
-          const label = `subscribe:${options?.label}`
-          const effect = this.reactivityGraph.makeEffect(
-            (get, _otelContext, debugRefreshReason) => onUpdate(get(query$.results$, otelContext, debugRefreshReason)),
-            { label },
-          )
+    return this.otel.tracer.startActiveSpan(
+      `LiveStore.subscribe`,
+      { attributes: { label: options?.label, queryLabel: isQueryBuilder(query) ? query.toString() : query.label } },
+      options?.otelContext ?? this.otel.queriesSpanContext,
+      (span) => {
+        // console.debug('store sub', query$.id, query$.label)
+        const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-          if (options?.stackInfo) {
-            query$.activeSubscriptions.add(options.stackInfo)
-          }
+        const queryRcRef = isQueryBuilder(query)
+          ? queryDb(query).make(this.reactivityGraph.context!)
+          : query._tag === 'def' || query._tag === 'signal-def'
+            ? query.make(this.reactivityGraph.context!)
+            : {
+                value: query as LiveQuery<TResult>,
+                deref: () => {},
+              }
+        const query$ = queryRcRef.value
 
-          options?.onSubscribe?.(query$)
+        const label = `subscribe:${options?.label}`
+        const effect = this.reactivityGraph.makeEffect(
+          (get, _otelContext, debugRefreshReason) => onUpdate(get(query$.results$, otelContext, debugRefreshReason)),
+          { label },
+        )
 
-          this.activeQueries.add(query$ as LiveQuery<TResult>)
+        if (options?.stackInfo) {
+          query$.activeSubscriptions.add(options.stackInfo)
+        }
 
-          // Running effect right away to get initial value (unless `skipInitialRun` is set)
-          if (options?.skipInitialRun !== true && !query$.isDestroyed) {
-            effect.doEffect(otelContext, {
-              _tag: 'subscribe.initial',
-              label: `subscribe-initial-run:${options?.label}`,
-            })
-          }
+        options?.onSubscribe?.(query$)
 
-          const unsubscribe = () => {
-            // console.debug('store unsub', query$.id, query$.label)
-            try {
-              this.reactivityGraph.destroyNode(effect)
-              this.activeQueries.remove(query$ as LiveQuery<TResult>)
+        this.activeQueries.add(query$ as LiveQuery<TResult>)
 
-              if (options?.stackInfo) {
-                query$.activeSubscriptions.delete(options.stackInfo)
-              }
+        // Running effect right away to get initial value (unless `skipInitialRun` is set)
+        if (options?.skipInitialRun !== true && !query$.isDestroyed) {
+          effect.doEffect(otelContext, { _tag: 'subscribe.initial', label: `subscribe-initial-run:${options?.label}` })
+        }
 
-              queryRcRef.deref()
+        const unsubscribe = () => {
+          // console.debug('store unsub', query$.id, query$.label)
+          try {
+            this.reactivityGraph.destroyNode(effect)
+            this.activeQueries.remove(query$ as LiveQuery<TResult>)
 
-              options?.onUnsubsubscribe?.()
-            } finally {
-              span.end()
+            if (options?.stackInfo) {
+              query$.activeSubscriptions.delete(options.stackInfo)
             }
-          }
 
-          return unsubscribe
-        },
-      )
-    }
-
-    return this.subscribeAsAsyncIterator(query, onUpdateOrOptions)
-  }
+            queryRcRef.deref()
 
-  private subscribeAsAsyncIterator = <TResult>(
-    query: SubscribeQuery<TResult>,
-    options?: SubscribeOptions<TResult>,
-  ): AsyncIterableIterator<TResult> => {
-    this.checkShutdown('subscribe')
-
-    const iterator = Stream.toAsyncIterable(this.subscribeStream(query, options))[Symbol.asyncIterator]()
+            options?.onUnsubsubscribe?.()
+          } finally {
+            span.end()
+          }
+        }
 
-    return Object.assign(iterator, {
-      [Symbol.asyncIterator]() {
-        return this
+        return unsubscribe
       },
-    })
+    )
   }
 
   subscribeStream = <TResult>(
-    query: SubscribeQuery<TResult>,
-    options?: SubscribeOptions<TResult>,
+    query$: LiveQueryDef<TResult>,
+    options?: { label?: string; skipInitialRun?: boolean } | undefined,
   ): Stream.Stream<TResult> =>
     Stream.asyncPush<TResult>((emit) =>
       Effect.gen(this, function* () {
@@ -483,10 +451,11 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
         yield* Effect.acquireRelease(
           Effect.sync(() =>
-            this.subscribe(query, (result) => emit.single(result), {
-              ...(options ?? {}),
-              otelContext,
-            }),
+            this.subscribe(
+              query$,
+              (result) => emit.single(result),
+              omitUndefineds({ otelContext, label: options?.label }),
+            ),
           ),
           (unsub) => Effect.sync(() => unsub()),
         )
@@ -886,14 +855,11 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       Effect.gen(this, function* () {
         const session = yield* this.syncProcessor.syncState
         yield* Effect.log(
-          `Session sync state: ${EventSequenceNumber.toString(session.localHead)} (upstream: ${EventSequenceNumber.toString(session.upstreamHead)})`,
+          `Session sync state: ${session.localHead} (upstream: ${session.upstreamHead})`,
           session.toJSON(),
         )
         const leader = yield* this.clientSession.leaderThread.getSyncState
-        yield* Effect.log(
-          `Leader sync state: ${EventSequenceNumber.toString(leader.localHead)} (upstream: ${EventSequenceNumber.toString(leader.upstreamHead)})`,
-          leader.toJSON(),
-        )
+        yield* Effect.log(`Leader sync state: ${leader.localHead} (upstream: ${leader.upstreamHead})`, leader.toJSON())
       }).pipe(this.runEffectFork)
     },