@livestore/livestore 0.0.47-dev.0 → 0.0.48-dev.0

package/src/index.ts

@@ -1,5 +1,5 @@
 export { Store, createStore } from './store.js'
-export type { BaseGraphQLContext, QueryDebugInfo, RefreshReason, BootDb } from './store.js'
+export type { BaseGraphQLContext, QueryDebugInfo, RefreshReason } from './store.js'
 
 export type { QueryDefinition, LiveStoreCreateStoreOptions, LiveStoreContext } from './effect/LiveStore.js'
 
@@ -26,14 +26,16 @@ export { globalDbGraph, dynamicallyRegisteredTables } from './global-state.js'
 
 export { type RowResult, type RowResultEncoded, rowQuery, deriveColQuery } from './row-query.js'
 
-export * from './cud.js'
-
 export * from '@livestore/common/schema'
-export { sql } from '@livestore/common'
+export { sql, type BootDb, type InMemoryDatabase } from '@livestore/common'
 
 export { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 export { prepareBindValues, type Bindable, type PreparedBindValues } from './utils/util.js'
 export { isEqual } from 'lodash-es'
 
-export type { DatabaseImpl, DatabaseFactory, PreparedStatement } from '@livestore/common'
+export type {
+  StoreAdapter as DatabaseImpl,
+  StoreAdapterFactory as DatabaseFactory,
+  PreparedStatement,
+} from '@livestore/common'

package/src/react/LiveStoreProvider.test.tsx

@@ -1,13 +1,13 @@
+import type { BootDb } from '@livestore/common'
 import { sql } from '@livestore/common'
-import { makeDb } from '@livestore/web'
-import { InMemoryStorage } from '@livestore/web/storage/in-memory'
+import { makeInMemoryAdapter } from '@livestore/web'
 import { render, screen, waitFor, waitForElementToBeRemoved } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
 import { parseTodos, schema } from '../__tests__/react/fixture.js'
 import { querySQL } from '../reactiveQueries/sql.js'
-import type { BootDb, Store } from '../store.js'
+import type { Store } from '../store.js'
 import * as LiveStoreReact from './index.js'
 import { LiveStoreProvider } from './LiveStoreProvider.js'
 
@@ -35,9 +35,9 @@ describe('LiveStoreProvider', () => {
         [],
       )
       // eslint-disable-next-line react-hooks/exhaustive-deps
-      const makeDbMemo = React.useMemo(() => makeDb(() => InMemoryStorage.load()), [forceUpdate])
+      const adapterMemo = React.useMemo(() => makeInMemoryAdapter(), [forceUpdate])
       return (
-        <LiveStoreProvider schema={schema} fallback={<div>Loading LiveStore</div>} makeDb={makeDbMemo} boot={bootCb}>
+        <LiveStoreProvider schema={schema} fallback={<div>Loading LiveStore</div>} adapter={adapterMemo} boot={bootCb}>
           <App />
         </LiveStoreProvider>
       )

package/src/react/LiveStoreProvider.tsx

@@ -1,4 +1,4 @@
-import type { DatabaseFactory } from '@livestore/common'
+import type { BootDb, StoreAdapterFactory } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
@@ -7,7 +7,7 @@ import React from 'react'
 
 // TODO refactor so the `react` module doesn't depend on `effect` module
 import type { LiveStoreContext as StoreContext_, LiveStoreCreateStoreOptions } from '../effect/LiveStore.js'
-import type { BaseGraphQLContext, BootDb, GraphQLOptions, Store } from '../store.js'
+import type { BaseGraphQLContext, GraphQLOptions, Store } from '../store.js'
 import { createStore } from '../store.js'
 import { LiveStoreContext } from './LiveStoreContext.js'
 
@@ -18,7 +18,7 @@ interface LiveStoreProviderProps<GraphQLContext> {
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
   fallback: ReactElement
-  makeDb: DatabaseFactory
+  adapter: StoreAdapterFactory
   batchUpdates?: (run: () => void) => void
 }
 
@@ -30,7 +30,7 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   children,
   schema,
   boot,
-  makeDb,
+  adapter,
   batchUpdates,
 }: LiveStoreProviderProps<GraphQLContext> & { children?: ReactNode }): JSX.Element => {
   const storeCtx = useCreateStore({
@@ -39,7 +39,7 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
     otelTracer,
     otelRootSpanContext,
     boot,
-    makeDb,
+    adapter,
     batchUpdates,
   })
 
@@ -58,7 +58,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   otelTracer,
   otelRootSpanContext,
   boot,
-  makeDb,
+  adapter,
   batchUpdates,
 }: LiveStoreCreateStoreOptions<GraphQLContext>) => {
   const [_, rerender] = React.useState(0)
@@ -69,7 +69,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
     otelTracer,
     otelRootSpanContext,
     boot,
-    makeDb,
+    adapter,
     batchUpdates,
   })
   const oldStoreAlreadyDestroyedRef = React.useRef(false)
