@livestore/common 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/schema/table-def.ts

@@ -0,0 +1,312 @@
+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 { DerivedMutationHelperFns } from '../derived-mutations.js'
+import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
+
+export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
+
+export { type 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>
+
+// export type TableDefConstraint<
+//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+//   TIsSingleColumn extends boolean = boolean,
+//   TOptions extends TableOptions = TableOptions,
+// > = TableDefBase<TSqliteDef, TIsSingleColumn, TOptions> & { schema: Schema.Schema<any> }
+
+// /**
+//  * NOTE in the past we used to have a single `TableDef` but there are some TS issues when indroducing
+//  * `schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>` so we split it into two types
+//  * and only use `TableDefConstraint` in some places
+//  */
+// export type TableDefBase<
+//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+//   TIsSingleColumn extends boolean = boolean,
+//   TOptions extends TableOptions = TableOptions,
+// > = {
+//   sqliteDef: TSqliteDef
+//   // schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>
+//   // schema: any;
+//   isSingleColumn: TIsSingleColumn
+//   options: TOptions
+// }
+
+export type TableDef<
+  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
+  TIsSingleColumn extends boolean = boolean,
+  TOptions extends TableOptions = TableOptions,
+  // 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<
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.Type<TSqliteDef['columns'][K]['schema']> }
+    >,
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.Encoded<TSqliteDef['columns'][K]['schema']> }
+    >
+  >,
+> = {
+  sqliteDef: TSqliteDef
+  // TODO move this into options (for now it's duplicated)
+  isSingleColumn: TIsSingleColumn
+  options: TOptions
+  schema: TSchema
+} & (TOptions['deriveMutations']['enabled'] extends true
+  ? DerivedMutationHelperFns<TSqliteDef['columns'], TOptions>
+  : {})
+
+export type TableOptionsInput = Partial<
+  Omit<TableOptions, 'isSingleColumn' | 'deriveMutations'> & {
+    indexes: SqliteDsl.Index[]
+    deriveMutations:
+      | boolean
+      | {
+          enabled: true
+          localOnly?: boolean
+        }
+  }
+>
+
+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
+   */
+  isSingleton: boolean
+  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.
+   */
+  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) */
+  isSingleColumn: boolean
+}
+
+export const table = <
+  TName extends string,
+  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
+  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
+>(
+  name: TName,
+  columnOrColumns: TColumns,
+  options?: TOptionsInput,
+): TableDef<
+  SqliteDsl.TableDefinition<
+    TName,
+    PrettifyFlat<
+      WithId<
+        TColumns extends SqliteDsl.Columns ? TColumns : { value: TColumns },
+        WithDefaults<TOptionsInput, SqliteDsl.IsSingleColumn<TColumns>>
+      >
+    >
+  >,
+  SqliteDsl.IsSingleColumn<TColumns>,
+  WithDefaults<TOptionsInput, SqliteDsl.IsSingleColumn<TColumns>>
+> => {
+  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,
+  }
+
+  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 schema = SqliteDsl.structSchemaForTable(sqliteDef)
+  const tableDef = { sqliteDef, isSingleColumn, options: options_, schema } satisfies TableDef
+
+  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)
+  }
+
+  return tableDef as any
+}
+
+export const tableHasDerivedMutations = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): tableDef is TTableDef & {
+  options: { deriveMutations: { enabled: true; localOnly: boolean } }
+} & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
+  tableDef.options.deriveMutations.enabled === true
+
+export const tableIsSingleton = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
+
+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, TIsSingleColumn extends boolean> = {
+  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: TIsSingleColumn
+}
+
+export namespace FromTable {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TTableDef extends TableDef> = PrettifyFlat<
+    Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type NullableColumnNames<TTableDef extends TableDef> = FromColumns.NullableColumnNames<
+    TTableDef['sqliteDef']['columns']
+  >
+
+  export type Columns<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
+  }
+
+  export type RowEncodeNonNullable<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Encoded<
+      TTableDef['sqliteDef']['columns'][K]['schema']
+    >
+  }
+
+  export type RowEncoded<TTableDef extends TableDef> = PrettifyFlat<
+    Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type RowDecodedAll<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Type<TTableDef['sqliteDef']['columns'][K]['schema']>
+  }
+}
+
+export namespace FromColumns {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+    Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowDecodedAll<TColumns extends SqliteDsl.Columns> = {
+    [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
+  }
+
+  export type RowEncoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+    Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowEncodeNonNullable<TColumns extends SqliteDsl.Columns> = {
+    [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+  }
+
+  export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
+    [K in keyof TColumns as TColumns[K]['default'] extends true ? K : never]: {}
+  }
+
+  export type RequiredInsertColumnNames<TColumns extends SqliteDsl.Columns> =
+    SqliteDsl.FromColumns.RequiredInsertColumnNames<TColumns>
+
+  export type InsertRowDecoded<TColumns extends SqliteDsl.Columns> = SqliteDsl.FromColumns.InsertRowDecoded<TColumns>
+}

package/src/schema-management/common.ts

@@ -0,0 +1,44 @@
+import type { SynchronousDatabase } from '../adapter-types.js'
+import type { ParamsObject } from '../util.js'
+import { prepareBindValues } from '../util.js'
+
+// TODO bring back statement caching
+// 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) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
+
+  stmt.execute(preparedBindValues)
+
+  stmt.finalize()
+}
+
+export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  const res = stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+  stmt.finalize()
+  return res
+}
+
+export interface SchemaManager {
+  getMutationDefInfos: () => ReadonlyArray<MutationDefInfo>
+
+  setMutationDefInfo: (mutationDefInfo: MutationDefInfo) => void
+}
+
+export type MutationDefInfo = {
+  mutationName: string
+  schemaHash: number
+}

