@livestore/livestore 0.0.39 → 0.0.41-dev.0

package/src/reactiveQueries/base-class.ts

@@ -57,6 +57,8 @@ export interface LiveQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone
   queryInfo: TQueryInfo
 
   runs: number
+
+  executionTimes: number[]
 }
 
 export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
@@ -81,6 +83,8 @@ export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
     return this.results$.recomputations
   }
 
+  executionTimes: number[] = []
+
   abstract destroy: () => void
 
   run = (otelContext?: otel.Context, debugRefreshReason?: RefreshReason): TResult =>

package/src/reactiveQueries/graphql.ts

@@ -197,6 +197,8 @@ export class LiveStoreGraphQLQuery<
 
       const durationMs = getDurationMsFromSpan(span)
 
+      this.executionTimes.push(durationMs)
+
       return {
         result,
         queriedTables: Array.from(context.queriedTables.values()),

package/src/reactiveQueries/js.ts

@@ -80,6 +80,8 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
 
           const durationMs = getDurationMsFromSpan(span)
 
+          this.executionTimes.push(durationMs)
+
           setDebugInfo({ _tag: 'js', label, query: fn.toString(), durationMs })
 
           return res

package/src/{__tests__/reactiveQueries → reactiveQueries}/sql.test.ts

@@ -3,8 +3,8 @@ import type { ReadableSpan } from '@opentelemetry/sdk-trace-base'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
 import { describe, expect, it } from 'vitest'
 
-import { computed, ParseUtils, querySQL, sql } from '../../index.js'
-import { makeTodoMvc, todos } from '../react/fixture.js'
+import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
+import { computed, ParseUtils, querySQL, rawSqlMutation, sql } from '../index.js'
 
 /*
 TODO write tests for:
@@ -40,10 +40,7 @@ describe('otel', () => {
     const query = querySQL(`select * from todos`, { queriedTables: new Set(['todos']) })
     expect(query.run()).toMatchInlineSnapshot('[]')
 
-    store.applyEvent('livestore.RawSql', {
-      sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
-      writeTables: ['todos'],
-    })
+    store.mutate(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
 
     expect(query.run()).toMatchInlineSnapshot(`
       [
@@ -91,28 +88,36 @@ describe('otel', () => {
             },
           },
           {
-            "_name": "LiveStore:applyEvents",
+            "_name": "LiveStore:mutations",
             "children": [
               {
-                "_name": "LiveStore:applyEvent",
+                "_name": "LiveStore:mutate",
+                "attributes": {
+                  "livestore.mutateLabel": "mutate",
+                },
                 "children": [
                   {
-                    "_name": "LiveStore:applyEventWithoutRefresh",
+                    "_name": "LiveStore:processWrites",
                     "attributes": {
-                      "livestore.actionType": "livestore.RawSql",
-                      "livestore.args": "{
-        "sql": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
-        "writeTables": [
-          "todos"
-        ]
-      }",
+                      "livestore.mutateLabel": "mutate",
                     },
                     "children": [
                       {
-                        "_name": "livestore.in-memory-db:execute",
+                        "_name": "LiveStore:mutatetWithoutRefresh",
                         "attributes": {
-                          "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
+                          "livestore.args": "{
+        "sql": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)"
+      }",
+                          "livestore.mutation": "livestore.RawSql",
                         },
+                        "children": [
+                          {
+                            "_name": "livestore.in-memory-db:execute",
+                            "attributes": {
+                              "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)",
+                            },
+                          },
+                        ],
                       },
                     ],
                   },
@@ -183,10 +188,7 @@ describe('otel', () => {
       }
     `)
 
-    store.applyEvent('livestore.RawSql', {
-      sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
-      writeTables: ['todos'],
-    })
+    store.mutate(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
 
     expect(query.run()).toMatchInlineSnapshot(`
       {
@@ -232,28 +234,36 @@ describe('otel', () => {
             },
           },
           {
-            "_name": "LiveStore:applyEvents",
+            "_name": "LiveStore:mutations",
             "children": [
               {
-                "_name": "LiveStore:applyEvent",
+                "_name": "LiveStore:mutate",
+                "attributes": {
+                  "livestore.mutateLabel": "mutate",
+                },
                 "children": [
                   {
-                    "_name": "LiveStore:applyEventWithoutRefresh",
+                    "_name": "LiveStore:processWrites",
                     "attributes": {
-                      "livestore.actionType": "livestore.RawSql",
-                      "livestore.args": "{
-        "sql": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
-        "writeTables": [
-          "todos"
-        ]
-      }",
+                      "livestore.mutateLabel": "mutate",
                     },
                     "children": [
                       {
-                        "_name": "livestore.in-memory-db:execute",
+                        "_name": "LiveStore:mutatetWithoutRefresh",
                         "attributes": {
-                          "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
+                          "livestore.args": "{
+        "sql": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)"
+      }",
+                          "livestore.mutation": "livestore.RawSql",
                         },
+                        "children": [
+                          {
+                            "_name": "livestore.in-memory-db:execute",
+                            "attributes": {
+                              "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)",
+                            },
+                          },
+                        ],
                       },
                     ],
                   },

package/src/reactiveQueries/sql.ts

@@ -173,6 +173,8 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
 
             const durationMs = getDurationMsFromSpan(span)
 
+            this.executionTimes.push(durationMs)
+
             setDebugInfo({ _tag: 'sql', label, query: sqlString, durationMs })
 
             return result

package/src/row-query.ts

@@ -1,5 +1,5 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
@@ -138,20 +138,19 @@ const insertRowWithDefaultValuesOrIgnore = ({
   otelContext: otel.Context
   defaultValues: Partial<RowResult<TableDef>> | undefined
 }) => {
-  const columnNames = Object.keys(table.sqliteDef.columns)
-  const columnValues = columnNames.map((name) => `$${name}`).join(', ')
+  const defaultValues = getDefaultValuesEncoded(table, explicitDefaultValues)
+
+  const defaultColumnNames = [...Object.keys(defaultValues), 'id']
+  const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
 
   const tableName = table.sqliteDef.name
-  const insertQuery = sql`insert into ${tableName} (${columnNames.join(
+  const insertQuery = sql`insert into ${tableName} (${defaultColumnNames.join(
     ', ',
   )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = '${id}')`
 
-  const defaultValues = pipe(
-    getDefaultValuesEncoded(table),
-    ReadonlyRecord.map((val, columnName) => explicitDefaultValues?.[columnName] ?? val),
-  )
-
-  db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), [tableName], { otelContext })
+  db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), new Set([tableName]), {
+    otelContext,
+  })
 }
 
 const makeExecBeforeFirstRun =

package/src/schema/index.ts

@@ -1,33 +1,47 @@
+import type { ReadonlyArray } from '@livestore/utils/effect'
 import type { SqliteDsl } from 'effect-db-schema'
 
-import type { ActionDefinitions } from './action.js'
+import { isReadonlyArray } from '../utils/util.js'
+import {
+  type MutationDef,
+  type MutationDefMap,
+  type MutationDefRecord,
+  type RawSqlMutation,
+  rawSqlMutation,
+} from './mutations.js'
 import { systemTables } from './system-tables.js'
 import type { TableDef } from './table-def.js'
 
-export * from './action.js'
 export * from './system-tables.js'
 export * as DbSchema from './table-def.js'
 export * as ParseUtils from './parse-utils.js'
+export * from './mutations.js'
 
-// export { SqliteDsl as DbSchema } from 'effect-db-schema'
-
-export type LiveStoreSchema<TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema> = {
+export type LiveStoreSchema<
+  TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
+  TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
+> = {
   /** Only used on type-level */
   readonly _DbSchemaType: TDbSchema
+  /** Only used on type-level */
+  readonly _MutationDefMapType: TMutationsDefRecord
 
   readonly tables: Map<string, TableDef>
-  readonly actions: ActionDefinitions<any>
+  readonly mutations: MutationDefMap
 }
 
 export type InputSchema = {
-  tables: Record<string, TableDef> | ReadonlyArray<TableDef>
-  actions: ActionDefinitions<any>
+  readonly tables: Record<string, TableDef> | ReadonlyArray<TableDef>
+  readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
 }
 
 export const makeSchema = <TInputSchema extends InputSchema>(
-  /** Note when using the object-notation for tables, the object keys are ignored and not used as table names */
+  /** Note when using the object-notation for tables/mutations, the object keys are ignored and not used as table/mutation names */
   schema: TInputSchema,
-): LiveStoreSchema<DbSchemaFromInputSchemaTables<TInputSchema['tables']>> => {
+): LiveStoreSchema<
+  DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
+  MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
+> => {
   const inputTables: ReadonlyArray<TableDef> = Array.isArray(schema.tables)
     ? schema.tables
     : // TODO validate that table names are unique in this case
@@ -44,10 +58,25 @@ export const makeSchema = <TInputSchema extends InputSchema>(
     tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
+  const mutations: MutationDefMap = new Map()
+
+  if (isReadonlyArray(schema.mutations)) {
+    for (const mutation of schema.mutations) {
+      mutations.set(mutation.name, mutation)
+    }
+  } else {
+    for (const [name, mutation] of Object.entries(schema.mutations ?? {})) {
+      mutations.set(name, mutation)
+    }
+  }
+
+  mutations.set('livestore.RawSql', rawSqlMutation)
+
   return {
     _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
+    _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
     tables,
-    actions: schema.actions,
+    mutations,
   } satisfies LiveStoreSchema
 }
 
@@ -62,3 +91,10 @@ export type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']>
     : TTables extends Record<string, TableDef>
       ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
       : never
+
+export type MutationDefRecordFromInputSchemaMutations<TMutations extends InputSchema['mutations']> =
+  TMutations extends ReadonlyArray<MutationDef.Any>
+    ? { [K in TMutations[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlMutation }
+    : TMutations extends { [name: string]: MutationDef.Any }
+      ? { [K in keyof TMutations as TMutations[K]['name']]: TMutations[K] } & { 'livestore.RawSql': RawSqlMutation }
+      : never

package/src/schema/mutations.ts

@@ -0,0 +1,129 @@
+import type { BindValues } from '@livestore/sql-queries'
+import { cuid } from '@livestore/utils/cuid'
+import { Schema } from '@livestore/utils/effect'
+
+import type { LiveStoreSchema } from './index.js'
+
+export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
+export type MutationDefRecord = {
+  'livestore.RawSql': RawSqlMutation
+  [name: string]: MutationDef.Any
+}
+
+export type InternalMutationSchema<TRecord extends MutationDefRecord = MutationDefRecord> = {
+  _DefRecord: TRecord
+
+  map: Map<keyof TRecord, TRecord[keyof TRecord]>
+  schemaHashMap: Map<keyof TRecord, number>
+}
+
+export type MutationDef<TName extends string, TFrom, TTo> = {
+  name: TName
+  schema: Schema.Schema<never, TFrom, TTo>
+  sql:
+    | string
+    | ((args: TTo) =>
+        | string
+        | {
+            sql: string
+            /** Note args need to be manually encoded to `BindValues` when returning this argument */
+            bindValues: BindValues
+            writeTables?: ReadonlySet<string>
+          })
+
+  /** Helper function to construct mutation event */
+  (args: TTo): { mutation: TName; args: TTo; id: string }
+}
+
+export namespace MutationDef {
+  export type Any = MutationDef<string, any, any>
+}
+
+// TODO possibly also allow for mutation event subsumption behaviour
+export const defineMutation = <TName extends string, TFrom, TTo>(
+  name: TName,
+  schema: Schema.Schema<never, TFrom, TTo>,
+  sql: string | ((args: TTo) => string | { sql: string; bindValues: BindValues; writeTables?: ReadonlySet<string> }),
+): MutationDef<TName, TFrom, TTo> => {
+  const makeEvent = (args: TTo) => ({ mutation: name, args, id: cuid() })
+
+  Object.defineProperty(makeEvent, 'name', { value: name })
+  Object.defineProperty(makeEvent, 'schema', { value: schema })
+  Object.defineProperty(makeEvent, 'sql', { value: sql })
+
+  return makeEvent as MutationDef<TName, TFrom, TTo>
+}
+
+export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
+  inputRecord: TInputRecord,
+): {
+  [K in TInputRecord[keyof TInputRecord]['name']]: Extract<TInputRecord[keyof TInputRecord], { name: K }>
+} => {
+  const result: any = {}
+
+  for (const [name, def] of Object.entries(inputRecord)) {
+    result[name] = def
+  }
+
+  result['livestore.RawSql'] = rawSqlMutation
+
+  return result
+}
+
+export const rawSqlMutation = defineMutation(
+  'livestore.RawSql',
+  Schema.struct({
+    sql: Schema.string,
+    bindValues: Schema.optional(Schema.record(Schema.string, Schema.any)),
+    writeTables: Schema.optional(Schema.readonlySet(Schema.string)),
+  }),
+  ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
+)
+
+export type RawSqlMutation = typeof rawSqlMutation
+export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>
+
+export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
+  mutation: TMutationsDef['name']
+  args: Schema.Schema.To<TMutationsDef['schema']>
+  id: string
+}
+
+export namespace MutationEvent {
+  export type Any = MutationEvent<MutationDef.Any>
+
+  export type ForSchema<TSchema extends LiveStoreSchema> = {
+    [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
+  }[keyof TSchema['_MutationDefMapType']]
+}
+
+export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
+  never,
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.From<TMutationsDefRecord[K]['schema']>
+      id: string
+    }
+  }[keyof TMutationsDefRecord],
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.To<TMutationsDefRecord[K]['schema']>
+      id: string
+    }
+  }[keyof TMutationsDefRecord]
+>
+
+export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefRecord>(
+  mutationDefRecord: TMutationsDefRecord,
+): MutationEventSchema<TMutationsDefRecord> =>
+  Schema.union(
+    ...Object.values(mutationDefRecord).map((def) =>
+      Schema.struct({
+        mutation: Schema.literal(def.name),
+        args: def.schema,
+        id: Schema.string,
+      }),
+    ),
+  ) as any

