@livestore/livestore 0.0.12 → 0.0.15

package/src/store.ts

@@ -1,28 +1,33 @@
 import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
 import { assertNever, makeNoopSpan, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
+import { identity } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 import * as graphql from 'graphql'
 import { uniqueId } from 'lodash-es'
 import * as ReactDOM from 'react-dom'
+import type * as Sqlite from 'sqlite-esm'
 import { v4 as uuid } from 'uuid'
 
-import type { Backend, BackendOptions } from './backends/index.js'
-import { createBackend } from './backends/index.js'
 import type { ComponentKey } from './componentKey.js'
 import { tableNameForComponentKey } from './componentKey.js'
+import type { QueryDefinition } from './effect/LiveStore.js'
 import type { LiveStoreEvent } from './events.js'
 import { InMemoryDatabase } from './inMemoryDatabase.js'
+import { migrateDb } from './migrations.js'
 import { getDurationMsFromSpan } from './otel.js'
-import type { GetAtom, Ref } from './reactive.js'
+import type { Atom, Ref } from './reactive.js'
 import { ReactiveGraph } from './reactive.js'
 import { LiveStoreGraphQLQuery } from './reactiveQueries/graphql.js'
 import { LiveStoreJSQuery } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
-import type { ActionDefinition, GetActionArgs, Schema } from './schema.js'
-import { componentStateTables, loadSchema } from './schema.js'
+import type { ActionDefinition, GetActionArgs, Schema, SQLWriteStatement } from './schema.js'
+import { componentStateTables } from './schema.js'
+import type { Storage, StorageInit } from './storage/index.js'
 import type { Bindable, ParamsObject } from './util.js'
-import { sql } from './util.js'
+import { isPromise, prepareBindValues, sql } from './util.js'
+
+export type GetAtomResult = <T>(atom: Atom<T> | LiveStoreJSQuery<T>) => T
 
 export type LiveStoreQuery<TResult extends Record<string, any> = any> =
   | LiveStoreSQLQuery<TResult>
@@ -35,8 +40,6 @@ export type BaseGraphQLContext = {
   otelContext?: otel.Context
 }
 
-export const RESET_DB_LOCAL_STORAGE_KEY = 'livestore-reset'
-
 export type QueryResult<TQuery> = TQuery extends LiveStoreSQLQuery<infer R>
   ? ReadonlyArray<Readonly<R>>
   : TQuery extends LiveStoreJSQuery<infer S>
@@ -54,8 +57,10 @@ export type GraphQLOptions<TContext> = {
 
 export type StoreOptions<TGraphQLContext extends BaseGraphQLContext> = {
   db: InMemoryDatabase
+  /** A `Proxy`d version of `db` except that it also mirrors `execute` calls to the storage */
+  dbProxy: InMemoryDatabase
   schema: Schema
-  backend?: Backend
+  storage?: Storage
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelTracer: otel.Tracer
   otelRootSpanContext: otel.Context
@@ -98,9 +103,11 @@ export type StoreOtel = {
   queriesSpanContext: otel.Context
 }
 
-export class Store<TGraphQLContext extends BaseGraphQLContext> {
+export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLContext> {
   graph: ReactiveGraph<RefreshReason, QueryDebugInfo>
   inMemoryDB: InMemoryDatabase
+  // TODO refactor
+  _proxyDb: InMemoryDatabase
   schema: Schema
   graphQLSchema?: GraphQLSchema
   graphQLContext?: TGraphQLContext
@@ -111,18 +118,20 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
    */
   tableRefs: { [key: string]: Ref<null> }
   activeQueries: Set<LiveStoreQuery>
-  backend?: Backend
+  storage?: Storage
   temporaryQueries: Set<LiveStoreQuery> | undefined
 
   private constructor({
     db,
+    dbProxy,
     schema,
-    backend,
+    storage,
     graphQLOptions,
     otelTracer,
     otelRootSpanContext,
   }: StoreOptions<TGraphQLContext>) {
     this.inMemoryDB = db
+    this._proxyDb = dbProxy
     this.graph = new ReactiveGraph({
       // TODO move this into React module
       // Do all our updates inside a single React setState batch to avoid multiple UI re-renders
@@ -133,7 +142,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
     this.activeQueries = new Set()
-    this.backend = backend
+    this.storage = storage
 
     const applyEventsSpan = otelTracer.startSpan('LiveStore:applyEvents', {}, otelRootSpanContext)
     const otelApplyEventsSpanContext = otel.trace.setSpan(otel.context.active(), applyEventsSpan)
@@ -186,7 +195,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
    * NOTE The query is actually running (even if no one has subscribed to it yet) and will be kept up to date.
    */
   querySQL = <TResult>(
-    genQueryString: (get: GetAtom) => string,
+    genQueryString: string | ((get: GetAtomResult) => string),
     {
       queriedTables,
       bindValues,
@@ -216,9 +225,17 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
 
         const queryString$ = this.graph.makeThunk(
           (get, addDebugInfo) => {
-            const queryString = genQueryString(get)
-            addDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString })
-            return queryString
+            if (typeof genQueryString === 'function') {
+              const getAtom: GetAtomResult = (atom) => {
+                if (atom._tag === 'thunk' || atom._tag === 'ref') return get(atom)
+                return get(atom.results$)
+              }
+              const queryString = genQueryString(getAtom)
+              addDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString })
+              return queryString
+            } else {
+              return genQueryString
+            }
           },
           { label: `${label}:queryString`, meta: { liveStoreThunkType: 'sqlQueryString' } },
           otelContext,
@@ -229,10 +246,10 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
 
         const queryLabel = `${label}:results` + (this.temporaryQueries ? ':temp' : '')
 
-        const results$ = this.graph.makeThunk<TResult[]>(
+        const results$ = this.graph.makeThunk<ReadonlyArray<TResult>>(
           (get, addDebugInfo) =>
             this.otel.tracer.startActiveSpan(
-              'sql', // NOTE span name will be overridden further down
+              'sql:', // NOTE span name will be overridden further down
               {},
               otelContext,
               (span) => {
@@ -250,12 +267,16 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
                   span.setAttribute('sql.query', sqlString)
                   span.updateName(`sql:${sqlString.slice(0, 50)}`)
 
-                  const results = this.inMemoryDB.select(sqlString, { queriedTables, bindValues, otelContext })
+                  const results = this.inMemoryDB.select<TResult>(sqlString, {
+                    queriedTables,
+                    bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
+                    otelContext,
+                  })
 
                   span.setAttribute('sql.rowsCount', results.length)
                   addDebugInfo({ _tag: 'sql', label: label ?? '', query: sqlString })
 
-                  return results as unknown as TResult[]
+                  return results
                 } finally {
                   span.end()
                 }
@@ -287,7 +308,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
     )
 
   queryJS = <TResult>(
-    genResults: (get: GetAtom) => TResult,
+    genResults: (get: GetAtomResult) => TResult,
     {
       componentKey = globalComponentKey,
       label = `js${uniqueId()}`,
@@ -299,8 +320,12 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
       const queryLabel = `${label}:results` + (this.temporaryQueries ? ':temp' : '')
       const results$ = this.graph.makeThunk(
         (get, addDebugInfo) => {
+          const getAtom: GetAtomResult = (atom) => {
+            if (atom._tag === 'thunk' || atom._tag === 'ref') return get(atom)
+            return get(atom.results$)
+          }
           addDebugInfo({ _tag: 'js', label, query: genResults.toString() })
-          return genResults(get)
+          return genResults(getAtom)
         },
         { label: queryLabel, meta: { liveStoreThunkType: 'jsResults' } },
         otelContext,
@@ -327,7 +352,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
 
   queryGraphQL = <TResult extends Record<string, any>, TVariableValues extends Record<string, any>>(
     document: DocumentNode<TResult, TVariableValues>,
-    genVariableValues: (get: GetAtom) => TVariableValues,
+    genVariableValues: TVariableValues | ((get: GetAtomResult) => TVariableValues),
     {
       componentKey,
       label,
@@ -354,7 +379,17 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
         span.updateName(`queryGraphQL:${labelWithDefault}`)
 
         const variableValues$ = this.graph.makeThunk(
-          genVariableValues,
+          (get) => {
+            if (typeof genVariableValues === 'function') {
+              const getAtom: GetAtomResult = (atom) => {
+                if (atom._tag === 'thunk' || atom._tag === 'ref') return get(atom)
+                return get(atom.results$)
+              }
+              return genVariableValues(getAtom)
+            } else {
+              return genVariableValues
+            }
+          },
           { label: `${labelWithDefault}:variableValues`, meta: { liveStoreThunkType: 'graphqlVariableValues' } },
           otelContext,
         )
@@ -642,7 +677,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
               try {
                 const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-                // TODO: what to do about backend transaction here?
+                // TODO: what to do about storage transaction here?
                 this.inMemoryDB.txn(() => {
                   for (const event of events) {
                     try {
@@ -718,6 +753,13 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
     )
   }
 
+  // TODO get rid of this as part of new query definition approach https://www.notion.so/schickling/New-query-definition-approach-1097a78ef0e9495bac25f90417374756?pvs=4
+  runOnce = <TQueryDef extends QueryDefinition>(queryDef: TQueryDef): QueryResult<ReturnType<TQueryDef>> => {
+    return this.inTempQueryContext(() => {
+      return queryDef(this).results$.result
+    })
+  }
+
   /**
    * Apply an event to the store.
    * Returns the tables that were affected by the event.
@@ -757,6 +799,15 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
               }
             },
           },
+
+          RawSql: {
+            statement: ({ sql, writeTables }: { sql: string; writeTables: string[] }) => ({
+              sql,
+              writeTables,
+              argsAlreadyBound: false,
+            }),
+            prepareBindValues: ({ bindValues }) => bindValues,
+          },
         }
 
         const actionDefinition = actionDefinitions[eventType] ?? shouldNeverHappen(`Unknown event type: ${eventType}`)
@@ -765,20 +816,30 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
         const eventWithId: LiveStoreEvent = { id: uuid(), type: eventType, args }
 
         // Synchronously apply the event to the in-memory database
-        const { durationMs } = this.inMemoryDB.applyEvent(eventWithId, actionDefinition, otelContext)
+        // const { durationMs } = this.inMemoryDB.applyEvent(eventWithId, actionDefinition, otelContext)
+        const { statement, bindValues } = eventToSql(eventWithId, actionDefinition)
+        const { durationMs } = this.inMemoryDB.execute(
+          statement.sql,
+          prepareBindValues(bindValues, statement.sql),
+          statement.writeTables,
+          {
+            otelContext,
+          },
+        )
 
-        // Asynchronously apply the event to a persistent backend (we're not awaiting this promise here)
-        if (this.backend !== undefined) {
-          this.backend.applyEvent(eventWithId, actionDefinition, span)
+        // Asynchronously apply the event to a persistent storage (we're not awaiting this promise here)
+        if (this.storage !== undefined) {
+          // this.storage.applyEvent(eventWithId, actionDefinition, span)
+          this.storage.execute(statement.sql, prepareBindValues(bindValues, statement.sql), span)
         }
 
         // Uncomment to print a list of queries currently registered on the store
         // console.log(JSON.parse(JSON.stringify([...this.queries].map((q) => `${labelForKey(q.componentKey)}/${q.label}`))))
 
-        const statement =
-          typeof actionDefinition.statement === 'function'
-            ? actionDefinition.statement(args)
-            : actionDefinition.statement
+        // const statement =
+        //   typeof actionDefinition.statement === 'function'
+        //     ? actionDefinition.statement(args)
+        //     : actionDefinition.statement
 
         span.end()
 
@@ -793,11 +854,11 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
    * all app writes should go through applyEvent.
    */
   execute = async (query: string, params: ParamsObject = {}, writeTables?: string[]) => {
-    this.inMemoryDB.execute(query, params, writeTables)
+    this.inMemoryDB.execute(query, prepareBindValues(params, query), writeTables)
 
-    if (this.backend !== undefined) {
+    if (this.storage !== undefined) {
       const parentSpan = otel.trace.getSpan(otel.context.active())
-      this.backend.execute(query, params, parentSpan)
+      this.storage.execute(query, prepareBindValues(params, query), parentSpan)
     }
   }
 }
@@ -805,83 +866,95 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
 /** Create a new LiveStore Store */
 export const createStore = async <TGraphQLContext extends BaseGraphQLContext>({
   schema,
-  backendOptions,
+  loadStorage,
   graphQLOptions,
   otelTracer = makeNoopTracer(),
   otelRootSpanContext = otel.context.active(),
   boot,
+  sqlite3,
 }: {
   schema: Schema
-  backendOptions: BackendOptions
+  loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
-  boot?: (backend: Backend, parentSpan: otel.Span) => Promise<void>
+  boot?: (db: InMemoryDatabase, parentSpan: otel.Span) => unknown | Promise<unknown>
+  sqlite3: Sqlite.Sqlite3Static
 }): Promise<Store<TGraphQLContext>> => {
   return otelTracer.startActiveSpan('createStore', {}, otelRootSpanContext, async (span) => {
     try {
-      let persistedData: Uint8Array | undefined
-      const backend = await createBackend(backendOptions, {
-        otelTracer: otelTracer ?? makeNoopTracer(),
-        parentSpan: otel.trace.getSpan(otelRootSpanContext ?? otel.context.active()) ?? makeNoopSpan(),
-      })
-      // if we're resetting the database, run boot here.
+      const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-      let shouldResetDB = false
-      // Uncomment this line if you want to reset the database contents.
-      // let shouldResetDB = true
+      const storage = await otelTracer.startActiveSpan('storage:load', {}, otelContext, async (span) => {
+        try {
+          const init = await loadStorage()
+          const parentSpan = otel.trace.getSpan(otel.context.active()) ?? makeNoopSpan()
+          return init({ otelTracer, parentSpan })
+        } finally {
+          span.end()
+        }
+      })
 
-      const existingTablesRaw = await backend.select(
-        sql`SELECT * FROM sqlite_master WHERE type='table';`,
-        undefined,
-        span,
+      const persistedData = await otelTracer.startActiveSpan(
+        'storage:getPersistedData',
+        {},
+        otelContext,
+        async (span) => {
+          try {
+            return await storage.getPersistedData(span)
+          } finally {
+            span.end()
+          }
+        },
       )
-      const existingTables = existingTablesRaw.results.map((t: { name: string }) => t.name)
-      const missingTables = Object.keys(schema.tables).filter((tableName) => !existingTables.includes(tableName))
-      if (existingTables.length === 0) {
-        console.log('No existing tables found, loading from schema')
-        shouldResetDB = true
-      } else if (
-        missingTables.length > 0 &&
-        window.confirm(
-          `Existing DB is missing ${missingTables.length} tables: ${missingTables.join(
-            ', ',
-          )}\n\nReset DB? This will reset all of the following tables to empty: ${Object.keys(schema).join(', ')}`,
-        )
-      ) {
-        shouldResetDB = true
-      }
-
-      if (localStorage.getItem(RESET_DB_LOCAL_STORAGE_KEY) !== null) {
-        shouldResetDB = true
-      }
 
-      if (shouldResetDB) {
-        await loadSchema(backend, schema)
-        localStorage.removeItem(RESET_DB_LOCAL_STORAGE_KEY)
-      }
+      const db = InMemoryDatabase.load({ data: persistedData, otelTracer, otelRootSpanContext, sqlite3 })
 
-      if (boot) {
-        await boot(backend!, span)
-      }
+      // Proxy to `db` that also mirrors `execute` calls to `storage`
+      const dbProxy = new Proxy(db, {
+        get: (db, prop, receiver) => {
+          if (prop === 'execute') {
+            const execute: InMemoryDatabase['execute'] = (query, bindValues, writeTables, options) => {
+              storage.execute(query, bindValues, span)
+              return db.execute(query, bindValues, writeTables, options)
+            }
+            return execute
+          } else if (prop === 'select') {
+            // NOTE we're even proxying `select` calls here as some apps (e.g. Overtone) currently rely on this
+            // TODO remove this once we've migrated all apps to use `execute` instead of `select`
+            const select: InMemoryDatabase['select'] = (query, options = {}) => {
+              storage.execute(query, options.bindValues as any)
+              return db.select(query, options)
+            }
+            return select
+          } else {
+            return Reflect.get(db, prop, receiver)
+          }
+        },
+      })
 
-      const otelContext = otel.trace.setSpan(otel.context.active(), span)
-      await otelTracer.startActiveSpan('backend-getPersistedData', {}, otelContext, async (span) => {
+      otelTracer.startActiveSpan('migrateDb', {}, otelContext, async (span) => {
         try {
-          persistedData = await backend!.getPersistedData(span)
+          const otelContext = otel.trace.setSpan(otel.context.active(), span)
+          migrateDb({ db: dbProxy, schema, otelContext })
         } finally {
           span.end()
         }
       })
 
-      const db: InMemoryDatabase = await InMemoryDatabase.load(persistedData, otelTracer, otelRootSpanContext)
-      configureSQLite(db)
+      if (boot !== undefined) {
+        const booting = boot(dbProxy, span)
+        // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
+        if (isPromise(booting)) {
+          await booting
+        }
+      }
 
       // TODO: we can't apply the schema at this point, we've already loaded persisted data!
       // Think about what to do about this case.
       // await applySchema(db, schema)
       return Store.createStore<TGraphQLContext>(
-        { db, schema, backend, graphQLOptions, otelTracer, otelRootSpanContext },
+        { db, dbProxy, schema, storage, graphQLOptions, otelTracer, otelRootSpanContext },
         span,
       )
     } finally {
@@ -890,17 +963,17 @@ export const createStore = async <TGraphQLContext extends BaseGraphQLContext>({
   })
 }
 
-/** Set up SQLite performance; hasn't been super carefully optimized yet. */
-const configureSQLite = (db: InMemoryDatabase) => {
-  db.execute(
-    // TODO: revisit these tuning parameters for max performance
-    sql`
-      PRAGMA page_size=32768;
-      PRAGMA cache_size=10000;
-      PRAGMA journal_mode='MEMORY'; -- we don't flush to disk before committing a write
-      PRAGMA synchronous='OFF';
-      PRAGMA temp_store='MEMORY';
-      PRAGMA foreign_keys='ON'; -- we want foreign key constraints to be enforced
-    `,
-  )
+const eventToSql = (
+  event: LiveStoreEvent,
+  eventDefinition: ActionDefinition,
+): { statement: SQLWriteStatement; bindValues: ParamsObject } => {
+  const statement =
+    typeof eventDefinition.statement === 'function' ? eventDefinition.statement(event.args) : eventDefinition.statement
+
+  const prepareBindValues = eventDefinition.prepareBindValues ?? identity
+
+  const bindValues =
+    typeof eventDefinition.statement === 'function' && statement.argsAlreadyBound ? {} : prepareBindValues(event.args)
+
+  return { statement, bindValues }
 }

package/src/util.ts

@@ -1,8 +1,14 @@
+/// <reference lib="es2022" />
+
+import type { Brand } from '@livestore/utils/effect'
+
 export type ParamsObject = Record<string, SqlValue>
-export type SqlValue = string | number | Uint8Array
+export type SqlValue = string | number | Uint8Array | null
 
 export type Bindable = SqlValue[] | ParamsObject
 
+export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>
+
 /**
  * This is a tag function for tagged literals.
  * it lets us get syntax highlighting on SQL queries in VSCode, but
@@ -23,7 +29,9 @@ export const sql = (template: TemplateStringsArray, ...args: unknown[]): string
 /*  because rusqlite doesn't allow unused named params
 /*  TODO: Search for unused params via proper parsing, not string search
 **/
-export const prepareBindValues = (values: ParamsObject, statement: string): ParamsObject => {
+export const prepareBindValues = (values: Bindable, statement: string): PreparedBindValues => {
+  if (Array.isArray(values)) return values as PreparedBindValues
+
   const result: ParamsObject = {}
   for (const [key, value] of Object.entries(values)) {
     if (statement.includes(key)) {
@@ -31,7 +39,7 @@ export const prepareBindValues = (values: ParamsObject, statement: string): Para
     }
   }
 
-  return result
+  return result as PreparedBindValues
 }
 
 /**
@@ -57,3 +65,5 @@ export const objectToString = (error: any): string => {
     return 'Error while printing error: ' + e
   }
 }
+
+export const isPromise = (value: any): value is Promise<unknown> => typeof value?.then === 'function'

package/tsconfig.json

@@ -9,7 +9,5 @@
     "tsBuildInfoFile": "./dist/.tsbuildinfo"
   },
   "include": ["./src"],
-  "references": [
-    { "path": "../utils" },
-  ]
+  "references": [{ "path": "../../effect-db-schema" }, { "path": "../utils" }]
 }

package/src/backends/base.ts

@@ -1,67 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { errorToString } from '@livestore/utils'
-import { identity } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
-
-import type { LiveStoreEvent } from '../events.js'
-// import { EVENTS_TABLE_NAME } from '../events.js'
-import type { ActionDefinition } from '../schema.js'
-import type { ParamsObject } from '../util.js'
-import type { Backend, SelectResponse } from './index.js'
-
-export abstract class BaseBackend implements Backend {
-  abstract otelTracer: otel.Tracer
-
-  select = async <T = any>(query: string, bindValues?: ParamsObject): Promise<SelectResponse<T>> => {
-    throw new Error('Method not implemented.')
-  }
-
-  execute = (query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): void => {
-    throw new Error('Method not implemented.')
-  }
-
-  getPersistedData = async (parentSpan?: otel.Span): Promise<Uint8Array> => {
-    throw new Error('Method not implemented.')
-  }
-
-  // TODO move `applyEvent` logic to Store and only call `execute` here
-  applyEvent = (event: LiveStoreEvent, eventDefinition: ActionDefinition, parentSpan?: otel.Span): void => {
-    const ctx = parentSpan ? otel.trace.setSpan(otel.context.active(), parentSpan) : otel.context.active()
-    this.otelTracer.startActiveSpan('LiveStore:backend:applyEvent', {}, ctx, (span) => {
-      try {
-        // Careful: this SQL statement is duplicated in the backend.
-        // Remember to update it in src-tauri/src/store.rs:apply_event as well.
-        // await this.execute(sql`insert into ${EVENTS_TABLE_NAME} (id, type, args) values ($id, $type, $args)`, {
-        //   id: event.id,
-        //   type: event.type,
-        //   args: JSON.stringify(event.args ?? {}),
-        // })
-
-        const statement =
-          typeof eventDefinition.statement === 'function'
-            ? eventDefinition.statement(event.args)
-            : eventDefinition.statement
-
-        const prepareBindValues = eventDefinition.prepareBindValues ?? identity
-
-        const bindValues =
-          typeof eventDefinition.statement === 'function' && statement.argsAlreadyBound
-            ? {}
-            : prepareBindValues(event.args)
-
-        span.setAttributes({
-          'livestore.statement.sql': statement.sql,
-          'livestore.statement.writeTables': statement.writeTables,
-          'livestore.statement.bindVales': JSON.stringify(bindValues),
-        })
-
-        this.execute(statement.sql, bindValues, span)
-      } catch (e: any) {
-        span.setStatus({ code: otel.SpanStatusCode.ERROR, message: errorToString(e) })
-        throw e
-      } finally {
-        span.end()
-      }
-    })
-  }
-}