package/src/schema-management/migrations.ts

@@ -0,0 +1,188 @@
+import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
+import { memoizeByStringifyArgs } from '@livestore/utils'
+import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
+
+import type { SynchronousDatabase } from '../adapter-types.js'
+import type { LiveStoreSchema } from '../schema/index.js'
+import type { SchemaMetaRow, SchemaMutationsMetaRow } from '../schema/system-tables.js'
+import {
+  SCHEMA_META_TABLE,
+  SCHEMA_MUTATIONS_META_TABLE,
+  schemaMetaTable,
+  schemaMutationsMetaTable,
+  systemTables,
+} from '../schema/system-tables.js'
+import { sql } from '../util.js'
+import type { SchemaManager } from './common.js'
+import { dbExecute, dbSelect } from './common.js'
+import { validateSchema } from './validate-mutation-defs.js'
+
+const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
+
+export const makeSchemaManager = (db: SynchronousDatabase): Effect.Effect<SchemaManager> =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      tableAst: schemaMutationsMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
+
+    return {
+      getMutationDefInfos: () =>
+        dbSelect<SchemaMutationsMetaRow>(db, sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`),
+
+      setMutationDefInfo: (info) => {
+        dbExecute(
+          db,
+          sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
+          {
+            mutationName: info.mutationName,
+            schemaHash: info.schemaHash,
+            updatedAt: new Date().toISOString(),
+          },
+        )
+      },
+    }
+  })
+
+// TODO more graceful DB migration (e.g. backup DB before destructive migrations)
+export const migrateDb = ({
+  db,
+  schema,
+  onProgress,
+}: {
+  db: SynchronousDatabase
+  schema: LiveStoreSchema
+  onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      tableAst: schemaMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
+
+    // TODO enforce that migrating tables isn't allowed once the store is running
+
+    const schemaManager = yield* makeSchemaManager(db)
+    yield* validateSchema(schema, schemaManager)
+
+    const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
+
+    const dbSchemaHashByTable = Object.fromEntries(
+      schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
+    )
+
+    const tableDefs = new Set([
+      // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
+      ...systemTables,
+      ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
+    ])
+
+    const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
+
+    for (const tableDef of tableDefs) {
+      const tableAst = tableDef.sqliteDef.ast
+      const tableName = tableAst.name
+      const dbSchemaHash = dbSchemaHashByTable[tableName]
+      const schemaHash = SqliteAst.hash(tableAst)
+
+      if (schemaHash !== dbSchemaHash) {
+        tablesToMigrate.add({ tableAst, schemaHash })
+
+        console.log(
+          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
+        )
+      }
+    }
+
+    let processedTables = 0
+    const tablesCount = tablesToMigrate.size
+
+    for (const { tableAst, schemaHash } of tablesToMigrate) {
+      yield* migrateTable({ db, tableAst, schemaHash, behaviour: 'create-if-not-exists' })
+
+      if (onProgress !== undefined) {
+        processedTables++
+        yield* onProgress({ done: processedTables, total: tablesCount })
+      }
+    }
+  })
+
+export const migrateTable = ({
+  db,
+  tableAst,
+  schemaHash = SqliteAst.hash(tableAst),
+  behaviour,
+  skipMetaTable = false,
+}: {
+  db: SynchronousDatabase
+  tableAst: SqliteAst.Table
+  schemaHash?: number
+  behaviour: 'drop-and-recreate' | 'create-if-not-exists'
+  skipMetaTable?: boolean
+}) =>
+  Effect.gen(function* () {
+    // console.log(`Migrating table '${tableAst.name}'...`)
+    const tableName = tableAst.name
+    const columnSpec = makeColumnSpec(tableAst)
+
+    if (behaviour === 'drop-and-recreate') {
+      // TODO need to possibly handle cascading deletes due to foreign keys
+      dbExecute(db, sql`drop table if exists ${tableName}`)
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    } else if (behaviour === 'create-if-not-exists') {
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    }
+
+    for (const index of tableAst.indexes) {
+      dbExecute(db, createIndexFromDefinition(tableName, index))
+    }
+
+    if (skipMetaTable !== true) {
+      const updatedAt = getMemoizedTimestamp()
+
+      dbExecute(
+        db,
+        sql`
+      INSERT INTO ${SCHEMA_META_TABLE} (tableName, schemaHash, updatedAt) VALUES ($tableName, $schemaHash, $updatedAt)
+        ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
+    `,
+        { tableName, schemaHash, updatedAt },
+      )
+    }
+  }).pipe(Effect.withSpan('@livestore/common:migrateTable', { attributes: { tableName: tableAst.name } }))
+
+const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
+  const uniqueStr = index.unique ? 'UNIQUE' : ''
+  return sql`create ${uniqueStr} index if not exists ${index.name} on ${tableName} (${index.columns.join(', ')})`
+}
+
+export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
+  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => _.name)
+  const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
+  if (primaryKeys.length > 0) {
+    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  }
+
+  return columnDefStrs.join(', ')
+}
+
+/** NOTE primary keys are applied on a table level not on a column level to account for multi-column primary keys */
+const toSqliteColumnSpec = (column: SqliteAst.Column) => {
+  const columnTypeStr = column.type._tag
+  const nullableStr = column.nullable === false ? 'not null' : ''
+  const defaultValueStr = (() => {
+    if (column.default._tag === 'None') return ''
+
+    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+
+    const encodeValue = EffectSchema.encodeSync(column.schema)
+    const encodedDefaultValue = encodeValue(column.default.value)
+
+    if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
+    return `default ${encodedDefaultValue}`
+  })()
+
+  return `${column.name} ${columnTypeStr} ${nullableStr} ${defaultValueStr}`
+}

package/src/schema-management/validate-mutation-defs.ts

@@ -0,0 +1,63 @@
+import { Effect, Schema } from '@livestore/utils/effect'
+
+import { UnexpectedError } from '../adapter-types.js'
+import type { LiveStoreSchema } from '../schema/index.js'
+import type { MutationDef } from '../schema/mutations.js'
+import type { MutationDefInfo, SchemaManager } from './common.js'
+
+export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) =>
+  Effect.gen(function* () {
+    // Validate mutation definitions
+    const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
+
+    const missingMutationDefs = registeredMutationDefInfos.filter(
+      (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
+    )
+
+    if (missingMutationDefs.length > 0) {
+      yield* new UnexpectedError({
+        cause: `Missing mutation definitions: ${missingMutationDefs.map((info) => info.mutationName).join(', ')}`,
+      })
+    }
+
+    for (const [, mutationDef] of schema.mutations) {
+      const registeredMutationDefInfo = registeredMutationDefInfos.find(
+        (info) => info.mutationName === mutationDef.name,
+      )
+
+      validateMutationDef(mutationDef, schemaManager, registeredMutationDefInfo)
+    }
+
+    // Validate table schemas
+  })
+
+export const validateMutationDef = (
+  mutationDef: MutationDef.Any,
+  schemaManager: SchemaManager,
+  registeredMutationDefInfo: MutationDefInfo | undefined,
+) => {
+  const schemaHash = Schema.hash(mutationDef.schema)
+
+  if (registeredMutationDefInfo === undefined) {
+    schemaManager.setMutationDefInfo({
+      schemaHash,
+      mutationName: mutationDef.name,
+    })
+
+    return
+  }
+
+  if (schemaHash === registeredMutationDefInfo.schemaHash) return
+
+  // TODO bring back some form of schema compatibility check (see https://github.com/livestorejs/livestore/issues/69)
+  // const newSchemaIsCompatibleWithOldSchema = Schema.isSubType(jsonSchemaDefFromMgmtStore, mutationDef.schema)
+
+  // if (!newSchemaIsCompatibleWithOldSchema) {
+  //   shouldNeverHappen(`Schema for mutation ${mutationDef.name} has changed in an incompatible way`)
+  // }
+
+  schemaManager.setMutationDefInfo({
+    schemaHash,
+    mutationName: mutationDef.name,
+  })
+}

package/src/sql-queries/index.ts

@@ -0,0 +1,3 @@
+export * from './sql-queries.js'
+export * from './sql-query-builder.js'
+export * from './types.js'

package/src/sql-queries/misc.ts

@@ -0,0 +1,2 @@
+export const objectEntries = <T extends Record<string, any>>(obj: T): [keyof T & string, T[keyof T]][] =>
+  Object.entries(obj) as [keyof T & string, T[keyof T]][]