@livestore/common 0.3.0-dev.28 → 0.3.0-dev.29

package/src/schema/schema.ts

@@ -1,103 +1,101 @@
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 
 import type { MigrationOptions } from '../adapter-types.js'
-import { makeDerivedMutationDefsForTable } from '../derived-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 MutationDef,
-  type MutationDefMap,
-  type MutationDefRecord,
-  type RawSqlMutation,
-  rawSqlMutation,
-} from './mutations.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 = {
-    map: new Map(),
-    wasProvided: inputSchema.mutations !== undefined,
-  }
+  const eventsDefsMap = new Map<string, EventDef.AnyWithoutFn>()
 
-  if (isReadonlyArray(inputSchema.mutations)) {
-    for (const mutation of inputSchema.mutations) {
-      mutations.map.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.map.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.map.set(mutation.name, mutation)
+      eventsDefsMap.set(eventDef.name, eventDef)
     }
   }
 
-  mutations.map.set(rawSqlMutation.name, rawSqlMutation)
+  eventsDefsMap.set(rawSqlEvent.name, rawSqlEvent)
 
   for (const tableDef of tables.values()) {
-    if (tableHasDerivedMutations(tableDef)) {
-      const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
-      mutations.map.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
-      mutations.map.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
-      mutations.map.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
+    if (tableIsClientDocumentTable(tableDef) && eventsDefsMap.has(tableDef.set.name) === false) {
+      eventsDefsMap.set(tableDef.set.name, tableDef.set)
     }
   }
 
@@ -109,27 +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: 'from-mutation-log' },
+    _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 getMutationDef = <TSchema extends LiveStoreSchema>(schema: TSchema, mutationName: string) => {
-  const mutationDef = schema.mutations.map.get(mutationName)
-  if (mutationDef === undefined) {
-    const extraInfo = schema.mutations.wasProvided ? '' : ' Please provide \`mutations\` in the schema options.'
-    return shouldNeverHappen(`No mutation definition found for \`${mutationName}\`.${extraInfo}`)
+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 mutationDef
+  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']>
   >
 
   /**
@@ -137,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>>
+}

package/src/schema/system-tables.ts

@@ -2,40 +2,37 @@ import { Schema } from '@livestore/utils/effect'
 
 import { SqliteDsl } from './db-schema/mod.js'
 import * as EventId from './EventId.js'
-import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
 
-/// App DB
+/// Read model DB
 
 export const SCHEMA_META_TABLE = '__livestore_schema'
 
-export const schemaMetaTable = table(
-  SCHEMA_META_TABLE,
-  {
+export const schemaMetaTable = table({
+  name: SCHEMA_META_TABLE,
+  columns: {
     tableName: SqliteDsl.text({ primaryKey: true }),
     schemaHash: SqliteDsl.integer({ nullable: false }),
     /** ISO date format */
     updatedAt: SqliteDsl.text({ nullable: false }),
   },
-  { disableAutomaticIdColumn: true },
-)
+})
 
-export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
+export type SchemaMetaRow = typeof schemaMetaTable.Type
 
-export const SCHEMA_MUTATIONS_META_TABLE = '__livestore_schema_mutations'
+export const SCHEMA_EVENT_DEFS_META_TABLE = '__livestore_schema_event_defs'
 