@@ -80,7 +80,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
     inputPropsCacheRef.current.otelTracer !== otelTracer ||
     inputPropsCacheRef.current.otelRootSpanContext !== otelRootSpanContext ||
     inputPropsCacheRef.current.boot !== boot ||
-    inputPropsCacheRef.current.makeDb !== makeDb ||
+    inputPropsCacheRef.current.adapter !== adapter ||
     inputPropsCacheRef.current.batchUpdates !== batchUpdates
   ) {
     inputPropsCacheRef.current = {
@@ -89,7 +89,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
       otelTracer,
       otelRootSpanContext,
       boot,
-      makeDb,
+      adapter,
       batchUpdates,
     }
     ctxValueRef.current?.store.destroy()
@@ -108,7 +108,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
           otelTracer,
           otelRootSpanContext,
           boot,
-          makeDb,
+          adapter,
           batchUpdates,
         })
         ctxValueRef.current = { store }
@@ -124,7 +124,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
         store?.destroy()
       }
     }
-  }, [schema, graphQLOptions, otelTracer, otelRootSpanContext, boot, makeDb, batchUpdates])
+  }, [schema, graphQLOptions, otelTracer, otelRootSpanContext, boot, adapter, batchUpdates])
 
   return ctxValueRef.current
 }

package/src/react/index.ts

@@ -11,6 +11,7 @@ export {
   type UseRowResult as UseStateResult,
 } from './useRow.js'
 export { useAtom } from './useAtom.js'
+export { useLocalId, getLocalId } from './useLocalId.js'
 
 export { LiveList, type LiveListProps } from './components/LiveList.js'
 

package/src/react/useAtom.ts

@@ -1,26 +1,52 @@
+import { type QueryInfoCol, type QueryInfoRow } from '@livestore/common'
+import type { DbSchema } from '@livestore/common/schema'
 import React from 'react'
 
-import { mutationForQueryInfo, type QueryInfoCol, type QueryInfoRow } from '../query-info.js'
 import type { LiveQuery } from '../reactiveQueries/base-class.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, QueryInfoRow<any> | QueryInfoCol<any, any>>>(
