@livestore/common 0.3.0-dev.3 → 0.3.0-dev.31

package/src/schema/db-schema/dsl/mod.ts

@@ -0,0 +1,222 @@
+import type { Nullable } from '@livestore/utils'
+import type { Option, Types } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
+
+import type * as SqliteAst from '../ast/sqlite.js'
+import type { ColumnDefinition } from './field-defs.js'
+
+export * from './field-defs.js'
+
+export type DbSchema = {
+  [key: string]: TableDefinition<string, Columns>
+}
+
+/** Note when using the object-notation, the object keys are ignored and not used as table names */
+export type DbSchemaInput = Record<string, TableDefinition<any, any>> | ReadonlyArray<TableDefinition<any, any>>
+
+/**
+ * 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 DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
+  TSchemaInput extends ReadonlyArray<TableDefinition<any, any>>
+    ? { [K in TSchemaInput[number] as K['name']]: K }
+    : TSchemaInput extends Record<string, TableDefinition<any, any>>
+      ? { [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K] }
+      : never
+
+// TODO ensure via runtime check (possibly even via type-level check) that all index names are unique
+export const makeDbSchema = <TDbSchemaInput extends DbSchemaInput>(
+  schema: TDbSchemaInput,
+): DbSchemaFromInputSchema<TDbSchemaInput> => {
+  return Array.isArray(schema) ? Object.fromEntries(schema.map((_) => [_.name, _])) : (schema as any)
+}
+
+export const table = <TTableName extends string, TColumns extends Columns, TIndexes extends Index[]>(
+  name: TTableName,
+  columns: TColumns,
+  indexes?: TIndexes,
+): TableDefinition<TTableName, TColumns> => {
+  const ast: SqliteAst.Table = {
+    _tag: 'table',
+    name,
+    columns: columsToAst(columns),
+    indexes: indexesToAst(indexes ?? []),
+  }
+
+  return { name, columns, indexes, ast }
+}
+
+export type AnyIfConstained<In, Out> = '__constrained' extends keyof In ? any : Out
+export type EmptyObjIfConstained<In> = '__constrained' extends keyof In ? {} : In
+
+export type StructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<
+  AnyIfConstained<TCols, FromColumns.RowDecoded<TCols>>,
+  AnyIfConstained<TCols, FromColumns.RowEncoded<TCols>>
+>
+
+export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<
+  AnyIfConstained<TCols, FromColumns.InsertRowDecoded<TCols>>,
+  AnyIfConstained<TCols, FromColumns.InsertRowEncoded<TCols>>
+>
+
+export const structSchemaForTable = <TTableDefinition extends TableDefinition<any, any>>(
+  tableDef: TTableDefinition,
+): StructSchemaForColumns<TTableDefinition['columns']> =>
+  Schema.Struct(Object.fromEntries(tableDef.ast.columns.map((column) => [column.name, column.schema]))).annotations({
+    title: tableDef.name,
+  }) as any
+
+export const insertStructSchemaForTable = <TTableDefinition extends TableDefinition<any, any>>(
+  tableDef: TTableDefinition,
+): InsertStructSchemaForColumns<TTableDefinition['columns']> =>
+  Schema.Struct(
+    Object.fromEntries(
+      tableDef.ast.columns.map((column) => [
+        column.name,
+        column.nullable === true || column.default._tag === 'Some' ? Schema.optional(column.schema) : column.schema,
+      ]),
+    ),
+  ).annotations({
+    title: tableDef.name,
+  }) as any
+
+const columsToAst = (columns: Columns): ReadonlyArray<SqliteAst.Column> => {
+  return Object.entries(columns).map(([name, column]) => {
+    return {
+      _tag: 'column',
+      name,
+      schema: column.schema,
+      default: column.default as any,
+      nullable: column.nullable ?? false,
+      primaryKey: column.primaryKey ?? false,
+      type: { _tag: column.columnType },
+    } satisfies SqliteAst.Column
+  })
+}
+
+const indexesToAst = (indexes: ReadonlyArray<Index>): ReadonlyArray<SqliteAst.Index> => {
+  return indexes.map(
+    (_) => ({ _tag: 'index', columns: _.columns, name: _.name, unique: _.isUnique ?? false }) satisfies SqliteAst.Index,
+  )
+}
+
+/// Other
+
+export type TableDefinition<TName extends string, TColumns extends Columns> = {
+  name: TName
+  columns: TColumns
+  indexes?: ReadonlyArray<Index>
+  ast: SqliteAst.Table
+}
+
+export type Columns = Record<string, ColumnDefinition<any, any>>
+
+export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> =
+  TColumns extends ColumnDefinition<any, any> ? true : false
+
+/**
+ * NOTE this is only needed to avoid a TS limitation where `StructSchemaForColumns` in the default case
+ * results in `Record<string, any>` instead of `any`. (Thanks to Andarist for the workaround)
+ *
+ * Hopefully this can be removed in the future
+ */
+export type ConstraintColumns = Record<string, ColumnDefinition<any, any>> & { __constrained?: never }
+
+export type Index = {
+  name: string
+  columns: ReadonlyArray<string>
+  /** @default false */
+  isUnique?: boolean
+}
+
+export namespace FromTable {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TTableDefinition extends TableDefinition<any, any>> = Types.Simplify<
+    Nullable<Pick<RowDecodedAll<TTableDefinition>, NullableColumnNames<TTableDefinition>>> &
+      Omit<RowDecodedAll<TTableDefinition>, NullableColumnNames<TTableDefinition>>
+  >
+
+  export type NullableColumnNames<TTableDefinition extends TableDefinition<any, any>> = FromColumns.NullableColumnNames<
+    TTableDefinition['columns']
+  >
+
+  export type Columns<TTableDefinition extends TableDefinition<any, any>> = {
+    [K in keyof TTableDefinition['columns']]: TTableDefinition['columns'][K]['columnType']
+  }
+
+  export type RowEncodeNonNullable<TTableDefinition extends TableDefinition<any, any>> = {
+    [K in keyof TTableDefinition['columns']]: Schema.Schema.Encoded<TTableDefinition['columns'][K]['schema']>
+  }
+
+  export type RowEncoded<TTableDefinition extends TableDefinition<any, any>> = Types.Simplify<
+    Nullable<Pick<RowEncodeNonNullable<TTableDefinition>, NullableColumnNames<TTableDefinition>>> &
+      Omit<RowEncodeNonNullable<TTableDefinition>, NullableColumnNames<TTableDefinition>>
+  >
+
+  // export type RowEncoded<TTableDefinition extends TableDefinition<any, any>> = NullableColumnNames<
+  //   TTableDefinition['columns']
+  // >
+
+  //   &
+  //     Omit<RowEncodeNonNullable<TTableDefinition>, NullableColumnNames<TTableDefinition['columns']>>
+  // >
+
+  export type RowDecodedAll<TTableDefinition extends TableDefinition<any, any>> = {
+    [K in keyof TTableDefinition['columns']]: Schema.Schema.Type<TTableDefinition['columns'][K]['schema']>
+  }
+}
+
+export namespace FromColumns {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TColumns extends Columns> = Types.Simplify<
+    Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowDecodedAll<TColumns extends Columns> = {
+    readonly [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
+  }
+
+  export type RowEncodedAll<TColumns extends Columns> = {
+    readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+  }
+
+  export type RowEncoded<TColumns extends Columns> = Types.Simplify<
+    Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowEncodeNonNullable<TColumns extends Columns> = {
+    readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+  }
+
+  export type NullableColumnNames<TColumns extends Columns> = keyof {
+    // TODO double check why there is a `true` in the type
+    [K in keyof TColumns as TColumns[K] extends ColumnDefinition<any, true> ? K : never]: {}
+  }
+
+  export type RequiredInsertColumns<TColumns extends Columns> = {
+    [K in keyof TColumns as TColumns[K]['nullable'] extends true
+      ? never
+      : TColumns[K]['default'] extends Option.Some<any>
+        ? never
+        : K]: {}
+  }
+
+  export type RequiredInsertColumnNames<TColumns extends Columns> = keyof RequiredInsertColumns<TColumns>
+
+  export type RequiresInsertValues<TColumns extends Columns> =
+    RequiredInsertColumnNames<TColumns> extends never ? false : true
+
+  export type InsertRowDecoded<TColumns extends Columns> = Types.Simplify<
+    Pick<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &
+      Partial<Omit<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>>
+  >
+
+  export type InsertRowEncoded<TColumns extends Columns> = Types.Simplify<
+    Pick<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &
+      Partial<Omit<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>>
+  >
+}

package/src/schema/db-schema/hash.ts

@@ -0,0 +1,14 @@
+// Based on https://stackoverflow.com/a/7616484
+export const hashCode = (str: string) => {
+  let hash = 0,
+    i,
+    chr
+  if (str.length === 0) return hash
+  for (i = 0; i < str.length; i++) {
+    // eslint-disable-next-line unicorn/prefer-code-point
+    chr = str.charCodeAt(i)
+    hash = (hash << 5) - hash + chr
+    hash = Math.trunc(hash) // Convert to 32bit integer
+  }
+  return hash
+}

package/src/schema/db-schema/mod.ts

@@ -0,0 +1,2 @@
+export * as SqliteDsl from './dsl/mod.js'
+export * as SqliteAst from './ast/sqlite.js'

package/src/schema/events.ts

@@ -0,0 +1 @@
+export { defineEvent, synced, clientOnly } from './EventDef.js'

package/src/schema/mod.ts

@@ -1,7 +1,9 @@
 export * from './system-tables.js'
-export * as DbSchema from './table-def.js'
-export * from './mutations.js'
+export { SqliteAst, SqliteDsl } from './db-schema/mod.js'
+export * from './EventDef.js'
 export * from './schema-helpers.js'
 export * from './schema.js'
-export * as MutationEvent from './MutationEvent.js'
+export * as State from './view.js'
+export * as LiveStoreEvent from './LiveStoreEvent.js'
 export * as EventId from './EventId.js'
+export * as Events from './events.js'

package/src/schema/schema-helpers.ts

@@ -1,7 +1,7 @@
-import { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 
+import { SqliteDsl } from '../schema/db-schema/mod.js'
 import type { TableDef, TableDefBase } from './table-def.js'
 
 export const getDefaultValuesEncoded = <TTableDef extends TableDef>(

package/src/schema/schema.ts

@@ -1,100 +1,101 @@
-import type { SqliteDsl } from '@livestore/db-schema'
-import { SqliteAst } from '@livestore/db-schema'
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 
 import type { MigrationOptions } from '../adapter-types.js'
-import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
-import {
-  type MutationDef,
-  type MutationDefMap,
-  type MutationDefRecord,
-  type RawSqlMutation,
-  rawSqlMutation,
-} from './mutations.js'
+import { tableIsClientDocumentTable } from './client-document-def.js'
+import type { SqliteDsl } from './db-schema/mod.js'
+import { SqliteAst } from './db-schema/mod.js'
+import type { EventDef, EventDefRecord, Materializer, RawSqlEvent } from './EventDef.js'
+import { rawSqlEvent } from './EventDef.js'
 import { systemTables } from './system-tables.js'
-import type { TableDef, TableDefBase } from './table-def.js'
-import { tableHasDerivedMutations } from './table-def.js'
+import type { TableDef } from './table-def.js'
 
 export const LiveStoreSchemaSymbol = Symbol.for('livestore.LiveStoreSchema')
 export type LiveStoreSchemaSymbol = typeof LiveStoreSchemaSymbol
 
 export type LiveStoreSchema<
   TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
-  TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
+  TEventsDefRecord extends EventDefRecord = EventDefRecord,
 > = {
   readonly _Type: LiveStoreSchemaSymbol
   /** Only used on type-level */
   readonly _DbSchemaType: TDbSchema
   /** Only used on type-level */
-  readonly _MutationDefMapType: TMutationsDefRecord
+  readonly _EventDefMapType: TEventsDefRecord
 
+  // TODO remove in favour of `state`
   readonly tables: Map<string, TableDef>
-  readonly mutations: MutationDefMap
   /** Compound hash of all table defs etc */
   readonly hash: number
+  readonly state: State
+
+  readonly eventsDefsMap: Map<string, EventDef.AnyWithoutFn>
+
+  // readonly materializers: Map<string, Materializer>
 
   migrationOptions: MigrationOptions
 }
 
+export type State = {
+  readonly tables: Map<string, TableDef.Any>
+  readonly materializers: Map<string, Materializer>
+}
+
 export type InputSchema = {
-  readonly tables: Record<string, TableDefBase> | ReadonlyArray<TableDefBase>
-  readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
-  /**
-   * Can be used to isolate multiple LiveStore apps running in the same origin
-   */
-  // TODO remove this in favour of storeId
-  readonly key?: string
+  readonly events: ReadonlyArray<EventDef.AnyWithoutFn> | Record<string, EventDef.AnyWithoutFn>
+  readonly state: State
 }
 
 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 */
+  /** Note when using the object-notation for tables/events, the object keys are ignored and not used as table/mutation names */
   inputSchema: TInputSchema & {
     /** "hard-reset" is currently the default strategy */
-    migrations?: MigrationOptions<FromInputSchema.DeriveSchema<TInputSchema>>
+    migrations?: MigrationOptions
   },
 ): FromInputSchema.DeriveSchema<TInputSchema> => {
-  const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)
-    ? inputSchema.tables
-    : Object.values(inputSchema.tables)
+  // const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)
+  //   ? inputSchema.tables
+  //   : Object.values(inputSchema.tables)
 
-  const tables = new Map<string, TableDef>()
+  // const inputTables = []
 
-  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)
-  }
+  // 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)
+  // }
+
+  const state = inputSchema.state
+  const tables = inputSchema.state.tables
 
   for (const tableDef of systemTables) {
-    // @ts-expect-error TODO fix type level issue
+    // // @ts-expect-error TODO fix type level issue
     tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
-  const mutations: MutationDefMap = new Map()
+  const eventsDefsMap = new Map<string, EventDef.AnyWithoutFn>()
 
-  if (isReadonlyArray(inputSchema.mutations)) {
-    for (const mutation of inputSchema.mutations) {
-      mutations.set(mutation.name, mutation)
+  if (isReadonlyArray(inputSchema.events)) {
+    for (const eventDef of inputSchema.events) {
+      eventsDefsMap.set(eventDef.name, eventDef)
     }
   } else {
-    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.`)
+    for (const eventDef of Object.values(inputSchema.events ?? {})) {
+      if (eventsDefsMap.has(eventDef.name)) {
+        shouldNeverHappen(`Duplicate event name: ${eventDef.name}. Please use unique names for events.`)
       }
-      mutations.set(mutation.name, mutation)
+      eventsDefsMap.set(eventDef.name, eventDef)
     }
   }
 
-  mutations.set(rawSqlMutation.name, rawSqlMutation)
+  eventsDefsMap.set(rawSqlEvent.name, rawSqlEvent)
 
   for (const tableDef of tables.values()) {
-    if (tableHasDerivedMutations(tableDef)) {
-      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)
+    if (tableIsClientDocumentTable(tableDef) && eventsDefsMap.has(tableDef.set.name) === false) {
+      eventsDefsMap.set(tableDef.set.name, tableDef.set)
     }
   }
 
@@ -106,18 +107,39 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   return {
     _Type: LiveStoreSchemaSymbol,
     _DbSchemaType: Symbol.for('livestore.DbSchemaType') as any,
-    _MutationDefMapType: Symbol.for('livestore.MutationDefMapType') as any,
-    tables,
-    mutations,
-    migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },
+    _EventDefMapType: Symbol.for('livestore.EventDefMapType') as any,
+    // tables,
+    // events,
+    state,
+    tables: state.tables,
+    eventsDefsMap,
+    migrationOptions: inputSchema.migrations ?? { strategy: 'from-eventlog' },
     hash,
   } satisfies LiveStoreSchema
 }
 
+export const getEventDef = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+  eventName: string,
+): {
+  eventDef: EventDef.AnyWithoutFn
+  materializer: Materializer
+} => {
+  const eventDef = schema.eventsDefsMap.get(eventName)
+  if (eventDef === undefined) {
+    return shouldNeverHappen(`No mutation definition found for \`${eventName}\`.`)
+  }
+  const materializer = schema.state.materializers.get(eventName)
+  if (materializer === undefined) {
+    return shouldNeverHappen(`No materializer found for \`${eventName}\`.`)
+  }
+  return { eventDef, materializer }
+}
+
 export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
-    DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
-    MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
+    DbSchemaFromInputSchemaTables<TInputSchema['state']['tables']>,
+    EventDefRecordFromInputSchemaEvents<TInputSchema['events']>
   >
 
   /**
@@ -125,17 +147,17 @@ export namespace FromInputSchema {
    * - 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']> =
+  type DbSchemaFromInputSchemaTables<TTables extends InputSchema['state']['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 }
+  type EventDefRecordFromInputSchemaEvents<TEvents extends InputSchema['events']> =
+    TEvents extends ReadonlyArray<EventDef.Any>
+      ? { [K in TEvents[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlEvent }
+      : TEvents extends { [name: string]: EventDef.Any }
+        ? { [K in keyof TEvents as TEvents[K]['name']]: TEvents[K] } & { 'livestore.RawSql': RawSqlEvent }
         : never
 }

package/src/schema/sqlite-state.ts

@@ -0,0 +1,62 @@
+import { shouldNeverHappen } from '@livestore/utils'
+
+import { ClientDocumentTableDefSymbol, tableIsClientDocumentTable } from './client-document-def.js'
+import { type Materializer, rawSqlEvent, rawSqlMaterializer } from './EventDef.js'
+import type { State } from './schema.js'
+import { systemTables } from './system-tables.js'
+import { type TableDef, type TableDefBase } from './table-def.js'
+
+export * from './table-def.js'
+export {
+  ClientDocumentTableDefSymbol,
+  tableIsClientDocumentTable,
+  clientDocument,
+  type ClientDocumentTableDef,
+  type ClientDocumentTableOptions,
+} from './client-document-def.js'
+export * from './EventDef.js'
+
+export const makeState = <TStateInput extends InputState>(inputSchema: TStateInput): State => {
+  const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)
+    ? inputSchema.tables
+    : Object.values(inputSchema.tables)
+
+  const tables = new Map<string, TableDef.Any>()
+
+  for (const tableDef of inputTables) {
+    const sqliteDef = tableDef.sqliteDef
+    // TODO validate tables (e.g. index names are unique)
+    if (tables.has(sqliteDef.ast.name)) {
+      shouldNeverHappen(`Duplicate table name: ${sqliteDef.ast.name}. Please use unique names for tables.`)
+    }
+    tables.set(sqliteDef.ast.name, tableDef)
+  }
+
+  for (const tableDef of systemTables) {
+    tables.set(tableDef.sqliteDef.name, tableDef)
+  }
+
+  const materializers = new Map<string, Materializer<any>>()
+
+  for (const [name, materializer] of Object.entries(inputSchema.materializers)) {
+    materializers.set(name, materializer)
+  }
+
+  materializers.set(rawSqlEvent.name, rawSqlMaterializer)
+
+  for (const tableDef of inputTables) {
+    if (tableIsClientDocumentTable(tableDef)) {
+      materializers.set(
+        tableDef[ClientDocumentTableDefSymbol].derived.setEventDef.name,
+        tableDef[ClientDocumentTableDefSymbol].derived.setMaterializer,
+      )
+    }
+  }
+
+  return { tables, materializers }
+}
+
+export type InputState = {
+  readonly tables: Record<string, TableDefBase> | ReadonlyArray<TableDefBase>
+  readonly materializers: Record<string, Materializer<any>>
+}