@livestore/livestore 0.0.39-dev.3 → 0.0.40

package/src/reactiveQueries/sql.ts

@@ -3,9 +3,9 @@ import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import { globalDbGraph } from '../global-state.js'
+import type { QueryInfo, QueryInfoNone } from '../query-info.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
-import type { UpdatePathDesc, UpdatePathDescNone } from '../update-path.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { Bindable } from '../utils/util.js'
 import { prepareBindValues } from '../utils/util.js'
@@ -14,12 +14,12 @@ import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
 export type MapRows<TResult, TRaw = any> =
   | ((rows: ReadonlyArray<TRaw>) => TResult)
-  | Schema.Schema<ReadonlyArray<TRaw>, TResult>
+  | Schema.Schema<never, ReadonlyArray<TRaw>, TResult>
 
-export const querySQL = <Result, TRaw = any>(
+export const querySQL = <TResult, TRaw = any>(
   query: string | ((get: GetAtomResult) => string),
   options?: {
-    map?: MapRows<Result, TRaw>
+    map?: MapRows<TResult, TRaw>
     /**
      * Can be provided explicitly to slightly speed up initial query performance
      *
@@ -30,29 +30,29 @@ export const querySQL = <Result, TRaw = any>(
     label?: string
     dbGraph?: DbGraph
   },
-): LiveQuery<Result, UpdatePathDescNone> =>
-  new LiveStoreSQLQuery<Result, UpdatePathDescNone>({
+): LiveQuery<TResult, QueryInfoNone> =>
+  new LiveStoreSQLQuery<TResult, QueryInfoNone>({
     label: options?.label,
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
     dbGraph: options?.dbGraph,
     map: options?.map,
-    updatePathDesc: { _tag: 'None' },
+    queryInfo: { _tag: 'None' },
   })
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<
-  Result,
-  TUpdatePath extends UpdatePathDesc = UpdatePathDescNone,
-> extends LiveStoreQueryBase<Result, TUpdatePath> {
+export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> extends LiveStoreQueryBase<
+  TResult,
+  TQueryInfo
+> {
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
   queryString$: Thunk<string, DbContext, RefreshReason>
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<Result, DbContext, RefreshReason>
+  results$: Thunk<TResult, DbContext, RefreshReason>
 
   label: string
 
@@ -63,7 +63,7 @@ export class LiveStoreSQLQuery<
 
   private mapRows
 
-  updatePathDesc: TUpdatePath
+  queryInfo: TQueryInfo
 
   constructor({
     genQueryString,
@@ -73,16 +73,16 @@ export class LiveStoreSQLQuery<
     dbGraph,
     map,
     execBeforeFirstRun,
-    updatePathDesc,
+    queryInfo,
   }: {
     label?: string
     genQueryString: string | ((get: GetAtomResult) => string)
     queriedTables?: Set<string>
     bindValues?: Bindable
     dbGraph?: DbGraph
-    map?: MapRows<Result>
+    map?: MapRows<TResult>
     execBeforeFirstRun?: (ctx: DbContext) => void
-    updatePathDesc?: TUpdatePath
+    queryInfo?: TQueryInfo
   }) {
     super()
 
@@ -90,18 +90,18 @@ export class LiveStoreSQLQuery<
     this.label = `sql(${label})`
     this.dbGraph = dbGraph ?? globalDbGraph
     this.execBeforeFirstRun = execBeforeFirstRun
-    this.updatePathDesc = updatePathDesc ?? ({ _tag: 'None' } as TUpdatePath)
+    this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
     this.mapRows =
       map === undefined
-        ? (rows: any) => rows as Result
+        ? (rows: any) => rows as TResult
         : Schema.isSchema(map)
           ? (rows: any) => {
-              const parseResult = Schema.parseEither(map)(rows)
+              const parseResult = Schema.decodeEither(map as Schema.Schema<never, ReadonlyArray<any>, TResult>)(rows)
               if (parseResult._tag === 'Left') {
                 console.error(`Error parsing SQL query result: ${TreeFormatter.formatError(parseResult.left)}`)
                 return shouldNeverHappen(`Error parsing SQL query result: ${parseResult.left}`)
               } else {
-                return parseResult.right as Result
+                return parseResult.right as TResult
               }
             }
           : typeof map === 'function'
@@ -130,7 +130,7 @@ export class LiveStoreSQLQuery<
 
     const queriedTablesRef = { current: queriedTables }
 
-    const results$ = this.dbGraph.makeThunk<Result>(
+    const results$ = this.dbGraph.makeThunk<TResult>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
           'sql:...', // NOTE span name will be overridden further down
@@ -173,6 +173,8 @@ export class LiveStoreSQLQuery<
 
             const durationMs = getDurationMsFromSpan(span)
 
+            this.executionTimes.push(durationMs)
+
             setDebugInfo({ _tag: 'sql', label, query: sqlString, durationMs })
 
             return result
@@ -197,7 +199,7 @@ export class LiveStoreSQLQuery<
   //     label: `${this.label}:js`,
   //     onDestroy: () => this.destroy(),
   //     dbGraph: this.dbGraph,
-  //     updatePathDesc: undefined,
+  //     queryInfo: undefined,
   //   })
 
   /** Returns a reactive query  */

package/src/row-query.ts

@@ -6,8 +6,9 @@ import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 import { computed } from './index.js'
 import type { InMemoryDatabase } from './inMemoryDatabase.js'
 import { migrateTable } from './migrations.js'
+import type { QueryInfoCol, QueryInfoNone, QueryInfoRow } from './query-info.js'
 import type { Ref } from './reactive.js'
-import type { DbContext, DbGraph, GetResult, LiveQuery, LiveQueryAny } from './reactiveQueries/base-class.js'
+import type { DbContext, DbGraph, LiveQuery, LiveQueryAny } from './reactiveQueries/base-class.js'
 // import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
 import { SCHEMA_META_TABLE } from './schema/index.js'
@@ -18,7 +19,6 @@ import {
   type TableOptions,
 } from './schema/table-def.js'
 import type { RefreshReason } from './store.js'
-import type { UpdatePathDesc, UpdatePathDescCol, UpdatePathDescNone, UpdatePathDescRow } from './update-path.js'
 import type { GetValForKey } from './utils/util.js'
 import { prepareBindValues, sql } from './utils/util.js'
 
@@ -36,13 +36,13 @@ export type MakeRowQuery = {
   <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: true }>>(
     table: TTableDef,
     options?: RowQueryOptions,
-  ): LiveQuery<RowResult<TTableDef>, UpdatePathDescRow<TTableDef>>
+  ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
   <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: false }>>(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
     id: string,
     options?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
-  ): LiveQuery<RowResult<TTableDef>, UpdatePathDescRow<TTableDef>>
+  ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
 }
 
 // TODO also allow other where clauses and multiple rows
@@ -85,7 +85,7 @@ export const rowQuery: MakeRowQuery = <TTableDef extends TableDef>(
       if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
 
       const componentStateEffectSchema = SqliteDsl.structSchemaForTable(stateSchema)
-      const parseResult = Schema.parseEither(componentStateEffectSchema)(results[0]!)
+      const parseResult = Schema.decodeEither(componentStateEffectSchema)(results[0]!)
 
       if (parseResult._tag === 'Left') {
         console.error('decode error', TreeFormatter.formatError(parseResult.left), 'results', results)
@@ -94,7 +94,7 @@ export const rowQuery: MakeRowQuery = <TTableDef extends TableDef>(
 
       return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
     },
-    updatePathDesc: { _tag: 'Row', table, id: id ?? 'singleton' },
+    queryInfo: { _tag: 'Row', table, id: id ?? 'singleton' },
   })
 }
 
