@livestore/common 0.3.0-dev.2 → 0.3.0-dev.22

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

@@ -0,0 +1,195 @@
+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, { readonly [K in keyof TCols]: TCols[K]['schema']['Type'] }>,
+  AnyIfConstained<TCols, { readonly [K in keyof TCols]: TCols[K]['schema']['Encoded'] }>
+>
+
+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
+
+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 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>>>
+  >
+}

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/mod.ts

@@ -1,5 +1,6 @@
 export * from './system-tables.js'
 export * as DbSchema from './table-def.js'
+export { SqliteAst, SqliteDsl } from './db-schema/mod.js'
 export * from './mutations.js'
 export * from './schema-helpers.js'
 export * from './schema.js'

package/src/schema/mutations.ts

@@ -1,9 +1,11 @@
 import { Schema } from '@livestore/utils/effect'
 
 import type { BindValues } from '../sql-queries/sql-queries.js'
-import type * as EventId from './EventId.js'
 
-export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
+export type MutationDefMap = {
+  map: Map<string | 'livestore.RawSql', MutationDef.Any>
+  wasProvided: boolean
+}
 export type MutationDefRecord = {
   'livestore.RawSql': RawSqlMutation
   [name: string]: MutationDef.Any
@@ -38,24 +40,17 @@ export type MutationDef<TName extends string, TFrom, TTo> = {
     /** Warning: This feature is not fully implemented yet */
     historyId: string
     /**
-     * When set to true, the mutation won't be synced over the network
+     * When set to true, the mutation won't be synced across clients but
      */
-    localOnly: boolean
+    clientOnly: boolean
     /** Warning: This feature is not fully implemented yet */
     facts: FactsCallback<TTo> | undefined
   }
 
   /** Helper function to construct a partial mutation event */
-  (
-    args: TTo,
-    options?: {
-      id?: number
-    },
-  ): {
+  (args: TTo): {
     mutation: TName
     args: TTo
-    // TODO remove/clean up after sync-next is fully implemented
-    id?: EventId.EventId
   }
 }
 
@@ -120,7 +115,7 @@ export type DefineMutationOptions<TTo> = {
   /**
    * When set to true, the mutation won't be synced over the network
    */
-  localOnly?: boolean
+  clientOnly?: boolean
 }
 
 // TODO possibly also allow for mutation event subsumption behaviour
@@ -130,12 +125,7 @@ export const defineMutation = <TName extends string, TFrom, TTo>(
   sql: MutationDefSqlResult<NoInfer<TTo>>,
   options?: DefineMutationOptions<TTo>,
 ): MutationDef<TName, TFrom, TTo> => {
-  const makePartialEvent = (
-    args: TTo,
-    options?: {
-      id?: EventId.EventId
-    },
-  ) => ({ mutation: name, args, ...options })
+  const makePartialEvent = (args: TTo) => ({ mutation: name, args })
 
   Object.defineProperty(makePartialEvent, 'name', { value: name })
   Object.defineProperty(makePartialEvent, 'schema', { value: schema })
@@ -143,7 +133,7 @@ export const defineMutation = <TName extends string, TFrom, TTo>(
   Object.defineProperty(makePartialEvent, 'options', {
     value: {
       historyId: options?.historyId ?? 'main',
-      localOnly: options?.localOnly ?? false,
+      clientOnly: options?.clientOnly ?? false,
       facts: options?.facts
         ? (args, currentFacts) => {
             const res = options.facts!(args, currentFacts)

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,9 +1,9 @@
-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 { SqliteDsl } from './db-schema/mod.js'
+import { SqliteAst } from './db-schema/mod.js'
 import {
   type MutationDef,
   type MutationDefMap,
@@ -72,29 +72,32 @@ export const makeSchema = <TInputSchema extends InputSchema>(
     tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
-  const mutations: MutationDefMap = new Map()
+  const mutations: MutationDefMap = {
+    map: new Map(),
+    wasProvided: inputSchema.mutations !== undefined,
+  }
 
   if (isReadonlyArray(inputSchema.mutations)) {
     for (const mutation of inputSchema.mutations) {
-      mutations.set(mutation.name, mutation)
+      mutations.map.set(mutation.name, mutation)
     }
   } else {
     for (const mutation of Object.values(inputSchema.mutations ?? {})) {
-      if (mutations.has(mutation.name)) {
+      if (mutations.map.has(mutation.name)) {
         shouldNeverHappen(`Duplicate mutation name: ${mutation.name}. Please use unique names for mutations.`)
       }
-      mutations.set(mutation.name, mutation)
+      mutations.map.set(mutation.name, mutation)
     }
   }
 
-  mutations.set(rawSqlMutation.name, rawSqlMutation)
+  mutations.map.set(rawSqlMutation.name, rawSqlMutation)
 
   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)
+      mutations.map.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
+      mutations.map.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
+      mutations.map.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
     }
   }
 
@@ -114,6 +117,15 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   } 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}`)
+  }
+  return mutationDef
+}
+
 export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
     DbSchemaFromInputSchemaTables<TInputSchema['tables']>,

package/src/schema/system-tables.ts

@@ -1,6 +1,7 @@
-import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 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'
 
@@ -46,14 +47,15 @@ export const sessionChangesetMetaTable = table(
   SESSION_CHANGESET_META_TABLE,
   {
     // 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 },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [{ columns: ['idGlobal', 'idClient'], name: 'idx_session_changeset_id' }],
+  },
 )
 
 export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
@@ -62,7 +64,7 @@ export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionC
 
 /// Mutation log DB
 
-export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'localOnly')
+export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'clientOnly')
 export type SyncStatus = typeof SyncStatus.Type
 
 export const MUTATION_LOG_META_TABLE = 'mutation_log'
@@ -70,16 +72,25 @@ export const MUTATION_LOG_META_TABLE = 'mutation_log'
 export const mutationLogMetaTable = table(
   MUTATION_LOG_META_TABLE,
   {
-    idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    idLocal: SqliteDsl.integer({ primaryKey: true }),
-    parentIdGlobal: SqliteDsl.integer({}),
-    parentIdLocal: SqliteDsl.integer({}),
+    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({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
+    clientId: SqliteDsl.text({}),
+    /** Only available for mutations which were executed in this client */
+    sessionId: SqliteDsl.text({ nullable: true }),
     schemaHash: SqliteDsl.integer({}),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  { disableAutomaticIdColumn: true, indexes: [] },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [
+      { columns: ['idGlobal'], name: 'idx_idGlobal' },
+      { columns: ['idGlobal', 'idClient'], name: 'idx_mutationlog_id' },
+    ],
+  },
 )
 
 export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>

package/src/schema/table-def.ts

@@ -1,17 +1,16 @@
-import type { Nullable, PrettifyFlat } from '@livestore/db-schema'
-import { SqliteDsl } from '@livestore/db-schema'
+import type { Nullable } from '@livestore/utils'
 import { shouldNeverHappen } from '@livestore/utils'
+import type { Types } from '@livestore/utils/effect'
 import { ReadonlyRecord, Schema } 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 { 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>
@@ -60,8 +59,7 @@ export type TableOptionsInput = Partial<{
   deriveMutations:
     | boolean
     | {
-        enabled: true
-        localOnly?: boolean
+        clientOnly?: boolean
       }
 }>
 
@@ -115,7 +113,7 @@ export type TableOptions = {
         /**
          * When set to true, the mutations won't be synced over the network
          */
-        localOnly: boolean
+        clientOnly: boolean
       }
 
   /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
@@ -153,12 +151,12 @@ export const table = <
     disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
     deriveMutations:
       options?.deriveMutations === true
-        ? { enabled: true as const, localOnly: false }
+        ? { enabled: true as const, clientOnly: false }
         : options?.deriveMutations === false
           ? { enabled: false as const }
           : options?.deriveMutations === undefined
             ? { enabled: false as const }
-            : { enabled: true as const, localOnly: options.deriveMutations.localOnly ?? false },
+            : { enabled: true as const, clientOnly: options.deriveMutations.clientOnly ?? false },
     isSingleColumn: SqliteDsl.isColumnDefinition(columnOrColumns) === true,
     requiredInsertColumnNames: 'type-level-only',
   }
@@ -234,7 +232,7 @@ export const table = <
 export const tableHasDerivedMutations = <TTableDef extends TableDefBase>(
   tableDef: TTableDef,
 ): tableDef is TTableDef & {
-  options: { deriveMutations: { enabled: true; localOnly: boolean } }
+  options: { deriveMutations: { enabled: true; clientOnly: boolean } }
 } & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
   tableDef.options.deriveMutations.enabled === true
 
@@ -242,6 +240,8 @@ export const tableIsSingleton = <TTableDef extends TableDefBase>(
   tableDef: TTableDef,
 ): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
 
+export type PrettifyFlat<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
+
 type SqliteTableDefForInput<
   TName extends string,
   TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
@@ -268,13 +268,13 @@ type WithDefaults<
   isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
   disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
   deriveMutations: TOptionsInput['deriveMutations'] extends true
-    ? { enabled: true; localOnly: boolean }
+    ? { enabled: true; clientOnly: false }
     : TOptionsInput['deriveMutations'] extends false
       ? { enabled: false }
-      : TOptionsInput['deriveMutations'] extends { enabled: true; localOnly?: boolean }
+      : TOptionsInput['deriveMutations'] extends { clientOnly: boolean }
         ? {
             enabled: true
-            localOnly: TOptionsInput['deriveMutations']['localOnly'] extends true ? true : false
+            clientOnly: TOptionsInput['deriveMutations']['clientOnly'] extends true ? true : false
           }
         : never
   isSingleColumn: SqliteDsl.IsSingleColumn<TColumns>
@@ -283,7 +283,7 @@ type WithDefaults<
 
 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 +302,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 +314,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 +323,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>>
   >

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)