-export const schemaMutationsMetaTable = table(
-  SCHEMA_MUTATIONS_META_TABLE,
-  {
-    mutationName: SqliteDsl.text({ primaryKey: true }),
+export const schemaEventDefsMetaTable = table({
+  name: SCHEMA_EVENT_DEFS_META_TABLE,
+  columns: {
+    eventName: SqliteDsl.text({ primaryKey: true }),
     schemaHash: SqliteDsl.integer({ nullable: false }),
     /** ISO date format */
     updatedAt: SqliteDsl.text({ nullable: false }),
   },
-  { disableAutomaticIdColumn: true },
-)
+})
 
-export type SchemaMutationsMetaRow = FromTable.RowDecoded<typeof schemaMutationsMetaTable>
+export type SchemaEventDefsMetaRow = typeof schemaEventDefsMetaTable.Type
 
 /**
  * Table which stores SQLite changeset blobs which is used for rolling back
@@ -43,84 +40,76 @@ export type SchemaMutationsMetaRow = FromTable.RowDecoded<typeof schemaMutations
  */
 export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
 
-export const sessionChangesetMetaTable = table(
-  SESSION_CHANGESET_META_TABLE,
-  {
+export const sessionChangesetMetaTable = table({
+  name: SESSION_CHANGESET_META_TABLE,
+  columns: {
     // TODO bring back primary key
     idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
     idClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
     changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
-  {
-    disableAutomaticIdColumn: true,
-    indexes: [{ columns: ['idGlobal', 'idClient'], name: 'idx_session_changeset_id' }],
-  },
-)
+  indexes: [{ columns: ['idGlobal', 'idClient'], name: 'idx_session_changeset_id' }],
+})
 
-export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
+export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
 
 export const LEADER_MERGE_COUNTER_TABLE = '__livestore_leader_merge_counter'
 
-export const leaderMergeCounterTable = table(
-  LEADER_MERGE_COUNTER_TABLE,
-  {
+export const leaderMergeCounterTable = table({
+  name: LEADER_MERGE_COUNTER_TABLE,
+  columns: {
     id: SqliteDsl.integer({ primaryKey: true, schema: Schema.Literal(0) }),
     mergeCounter: SqliteDsl.integer({ primaryKey: true }),
   },
-  { disableAutomaticIdColumn: true },
-)
+})
 
-export type LeaderMergeCounterRow = FromTable.RowDecoded<typeof leaderMergeCounterTable>
+export type LeaderMergeCounterRow = typeof leaderMergeCounterTable.Type
 
 export const systemTables = [
   schemaMetaTable,
-  schemaMutationsMetaTable,
+  schemaEventDefsMetaTable,
   sessionChangesetMetaTable,
   leaderMergeCounterTable,
 ]
 
-/// Mutation log DB
+/// Eventlog DB
 
 export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'clientOnly')
 export type SyncStatus = typeof SyncStatus.Type
 
-export const MUTATION_LOG_META_TABLE = 'mutation_log'
+export const EVENTLOG_META_TABLE = 'eventlog'
 
-export const mutationLogMetaTable = table(
-  MUTATION_LOG_META_TABLE,
-  {
+export const eventlogMetaTable = table({
+  name: EVENTLOG_META_TABLE,
+  columns: {
     // TODO Adjust modeling so a global event never needs a client id component
     idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
     idClient: SqliteDsl.integer({ primaryKey: true, schema: EventId.ClientEventId }),
     parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
     parentIdClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
-    mutation: SqliteDsl.text({}),
+    name: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     clientId: SqliteDsl.text({}),
     sessionId: SqliteDsl.text({}),
     schemaHash: SqliteDsl.integer({}),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  {
-    disableAutomaticIdColumn: true,
-    indexes: [
-      { columns: ['idGlobal'], name: 'idx_idGlobal' },
-      { columns: ['idGlobal', 'idClient'], name: 'idx_mutationlog_id' },
-    ],
-  },
-)
+  indexes: [
+    { columns: ['idGlobal'], name: 'idx_eventlog_idGlobal' },
+    { columns: ['idGlobal', 'idClient'], name: 'idx_eventlog_id' },
+  ],
+})
 
-export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>
+export type EventlogMetaRow = typeof eventlogMetaTable.Type
 
 export const SYNC_STATUS_TABLE = '__livestore_sync_status'
 
-export const syncStatusTable = table(
-  SYNC_STATUS_TABLE,
-  {
+export const syncStatusTable = table({
+  name: SYNC_STATUS_TABLE,
+  columns: {
     head: SqliteDsl.integer({ primaryKey: true }),
   },
-  { disableAutomaticIdColumn: true },
-)
+})
 
-export type SyncStatusRow = FromTable.RowDecoded<typeof syncStatusTable>
+export type SyncStatusRow = typeof syncStatusTable.Type