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

package/src/derived-mutations.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'vitest'
+
+import { appConfig, todos } from './__tests__/fixture.js'
+import type { MutationEvent } from './schema/mutations.js'
+
+describe('derived mutations', () => {
+  test('todos', () => {
+    expect(patchId(todos.insert({ id: 't1', completed: true, text: 'Task 1' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "completed": true,
+          "id": "t1",
+          "text": "Task 1",
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_todos",
+      }
+    `)
+
+    expect(patchId(todos.update({ where: { id: 't1' }, values: { text: 'Task 1 - fixed' } }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "values": {
+            "text": "Task 1 - fixed",
+          },
+          "where": {
+            "id": "t1",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Update_todos",
+      }
+    `)
+
+    expect(patchId(todos.delete({ where: { id: 't1' } }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "where": {
+            "id": "t1",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Delete_todos",
+      }
+    `)
+  })
+
+  test('app_config', () => {
+    expect(patchId(appConfig.insert())).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "singleton",
+          "value": {
+            "value": undefined,
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_app_config",
+      }
+    `)
+
+    expect(patchId(appConfig.insert({ fontSize: 12, theme: 'dark' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "singleton",
+          "value": {
+            "value": {
+              "fontSize": 12,
+              "theme": "dark",
+            },
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_app_config",
+      }
+    `)
+
+    expect(patchId(appConfig.update({ fontSize: 13 }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "values": {
+            "value": {
+              "fontSize": 13,
+            },
+          },
+          "where": {
+            "id": "singleton",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Update_app_config",
+      }
+    `)
+  })
+})
+
+const patchId = (muationEvent: MutationEvent.Any) => {
+  const id = `00000000-0000-0000-0000-000000000000`
+  return { ...muationEvent, id }
+}

package/src/derived-mutations.ts

@@ -0,0 +1,126 @@
+import type { GetValForKey } from '@livestore/utils'
+import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
+import type { SqliteDsl } from 'effect-db-schema'
+
+import type { MutationEvent } from './schema/index.js'
+import { DbSchema, defineMutation } from './schema/index.js'
+import type { TableOptions } from './schema/table-def.js'
+import { deleteRows, insertRow, updateRows } from './sql-queries/sql-queries.js'
+
+export const makeDerivedMutationDefsForTable = <TTableDef extends DbSchema.TableDef>(table: TTableDef) => ({
+  insert: deriveCreateMutationDef(table),
+  update: deriveUpdateMutationDef(table),
+  delete: deriveDeleteMutationDef(table),
+})
+
+export const deriveCreateMutationDef = <TTableDef extends DbSchema.TableDef>(table: TTableDef) => {
+  const tableName = table.sqliteDef.name
+
+  const [optionalFields, requiredColumns] = ReadonlyRecord.partition(
+    (table.sqliteDef as DbSchema.DefaultSqliteTableDef).columns,
+    (col) => col.nullable === false && col.default._tag === 'None',
+  )
+
+  const insertSchema = Schema.Struct(ReadonlyRecord.map(requiredColumns, (col) => col.schema)).pipe(
+    Schema.extend(Schema.partial(Schema.Struct(ReadonlyRecord.map(optionalFields, (col) => col.schema)))),
+  )
+
+  return defineMutation(`_Derived_Create_${tableName}`, insertSchema, ({ id, ...explicitDefaultValues }) => {
+    const defaultValues = DbSchema.getDefaultValuesDecoded(table, explicitDefaultValues)
+
+    const [sql, bindValues] = insertRow({
+      tableName: table.sqliteDef.name,
+      columns: table.sqliteDef.columns,
+      values: { ...defaultValues, id },
+    })
+
+    return { sql, bindValues, writeTables: new Set([tableName]) }
+  })
+}
+
+export const deriveUpdateMutationDef = <TTableDef extends DbSchema.TableDef>(table: TTableDef) => {
+  const tableName = table.sqliteDef.name
+
+  return defineMutation(
+    `_Derived_Update_${tableName}`,
+    Schema.Struct({
+      where: Schema.partial(table.schema),
+      values: Schema.partial(table.schema),
+    }),
+    ({ where, values }) => {
+      const [sql, bindValues] = updateRows({
+        tableName: table.sqliteDef.name,
+        columns: table.sqliteDef.columns,
+        where,
+        updateValues: values,
+      })
+
+      return { sql, bindValues, writeTables: new Set([tableName]) }
+    },
+  )
+}
+
+export const deriveDeleteMutationDef = <TTableDef extends DbSchema.TableDef>(table: TTableDef) => {
+  const tableName = table.sqliteDef.name
+
+  return defineMutation(
+    `_Derived_Delete_${tableName}`,
+    Schema.Struct({
+      where: Schema.partial(table.schema),
+    }),
+    ({ where }) => {
+      const [sql, bindValues] = deleteRows({
+        tableName: table.sqliteDef.name,
+        columns: table.sqliteDef.columns,
+        where,
+      })
+
+      return { sql, bindValues, writeTables: new Set([tableName]) }
+    },
+  )
+}
+
+/**
+ * Convenience helper functions on top of the derived mutation definitions.
+ */
+export type DerivedMutationHelperFns<TColumns extends SqliteDsl.ConstraintColumns, TOptions extends TableOptions> = {
+  insert: DerivedMutationHelperFns.InsertMutationFn<TColumns, TOptions>
+  update: DerivedMutationHelperFns.UpdateMutationFn<TColumns, TOptions>
+  delete: DerivedMutationHelperFns.DeleteMutationFn<TColumns, TOptions>
+  // TODO also consider adding upsert and deep json mutations (like lenses)
+}
+
+export namespace DerivedMutationHelperFns {
+  export type InsertMutationFn<
+    TColumns extends SqliteDsl.ConstraintColumns,
+    TOptions extends TableOptions,
+  > = SqliteDsl.AnyIfConstained<
+    TColumns,
+    UseShortcut<TOptions> extends true
+      ? (values?: GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TColumns>, 'value'>) => MutationEvent.Any
+      : (values: SqliteDsl.FromColumns.InsertRowDecoded<TColumns>) => MutationEvent.Any
+  >
+
+  export type UpdateMutationFn<
+    TColumns extends SqliteDsl.ConstraintColumns,
+    TOptions extends TableOptions,
+  > = SqliteDsl.AnyIfConstained<
+    TColumns,
+    UseShortcut<TOptions> extends true
+      ? (values: Partial<GetValForKey<SqliteDsl.FromColumns.RowDecoded<TColumns>, 'value'>>) => MutationEvent.Any
+      : (args: {
+          where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+          values: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+        }) => MutationEvent.Any
+  >
+
+  export type DeleteMutationFn<TColumns extends SqliteDsl.ConstraintColumns, _TOptions extends TableOptions> = (args: {
+    where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+  }) => MutationEvent.Any
+
+  type UseShortcut<TOptions extends TableOptions> = TOptions['isSingleColumn'] extends true
+    ? TOptions['isSingleton'] extends true
+      ? true
+      : false
+    : false
+}

package/src/index.ts

@@ -1,6 +1,10 @@
+export * from './schema/system-tables.js'
 export * from './util.js'
-export * from './database.js'
-export * from './migrations.js'
+export * from './adapter-types.js'
+export * from './schema-management/migrations.js'
 export * from './mutation.js'
 export * from './init-singleton-tables.js'
 export * from './rehydrate-from-mutationlog.js'
+export * from './query-info.js'
+export * from './derived-mutations.js'
+export * from './sync/index.js'

package/src/init-singleton-tables.ts

@@ -1,9 +1,9 @@
-import type { MainDatabase } from './database.js'
+import type { InMemoryDatabase } from './adapter-types.js'
 import type { LiveStoreSchema } from './schema/index.js'
 import { DbSchema } from './schema/index.js'
 import { prepareBindValues, sql } from './util.js'
 
-export const initializeSingletonTables = (schema: LiveStoreSchema, db: MainDatabase) => {
+export const initializeSingletonTables = (schema: LiveStoreSchema, db: InMemoryDatabase) => {
   for (const [, tableDef] of schema.tables) {
     if (tableDef.options.isSingleton) {
       const defaultValues = DbSchema.getDefaultValuesEncoded(tableDef, undefined)

package/src/query-info.ts

@@ -0,0 +1,104 @@
+import type { Schema } from '@livestore/utils/effect'
+
+import type { DbSchema } from './schema/index.js'
+
+/**
+ * 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 QueryInfo<TTableDef extends DbSchema.TableDef = DbSchema.TableDef> =
+  | QueryInfoNone
+  | QueryInfoRow<TTableDef>
+  | QueryInfoColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
+  | QueryInfoCol<TTableDef, keyof TTableDef['sqliteDef']['columns']>
+
+export type QueryInfoNone = {
+  _tag: 'None'
+}
+
+export type QueryInfoRow<TTableDef extends DbSchema.TableDef> = {
+  _tag: 'Row'
+  table: TTableDef
+  id: string
+}
+
+export type QueryInfoCol<
+  TTableDef extends DbSchema.TableDef,
+  TColName extends keyof TTableDef['sqliteDef']['columns'],
+> = {
+  _tag: 'Col'
+  table: TTableDef
+  id: string
+  column: TColName
+}
+
+export type QueryInfoColJsonValue<TTableDef extends DbSchema.TableDef, TColName extends GetJsonColumn<TTableDef>> = {
+  _tag: 'ColJsonValue'
+  table: TTableDef
+  id: string
+  column: TColName
+  /**
+   * example: `$.tabs[3].items[2]` (`$` referring to the column value)
+   */
+  jsonPath: string
+}
+
+type GetJsonColumn<TTableDef extends DbSchema.TableDef> = keyof {
+  [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
+    ? ColName
+    : never]: {}
+}
+
+export type UpdateValueForPath<TQueryInfo extends QueryInfo> = TQueryInfo extends { _tag: 'Row' }
+  ? Partial<DbSchema.FromTable.RowDecodedAll<TQueryInfo['table']>>
+  : TQueryInfo extends { _tag: 'Col' }
+    ? Schema.Schema.Type<TQueryInfo['table']['sqliteDef']['columns'][TQueryInfo['column']]['schema']>
+    : TQueryInfo extends { _tag: 'ColJsonValue' }
+      ? { TODO: true }
+      : never
+
+// export const mutationForQueryInfo = <const TQueryInfo extends QueryInfo>(
+//   queryInfo: TQueryInfo,
+//   value: UpdateValueForPath<TQueryInfo>,
+// ): RawSqlMutationEvent => {
+//   if (queryInfo._tag === 'ColJsonValue' || queryInfo._tag === 'None') {
+//     return notYetImplemented('TODO')
+//   }
+
+//   const sqliteTableDef = queryInfo.table.sqliteDef
+//   const id = queryInfo.id
+
+//   const { columnNames, bindValues } = (() => {
+//     if (queryInfo._tag === 'Row') {
+//       const columnNames = Object.keys(value)
+
+//       const partialStructSchema = queryInfo.table.schema.pipe(Schema.pick(...columnNames))
+
+//       // const columnNames = Object.keys(value)
+//       const encodedBindValues = Schema.encodeEither(partialStructSchema)(value)
+//       if (encodedBindValues._tag === 'Left') {
+//         return shouldNeverHappen(encodedBindValues.left.toString())
+//       } else {
+//         return { columnNames, bindValues: encodedBindValues.right }
+//       }
+//     } else if (queryInfo._tag === 'Col') {
+//       const columnName = queryInfo.column
+//       const columnSchema =
+//         sqliteTableDef.columns[columnName]?.schema ?? shouldNeverHappen(`Column ${columnName} not found`)
+//       const bindValues = { [columnName]: Schema.encodeSync(columnSchema)(value) }
+//       return { columnNames: [columnName], bindValues }
+//     } else {
+//       return shouldNeverHappen()
+//     }
+//   })()
+
+//   const updateClause = columnNames.map((columnName) => `${columnName} = $${columnName}`).join(', ')
+
+//   const whereClause = `where id = '${id}'`
+//   const sql = `UPDATE ${sqliteTableDef.name} SET ${updateClause} ${whereClause}`
+//   const writeTables = new Set<string>([queryInfo.table.sqliteDef.name])
+
+//   return rawSqlMutation({ sql, bindValues, writeTables })
+// }

package/src/rehydrate-from-mutationlog.ts

@@ -1,45 +1,52 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
-import type { MainDatabase } from './database.js'
+import type { InMemoryDatabase, MigrationOptionsFromMutationLog } from './adapter-types.js'
 import { getExecArgsFromMutation } from './mutation.js'
-import type { LiveStoreSchema } from './schema/index.js'
+import type { LiveStoreSchema, MutationLogMetaRow } from './schema/index.js'
+import { MUTATION_LOG_META_TABLE } from './schema/index.js'
 
-type MutationLogRow = {
-  id: string
-  mutation: string
-  args_json: string
-  schema_hash: number
-  created_at: string
-}
-
-export const rehydrateFromMutationLog = ({
+export const rehydrateFromMutationLog = async ({
   logDb,
   db,
   schema,
+  migrationOptions,
 }: {
-  logDb: MainDatabase
-  db: MainDatabase
+  logDb: InMemoryDatabase
+  db: InMemoryDatabase
   schema: LiveStoreSchema
+  migrationOptions: MigrationOptionsFromMutationLog
 }) => {
   try {
-    const stmt = logDb.prepare('SELECT * FROM mutation_log ORDER BY id ASC')
-    const results = stmt.select<MutationLogRow>(undefined)
+    // TODO possibly implement this in a streaming fashion
+    const stmt = logDb.prepare(`SELECT * FROM ${MUTATION_LOG_META_TABLE} ORDER BY id ASC`)
+    const results = stmt.select<MutationLogMetaRow>(undefined)
 
     performance.mark('livestore:hydrate-from-mutationlog:start')
 
     for (const row of results) {
       const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
 
-      if (Schema.hash(mutationDef.schema) !== row.schema_hash) {
-        throw new Error(`Schema hash mismatch for mutation ${row.mutation}`)
+      if (migrationOptions.excludeMutations?.has(row.mutation) === true) continue
+
+      if (Schema.hash(mutationDef.schema) !== row.schemaHash) {
+        console.warn(`Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`)
+      }
+
+      const argsDecodedEither = Schema.decodeUnknownEither(Schema.parseJson(mutationDef.schema))(row.argsJson)
+      if (argsDecodedEither._tag === 'Left') {
+        return shouldNeverHappen(`\
+There was an error decoding the persisted mutation event args for mutation "${row.mutation}".
+This likely means the schema has changed in an incompatible way.
+
+Error: ${argsDecodedEither.left}
+        `)
       }
 
-      const argsDecoded = Schema.decodeUnknownSync(Schema.parseJson(mutationDef.schema))(row.args_json)
       const mutationEventDecoded = {
         id: row.id,
         mutation: row.mutation,
-        args: argsDecoded,
+        args: argsDecodedEither.right,
       }
       // const argsEncoded = JSON.parse(row.args_json)
       // const mutationSqlRes =
@@ -53,7 +60,14 @@ export const rehydrateFromMutationLog = ({
 
       for (const { statementSql, bindValues } of execArgsArr) {
         try {
-          db.execute(statementSql, bindValues)
+          const getRowsChanged = db.execute(statementSql, bindValues)
+          if (
+            import.meta.env.DEV &&
+            getRowsChanged() === 0 &&
+            migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
+          ) {
+            console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+          }
           // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
         } catch (e) {
           console.error(`Error executing migration for mutation ${statementSql}`, bindValues, e)

package/src/schema/index.ts

@@ -1,7 +1,9 @@
-import { isReadonlyArray } from '@livestore/utils'
+import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 import type { ReadonlyArray } from '@livestore/utils/effect'
 import { SqliteAst, type SqliteDsl } from 'effect-db-schema'
 
+import type { MigrationOptions } from '../adapter-types.js'
+import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
 import {
   type MutationDef,
   type MutationDefMap,
@@ -28,6 +30,10 @@ export type LiveStoreSchema<
 
   readonly tables: Map<string, TableDef>
   readonly mutations: MutationDefMap
+  /** Compound hash of all table defs etc */
+  readonly hash: number
+
+  migrationOptions: MigrationOptions
 }
 
 export type InputSchema = {
@@ -37,20 +43,22 @@ export type InputSchema = {
 
 export const makeSchema = <TInputSchema extends InputSchema>(
   /** 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']>,
-  MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
-> => {
-  const inputTables: ReadonlyArray<TableDef> = Array.isArray(schema.tables)
-    ? schema.tables
-    : // TODO validate that table names are unique in this case
-      Object.values(schema.tables)
+  inputSchema: TInputSchema & {
+    /** "hard-reset" is currently the default strategy */
+    migrations?: MigrationOptions<FromInputSchema.DeriveSchema<TInputSchema>>
+  },
+): FromInputSchema.DeriveSchema<TInputSchema> => {
+  const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)
+    ? inputSchema.tables
+    : Object.values(inputSchema.tables)
 
   const tables = new Map<string, TableDef>()
 
   for (const tableDef of inputTables) {
     // TODO validate tables (e.g. index names are unique)
+    if (tables.has(tableDef.sqliteDef.ast.name)) {
+      shouldNeverHappen(`Duplicate table name: ${tableDef.sqliteDef.ast.name}. Please use unique names for tables.`)
+    }
     tables.set(tableDef.sqliteDef.ast.name, tableDef)
   }
 
@@ -60,47 +68,67 @@ export const makeSchema = <TInputSchema extends InputSchema>(
 
   const mutations: MutationDefMap = new Map()
 
-  if (isReadonlyArray(schema.mutations)) {
-    for (const mutation of schema.mutations) {
+  if (isReadonlyArray(inputSchema.mutations)) {
+    for (const mutation of inputSchema.mutations) {
       mutations.set(mutation.name, mutation)
     }
   } else {
-    for (const [name, mutation] of Object.entries(schema.mutations ?? {})) {
-      mutations.set(name, mutation)
+    for (const mutation of Object.values(inputSchema.mutations ?? {})) {
+      if (mutations.has(mutation.name)) {
+        shouldNeverHappen(`Duplicate mutation name: ${mutation.name}. Please use unique names for mutations.`)
+      }
+      mutations.set(mutation.name, mutation)
     }
   }
 
-  mutations.set('livestore.RawSql', rawSqlMutation)
+  mutations.set(rawSqlMutation.name, rawSqlMutation)
+
+  for (const tableDef of tables.values()) {
+    if (tableDef.options.deriveMutations) {
+      const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
+      mutations.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
+      mutations.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
+      mutations.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
+    }
+  }
+
+  const hash = SqliteAst.hash({
+    _tag: 'dbSchema',
+    tables: [...tables.values()].map((_) => _.sqliteDef.ast),
+  })
 
   return {
     _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
     _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
     tables,
     mutations,
+    migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },
+    hash,
   } satisfies LiveStoreSchema
 }
 
-export const makeSchemaHash = (schema: LiveStoreSchema) =>
-  SqliteAst.hash({
-    _tag: 'dbSchema',
-    tables: [...schema.tables.values()].map((_) => _.sqliteDef.ast),
-  })
-
-/**
- * In case of ...
- * - array: we use the table name of each array item (= table definition) as the object key
- * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
- */
-export type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
-  TTables extends ReadonlyArray<TableDef>
-    ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
-    : 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
+namespace FromInputSchema {
+  export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
+    DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
+    MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
+  >
+
+  /**
+   * In case of ...
+   * - array: we use the table name of each array item (= table definition) as the object key
+   * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
+   */
+  type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
+    TTables extends ReadonlyArray<TableDef>
+      ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
+      : TTables extends Record<string, TableDef>
+        ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
+        : never
+
+  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

@@ -77,10 +77,10 @@ export const makeMutationDefRecord = <TInputRecord extends Record<string, Mutati
 
 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)),
+  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 }),
 )
@@ -94,8 +94,15 @@ export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
   id: string
 }
 
+export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
+  mutation: TMutationsDef['name']
+  args: Schema.Schema.Encoded<TMutationsDef['schema']>
+  id: string
+}
+
 export namespace MutationEvent {
   export type Any = MutationEvent<MutationDef.Any>
+  export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
 
   export type ForSchema<TSchema extends LiveStoreSchema> = {
     [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
@@ -122,12 +129,24 @@ export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> =
 export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefRecord>(
   mutationDefRecord: TMutationsDefRecord,
 ): MutationEventSchema<TMutationsDefRecord> =>
-  Schema.union(
+  Schema.Union(
     ...Object.values(mutationDefRecord).map((def) =>
-      Schema.struct({
-        mutation: Schema.literal(def.name),
+      Schema.Struct({
+        mutation: Schema.Literal(def.name),
         args: def.schema,
-        id: Schema.string,
+        id: Schema.String,
       }),
     ),
-  ) as any
+  ).annotations({ title: 'MutationEventSchema' }) as any
+
+export const mutationEventSchemaDecodedAny = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: Schema.String,
+}).annotations({ title: 'MutationEventSchema.DecodedAny' })
+
+export const mutationEventSchemaEncodedAny = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: Schema.String,
+}).annotations({ title: 'MutationEventSchema.EncodedAny' })