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

package/src/schema/system-tables.ts

@@ -1,40 +1,38 @@
-import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { Schema } from '@livestore/utils/effect'
 
-import type { FromTable } from './table-def.js'
+import { SqliteDsl } from './db-schema/mod.js'
+import * as EventId from './EventId.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
@@ -42,56 +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({}),
-    idLocal: SqliteDsl.integer({}),
-    // idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    // idLocal: SqliteDsl.integer({ primaryKey: true }),
-    changeset: SqliteDsl.blob({}),
+    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' }],
+})
 
-export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
+export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
 
-export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionChangesetMetaTable]
+export const LEADER_MERGE_COUNTER_TABLE = '__livestore_leader_merge_counter'
 
-/// Mutation log DB
+export const leaderMergeCounterTable = table({
+  name: LEADER_MERGE_COUNTER_TABLE,
+  columns: {
+    id: SqliteDsl.integer({ primaryKey: true, schema: Schema.Literal(0) }),
+    mergeCounter: SqliteDsl.integer({ primaryKey: true }),
+  },
+})
 
-export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'localOnly')
-export type SyncStatus = typeof SyncStatus.Type
+export type LeaderMergeCounterRow = typeof leaderMergeCounterTable.Type
+
+export const systemTables = [
+  schemaMetaTable,
+  schemaEventDefsMetaTable,
+  sessionChangesetMetaTable,
+  leaderMergeCounterTable,
+]
 
-export const MUTATION_LOG_META_TABLE = 'mutation_log'
+/// Eventlog DB
+
+export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'clientOnly')
+export type SyncStatus = typeof SyncStatus.Type
 
-export const mutationLogMetaTable = table(
-  MUTATION_LOG_META_TABLE,
-  {
-    idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    idLocal: SqliteDsl.integer({ primaryKey: true }),
-    parentIdGlobal: SqliteDsl.integer({}),
-    parentIdLocal: SqliteDsl.integer({}),
-    mutation: SqliteDsl.text({}),
+export const EVENTLOG_META_TABLE = 'eventlog'
+
+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 }),
+    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: [] },
-)
+  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

package/src/schema/table-def.ts

@@ -1,31 +1,30 @@
-import type { Nullable, PrettifyFlat } from '@livestore/db-schema'
-import { SqliteDsl } from '@livestore/db-schema'
-import { shouldNeverHappen } from '@livestore/utils'
-import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
+import { type Nullable } from '@livestore/utils'
+import type { Schema, Types } from '@livestore/utils/effect'
 
-import type { DerivedMutationHelperFns } from '../derived-mutations.js'
-import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
 import type { QueryBuilder } from '../query-builder/mod.js'
-import { makeQueryBuilder } from '../query-builder/mod.js'
+import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from '../query-builder/mod.js'
+import { SqliteDsl } from './db-schema/mod.js'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
-export { SqliteDsl } from '@livestore/db-schema'
-
 export type StateType = 'singleton' | 'dynamic'
 
 export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
 export type DefaultSqliteTableDefConstrained = SqliteDsl.TableDefinition<string, SqliteDsl.ConstraintColumns>
 
+// TODO use to hide table def internals
+export const TableDefInternalsSymbol = Symbol('TableDefInternals')
+export type TableDefInternalsSymbol = typeof TableDefInternalsSymbol
+
 export type TableDefBase<
   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
   TOptions extends TableOptions = TableOptions,
-  TSchema = SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>,
 > = {
   sqliteDef: TSqliteDef
   options: TOptions
   // Derived from `sqliteDef`, so only exposed for convenience
-  schema: TSchema
+  rowSchema: SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>
+  insertSchema: SqliteDsl.InsertStructSchemaForColumns<TSqliteDef['columns']>
 }
 
 export type TableDef<
@@ -47,243 +46,79 @@ export type TableDef<
   sqliteDef: TSqliteDef
   options: TOptions
   // Derived from `sqliteDef`, so only exposed for convenience