@@ -107,20 +107,20 @@ export type RowResultEncoded<TTableDef extends TableDef> = TTableDef['isSingleCo
   : SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>
 
 export const deriveColQuery: {
-  <TQuery extends LiveQuery<any, UpdatePathDescNone>, TCol extends keyof TQuery['result!'] & string>(
+  <TQuery extends LiveQuery<any, QueryInfoNone>, TCol extends keyof TQuery['__result!'] & string>(
     query$: TQuery,
     colName: TCol,
-  ): LiveQuery<TQuery['result!'][TCol], UpdatePathDescNone>
-  <TQuery extends LiveQuery<any, UpdatePathDescRow<any>>, TCol extends keyof TQuery['result!'] & string>(
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfoNone>
+  <TQuery extends LiveQuery<any, QueryInfoRow<any>>, TCol extends keyof TQuery['__result!'] & string>(
     query$: TQuery,
     colName: TCol,
-  ): LiveQuery<TQuery['result!'][TCol], UpdatePathDescCol<TQuery['updatePathDesc']['table'], TCol>>
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfoCol<TQuery['queryInfo']['table'], TCol>>
 } = (query$: LiveQueryAny, colName: string) => {
   return computed((get) => get(query$)[colName], {
     label: `deriveColQuery:${query$.label}:${colName}`,
-    updatePathDesc:
-      query$.updatePathDesc._tag === 'Row'
-        ? { _tag: 'Col', table: query$.updatePathDesc.table, column: colName, id: query$.updatePathDesc.id }
+    queryInfo:
+      query$.queryInfo._tag === 'Row'
+        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
         : undefined,
   }) as any
 }
@@ -138,20 +138,22 @@ 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 tableName = table.sqliteDef.name
-  const insertQuery = sql`insert into ${tableName} (${columnNames.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 })
+  const defaultColumnNames = [...Object.keys(defaultValues), 'id']
+  const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
+
+  const tableName = table.sqliteDef.name
+  const insertQuery = sql`insert into ${tableName} (${defaultColumnNames.join(
+    ', ',
+  )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = '${id}')`
+
+  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,56 +1,14 @@
 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'
 
-export const headUnsafe = <From, To>(schema: Schema.Schema<From, To>) =>
-  Schema.transform(
-    Schema.array(schema),
-    Schema.to(schema),
-    (rows) => rows[0]!,
-    (row) => [row],
-  )
-
-// export const head = <From, To>(schema: Schema.Schema<From, To>) =>
-//   Schema.transform(
-//     Schema.array(schema),
-//     Schema.optionFromSelf(Schema.to(schema)),
-//     (rows) => Option.fromNullable(rows[0]),
-//     (row) => (row._tag === 'None' ? [] : [row.value]),
-//   )
-
-export const headOr = <From, To>(schema: Schema.Schema<From, To>, fallback: To) =>
-  Schema.transform(
-    Schema.array(schema),
-    Schema.to(schema),
-    (rows) => rows[0] ?? fallback,
-    (row) => [row],
-  )
-
-// export const pluck = <From extends {}, To, K extends keyof From & keyof To & string>(
-//   schema: Schema.Schema<From, To>,
-//   prop: K,
-// ): Schema.Schema<From, To[K]> => {
-//   const toSchema = Schema.make(SchemaAST.getPropertySignatures(schema.ast).find((s) => s.name === prop)!.type) as any
-//   return Schema.transform(
-//     schema,
-//     toSchema,
-//     (row) => (row as any)[prop],
-//     (val) => ({ [prop]: val }) as any,
-//   )
-// }
-
-// export const schemaFor = <TTableDef extends TableDef>(
-//   table: TTableDef,
-// ): Schema.Schema<FromTable.RowEncoded<TTableDef>, FromTable.RowDecoded<TTableDef>> =>
-//   SqliteDsl.structSchemaForTable(table.sqliteDef) as any
-
 export const many = <TTableDef extends TableDef>(
   table: TTableDef,
 ): ((rawRows: ReadonlyArray<any>) => ReadonlyArray<FromTable.RowDecoded<TTableDef>>) => {
-  return Schema.parseSync(Schema.array(table.schema)) as TODO
+  return Schema.decodeSync(Schema.array(table.schema)) as TODO
 }
 
 export const first =
@@ -59,7 +17,7 @@ export const first =
     fallback?: FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>,
   ) =>
   (rawRows: ReadonlyArray<any>) => {
-    const rows = Schema.parseSync(Schema.array(table.schema))(rawRows)
+    const rows = Schema.decodeSync(Schema.array(table.schema))(rawRows)
 
     if (rows.length === 0) {
       const schemaDefaultValues = getDefaultValuesDecoded(table)

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'
 
@@ -18,7 +18,7 @@ export type DefaultSqliteTableDefConstrained = SqliteDsl.TableDefinition<string,
 //   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
 //   TIsSingleColumn extends boolean = boolean,
 //   TOptions extends TableOptions = TableOptions,
-// > = TableDefBase<TSqliteDef, TIsSingleColumn, TOptions> & { schema: Schema.Schema<any, any> }
+// > = TableDefBase<TSqliteDef, TIsSingleColumn, TOptions> & { schema: Schema.Schema<never, any, any> }
 
 // /**
 //  * NOTE in the past we used to have a single `TableDef` but there are some TS issues when indroducing
@@ -44,6 +44,7 @@ export type TableDef<
   // NOTE we're not using `SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>`
   // as we don't want the alias type for users to show up
   TSchema = Schema.Schema<
+    never,
     SqliteDsl.AnyIfConstained<
       TSqliteDef['columns'],
       { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.From<TSqliteDef['columns'][K]['schema']> }
@@ -159,6 +160,9 @@ export const getDefaultValuesEncoded = <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
@@ -172,6 +176,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)!
 }