+export const useAtom = <
+  TQuery extends LiveQuery<any, QueryInfoRow<TTableDef> | QueryInfoCol<TTableDef, any>>,
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: true }
+  >,
+>(
   query$: TQuery,
 ): [value: TQuery['__result!'], setValue: Dispatch<SetStateAction<Partial<TQuery['__result!']>>>] => {
   const query$Ref = useQueryRef(query$)
 
   const { store } = useStore()
 
+  // TODO make API equivalent to useRow
   const setValue = React.useMemo<Dispatch<SetStateAction<TQuery['__result!']>>>(() => {
     return (newValueOrFn: any) => {
       const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
 
-      if (query$.queryInfo._tag === 'Row' && query$.queryInfo.table.isSingleColumn) {
-        store.mutate(mutationForQueryInfo(query$.queryInfo!, { value: newValue }))
+      if (query$.queryInfo._tag === 'Row') {
+        if (query$.queryInfo.table.options.isSingleton && query$.queryInfo.table.isSingleColumn) {
+          store.mutate(query$.queryInfo.table.update(newValue))
+        } else if (query$.queryInfo.table.options.isSingleColumn) {
+          store.mutate(
+            query$.queryInfo.table.update({ where: { id: query$.queryInfo.id }, values: { value: newValue } }),
+          )
+        } else {
+          store.mutate(query$.queryInfo.table.update({ where: { id: query$.queryInfo.id }, values: newValue }))
+        }
       } else {
-        store.mutate(mutationForQueryInfo(query$.queryInfo!, newValue))
+        if (query$.queryInfo.table.options.isSingleton && query$.queryInfo.table.isSingleColumn) {
+          store.mutate(query$.queryInfo.table.update({ [query$.queryInfo.column]: newValue }))
+        } else {
+          store.mutate(
+            query$.queryInfo.table.update({
+              where: { id: query$.queryInfo.id },
+              values: { [query$.queryInfo.column]: newValue },
+            }),
+          )
+        }
       }
     }
   }, [query$.queryInfo, query$Ref, store])

package/src/react/useLocalId.ts

@@ -0,0 +1,25 @@
+import { cuid } from '@livestore/utils/cuid'
+import React from 'react'
+
+type LocalIdOptions = {
+  key: string
+  storageType: 'session' | 'local'
+  storageKeyPrefix: string
+  makeId: () => string
+}
+
+export const useLocalId = (opts?: Partial<LocalIdOptions>) => React.useMemo(() => getLocalId(opts), [opts])
+
+export const getLocalId = (opts?: Partial<LocalIdOptions>) => {
+  const { key = '', storageType = 'session', storageKeyPrefix = 'livestore:localid:', makeId = cuid } = opts ?? {}
+
+  const storage = storageType === 'session' ? window.sessionStorage : window.localStorage
+  const fullKey = `${storageKeyPrefix}:${key}`
+  const storedKey = storage.getItem(fullKey)
+
+  if (storedKey) return storedKey
+
+  const newKey = makeId()
+  storage.setItem(fullKey, newKey)
+  return newKey
+}

package/src/react/useQuery.test.tsx

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

package/src/react/useRow.test.tsx

@@ -1,7 +1,7 @@
 import { ReadonlyRecord } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
-import { act, render, renderHook } from '@testing-library/react'
+import { render, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
@@ -9,7 +9,6 @@ import type { Todo } from '../__tests__/react/fixture.js'
 import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
 import { getSimplifiedRootSpan } from '../__tests__/react/utils/otel.js'
 import * as LiveStore from '../index.js'
-import { mutationForQueryInfo } from '../query-info.js'
 import * as LiveStoreReact from './index.js'
 import type { StackInfo } from './utils/stack-info.js'
 
@@ -36,7 +35,7 @@ describe.concurrent('useRow', () => {
     expect(result.current.state.username).toBe('')
     expect(renderCount.val).toBe(1)
 
-    act(() =>
+    React.act(() =>
       store.mutate(
         LiveStore.rawSqlMutation({
           sql: LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2')`,
@@ -51,6 +50,8 @@ describe.concurrent('useRow', () => {
     expect(renderCount.val).toBe(2)
   })
 
+  // TODO add a test that makes sure React doesn't re-render when a setter is used to set the same value
+
   it('should update the data reactively - via setState', async () => {
     using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
 
@@ -72,7 +73,7 @@ describe.concurrent('useRow', () => {
     expect(result.current.state.username).toBe('')
     expect(renderCount.val).toBe(1)
 
-    act(() => result.current.setState.username('username_u1_hello'))
+    React.act(() => result.current.setState.username('username_u1_hello'))
 
     expect(result.current.state.id).toBe('u1')
     expect(result.current.state.username).toBe('username_u1_hello')
@@ -100,7 +101,7 @@ describe.concurrent('useRow', () => {
     expect(result.current.state.username).toBe('')
     expect(renderCount.val).toBe(1)
 
-    act(() =>
+    React.act(() =>
       store.mutate(
         LiveStore.rawSqlMutation({
           sql: LiveStore.sql`UPDATE UserInfo SET username = 'username_u1_hello' WHERE id = 'u1';`,
@@ -115,18 +116,10 @@ describe.concurrent('useRow', () => {
 
   it('should work for a larger app', async () => {
     using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
-    const { wrapper, store, dbGraph, makeRenderCount } = inputs
+    const { wrapper, store, dbGraph, makeRenderCount, AppRouterSchema } = inputs
 
     const allTodos$ = LiveStore.querySQL<Todo[]>(`select * from todos`, { label: 'allTodos', dbGraph })
 
-    const AppRouterSchema = LiveStore.DbSchema.table(
-      'AppRouter',
-      {
-        currentTaskId: LiveStore.DbSchema.text({ default: null, nullable: true }),
-      },
-      { isSingleton: true },
-    )
-
     const appRouterRenderCount = makeRenderCount()
     let globalSetState: LiveStoreReact.StateSetters<typeof AppRouterSchema> | undefined
     const AppRouter: React.FC = () => {
@@ -168,7 +161,7 @@ describe.concurrent('useRow', () => {
 
     expect(appRouterRenderCount.val).toBe(1)
 
-    act(() =>
+    React.act(() =>
       store.mutate(
         LiveStore.rawSqlMutation({
           sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)`,
@@ -179,7 +172,7 @@ describe.concurrent('useRow', () => {
     expect(appRouterRenderCount.val).toBe(1)
     expect(renderResult.getByRole('current-id').innerHTML).toMatchInlineSnapshot('"Current Task Id: -"')
 
-    act(() => globalSetState!.currentTaskId('t1'))
+    React.act(() => globalSetState!.currentTaskId('t1'))
 
     expect(appRouterRenderCount.val).toBe(2)
     expect(renderResult.getByRole('content').innerHTML).toMatchInlineSnapshot(
@@ -188,12 +181,12 @@ describe.concurrent('useRow', () => {
 
     expect(renderResult.getByRole('current-id').innerHTML).toMatchInlineSnapshot('"Current Task Id: t1"')
 
-    act(() =>
+    React.act(() =>
       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'),
+        AppRouterSchema.update({ where: { id: 'singleton' }, values: { currentTaskId: 't2' } }),
         LiveStore.rawSqlMutation({
           sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t3', 'buy bread', 0)`,
         }),
@@ -206,12 +199,12 @@ describe.concurrent('useRow', () => {
 
   it('should work for a useRow query chained with a useTemporary query', async () => {
     using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
-    const { store, wrapper, AppComponentSchema, dbGraph, makeRenderCount, cud } = inputs
+    const { store, wrapper, AppComponentSchema, dbGraph, makeRenderCount } = inputs
     const renderCount = makeRenderCount()
 
     store.mutate(
-      cud.todos.insert({ id: 't1', text: 'buy milk', completed: false }),
-      cud.todos.insert({ id: 't2', text: 'buy bread', completed: false }),
+      todos.insert({ id: 't1', text: 'buy milk', completed: false }),
+      todos.insert({ id: 't2', text: 'buy bread', completed: false }),
     )
 
     const { result, unmount, rerender } = renderHook(
@@ -233,7 +226,7 @@ describe.concurrent('useRow', () => {
       { wrapper, initialProps: 'u1' },
     )
 
-    act(() =>
+    React.act(() =>
       store.mutate(
         LiveStore.rawSqlMutation({
           sql: LiveStore.sql`INSERT INTO UserInfo (id, username, text) VALUES ('u2', 'username_u2', 'milk')`,
@@ -289,7 +282,7 @@ describe.concurrent('useRow', () => {
       expect(result.current.state.username).toBe('')
       expect(renderCount.val).toBe(1)
 
-      act(() =>
+      React.act(() =>
         store.mutate(
           LiveStore.rawSqlMutation({
             sql: LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2')`,
@@ -346,10 +339,18 @@ describe.concurrent('useRow', () => {
                 "_name": "sql-in-memory-select",
                 "attributes": {
                   "sql.cached": false,
-                  "sql.query": "SELECT schemaHash FROM __livestore_schema WHERE tableName = 'UserInfo'",
+                  "sql.query": "select 1 from UserInfo where id = 'u1'",
                   "sql.rowsCount": 0,
                 },
               },
+              {
+                "_name": "sql-in-memory-select",
+                "attributes": {
+                  "sql.cached": false,
+                  "sql.query": "select 1 from UserInfo where id = 'u2'",
+                  "sql.rowsCount": 1,
+                },
+              },
               {
                 "_name": "LiveStore:mutations",
                 "children": [
@@ -415,10 +416,21 @@ describe.concurrent('useRow', () => {
                     },
                     "children": [
                       {
-                        "_name": "livestore.in-memory-db:execute",
+                        "_name": "LiveStore:mutatetWithoutRefresh",
                         "attributes": {
-                          "sql.query": "insert into UserInfo (username, text, id) select $username, $text, $id where not exists(select 1 from UserInfo where id = 'u1')",
+                          "livestore.args": "{
+            "id": "u1"
+          }",
+                          "livestore.mutation": "_Derived_Create_UserInfo",
                         },
+                        "children": [
+                          {
+                            "_name": "livestore.in-memory-db:execute",
+                            "attributes": {
+                              "sql.query": "INSERT INTO UserInfo (username, text, id) VALUES ($username, $text, $id)",
+                            },
+                          },
+                        ],
                       },
                       {
                         "_name": "LiveStore:useQuery:sql(rowQuery:query:UserInfo:u1)",
@@ -490,10 +502,18 @@ describe.concurrent('useRow', () => {
                 "_name": "sql-in-memory-select",
                 "attributes": {
                   "sql.cached": false,
-                  "sql.query": "SELECT schemaHash FROM __livestore_schema WHERE tableName = 'UserInfo'",
+                  "sql.query": "select 1 from UserInfo where id = 'u1'",
                   "sql.rowsCount": 0,
                 },
               },
+              {
+                "_name": "sql-in-memory-select",
+                "attributes": {
+                  "sql.cached": false,
+                  "sql.query": "select 1 from UserInfo where id = 'u2'",
+                  "sql.rowsCount": 1,
+                },
+              },
               {
                 "_name": "LiveStore:mutations",
                 "children": [
@@ -559,10 +579,21 @@ describe.concurrent('useRow', () => {
                     },
                     "children": [
                       {
-                        "_name": "livestore.in-memory-db:execute",
+                        "_name": "LiveStore:mutatetWithoutRefresh",
                         "attributes": {
-                          "sql.query": "insert into UserInfo (username, text, id) select $username, $text, $id where not exists(select 1 from UserInfo where id = 'u1')",
+                          "livestore.args": "{
+            "id": "u1"
+          }",
+                          "livestore.mutation": "_Derived_Create_UserInfo",
                         },
+                        "children": [
+                          {
+                            "_name": "livestore.in-memory-db:execute",
+                            "attributes": {
+                              "sql.query": "INSERT INTO UserInfo (username, text, id) VALUES ($username, $text, $id)",
+                            },
+                          },
+                        ],
                       },
                       {
                         "_name": "LiveStore:useQuery:sql(rowQuery:query:UserInfo:u1)",
@@ -605,12 +636,6 @@ describe.concurrent('useRow', () => {
                       "id": "u2",
                     },
                     "children": [
-                      {
-                        "_name": "livestore.in-memory-db:execute",
-                        "attributes": {
-                          "sql.query": "insert into UserInfo (username, text, id) select $username, $text, $id where not exists(select 1 from UserInfo where id = 'u2')",
-                        },
-                      },
                       {
                         "_name": "LiveStore:useQuery:sql(rowQuery:query:UserInfo:u2)",
                         "attributes": {

package/src/react/useRow.ts

@@ -1,11 +1,14 @@
+import type { QueryInfo } from '@livestore/common'
+import {} from // deriveCreateMutationDef as deriveCreateMutationDef_,
+// updateMutationForQueryInfo as updateMutationForQueryInfo_,
+'@livestore/common'
 import { DbSchema } from '@livestore/common/schema'
+import { shouldNeverHappen } from '@livestore/utils'
 import type { SqliteDsl } from 'effect-db-schema'
 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 { useStore } from './LiveStoreContext.js'
@@ -40,7 +43,7 @@ export const useRow: {
     TTableDef extends DbSchema.TableDef<
       DbSchema.DefaultSqliteTableDef,
       boolean,
-      DbSchema.TableOptions & { isSingleton: true }
+      DbSchema.TableOptions & { isSingleton: true; deriveMutations: true }
     >,
   >(
     table: TTableDef,
@@ -50,7 +53,7 @@ export const useRow: {
     TTableDef extends DbSchema.TableDef<
       DbSchema.DefaultSqliteTableDef,
       boolean,
-      DbSchema.TableOptions & { isSingleton: false }
+      DbSchema.TableOptions & { isSingleton: false; deriveMutations: true }
     >,
   >(
     table: TTableDef,
@@ -58,7 +61,13 @@ export const useRow: {
     id: string,
     options?: UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>,
   ): UseRowResult<TTableDef>
-} = <TTableDef extends DbSchema.TableDef>(
+} = <
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: true }
+  >,
+>(
   table: TTableDef,
   idOrOptions?: string | UseRowOptionsBase,
   options_?: UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>,
@@ -68,11 +77,25 @@ export const useRow: {
   const options: (UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>) | undefined =
     typeof idOrOptions === 'string' ? options_ : idOrOptions
   const { defaultValues, dbGraph } = options ?? {}
+
   type TComponentState = SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
 
+  const tableName = table.sqliteDef.name
+
+  if (DbSchema.tableHasDerivedMutations(table) === false) {
+    shouldNeverHappen(`useRow called on table "${tableName}" which does not have 'deriveMutations: true' set`)
+  }
+
   const { store } = useStore()
 
-  // console.debug('useRow', table.sqliteDef.name, id)
+  if (
+    store.schema.tables.has(table.sqliteDef.name) === false &&
+    table.sqliteDef.name.startsWith('__livestore') === false
+  ) {
+    shouldNeverHappen(`Table "${table.sqliteDef.name}" not found in schema`)
+  }
+
+  // console.debug('useRow', tableName, id)
 
   const { query$, otelContext } = useMakeTemporaryQuery(
     (otelContext) =>
@@ -83,10 +106,10 @@ export const useRow: {
             defaultValues: defaultValues!,
             dbGraph,
           }) as any as LiveQuery<RowResult<TTableDef>, QueryInfo>),
-    [id!, table.sqliteDef.name],
+    [id!, tableName],
     {
       otel: {
-        spanName: `LiveStore:useRow:${table.sqliteDef.name}${id === undefined ? '' : `:${id}`}`,
+        spanName: `LiveStore:useRow:${tableName}${id === undefined ? '' : `:${id}`}`,
         attributes: { id },
       },
     },
@@ -100,7 +123,13 @@ export const useRow: {
         const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
         if (query$Ref.current === newValue) return
 
-        store.mutate(mutationForQueryInfo(query$.queryInfo!, { value: newValue }))
+        // NOTE we need to account for the short-hand syntax for single-column+singleton tables
+        if (table.options.isSingleton) {
+          store.mutate(table.update(newValue))
+        } else {
+          store.mutate(table.update({ where: { id }, values: { value: newValue } }))
+        }
+        // store.mutate(updateMutationForQueryInfo(query$.queryInfo!, { value: newValue }))
       }
     } else {
       const setState = // TODO: do we have a better type for the values that can go in SQLite?
@@ -113,7 +142,8 @@ export const useRow: {
           // @ts-expect-error TODO fix typing
           if (query$Ref.current[columnName] === newValue) return
 
-          store.mutate(mutationForQueryInfo(query$.queryInfo!, { [columnName]: newValue }))
+          store.mutate(table.update({ where: { id: id ?? 'singleton' }, values: { [columnName]: newValue } }))
+          // store.mutate(updateMutationForQueryInfo(query$.queryInfo!, { [columnName]: newValue }))
         })
 
       setState.setMany = (columnValuesOrFn: Partial<TComponentState>) => {
@@ -130,12 +160,13 @@ export const useRow: {
           return
         }
 
-        store.mutate(mutationForQueryInfo(query$.queryInfo!, columnValues))
+        store.mutate(table.update({ where: { id: id ?? 'singleton' }, values: columnValues }))
+        // store.mutate(updateMutationForQueryInfo(query$.queryInfo!, columnValues))
       }
 
       return setState as any
     }
-  }, [query$.queryInfo, query$Ref, sqliteTableDef.columns, store, table.isSingleColumn])
+  }, [id, query$Ref, sqliteTableDef.columns, store, table])
 
   return [query$Ref.current, setState, query$]
 }