@livestore/livestore 0.0.10 → 0.0.13

package/src/{backends/tauri.ts → storage/tauri/index.ts}

@@ -2,36 +2,31 @@ import { getTraceParentHeader } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import { invoke } from '@tauri-apps/api'
 
-import type { ParamsObject } from '../util.js'
-import { prepareBindValues } from '../util.js'
-import { BaseBackend } from './base.js'
-import type { BackendOtelProps, SelectResponse } from './index.js'
+import type { ParamsObject } from '../../util.js'
+import { prepareBindValues } from '../../util.js'
+import type { Storage, StorageOtelProps } from '../index.js'
 
-export type BackendOptionsTauri = {
-  type: 'tauri'
+export type StorageOptionsTauri = {
   dbDirPath: string
   appDbFileName: string
 }
 
-export class TauriBackend extends BaseBackend {
+export class TauriStorage implements Storage {
   constructor(
     readonly dbFilePath: string,
     readonly dbDirPath: string,
     readonly otelTracer: otel.Tracer,
     readonly parentSpan: otel.Span,
-  ) {
-    super()
-  }
+  ) {}
 
-  static load = async (
-    { dbDirPath, appDbFileName }: BackendOptionsTauri,
-    { otelTracer, parentSpan }: BackendOtelProps,
-  ): Promise<TauriBackend> => {
-    const dbFilePath = `${dbDirPath}/${appDbFileName}`
-    await invoke('initialize_connection', { dbName: dbFilePath, otelData: getOtelData_(parentSpan) })
+  static load =
+    ({ dbDirPath, appDbFileName }: StorageOptionsTauri) =>
+    async ({ otelTracer, parentSpan }: StorageOtelProps) => {
+      const dbFilePath = `${dbDirPath}/${appDbFileName}`
+      await invoke('initialize_connection', { dbName: dbFilePath, otelData: getOtelData_(parentSpan) })
 
-    return new TauriBackend(dbFilePath, dbDirPath, otelTracer, parentSpan)
-  }
+      return new TauriStorage(dbFilePath, dbDirPath, otelTracer, parentSpan)
+    }
 
   execute = (query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): void => {
     // console.log({ query, bindValues, prepared: prepareBindValues(bindValues ?? {}, query) })
@@ -43,15 +38,6 @@ export class TauriBackend extends BaseBackend {
     })
   }
 
-  select = async <T>(query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): Promise<SelectResponse<T>> => {
-    return invoke('select', {
-      db: this.dbFilePath,
-      query,
-      values: bindValues ?? {},
-      otelData: this.getOtelData(parentSpan),
-    })
-  }
-
   getPersistedData = async (parentSpan?: otel.Span): Promise<Uint8Array> => {
     const headers = new Headers()
     headers.set('traceparent', getTraceParentHeader(parentSpan ?? this.parentSpan))

package/src/storage/web-worker/index.ts

@@ -0,0 +1,118 @@
+import { casesHandled } from '@livestore/utils'
+import type * as otel from '@opentelemetry/api'
+import * as Comlink from 'comlink'
+
+import type { ParamsObject } from '../../util.js'
+import { prepareBindValues } from '../../util.js'
+import type { Storage, StorageOtelProps } from '../index.js'
+import { IDB } from '../utils/idb.js'
+import type { WrappedWorker } from './worker.js'
+
+export type StorageType = 'opfs' | 'indexeddb'
+
+export type StorageOptionsWeb = {
+  /** Specifies where to persist data for this storage */
+  type: StorageType
+  virtualFilename: string
+}
+
+export class WebWorkerStorage implements Storage {
+  worker: Comlink.Remote<WrappedWorker>
+  options: StorageOptionsWeb
+  otelTracer: otel.Tracer
+
+  executionBacklog: { query: string; bindValues?: ParamsObject }[] = []
+  executionPromise: Promise<void> | undefined
+
+  private constructor({
+    worker,
+    options,
+    otelTracer,
+    executionPromise,
+  }: {
+    worker: Comlink.Remote<WrappedWorker>
+    options: StorageOptionsWeb
+    otelTracer: otel.Tracer
+    executionPromise: Promise<void>
+  }) {
+    this.worker = worker
+    this.options = options
+    this.otelTracer = otelTracer
+    this.executionPromise = executionPromise
+
+    executionPromise.then(() => this.executeBacklog())
+  }
+
+  static load = (options: StorageOptionsWeb) => {
+    // TODO: Importing the worker like this only works with Vite;
+    // should this really be inside the LiveStore library?
+    // Doesn't work with Firefox right now during dev https://bugzilla.mozilla.org/show_bug.cgi?id=1247687
+    const worker = new Worker(new URL('./worker.js', import.meta.url), {
+      type: 'module',
+    })
+    const wrappedWorker = Comlink.wrap<WrappedWorker>(worker)
+
+    return ({ otelTracer }: StorageOtelProps) =>
+      new WebWorkerStorage({
+        worker: wrappedWorker,
+        options,
+        otelTracer,
+        executionPromise: wrappedWorker.initialize(options),
+      })
+  }
+
+  execute = (query: string, bindValues_?: ParamsObject) => {
+    const bindValues = prepareBindValues(bindValues_ ?? {}, query)
+    this.executionBacklog.push({ query, bindValues })
+
+    // Instead of sending the queries to the worker immediately, we wait a bit and batch them up (which reduces the number of messages sent to the worker)
+    if (this.executionPromise === undefined) {
+      this.executionPromise = new Promise((resolve) => {
+        setTimeout(() => {
+          this.executeBacklog()
+
+          resolve()
+        }, 10)
+      })
+    }
+  }
+
+  private executeBacklog = () => {
+    void this.worker.executeBulk(this.executionBacklog)
+    this.executionBacklog = []
+    this.executionPromise = undefined
+  }
+
+  getPersistedData = async (_parentSpan?: otel.Span): Promise<Uint8Array> => getPersistedData(this.options)
+}
+
+const getPersistedData = async (options: StorageOptionsWeb): Promise<Uint8Array> => {
+  switch (options.type) {
+    case 'opfs': {
+      try {
+        const rootHandle = await navigator.storage.getDirectory()
+        const fileHandle = await rootHandle.getFileHandle(options.virtualFilename + '.db')
+        const file = await fileHandle.getFile()
+        const buffer = await file.arrayBuffer()
+        const data = new Uint8Array(buffer)
+
+        return data
+      } catch (error: any) {
+        if (error instanceof DOMException && error.name === 'NotFoundError') {
+          return new Uint8Array()
+        }
+
+        throw error
+      }
+    }
+
+    case 'indexeddb': {
+      const idb = new IDB(options.virtualFilename)
+
+      return (await idb.get('db')) ?? new Uint8Array()
+    }
+    default: {
+      casesHandled(options.type)
+    }
+  }
+}

package/src/{backends/web-worker.ts → storage/web-worker/worker.ts}

@@ -8,10 +8,10 @@ import type * as SqliteWasm from 'sqlite-esm'
 import sqlite3InitModule from 'sqlite-esm'
 
 // import { v4 as uuid } from 'uuid'
-import type { Bindable } from '../util.js'
-import { casesHandled, sql } from '../util.js'
-import type { SelectResponse, WritableDatabaseLocation } from './index.js'
-import { IDB } from './utils/idb.js'
+import type { Bindable } from '../../util.js'
+import { casesHandled, sql } from '../../util.js'
+import { IDB } from '../utils/idb.js'
+import type { StorageOptionsWeb } from './index.js'
 
 // A global variable to hold the database connection.
 // let db: SqliteWasm.Database
@@ -19,11 +19,11 @@ let db: SqliteWasm.DatabaseApi
 
 let sqlite3: SqliteWasm.Sqlite3Static
 
-// TODO get rid of this in favour of a "proper" IDB SQLite backend
+// TODO get rid of this in favour of a "proper" IDB SQLite storage
 let idb: IDB | undefined
 
-/** The location where this database backend persists its data */
-let persistentDatabaseLocation_: WritableDatabaseLocation
+/** The location where this database storage persists its data */
+let options_: StorageOptionsWeb
 
 const configureConnection = () =>
   db.exec(sql`
@@ -35,18 +35,18 @@ const configureConnection = () =>
 /** A full virtual filename in the IDB FS */
 const fullyQualifiedFilename = (name: string) => `${name}.db`
 
-const initialize = async ({ persistentDatabaseLocation }: { persistentDatabaseLocation: WritableDatabaseLocation }) => {
-  persistentDatabaseLocation_ = persistentDatabaseLocation
+const initialize = async (options: StorageOptionsWeb) => {
+  options_ = options
 
   sqlite3 = await sqlite3InitModule({
     print: (message) => console.log(`[sql-client] ${message}`),
     printErr: (message) => console.error(`[sql-client] ${message}`),
   })
 
-  switch (persistentDatabaseLocation.type) {
+  switch (options.type) {
     case 'opfs': {
       try {
-        db = new sqlite3.oo1.OpfsDb(fullyQualifiedFilename(persistentDatabaseLocation.virtualFilename)) // , 'c'
+        db = new sqlite3.oo1.OpfsDb(fullyQualifiedFilename(options.virtualFilename)) // , 'c'
       } catch (e) {
         debugger
       }
@@ -55,7 +55,7 @@ const initialize = async ({ persistentDatabaseLocation }: { persistentDatabaseLo
     case 'indexeddb': {
       try {
         db = new sqlite3.oo1.DB({ filename: ':memory:', flags: 'c' })
-        idb = new IDB(persistentDatabaseLocation.virtualFilename)
+        idb = new IDB(options.virtualFilename)
 
         const bytes = await idb.get('db')
 
@@ -70,21 +70,15 @@ const initialize = async ({ persistentDatabaseLocation }: { persistentDatabaseLo
       }
       break
     }
-    case 'filesystem': {
-      throw new Error('Persisting to native FS is not supported in the web worker backend')
-    }
-    case 'volatile-in-memory': {
-      break
-    }
     default: {
-      casesHandled(persistentDatabaseLocation)
+      casesHandled(options.type)
     }
   }
 
   configureConnection()
 }
 
-// TODO get rid of this in favour of a "proper" IDB SQLite backend
+// TODO get rid of this in favour of a "proper" IDB SQLite storage
 let idbPersistTimeout: NodeJS.Timeout | undefined
 
 type ExecutionQueueItem = { query: string; bindValues?: Bindable }
@@ -119,8 +113,8 @@ const executeBulk = (executionItems: ExecutionQueueItem[]): void => {
     }
   }
 
-  // TODO get rid of this in favour of a "proper" IDB SQLite backend
-  if (persistentDatabaseLocation_.type === 'indexeddb') {
+  // TODO get rid of this in favour of a "proper" IDB SQLite storage
+  if (options_.type === 'indexeddb') {
     if (idbPersistTimeout !== undefined) {
       clearTimeout(idbPersistTimeout)
     }
@@ -133,36 +127,7 @@ const executeBulk = (executionItems: ExecutionQueueItem[]): void => {
   }
 }
 
-const select = <T = any>(query: string, bindValues?: Bindable): SelectResponse<T> => {
-  const resultRows: T[] = []
-
-  db.exec({
-    sql: query,
-    bind: bindValues,
-    rowMode: 'object',
-    resultRows,
-  } as TODO)
-
-  return { results: resultRows }
-}
-
-const getPersistedData = async (): Promise<Uint8Array> => {
-  // TODO get rid of this in favour of a "proper" IDB SQLite backend
-  if (persistentDatabaseLocation_.type === 'indexeddb') {
-    const data = sqlite3.capi.sqlite3_js_db_export(db.pointer)
-    return Comlink.transfer(data, [data.buffer])
-  }
-
-  const rootHandle = await navigator.storage.getDirectory()
-  const fileHandle = await rootHandle.getFileHandle(db.filename)
-  const file = await fileHandle.getFile()
-  const buffer = await file.arrayBuffer()
-  const data = new Uint8Array(buffer)
-
-  return Comlink.transfer(data, [data.buffer])
-}
-
-const wrappedWorker = { initialize, executeBulk, select, getPersistedData }
+const wrappedWorker = { initialize, executeBulk }
 
 export type WrappedWorker = typeof wrappedWorker
 

package/src/store.ts

@@ -1,28 +1,30 @@
 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 initSqlite3Wasm 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 { 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 { 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, sql } from './util.js'
 
 export type LiveStoreQuery<TResult extends Record<string, any> = any> =
   | LiveStoreSQLQuery<TResult>
@@ -55,7 +57,7 @@ export type GraphQLOptions<TContext> = {
 export type StoreOptions<TGraphQLContext extends BaseGraphQLContext> = {
   db: InMemoryDatabase
   schema: Schema
-  backend?: Backend
+  storage?: Storage
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelTracer: otel.Tracer
   otelRootSpanContext: otel.Context
@@ -111,13 +113,13 @@ 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,
     schema,
-    backend,
+    storage,
     graphQLOptions,
     otelTracer,
     otelRootSpanContext,
@@ -133,7 +135,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)
@@ -642,7 +644,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 {
@@ -757,6 +759,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 +776,25 @@ 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, bindValues, 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, bindValues, 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()
 
@@ -795,9 +811,9 @@ export class Store<TGraphQLContext extends BaseGraphQLContext> {
   execute = async (query: string, params: ParamsObject = {}, writeTables?: string[]) => {
     this.inMemoryDB.execute(query, params, 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, params, parentSpan)
     }
   }
 }
@@ -805,83 +821,100 @@ 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,
 }: {
   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>
 }): 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 loadStorageAndPersistedData = async () => {
+        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 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(', ')}`,
+        const persistedData = await otelTracer.startActiveSpan(
+          'storage:getPersistedData',
+          {},
+          otelContext,
+          async (span) => {
+            try {
+              return await storage.getPersistedData(span)
+            } finally {
+              span.end()
+            }
+          },
         )
-      ) {
-        shouldResetDB = true
-      }
 
-      if (localStorage.getItem(RESET_DB_LOCAL_STORAGE_KEY) !== null) {
-        shouldResetDB = true
+        return { storage, persistedData }
       }
 
-      if (shouldResetDB) {
-        await loadSchema(backend, schema)
-        localStorage.removeItem(RESET_DB_LOCAL_STORAGE_KEY)
-      }
+      const loadSqlite3 = () =>
+        initSqlite3Wasm({
+          // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want
+          // You can omit locateFile completely when running in node
+          // locateFile: () => `/sql-wasm.wasm`,
+          print: (message) => console.log(`[livestore sqlite] ${message}`),
+          printErr: (message) => console.error(`[livestore sqlite] ${message}`),
+        })
 
-      if (boot) {
-        await boot(backend!, span)
-      }
+      const [{ storage, persistedData }, sqlite3] = await Promise.all([loadStorageAndPersistedData(), loadSqlite3()])
 
-      const otelContext = otel.trace.setSpan(otel.context.active(), span)
-      await otelTracer.startActiveSpan('backend-getPersistedData', {}, otelContext, async (span) => {
+      const db = InMemoryDatabase.load(persistedData, otelTracer, otelRootSpanContext, sqlite3)
+
+      // 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 {
+            return Reflect.get(db, prop, receiver)
+          }
+        },
+      })
+
+      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, schema, storage, graphQLOptions, otelTracer, otelRootSpanContext },
         span,
       )
     } finally {
@@ -890,17 +923,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,5 +1,7 @@
+/// <reference lib="es2022" />
+
 export type ParamsObject = Record<string, SqlValue>
-export type SqlValue = string | number | Uint8Array
+export type SqlValue = string | number | Uint8Array | null
 
 export type Bindable = SqlValue[] | ParamsObject
 
@@ -57,3 +59,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" }]
 }