@livestore/livestore 0.3.1-dev.0 → 0.3.2-dev.0

package/src/reactive.ts

@@ -279,7 +279,7 @@ export class ReactiveGraph<
             return compute(atom, otelContext, debugRefreshReason)
           }
 
-          let debugInfo: TDebugThunkInfo | undefined = undefined
+          let debugInfo: TDebugThunkInfo | undefined 
           const setDebugInfo = (debugInfo_: TDebugThunkInfo) => {
             debugInfo = debugInfo_
           }

package/src/store/create-store.ts

@@ -38,7 +38,7 @@ import type {
 } from './store-types.js'
 
 export const DEFAULT_PARAMS = {
-  leaderPushBatchSize: 1,
+  leaderPushBatchSize: 100,
 }
 
 export class LiveStoreContextRunning extends Context.Tag('@livestore/livestore/effect/LiveStoreContextRunning')<

package/src/store/devtools.ts

@@ -52,10 +52,10 @@ export const connectDevtoolsToStore = ({
 
     yield* Effect.addFinalizer(() =>
       Effect.sync(() => {
-        reactivityGraphSubcriptions.forEach((unsub) => unsub())
-        liveQueriesSubscriptions.forEach((unsub) => unsub())
-        debugInfoHistorySubscriptions.forEach((unsub) => unsub())
-        syncHeadClientSessionSubscriptions.forEach((unsub) => unsub())
+        for (const unsub of reactivityGraphSubcriptions.values()) unsub()
+        for (const unsub of liveQueriesSubscriptions.values()) unsub()
+        for (const unsub of debugInfoHistorySubscriptions.values()) unsub()
+        for (const unsub of syncHeadClientSessionSubscriptions.values()) unsub()
       }),
     )
 
@@ -202,7 +202,7 @@ export const connectDevtoolsToStore = ({
         }
         case 'LSD.ClientSession.DebugInfoRerunQueryReq': {
           const { queryStr, bindValues, queriedTables } = decodedMessage
-          store.sqliteDbWrapper.select(queryStr, bindValues, { queriedTables, skipCache: true })
+          store.sqliteDbWrapper.cachedSelect(queryStr, bindValues, { queriedTables, skipCache: true })
           sendToDevtools(
             Devtools.ClientSession.DebugInfoRerunQueryRes.make({ requestId, clientId, sessionId, liveStoreVersion }),
           )

package/src/store/store.ts

@@ -1,29 +1,28 @@
-import type {
-  ClientSession,
-  ClientSessionSyncProcessor,
-  ParamsObject,
-  PreparedBindValues,
-  QueryBuilder,
-  UnexpectedError,
-} from '@livestore/common'
 import {
+  type Bindable,
+  type ClientSession,
+  type ClientSessionSyncProcessor,
   Devtools,
   getDurationMsFromSpan,
-  getExecArgsFromEvent,
+  getExecStatementsFromMaterializer,
   getResultSchema,
+  hashMaterializerResults,
   IntentionalShutdownCause,
   isQueryBuilder,
   liveStoreVersion,
   makeClientSessionSyncProcessor,
+  type PreparedBindValues,
   prepareBindValues,
+  type QueryBuilder,
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
+  UnexpectedError,
 } from '@livestore/common'
 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, OtelTracer, Runtime, Schema, Stream } from '@livestore/utils/effect'
+import { Cause, Effect, Fiber, Inspectable, Option, OtelTracer, Runtime, Schema, Stream } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
@@ -36,6 +35,7 @@ import type {
 } from '../live-queries/base-class.js'
 import { makeReactivityGraph } from '../live-queries/base-class.js'
 import { makeExecBeforeFirstRun } from '../live-queries/client-document-get-query.js'
+import { queryDb } from '../live-queries/db-query.js'
 import type { Ref } from '../reactive.js'
 import { SqliteDbWrapper } from '../SqliteDbWrapper.js'
 import { ReferenceCountedSet } from '../utils/data-structures.js'
@@ -114,16 +114,33 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       schema,
       clientSession,
       runtime: effectContext.runtime,
-      materializeEvent: (eventDecoded, { otelContext, withChangeset }) => {
+      materializeEvent: (eventDecoded, { otelContext, withChangeset, materializerHashLeader }) => {
         const { eventDef, materializer } = getEventDef(schema, eventDecoded.name)
 
-        const execArgsArr = getExecArgsFromEvent({
+        const execArgsArr = getExecStatementsFromMaterializer({
           eventDef,
           materializer,
-          db: this.sqliteDbWrapper,
+          dbState: this.sqliteDbWrapper,
           event: { decoded: eventDecoded, encoded: undefined },
         })
 
+        const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+
+        if (
+          materializerHashLeader._tag === 'Some' &&
+          materializerHash._tag === 'Some' &&
+          materializerHashLeader.value !== materializerHash.value
+        ) {
+          void this.shutdown(
+            Cause.fail(
+              UnexpectedError.make({
+                cause: `Materializer hash mismatch detected for event "${eventDecoded.name}".`,
+                note: `Please make sure your event materializer is a pure function without side effects.`,
+              }),
+            ),
+          )
+        }
+
         const writeTablesForEvent = new Set<string>()
 
         const exec = () => {
@@ -132,12 +149,21 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
             bindValues,
             writeTables = this.sqliteDbWrapper.getTablesUsed(statementSql),
           } of execArgsArr) {
-            this.sqliteDbWrapper.execute(statementSql, bindValues, { otelContext, writeTables })
+            try {
+              this.sqliteDbWrapper.cachedExecute(statementSql, bindValues, { otelContext, writeTables })
+            } catch (cause) {
+              throw UnexpectedError.make({
+                cause,
+                note: `Error executing materializer for event "${eventDecoded.name}".\nStatement: ${statementSql}\nBind values: ${JSON.stringify(bindValues)}`,
+              })
+            }
 
             // durationMsTotal += durationMs
             for (const table of writeTables) {
               writeTablesForEvent.add(table)
             }
+
+            this.sqliteDbWrapper.debug.head = eventDecoded.seqNum
           }
         }
 
@@ -145,13 +171,14 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
           | { _tag: 'sessionChangeset'; data: Uint8Array; debug: any }
           | { _tag: 'no-op' }
           | { _tag: 'unset' } = { _tag: 'unset' }
+
         if (withChangeset === true) {
           sessionChangeset = this.sqliteDbWrapper.withChangeset(exec).changeset
         } else {
           exec()
         }
 
-        return { writeTables: writeTablesForEvent, sessionChangeset }
+        return { writeTables: writeTablesForEvent, sessionChangeset, materializerHash }
       },
       rollback: (changeset) => {
         this.sqliteDbWrapper.rollback(changeset)
@@ -264,7 +291,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
    * ```
    */
   subscribe = <TResult>(
-    query: LiveQueryDef<TResult, 'def' | 'signal-def'> | LiveQuery<TResult>,
+    query: LiveQueryDef<TResult, 'def' | 'signal-def'> | LiveQuery<TResult> | QueryBuilder<TResult, any, any>,
     options: {
       /** Called when the query result has changed */
       onUpdate: (value: TResult) => void
@@ -284,14 +311,15 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
   ): Unsubscribe =>
     this.otel.tracer.startActiveSpan(
       `LiveStore.subscribe`,
-      { attributes: { label: options?.label, queryLabel: query.label } },
+      { 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 =
-          query._tag === 'def' || query._tag === 'signal-def'
+        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>,
@@ -385,13 +413,17 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       | LiveQuery<TResult>
       | LiveQueryDef<TResult>
       | SignalDef<TResult>
-      | { query: string; bindValues: ParamsObject },
+      | { query: string; bindValues: Bindable; schema?: Schema.Schema<TResult> },
     options?: { otelContext?: otel.Context; debugRefreshReason?: RefreshReason },
   ): TResult => {
     if (typeof query === 'object' && 'query' in query && 'bindValues' in query) {
-      return this.sqliteDbWrapper.select(query.query, prepareBindValues(query.bindValues, query.query), {
+      const res = this.sqliteDbWrapper.cachedSelect(query.query, prepareBindValues(query.bindValues, query.query), {
         otelContext: options?.otelContext,
       }) as any
+      if (query.schema) {
+        return Schema.decodeSync(query.schema)(res)
+      }
+      return res
     } else if (isQueryBuilder(query)) {
       const ast = query[QueryBuilderAstSymbol]
       if (ast._tag === 'RowQuery') {
@@ -405,7 +437,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
 
       const sqlRes = query.asSql()
       const schema = getResultSchema(query)
-      const rawRes = this.sqliteDbWrapper.select(sqlRes.query, sqlRes.bindValues as any as PreparedBindValues, {
+      const rawRes = this.sqliteDbWrapper.cachedSelect(sqlRes.query, sqlRes.bindValues as any as PreparedBindValues, {
         otelContext: options?.otelContext,
         queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
       })
@@ -558,12 +590,12 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
         try {
+          // Materialize events to state
           const { writeTables } = (() => {
             try {
               const materializeEvents = () => this.syncProcessor.push(events, { otelContext })
 
               if (events.length > 1) {
-                // TODO: what to do about leader transaction here?
                 return this.sqliteDbWrapper.txn(materializeEvents)
               } else {
                 return materializeEvents()

package/src/utils/stack-info.test.ts

@@ -19,7 +19,9 @@ Error
 
   const stackInfo = extractStackInfoFromStackTrace(stackTrace)
   // Replacing file paths for snapshot testing as they are not stable
-  stackInfo.frames.forEach((_) => (_.filePath = '__REPLACED_FOR_SNAPSHOT__'))
+  stackInfo.frames.forEach((_) => {
+    _.filePath = '__REPLACED_FOR_SNAPSHOT__'
+  })
   expect(stackInfo).toMatchInlineSnapshot(`
     {
       "frames": [
@@ -61,7 +63,9 @@ Error
 
   const stackInfo = extractStackInfoFromStackTrace(stackTrace)
   // Replacing file paths for snapshot testing as they are not stable
-  stackInfo.frames.forEach((_) => (_.filePath = '__REPLACED_FOR_SNAPSHOT__'))
+  stackInfo.frames.forEach((_) => {
+    _.filePath = '__REPLACED_FOR_SNAPSHOT__'
+  })
   expect(stackInfo).toMatchInlineSnapshot(`
     {
       "frames": [

package/src/utils/stack-info.ts

@@ -32,7 +32,11 @@ export const extractStackInfoFromStackTrace = (stackTrace: string): StackInfo =>
   const frames: StackFrame[] = []
   let hasReachedStart = false
 
-  while ((match = namePattern.exec(stackTrace)) !== null) {
+  while (true) {
+    match = namePattern.exec(stackTrace)
+    if (match === null) {
+      break
+    }
     const [, name, filePath] = match as any as [string, string, string]
     // console.debug(name, filePath)
 

package/src/utils/tests/otel.ts

@@ -24,7 +24,7 @@ export const getSimplifiedRootSpan = (
   const createStoreSpanData = spans.find((_) => _.name === 'createStore')
   if (createStoreSpanData === undefined) {
     throw new Error(
-      "Could not find the root span named 'createStore'. Available spans: " + spans.map((s) => s.name).join(', '),
+      `Could not find the root span named 'createStore'. Available spans: ${spans.map((s) => s.name).join(', ')}`,
     )
   }
   const rootSpan = spansMap.get(createStoreSpanData.spanContext().spanId)!