package/src/schema/parse-utils.ts

@@ -1,7 +1,7 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import type { ReadonlyArray } from '@livestore/utils/effect'
 import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
-import { SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+import { SqliteDsl } from 'effect-db-schema' // eslint-disable-line
 
 import { type FromColumns, type FromTable, getDefaultValuesDecoded, type TableDef } from './table-def.js'
 

package/src/schema/table-def.ts

@@ -5,7 +5,7 @@ import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
-export { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+export { type SqliteDsl } from 'effect-db-schema'
 
 import { dynamicallyRegisteredTables } from '../global-state.js'
 
@@ -156,16 +156,25 @@ export const tableIsSingleton = <TTableDef extends TableDef>(
   tableDef: TTableDef,
 ): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
 
-export const getDefaultValuesEncoded = <TTableDef extends TableDef>(tableDef: TTableDef) =>
+export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+  fallbackValues?: Record<string, any>,
+) =>
   pipe(
     tableDef.sqliteDef.columns,
-    ReadonlyRecord.filter((_, key) => key !== 'id'),
+    ReadonlyRecord.filter((col, key) => {
+      if (fallbackValues?.[key] !== undefined) return true
+      if (key === 'id') return false
+      return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
+    }),
     ReadonlyRecord.map((column, columnName) =>
-      column!.default._tag === 'None'
-        ? column!.nullable === true
-          ? null
-          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-        : Schema.encodeSync(column!.schema)(column!.default.value),
+      fallbackValues?.[columnName] === undefined
+        ? column!.default._tag === 'None'
+          ? column!.nullable === true
+            ? null
+            : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+          : Schema.encodeSync(column!.schema)(column!.default.value)
+        : fallbackValues[columnName],
     ),
   )
 
@@ -173,6 +182,9 @@ export const getDefaultValuesDecoded = <TTableDef extends TableDef>(tableDef: TT
   pipe(
     tableDef.sqliteDef.columns,
     ReadonlyRecord.filter((_, key) => key !== 'id'),
+    ReadonlyRecord.filter(
+      (col) => col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false,
+    ),
     ReadonlyRecord.map((column, columnName) =>
       column!.default._tag === 'None'
         ? column!.nullable === true

package/src/storage/in-memory/index.ts

@@ -1,5 +1,6 @@
 import type * as otel from '@opentelemetry/api'
 
+import type { MutationEvent } from '../../index.js'
 import type { PreparedBindValues } from '../../utils/util.js'
 import type { Storage, StorageOtelProps } from '../index.js'
 
@@ -17,5 +18,11 @@ export class InMemoryStorage implements Storage {
 
   execute = (_query: string, _bindValues?: PreparedBindValues): void => {}
 
+  mutate = (_mutationEventEncoded: MutationEvent.Any, _parentSpan?: otel.Span | undefined) => {}
+
   getPersistedData = async (): Promise<Uint8Array> => new Uint8Array()
+
+  getMutationLogData = async (): Promise<Uint8Array> => new Uint8Array()
+
+  dangerouslyReset = async () => {}
 }

package/src/storage/index.ts

@@ -8,6 +8,7 @@
 
 import type * as otel from '@opentelemetry/api'
 
+import type { MutationEvent } from '../index.js'
 import type { PreparedBindValues } from '../utils/util.js'
 
 export type StorageInit = (otelProps: StorageOtelProps) => Promise<Storage> | Storage
@@ -16,8 +17,15 @@ export interface Storage {
   // TODO consider transferables for `bindValues` (e.g. Uint8Array values)
   execute(query: string, bindValues?: PreparedBindValues, parentSpan?: otel.Span): void
 
+  // TODO consider transferables for `bindValues` (e.g. Uint8Array values)
+  mutate(mutationEventEncoded: MutationEvent.Any, parentSpan?: otel.Span): void
+
   /** Return a snapshot of persisted data from the storage */
   getPersistedData(parentSpan?: otel.Span): Promise<Uint8Array>
+
+  getMutationLogData(parentSpan?: otel.Span): Promise<Uint8Array>
+
+  dangerouslyReset(): Promise<void>
 }
 
 export type StorageType = 'tauri' | 'web' | 'web-in-memory'

package/src/storage/tauri/index.ts

@@ -2,6 +2,7 @@ import { getTraceParentHeader } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import { invoke } from '@tauri-apps/api'
 
+import type { MutationEvent } from '../../schema/mutations.js'
 import type { PreparedBindValues } from '../../utils/util.js'
 import { prepareBindValues } from '../../utils/util.js'
 import type { Storage, StorageOtelProps } from '../index.js'
@@ -38,6 +39,8 @@ export class TauriStorage implements Storage {
     })
   }
 
+  mutate = (_mutationEventEncoded: MutationEvent.Any, _parentSpan?: otel.Span | undefined) => {}
+
   getPersistedData = async (parentSpan?: otel.Span): Promise<Uint8Array> => {
     const headers = new Headers()
     headers.set('traceparent', getTraceParentHeader(parentSpan ?? this.parentSpan))
@@ -47,6 +50,13 @@ export class TauriStorage implements Storage {
     )
   }
 
+  // TODO
+  getMutationLogData = async (): Promise<Uint8Array> => new Uint8Array()
+
+  dangerouslyReset = async () => {
+    // TODO
+  }
+
   private getOtelData = (parentSpan?: otel.Span) => getOtelData_(parentSpan ?? this.parentSpan)!
 }
 

package/src/storage/utils/idb.ts

@@ -68,4 +68,18 @@ export class IDB {
       }
     })
   }
+
+  public async deleteDb(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const deleteRequest = indexedDB.deleteDatabase(this.dbName)
+
+      deleteRequest.onsuccess = () => {
+        resolve()
+      }
+
+      deleteRequest.onerror = () => {
+        reject(new Error('Failed to delete database.'))
+      }
+    })
+  }
 }

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

@@ -0,0 +1,6 @@
+import type { MutationEvent } from '../../schema/mutations.js'
+import type { PreparedBindValues } from '../../utils/util.js'
+
+export type ExecutionBacklogItem =
+  | { _tag: 'execute'; query: string; bindValues?: PreparedBindValues }
+  | { _tag: 'mutate'; mutationEventEncoded: MutationEvent.Any }