-  schema: TSchema
-  query: QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDef<TSqliteDef & {}, TOptions>>
-} & (TOptions['deriveMutations']['enabled'] extends true
-  ? DerivedMutationHelperFns<TSqliteDef['columns'], TOptions>
-  : {})
+  rowSchema: TSchema
+  insertSchema: SqliteDsl.InsertStructSchemaForColumns<TSqliteDef['columns']>
+  // query: QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDefBase<TSqliteDef & {}, TOptions>>
+  readonly Type: Schema.Schema.Type<TSchema>
+  readonly Encoded: Schema.Schema.Encoded<TSchema>
+} & QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDefBase<TSqliteDef & {}, TOptions>>
 
 export type TableOptionsInput = Partial<{
   indexes: SqliteDsl.Index[]
-  disableAutomaticIdColumn: boolean
-  isSingleton: boolean
-  deriveMutations:
-    | boolean
-    | {
-        enabled: true
-        localOnly?: boolean
-      }
 }>
 
-type ToColumns<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>> =
-  TColumns extends SqliteDsl.Columns
-    ? TColumns
-    : TColumns extends SqliteDsl.ColumnDefinition<any, any>
-      ? { value: TColumns }
-      : never
-
-type ValidateTableOptionsInput<
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptionsInput extends TableOptionsInput,
-  TPassthroughIfValid,
-> =
-  SqliteDsl.FromColumns.RequiresInsertValues<ToColumns<TColumns>> extends true
-    ? TOptionsInput['isSingleton'] extends true
-      ? 'Error: To use `isSingleton: true` with this table, each column must have a default value or be nullable'
-      : TPassthroughIfValid
-    : TPassthroughIfValid
+export namespace TableDef {
+  export type Any = TableDef<any, any>
+}
 
 export type TableOptions = {
-  /**
-   * Setting this to true will have the following consequences:
-   * - An `id` column will be added with `primaryKey: true` and `"singleton"` as default value and only allowed value
-   * - LiveStore will automatically create the singleton row when booting up
-   * - LiveStore will fail if there is already a column defined with `primaryKey: true`
-   *
-   * @default false
-   */
-  readonly isSingleton: boolean
-
-  readonly disableAutomaticIdColumn: boolean
-
-  /**
-   * Setting this to true will automatically derive insert, update and delete mutations for this table. Example:
-   *
-   * ```ts
-   * const todos = table('todos', { ... }, { deriveMutations: true })
-   * todos.insert({ id: '1', text: 'Hello' })
-   * ```
-   *
-   * This is also a prerequisite for using the `useRow`, `useAtom` and `rowQuery` APIs.
-   *
-   * Important: When using this option, make sure you're following the "Rules of mutations" for the table schema.
-   */
-  readonly deriveMutations:
-    | { enabled: false }
-    | {
-        enabled: true
-        /**
-         * When set to true, the mutations won't be synced over the network
-         */
-        localOnly: boolean
-      }
-
   /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
-  readonly isSingleColumn: boolean
-
-  /**
-   * Derived based on whether the table definition has one or more columns (besides the `id` column) that require
-   * insert values (i.e. are not nullable and don't have a default value)
-   *
-   * `isSingleton` tables always imply `requiresInsertValues: false`
-   */
-  readonly requiredInsertColumnNames: string
+  readonly isClientDocumentTable: boolean
 }
 
 export const table = <
   TName extends string,
   TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptionsInput extends TableOptionsInput = TableOptionsInput,
