@livestore/livestore 0.0.39-dev.3 → 0.0.40

package/src/cud.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'vitest'
+
+import { tables } from './__tests__/react/fixture.js'
+import { makeCudMutations } from './cud.js'
+import type { MutationEvent } from './index.js'
+
+describe('cud mutations', () => {
+  const cud = makeCudMutations(tables)
+
+  test('basic', () => {
+    expect(patchId(cud.todos.insert({ id: 't1', completed: true, text: 'Task 1' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "bindValues": {
+            "completed": 1,
+            "id": "t1",
+            "text": "Task 1",
+          },
+          "sql": "INSERT  INTO todos (id, text, completed) VALUES ($id, $text, $completed)",
+          "writeTables": Set {
+            "todos",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "livestore.RawSql",
+      }
+    `)
+
+    expect(patchId(cud.todos.update({ where: { id: 't1' }, values: { text: 'Task 1 - fixed' } })))
+      .toMatchInlineSnapshot(`
+        {
+          "args": {
+            "bindValues": {
+              "update_text": "Task 1 - fixed",
+              "where_id": "t1",
+            },
+            "sql": "UPDATE todos SET text = $update_text WHERE id = $where_id",
+            "writeTables": Set {
+              "todos",
+            },
+          },
+          "id": "00000000-0000-0000-0000-000000000000",
+          "mutation": "livestore.RawSql",
+        }
+      `)
+  })
+})
+
+const patchId = (muationEvent: MutationEvent.Any) => {
+  const id = `00000000-0000-0000-0000-000000000000`
+  return { ...muationEvent, id }
+}

package/src/cud.ts

@@ -0,0 +1,92 @@
+import * as SqlQueries from '@livestore/sql-queries'
+import { pipe, ReadonlyRecord } from '@livestore/utils/effect'
+import type { SqliteDsl } from 'effect-db-schema'
+
+import type { RowResult } from './row-query.js'
+import { rawSqlMutation, type RawSqlMutationEvent } from './schema/index.js'
+import { getDefaultValuesEncoded, type TableDef } from './schema/table-def.js'
+import { type GetValForKey, isIterable } from './utils/util.js'
+
+export const makeCudMutations = <TTableDef extends TableDef>(
+  tables: Iterable<TTableDef> | Record<string, TTableDef>,
+): CudMutations<TTableDef> => {
+  const cudMutationRecord: CudMutations<TTableDef> = {} as any
+
+  const tables_ = isIterable(tables) ? tables : Object.values(tables)
+
+  for (const tableDef of tables_) {
+    const [tableName, cudMutation] = cudMutationsForTable(tableDef)
+    cudMutationRecord[tableName] = cudMutation as any
+  }
+
+  return cudMutationRecord
+}
+
+const cudMutationsForTable = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): [TTableDef['sqliteDef']['name'], CudMutation<TTableDef>] => {
+  const table = tableDef.sqliteDef
+  const writeTables = new Set([table.name])
+  const api = {
+    insert: (values_: any) => {
+      const defaultValues = getDefaultValuesEncoded(tableDef)
+      const values = pipe(
+        tableDef.sqliteDef.columns,
+        ReadonlyRecord.map((_, columnName) => values_?.[columnName] ?? defaultValues[columnName]),
+      )
+
+      const [sql, bindValues] = SqlQueries.insertRow({
+        tableName: table.name,
+        columns: table.columns,
+        options: { orReplace: false },
+        values: values as any,
+      })
+      return rawSqlMutation({ sql, bindValues, writeTables })
+    },
+    update: ({ where, values }) => {
+      const [sql, bindValues] = SqlQueries.updateRows({
+        tableName: table.name,
+        columns: table.columns,
+        where: where,
+        updateValues: values,
+      })
+      return rawSqlMutation({ sql, bindValues, writeTables })
+    },
+    delete: ({ where }) => {
+      const [sql, bindValues] = SqlQueries.deleteRows({
+        tableName: table.name,
+        columns: table.columns,
+        where: where,
+      })
+      return rawSqlMutation({ sql, bindValues, writeTables })
+    },
+  } satisfies CudMutation<TTableDef>
+
+  return [tableDef.sqliteDef.name, api]
+}
+
+export type UpdateMutation<TTableDef extends TableDef> = (args: {
+  // TODO also allow `id` if present in `TTableDef`
+  where: Partial<RowResult<TTableDef>>
+  values: Partial<RowResult<TTableDef>>
+}) => RawSqlMutationEvent
+
+export type RowInsert<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+  ? GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
+  : SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>
+
+export type InsertMutation<TTableDef extends TableDef> = (values: RowInsert<TTableDef>) => RawSqlMutationEvent
+
+export type DeleteMutation<TTableDef extends TableDef> = (args: {
+  where: Partial<RowResult<TTableDef>>
+}) => RawSqlMutationEvent
+
+export type CudMutation<TTableDef extends TableDef> = {
+  insert: InsertMutation<TTableDef>
+  update: UpdateMutation<TTableDef>
+  delete: DeleteMutation<TTableDef>
+}
+
+export type CudMutations<TTableDef extends TableDef> = {
+  [TTableName in TTableDef['sqliteDef']['name']]: CudMutation<Extract<TTableDef, { sqliteDef: { name: TTableName } }>>
+}

package/src/inMemoryDatabase.ts

@@ -138,7 +138,7 @@ export class InMemoryDatabase {
   execute(
     query: string,
     bindValues?: PreparedBindValues,
-    writeTables?: ReadonlyArray<string>,
+    writeTables?: ReadonlySet<string>,
     options?: { hasNoEffects?: boolean; otelContext?: otel.Context },
   ): { durationMs: number } {
     // console.debug('in-memory-db:execute', query, bindValues)
@@ -170,12 +170,7 @@ export class InMemoryDatabase {
             stmt.reset() // Reset is needed for next execution
           }
         } catch (error) {
-          shouldNeverHappen(
-            `Error executing query: ${error} \n ${JSON.stringify({
-              query,
-              bindValues,
-            })}`,
-          )
+          shouldNeverHappen(`Error executing query: ${error} \n ${JSON.stringify({ query, bindValues })}`)
         }
 
         if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {

package/src/index.ts

@@ -13,23 +13,29 @@ export { LiveStoreSQLQuery, querySQL, type MapRows } from './reactiveQueries/sql
 export { LiveStoreGraphQLQuery, queryGraphQL } from './reactiveQueries/graphql.js'
 export { type GetAtomResult, type DbGraph, makeDbGraph, type LiveQuery } from './reactiveQueries/base-class.js'
 
-export { globalDbGraph } from './global-state.js'
+export { globalDbGraph, dynamicallyRegisteredTables } from './global-state.js'
 
 export { type RowResult, type RowResultEncoded, rowQuery, deriveColQuery } from './row-query.js'
 
-export * from './mutations.js'
+export * from './cud.js'
 
-export { defineAction, defineActions, makeSchema, DbSchema, ParseUtils } from './schema/index.js'
+export {
+  makeSchema,
+  DbSchema,
+  ParseUtils,
+  defineMutation,
+  rawSqlMutation,
+  makeMutationEventSchema,
+  makeMutationDefRecord,
+} from './schema/index.js'
 
 export type {
   LiveStoreSchema,
   InputSchema,
-  GetActionArgs,
-  GetApplyEventArgs,
-  ActionDefinition,
-  ActionDefinitions,
-  SQLWriteStatement,
   SchemaMetaRow,
+  MutationDef,
+  MutationEvent,
+  MutationDefMap,
 } from './schema/index.js'
 
 export { SqliteAst, SqliteDsl } from 'effect-db-schema'

package/src/migrations.ts

@@ -1,6 +1,6 @@
 import { Schema as EffectSchema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
-import { SqliteAst } from 'effect-db-schema'
+import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 import { memoize } from 'lodash-es'
 
 import { dynamicallyRegisteredTables } from './global-state.js'
@@ -26,7 +26,7 @@ export const migrateDb = ({
     // TODO use schema migration definition from schema.ts instead
     sql`create table if not exists ${SCHEMA_META_TABLE} (tableName text primary key, schemaHash text, updatedAt text);`,
     undefined,
-    [],
+    new Set(),
     { otelContext },
   )
 
@@ -80,11 +80,11 @@ export const migrateTable = ({
   const columnSpec = makeColumnSpec(tableAst)
 
   // TODO need to possibly handle cascading deletes due to foreign keys
-  db.execute(sql`drop table if exists ${tableName}`, undefined, [], { otelContext })
-  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, [], { otelContext })
+  db.execute(sql`drop table if exists ${tableName}`, undefined, new Set(), { otelContext })
+  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, new Set(), { otelContext })
 
   for (const index of tableAst.indexes) {
-    db.execute(createIndexFromDefinition(tableName, index), undefined, [], { otelContext })
+    db.execute(createIndexFromDefinition(tableName, index), undefined, new Set(), { otelContext })
   }
 
   const updatedAt = getMemoizedTimestamp()
@@ -94,7 +94,7 @@ export const migrateTable = ({
         ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
     `,
     { $tableName: tableName, $schemaHash: schemaHash, $updatedAt: updatedAt } as unknown as PreparedBindValues,
-    [],
+    new Set(),
     { otelContext },
   )
 }
@@ -121,10 +121,13 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
+    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+
     const encodeValue = EffectSchema.encodeSync(column.schema)
     const encodedDefaultValue = encodeValue(column.default.value)
 
-    return columnTypeStr === 'text' ? `default '${encodedDefaultValue}'` : `default ${encodedDefaultValue}`
+    if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
+    return `default ${encodedDefaultValue}`
   })()
 
   return `${column.name} ${columnTypeStr} ${nullableStr} ${defaultValueStr}`

package/src/{update-path.ts → query-info.ts}

@@ -1,38 +1,39 @@
 import { notYetImplemented, shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
+import { rawSqlMutation, type RawSqlMutationEvent } from './schema/mutations.js'
 import type { FromTable, TableDef } from './schema/table-def.js'
 
 /**
- * A description of a path to update a value either ...
- * - as a whole row
- * - or a single column value
- * - or a sub value in a JSON column
+ * Semantic information about a query with supported cases being:
+ * - a whole row
+ * - a single column value
+ * - a sub value in a JSON column
  */
-export type UpdatePathDesc<TTableDef extends TableDef = TableDef> =
-  | UpdatePathDescNone
-  | UpdatePathDescRow<TTableDef>
-  | UpdatePathDescColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
-  | UpdatePathDescCol<TTableDef, keyof TTableDef['sqliteDef']['columns']>
+export type QueryInfo<TTableDef extends TableDef = TableDef> =
+  | QueryInfoNone
+  | QueryInfoRow<TTableDef>
+  | QueryInfoColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
+  | QueryInfoCol<TTableDef, keyof TTableDef['sqliteDef']['columns']>
 
-export type UpdatePathDescNone = {
+export type QueryInfoNone = {
   _tag: 'None'
 }
 
-export type UpdatePathDescRow<TTableDef extends TableDef> = {
+export type QueryInfoRow<TTableDef extends TableDef> = {
   _tag: 'Row'
   table: TTableDef
   id: string
 }
 
-export type UpdatePathDescCol<TTableDef extends TableDef, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
+export type QueryInfoCol<TTableDef extends TableDef, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
   _tag: 'Col'
   table: TTableDef
   id: string
   column: TColName
 }
 
-export type UpdatePathDescColJsonValue<TTableDef extends TableDef, TColName extends GetJsonColumn<TTableDef>> = {
+export type QueryInfoColJsonValue<TTableDef extends TableDef, TColName extends GetJsonColumn<TTableDef>> = {
   _tag: 'ColJsonValue'
   table: TTableDef
   id: string
@@ -49,9 +50,7 @@ type GetJsonColumn<TTableDef extends TableDef> = keyof {
     : never]: {}
 }
 
-// type GetObjValues<TObj extends {}> = TObj[keyof TObj]
-
-export type UpdateValueForPath<TPath extends UpdatePathDesc> = TPath extends { _tag: 'Row' }
+export type UpdateValueForPath<TPath extends QueryInfo> = TPath extends { _tag: 'Row' }
   ? Partial<FromTable.RowDecodedAll<TPath['table']>>
   : TPath extends { _tag: 'Col' }
     ? Schema.Schema.To<TPath['table']['sqliteDef']['columns'][TPath['column']]['schema']>
@@ -59,10 +58,10 @@ export type UpdateValueForPath<TPath extends UpdatePathDesc> = TPath extends { _
       ? { TODO: true }
       : never
 
-export const storeEventForUpdatePath = <TPath extends UpdatePathDesc>(
+export const mutationForQueryInfo = <const TPath extends QueryInfo>(
   updatePath: TPath,
   value: UpdateValueForPath<TPath>,
-): StoreEvent => {
+): RawSqlMutationEvent => {
   if (updatePath._tag === 'ColJsonValue' || updatePath._tag === 'None') {
     return notYetImplemented('TODO')
   }
@@ -96,7 +95,5 @@ export const storeEventForUpdatePath = <TPath extends UpdatePathDesc>(
   const sql = `UPDATE ${sqliteTableDef.name} SET ${updateClause} ${whereClause}`
   const writeTables = new Set<string>([updatePath.table.sqliteDef.name])
 
-  return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+  return rawSqlMutation({ sql, bindValues, writeTables })
 }
-
-type StoreEvent = { eventType: string; args: any }

package/src/react/LiveStoreContext.ts

@@ -1,15 +1,6 @@
 import React, { useContext } from 'react'
 
 import type { LiveStoreContext as LiveStoreContext_ } from '../effect/LiveStore.js'
-import type { LiveQuery } from '../reactiveQueries/base-class.js'
-
-// TODO remove this?
-declare global {
-  // NOTE Can be extended
-  interface LiveStoreQueryTypes {
-    [key: string]: LiveQuery<any>
-  }
-}
 
 export const LiveStoreContext = React.createContext<LiveStoreContext_ | undefined>(undefined)
 

package/src/react/useAtom.ts

@@ -1,25 +1,25 @@
 import React from 'react'
 
+import { mutationForQueryInfo, type QueryInfoCol, type QueryInfoRow } from '../query-info.js'
 import type { LiveQuery } from '../reactiveQueries/base-class.js'
-import { storeEventForUpdatePath, type UpdatePathDescCol, type UpdatePathDescRow } from '../update-path.js'
 import { useStore } from './LiveStoreContext.js'
 import { useQueryRef } from './useQuery.js'
 import type { Dispatch, SetStateAction } from './useRow.js'
 
-export const useAtom = <TQuery extends LiveQuery<any, UpdatePathDescRow<any> | UpdatePathDescCol<any, any>>>(
+export const useAtom = <TQuery extends LiveQuery<any, QueryInfoRow<any> | QueryInfoCol<any, any>>>(
   query$: TQuery,
-): [value: TQuery['result!'], setValue: Dispatch<SetStateAction<TQuery['result!']>>] => {
+): [value: TQuery['__result!'], setValue: Dispatch<SetStateAction<TQuery['__result!']>>] => {
   const query$Ref = useQueryRef(query$)
 
   const { store } = useStore()
 
-  const setValue = React.useMemo<Dispatch<SetStateAction<TQuery['result!']>>>(() => {
+  const setValue = React.useMemo<Dispatch<SetStateAction<TQuery['__result!']>>>(() => {
     return (newValueOrFn: any) => {
       const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
 
-      store.applyEvents([storeEventForUpdatePath(query$.updatePathDesc!, newValue)])
+      store.mutate(mutationForQueryInfo(query$.queryInfo!, newValue))
     }
-  }, [query$.updatePathDesc, query$Ref, store])
+  }, [query$.queryInfo, query$Ref, store])
 
   return [query$Ref.current, setValue]
 }

package/src/{__tests__/react → react}/useQuery.test.tsx

@@ -2,15 +2,15 @@ import { act, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import * as LiveStoreReact from '../../react/index.js'
-import { querySQL } from '../../reactiveQueries/sql.js'
-import { makeTodoMvc, parseTodos } from './fixture.js'
+import { makeTodoMvc, parseTodos } from '../__tests__/react/fixture.js'
+import { querySQL } from '../reactiveQueries/sql.js'
+import * as LiveStoreReact from './index.js'
 
 describe('useQuery', () => {
   it('simple', async () => {
     let renderCount = 0
 
-    const { wrapper, store, mutations } = await makeTodoMvc()
+    const { wrapper, store, cud } = await makeTodoMvc()
 
     const allTodos$ = querySQL(`select * from todos`, { map: parseTodos })
 
@@ -26,7 +26,7 @@ describe('useQuery', () => {
     expect(result.current.length).toBe(0)
     expect(renderCount).toBe(1)
 
-    act(() => store.applyEvents([mutations.todos.insert({ id: 't1', text: 'buy milk', completed: false })]))
+    act(() => store.mutate(cud.todos.insert({ id: 't1', text: 'buy milk', completed: false })))
 
     expect(result.current.length).toBe(1)
     expect(result.current[0]!.text).toBe('buy milk')
@@ -36,15 +36,15 @@ describe('useQuery', () => {
   it('same `useQuery` hook invoked with different queries', async () => {
     let renderCount = 0
 
-    const { wrapper, store, mutations } = await makeTodoMvc()
+    const { wrapper, store, cud } = await makeTodoMvc()
 
     const todo1$ = querySQL(`select * from todos where id = 't1'`, { label: 'libraryTracksView1', map: parseTodos })
     const todo2$ = querySQL(`select * from todos where id = 't2'`, { label: 'libraryTracksView2', map: parseTodos })
 
-    store.applyEvents([
-      mutations.todos.insert({ id: 't1', text: 'buy milk', completed: false }),
-      mutations.todos.insert({ id: 't2', text: 'buy eggs', completed: false }),
-    ])
+    store.mutate(
+      cud.todos.insert({ id: 't1', text: 'buy milk', completed: false }),
+      cud.todos.insert({ id: 't2', text: 'buy eggs', completed: false }),
+    )
 
     const { result, rerender } = renderHook(
       (todoId: string) => {
@@ -60,7 +60,7 @@ describe('useQuery', () => {
     expect(result.current).toBe('buy milk')
     expect(renderCount).toBe(1)
 
-    act(() => store.applyEvents([mutations.todos.update({ where: { id: 't1' }, values: { text: 'buy soy milk' } })]))
+    act(() => store.mutate(cud.todos.update({ where: { id: 't1' }, values: { text: 'buy soy milk' } })))
 
     expect(result.current).toBe('buy soy milk')
     expect(renderCount).toBe(2)

package/src/react/useQuery.ts

@@ -2,7 +2,7 @@ import * as otel from '@opentelemetry/api'
 import { isEqual } from 'lodash-es'
 import React from 'react'
 
-import type { GetResult, LiveQuery, LiveQueryAny } from '../reactiveQueries/base-class.js'
+import type { GetResult, LiveQueryAny } from '../reactiveQueries/base-class.js'
 import { useStore } from './LiveStoreContext.js'
 import { extractStackInfoFromStackTrace, originalStackLimit } from './utils/stack-info.js'
 import { useStateRefWithReactiveInput } from './utils/useStateRefWithReactiveInput.js'

package/src/{__tests__/react → react}/useRow.test.tsx

@@ -2,10 +2,11 @@ import { act, render, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import * as LiveStore from '../../index.js'
-import * as LiveStoreReact from '../../react/index.js'
-import type { Todo } from './fixture.js'
-import { makeTodoMvc, todos } from './fixture.js'
+import type { Todo } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
+import * as LiveStore from '../index.js'
+import { mutationForQueryInfo } from '../query-info.js'
+import * as LiveStoreReact from './index.js'
 
 describe('useRow', () => {
   it('should update the data based on component key', async () => {
@@ -27,9 +28,7 @@ describe('useRow', () => {
     expect(result.current.state.username).toBe('')
     expect(renderCount).toBe(1)
 
-    act(() => {
-      void store.execute(LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2');`)
-    })
+    act(() => store.execute(LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2')`))
 
     rerender('u2')
 
@@ -85,9 +84,7 @@ describe('useRow', () => {
 
     act(() => result.current.setState.username('username_u1_hello'))
 
-    act(() => {
-      void store.execute(LiveStore.sql`UPDATE UserInfo SET username = 'username_u1_hello' WHERE id = 'u1';`)
-    })
+    act(() => store.execute(LiveStore.sql`UPDATE UserInfo SET username = 'username_u1_hello' WHERE id = 'u1';`))
 
     expect(result.current.state.id).toBe('u1')
     expect(result.current.state.username).toBe('username_u1_hello')
@@ -149,10 +146,11 @@ describe('useRow', () => {
     expect(appRouterRenderCount).toBe(1)
 
     act(() =>
-      store.applyEvent('livestore.RawSql', {
-        sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
-        writeTables: ['todos'],
-      }),
+      store.mutate(
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)`,
+        }),
+      ),
     )
 
     expect(appRouterRenderCount).toBe(1)
@@ -168,31 +166,15 @@ describe('useRow', () => {
     expect(renderResult.getByRole('current-id').innerHTML).toMatchInlineSnapshot('"Current Task Id: t1"')
 
     act(() =>
-      store.applyEvents([
-        {
-          eventType: 'livestore.RawSql',
-          args: {
-            sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t2', 'buy eggs', 0);`,
-            writeTables: ['todos'],
-          },
-        },
-        {
-          eventType: 'livestore.UpdateComponentState',
-          args: {
-            id: 'singleton',
-            columnNames: ['currentTaskId'],
-            tableName: AppRouterSchema.sqliteDef.name,
-            bindValues: { currentTaskId: 't2' },
-          },
-        },
-        {
-          eventType: 'livestore.RawSql',
-          args: {
-            sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t3', 'buy bread', 0);`,
-            writeTables: ['todos'],
-          },
-        },
-      ]),
+      store.mutate(
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t2', 'buy eggs', 0)`,
+        }),
+        mutationForQueryInfo({ _tag: 'Col', table: AppRouterSchema, column: 'currentTaskId', id: 'singleton' }, 't2'),
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t3', 'buy bread', 0)`,
+        }),
+      ),
     )
 
     expect(appRouterRenderCount).toBe(3)

package/src/react/useRow.ts

@@ -4,18 +4,18 @@ import { mapValues } from 'lodash-es'
 import React from 'react'
 
 import type { DbGraph, LiveQuery } from '../index.js'
+import type { QueryInfo } from '../query-info.js'
+import { mutationForQueryInfo } from '../query-info.js'
 import type { RowResult } from '../row-query.js'
 import { rowQuery } from '../row-query.js'
 import { type DefaultSqliteTableDef, type TableDef, tableIsSingleton, type TableOptions } from '../schema/table-def.js'
-import type { UpdatePathDesc } from '../update-path.js'
-import { storeEventForUpdatePath } from '../update-path.js'
 import { useStore } from './LiveStoreContext.js'
 import { useQueryRef } from './useQuery.js'
 
 export type UseRowResult<TTableDef extends TableDef> = [
   row: RowResult<TTableDef>,
   setRow: StateSetters<TTableDef>,
-  query$: LiveQuery<RowResult<TTableDef>, UpdatePathDesc>,
+  query$: LiveQuery<RowResult<TTableDef>, QueryInfo>,
 ]
 
 export type UseRowOptionsDefaulValues<TTableDef extends TableDef> = {
@@ -69,7 +69,7 @@ export const useRow: {
       cachedItem.span.addEvent('new-subscriber', { reactId })
 
       return {
-        query$: cachedItem.query$ as LiveQuery<RowResult<TTableDef>, UpdatePathDesc>,
+        query$: cachedItem.query$ as LiveQuery<RowResult<TTableDef>, QueryInfo>,
         otelContext: cachedItem.otelContext,
       }
     }
@@ -83,12 +83,12 @@ export const useRow: {
     const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
     const query$ = tableIsSingleton(table)
-      ? (rowQuery(table, { otelContext, dbGraph }) as LiveQuery<RowResult<TTableDef>, UpdatePathDesc>)
+      ? (rowQuery(table, { otelContext, dbGraph }) as LiveQuery<RowResult<TTableDef>, QueryInfo>)
       : (rowQuery(table as TTableDef & { options: { isSingleton: false } }, id!, {
           otelContext,
           defaultValues: defaultValues!,
           dbGraph,
-        }) as any as LiveQuery<RowResult<TTableDef>, UpdatePathDesc>)
+        }) as any as LiveQuery<RowResult<TTableDef>, QueryInfo>)
 
     rcCache.set(table, id ?? 'singleton', query$, reactId, otelContext, span)
 
@@ -117,7 +117,7 @@ export const useRow: {
         const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
         if (query$Ref.current === newValue) return
 
-        store.applyEvents([storeEventForUpdatePath(query$.updatePathDesc!, { value: newValue })])
+        store.mutate(mutationForQueryInfo(query$.queryInfo!, { value: newValue }))
       }
     } else {
       const setState = // TODO: do we have a better type for the values that can go in SQLite?
@@ -130,7 +130,7 @@ export const useRow: {
           // @ts-expect-error TODO fix typing
           if (query$Ref.current[columnName] === newValue) return
 
-          store.applyEvents([storeEventForUpdatePath(query$.updatePathDesc!, { [columnName]: newValue })])
+          store.mutate(mutationForQueryInfo(query$.queryInfo!, { [columnName]: newValue }))
         })
 
       setState.setMany = (columnValuesOrFn: Partial<TComponentState>) => {
@@ -147,12 +147,12 @@ export const useRow: {
           return
         }
 
-        store.applyEvents([storeEventForUpdatePath(query$.updatePathDesc!, columnValues)])
+        store.mutate(mutationForQueryInfo(query$.queryInfo!, columnValues))
       }
 
       return setState as any
     }
-  }, [query$.updatePathDesc, query$Ref, sqliteTableDef.columns, store, table.isSingleColumn])
+  }, [query$.queryInfo, query$Ref, sqliteTableDef.columns, store, table.isSingleColumn])
 
   return [query$Ref.current, setState, query$]
 }

package/src/{__tests__/reactive.test.ts → reactive.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { ReactiveGraph } from '../reactive.js'
+import { ReactiveGraph } from './reactive.js'
 
 describe('a trivial graph', () => {
   const makeGraph = () => {