+  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
 >(
-  name: TName,
-  columnOrColumns: TColumns,
-  options?: TOptionsInput,
-): ValidateTableOptionsInput<
-  TColumns,
-  TOptionsInput,
-  TableDef<
-    SqliteTableDefForInput<TName, TColumns, WithDefaults<TOptionsInput, TColumns>>,
-    WithDefaults<TOptionsInput, TColumns>
-  >
-> => {
+  args: {
+    name: TName
+    columns: TColumns
+  } & Partial<TOptionsInput>,
+): TableDef<SqliteTableDefForInput<TName, TColumns>, WithDefaults<TColumns>> => {
+  const { name, columns: columnOrColumns, ...options } = args
   const tablePath = name
 
   const options_: TableOptions = {
-    isSingleton: options?.isSingleton ?? false,
-    disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
-    deriveMutations:
-      options?.deriveMutations === true
-        ? { enabled: true as const, localOnly: false }
-        : options?.deriveMutations === false
-          ? { enabled: false as const }
-          : options?.deriveMutations === undefined
-            ? { enabled: false as const }
-            : { enabled: true as const, localOnly: options.deriveMutations.localOnly ?? false },
-    isSingleColumn: SqliteDsl.isColumnDefinition(columnOrColumns) === true,
-    requiredInsertColumnNames: 'type-level-only',
+    isClientDocumentTable: false,
   }
 
   const columns = (
     SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
   ) as SqliteDsl.Columns
 
-  if (options_.disableAutomaticIdColumn === true) {
-    if (columns.id === undefined && options_.isSingleton === true) {
-      shouldNeverHappen(
-        `Cannot create table ${name} with "isSingleton: true" because there is no column with name "id" and "disableAutomaticIdColumn: true" is set`,
-      )
-    }
-  } else if (columns.id === undefined && ReadonlyRecord.some(columns, (_) => _.primaryKey === true) === false) {
-    if (options_.isSingleton) {
-      columns.id = SqliteDsl.text({ schema: Schema.Literal('singleton'), primaryKey: true, default: 'singleton' })
-    } else {
-      columns.id = SqliteDsl.text({ primaryKey: true })
-    }
-  }
-
   const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
 
-  // TODO also enforce this on the type level
-  if (options_.isSingleton) {
-    for (const column of sqliteDef.ast.columns) {
-      if (column.nullable === false && column.default._tag === 'None') {
-        shouldNeverHappen(
-          `When creating a singleton table, each column must be either nullable or have a default value. Column '${column.name}' is neither.`,
-        )
-      }
-    }
-  }
-
-  const isSingleColumn = SqliteDsl.isColumnDefinition(columnOrColumns) === true
+  const rowSchema = SqliteDsl.structSchemaForTable(sqliteDef)
+  const insertSchema = SqliteDsl.insertStructSchemaForTable(sqliteDef)
+  const tableDef = {
+    sqliteDef,
+    options: options_,
+    rowSchema,
+    insertSchema,
+  } satisfies TableDefBase
 
-  const schema = SqliteDsl.structSchemaForTable(sqliteDef)
-  const tableDef = { sqliteDef, options: options_, schema } satisfies TableDefBase
   const query = makeQueryBuilder(tableDef)
-  // const tableDef = { ...tableDefBase, query } satisfies TableDef
+  // tableDef.query = query
 
   // NOTE we're currently patching the existing tableDef object
   // as it's being used as part of the query builder API
-  // @ts-expect-error TODO properly implement this
-  tableDef.query = query
-
-  if (tableHasDerivedMutations(tableDef)) {
-    const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
-
-    tableDef.insert = (valuesOrValue: any) => {
-      if (isSingleColumn && options_.isSingleton) {
-        return derivedMutationDefs.insert({ id: 'singleton', value: { value: valuesOrValue } })
-      } else {
-        return derivedMutationDefs.insert(valuesOrValue as any)
-      }
-    }
-
-    tableDef.update = (argsOrValues: any) => {
-      if (isSingleColumn && options_.isSingleton) {
-        return derivedMutationDefs.update({ where: { id: 'singleton' }, values: { value: argsOrValues } as any })
-      } else {
-        return derivedMutationDefs.update(argsOrValues as any)
-      }
-    }
-
-    tableDef.delete = (args: any) => derivedMutationDefs.delete(args)
+  for (const key of Object.keys(query)) {
+    // @ts-expect-error TODO properly implement this
+    tableDef[key] = query[key]
   }
 
-  return tableDef as any
-}
-
-export const tableHasDerivedMutations = <TTableDef extends TableDefBase>(
-  tableDef: TTableDef,
-): tableDef is TTableDef & {
-  options: { deriveMutations: { enabled: true; localOnly: boolean } }
-} & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
-  tableDef.options.deriveMutations.enabled === true
+  // @ts-expect-error TODO properly type this
+  tableDef[QueryBuilderAstSymbol] = query[QueryBuilderAstSymbol]
+  // @ts-expect-error TODO properly type this
+  tableDef[QueryBuilderTypeId] = query[QueryBuilderTypeId]
 
-export const tableIsSingleton = <TTableDef extends TableDefBase>(
-  tableDef: TTableDef,
-): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
-
-type SqliteTableDefForInput<
-  TName extends string,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptions extends TableOptions,
-> = SqliteDsl.TableDefinition<TName, PrettifyFlat<WithId<ToColumns<TColumns>, TOptions>>>
-
-type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
-  ('id' extends keyof TColumns
-    ? {}
-    : TOptions['disableAutomaticIdColumn'] extends true
-      ? {}
-      : TOptions['isSingleton'] extends true
-        ? {
-            id: SqliteDsl.ColumnDefinition<'singleton', 'singleton'>
-          }
-        : {
-            id: SqliteDsl.ColumnDefinition<string, string>
-          })
-
-type WithDefaults<
-  TOptionsInput extends TableOptionsInput,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-> = {
-  isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
-  disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
-  deriveMutations: TOptionsInput['deriveMutations'] extends true
-    ? { enabled: true; localOnly: boolean }
-    : TOptionsInput['deriveMutations'] extends false
-      ? { enabled: false }
-      : TOptionsInput['deriveMutations'] extends { enabled: true; localOnly?: boolean }
-        ? {
-            enabled: true
-            localOnly: TOptionsInput['deriveMutations']['localOnly'] extends true ? true : false
-          }
-        : never
-  isSingleColumn: SqliteDsl.IsSingleColumn<TColumns>
-  requiredInsertColumnNames: SqliteDsl.FromColumns.RequiredInsertColumnNames<ToColumns<TColumns>>
+  return tableDef as any
 }
 
 export namespace FromTable {
   // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TTableDef extends TableDefBase> = PrettifyFlat<
+  export type RowDecoded<TTableDef extends TableDefBase> = Types.Simplify<
     Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
       Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
   >
@@ -302,7 +137,7 @@ export namespace FromTable {
     >
   }
 
-  export type RowEncoded<TTableDef extends TableDefBase> = PrettifyFlat<
+  export type RowEncoded<TTableDef extends TableDefBase> = Types.Simplify<
     Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
       Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
   >
@@ -314,7 +149,7 @@ export namespace FromTable {
 
 export namespace FromColumns {
   // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+  export type RowDecoded<TColumns extends SqliteDsl.Columns> = Types.Simplify<
     Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
       Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
   >
@@ -323,7 +158,7 @@ export namespace FromColumns {
     [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
   }
 
-  export type RowEncoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+  export type RowEncoded<TColumns extends SqliteDsl.Columns> = Types.Simplify<
     Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
       Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
   >
@@ -341,3 +176,22 @@ export namespace FromColumns {
 
   export type InsertRowDecoded<TColumns extends SqliteDsl.Columns> = SqliteDsl.FromColumns.InsertRowDecoded<TColumns>
 }
+
+type SqliteTableDefForInput<
+  TName extends string,
+  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
+> = SqliteDsl.TableDefinition<TName, PrettifyFlat<ToColumns<TColumns>>>
+
+type WithDefaults<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>> = {
+  isClientDocumentTable: false
+  requiredInsertColumnNames: SqliteDsl.FromColumns.RequiredInsertColumnNames<ToColumns<TColumns>>
+}
+
+export type PrettifyFlat<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
+
+type ToColumns<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>> =
+  TColumns extends SqliteDsl.Columns
+    ? TColumns
+    : TColumns extends SqliteDsl.ColumnDefinition<any, any>
+      ? { value: TColumns }
+      : never

package/src/schema/view.ts

@@ -0,0 +1,2 @@
+export * as SQLite from './sqlite-state.js'
+export { QueryBuilderAstSymbol, QueryBuilderTypeId } from '../query-builder/mod.js'

package/src/schema-management/common.ts

@@ -1,4 +1,4 @@
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import type { ParamsObject } from '../util.js'
 import { prepareBindValues } from '../util.js'
 
@@ -6,7 +6,7 @@ import { prepareBindValues } from '../util.js'
 // will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)
 // const cachedStmts = new Map<string, PreparedStatement>()
 
-export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)
@@ -20,7 +20,7 @@ export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?
   stmt.finalize()
 }
 
-export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)
@@ -33,12 +33,12 @@ export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValue
 }
 
 export interface SchemaManager {
-  getMutationDefInfos: () => ReadonlyArray<MutationDefInfo>
+  getEventDefInfos: () => ReadonlyArray<EventDefInfo>
 
-  setMutationDefInfo: (mutationDefInfo: MutationDefInfo) => void
+  setEventDefInfo: (eventDefInfo: EventDefInfo) => void
 }
 
-export type MutationDefInfo = {
-  mutationName: string
+export type EventDefInfo = {
+  eventName: string
   schemaHash: number
 }