@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/schema/state/sqlite/query-builder/impl.ts

@@ -0,0 +1,351 @@
+import { casesHandled, shouldNeverHappen } from '@livestore/utils'
+import { Match, Option, Predicate, Schema } from '@livestore/utils/effect'
+
+import type { TableDefBase } from '../table-def.js'
+import type { QueryBuilder, QueryBuilderAst } from './api.js'
+import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './api.js'
+import { astToSql } from './astToSql.js'
+export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
+  tableDef: TTableDef,
+  ast: QueryBuilderAst = emptyAst(tableDef),
+): QueryBuilder<TResult, TTableDef, never> => {
+  const api = {
+    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    select() {
+      assertSelectQueryBuilderAst(ast)
+
+      // eslint-disable-next-line prefer-rest-params
+      const params = [...arguments]
+
+      // Pluck if there's only one column selected
+      if (params.length === 1) {
+        const [col] = params as any as [string]
+        return makeQueryBuilder(tableDef, {
+          ...ast,
+          resultSchemaSingle: ast.resultSchemaSingle.pipe(Schema.pluck(col)),
+          select: { columns: [col] },
+        })
+      }
+
+      const columns = params as unknown as ReadonlyArray<string>
+
+      return makeQueryBuilder(tableDef, {
+        ...ast,
+        resultSchemaSingle:
+          columns.length === 0 ? ast.resultSchemaSingle : ast.resultSchemaSingle.pipe(Schema.pick(...columns)),
+        select: { columns },
+      }) as any
+    },
+    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    where: function () {
+      if (ast._tag === 'InsertQuery') return invalidQueryBuilder('Cannot use where with insert')
+      if (ast._tag === 'RowQuery') return invalidQueryBuilder('Cannot use where with row')
+
+      if (arguments.length === 1) {
+        // eslint-disable-next-line prefer-rest-params
+        const params = arguments[0]
+        const newOps = Object.entries(params)
+          .filter(([, value]) => value !== undefined)
+          .map<QueryBuilderAst.Where>(([col, value]) =>
+            Predicate.hasProperty(value, 'op') && Predicate.hasProperty(value, 'value')
+              ? ({ col, op: value.op, value: value.value } as any)
+              : { col, op: '=', value },
+          )
+
+        switch (ast._tag) {
+          case 'CountQuery':
+          case 'SelectQuery':
+          case 'UpdateQuery':
+          case 'DeleteQuery': {
+            return makeQueryBuilder(tableDef, {
+              ...ast,
+              where: [...ast.where, ...newOps],
+            }) as any
+          }
+          default: {
+            return casesHandled(ast)
+          }
+        }
+      }
+
+      // eslint-disable-next-line prefer-rest-params
+      const [col, opOrValue, valueOrUndefined] = arguments
+      const op = valueOrUndefined === undefined ? '=' : opOrValue
+      const value = valueOrUndefined === undefined ? opOrValue : valueOrUndefined
+
+      switch (ast._tag) {
+        case 'CountQuery':
+        case 'SelectQuery':
+        case 'UpdateQuery':
+        case 'DeleteQuery': {
+          return makeQueryBuilder(tableDef, {
+            ...ast,
+            where: [...ast.where, { col, op, value }],
+          }) as any
+        }
+        default: {
+          return casesHandled(ast)
+        }
+      }
+    },
+    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    orderBy() {
+      assertSelectQueryBuilderAst(ast)
+
+      if (arguments.length === 0 || arguments.length > 2) return invalidQueryBuilder()
+
+      if (arguments.length === 1) {
+        // eslint-disable-next-line prefer-rest-params
+        const params = arguments[0] as QueryBuilder.OrderByParams<TTableDef>
+        return makeQueryBuilder(tableDef, {
+          ...ast,
+          orderBy: [...ast.orderBy, ...params],
+        })
+      }
+
+      // eslint-disable-next-line prefer-rest-params
+      const [col, direction] = arguments as any as [keyof TTableDef['sqliteDef']['columns'] & string, 'asc' | 'desc']
+
+      return makeQueryBuilder(tableDef, {
+        ...ast,
+        orderBy: [...ast.orderBy, { col, direction }],
+      }) as any
+    },
+    limit: (limit) => {
+      assertSelectQueryBuilderAst(ast)
+
+      return makeQueryBuilder(tableDef, { ...ast, limit: Option.some(limit) })
+    },
+    offset: (offset) => {
+      assertSelectQueryBuilderAst(ast)
+
+      return makeQueryBuilder(tableDef, { ...ast, offset: Option.some(offset) })
+    },
+    count: () => {
+      if (isRowQuery(ast) || ast._tag === 'InsertQuery' || ast._tag === 'UpdateQuery' || ast._tag === 'DeleteQuery')
+        return invalidQueryBuilder()
+
+      return makeQueryBuilder(tableDef, {
+        _tag: 'CountQuery',
+        tableDef,
+        where: ast.where,
+        resultSchema: Schema.Struct({ count: Schema.Number }).pipe(
+          Schema.pluck('count'),
+          Schema.Array,
+          Schema.headOrElse(),
+        ),
+      })
+    },
+    first: (options) => {
+      assertSelectQueryBuilderAst(ast)
+
+      if (ast.limit._tag === 'Some') return invalidQueryBuilder(`.first() can't be called after .limit()`)
+
+      return makeQueryBuilder(tableDef, {
+        ...ast,
+        limit: Option.some(1),
+        pickFirst:
+          options?.fallback !== undefined && options.fallback !== 'throws' ? { fallback: options.fallback } : 'throws',
+      })
+    },
+    // // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    // getOrCreate() {
+    //   if (tableDef.options.isClientDocumentTable === false) {
+    //     return invalidQueryBuilder(`getOrCreate() is not allowed when table is not a client document table`)
+    //   }
+
+    //   // eslint-disable-next-line prefer-rest-params
+    //   const params = [...arguments]
+
+    //   let id: string | number
+
+    //   // TODO refactor to handle default id
+    //   id = params[0] as string | number
+    //   if (id === undefined) {
+    //     invalidQueryBuilder(`Id missing for row query on non-singleton table ${tableDef.sqliteDef.name}`)
+    //   }
+
+    //   // TODO validate all required columns are present and values are matching the schema
+    //   const insertValues: Record<string, unknown> = params[1]?.insertValues ?? {}
+
+    //   return makeQueryBuilder(tableDef, {
+    //     _tag: 'RowQuery',
+    //     id,
+    //     tableDef,
+    //     insertValues,
+    //   }) as any
+    // },
+    insert: (values) => {
+      const filteredValues = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined))
+
+      return makeQueryBuilder(tableDef, {
+        _tag: 'InsertQuery',
+        tableDef,
+        values: filteredValues,
+        onConflict: undefined,
+        returning: undefined,
+        resultSchema: Schema.Void,
+      }) as any
+    },
+    onConflict: (
+      targetOrTargets: string | string[],
+      action: 'ignore' | 'replace' | 'update',
+      updateValues?: Record<string, unknown>,
+    ) => {
+      const targets = Array.isArray(targetOrTargets) ? targetOrTargets : [targetOrTargets]
+
+      assertInsertQueryBuilderAst(ast)
+
+      const onConflict = Match.value(action).pipe(
+        Match.when('ignore', () => ({ targets, action: { _tag: 'ignore' } }) satisfies QueryBuilderAst.OnConflict),
+        Match.when('replace', () => ({ targets, action: { _tag: 'replace' } }) satisfies QueryBuilderAst.OnConflict),
+        Match.when(
+          'update',
+          () => ({ targets, action: { _tag: 'update', update: updateValues! } }) satisfies QueryBuilderAst.OnConflict,
+        ),
+        Match.exhaustive,
+      )
+
+      return makeQueryBuilder(tableDef, {
+        ...ast,
+        onConflict,
+      }) as any
+    },
+
+    returning: (...columns) => {
+      assertWriteQueryBuilderAst(ast)
+
+      return makeQueryBuilder(tableDef, {
+        ...ast,
+        returning: columns,
+        resultSchema: tableDef.rowSchema.pipe(Schema.pick(...columns), Schema.Array),
+      }) as any
+    },
+
+    update: (values) => {
+      const filteredValues = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined))
+
+      return makeQueryBuilder(tableDef, {
+        _tag: 'UpdateQuery',
+        tableDef,
+        values: filteredValues,
+        where: [],
+        returning: undefined,
+        resultSchema: Schema.Void,
+      }) as any
+    },
+
+    delete: () => {
+      return makeQueryBuilder(tableDef, {
+        _tag: 'DeleteQuery',
+        tableDef,
+        where: [],
+        returning: undefined,
+        resultSchema: Schema.Void,
+      }) as any
+    },
+  } satisfies QueryBuilder.ApiFull<TResult, TTableDef, never>
+
+  return {
+    [QueryBuilderTypeId]: QueryBuilderTypeId,
+    [QueryBuilderAstSymbol]: ast,
+    ['ResultType']: 'only-for-type-inference' as TResult,
+    asSql: () => astToSql(ast),
+    toString: () => {
+      try {
+        return astToSql(ast).query
+      } catch (cause) {
+        console.debug(`QueryBuilder.toString(): Error converting query builder to string`, cause, ast)
+        return `Error converting query builder to string`
+      }
+    },
+    ...api,
+  } satisfies QueryBuilder<TResult, TTableDef>
+}
+
+const emptyAst = (tableDef: TableDefBase): QueryBuilderAst.SelectQuery => ({
+  _tag: 'SelectQuery',
+  columns: [],
+  pickFirst: false,
+  select: { columns: [] },
+  orderBy: [],
+  offset: Option.none(),
+  limit: Option.none(),
+  tableDef,
+  where: [],
+  resultSchemaSingle: tableDef.rowSchema,
+})
+
+// Helper functions
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function assertSelectQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.SelectQuery {
+  if (ast._tag !== 'SelectQuery') {
+    return shouldNeverHappen('Expected SelectQuery but got ' + ast._tag)
+  }
+}
+
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function assertInsertQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.InsertQuery {
+  if (ast._tag !== 'InsertQuery') {
+    return shouldNeverHappen('Expected InsertQuery but got ' + ast._tag)
+  }
+}
+
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function assertWriteQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.WriteQuery {
+  if (ast._tag !== 'InsertQuery' && ast._tag !== 'UpdateQuery' && ast._tag !== 'DeleteQuery') {
+    return shouldNeverHappen('Expected WriteQuery but got ' + ast._tag)
+  }
+}
+
+const isRowQuery = (ast: QueryBuilderAst): ast is QueryBuilderAst.RowQuery => ast._tag === 'RowQuery'
+
+export const invalidQueryBuilder = (msg?: string) => {
+  return shouldNeverHappen('Invalid query builder' + (msg ? `: ${msg}` : ''))
+}
+
+export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<any> => {
+  const queryAst = qb[QueryBuilderAstSymbol]
+  switch (queryAst._tag) {
+    case 'SelectQuery': {
+      const arraySchema = Schema.Array(queryAst.resultSchemaSingle)
+      if (queryAst.pickFirst === false) {
+        return arraySchema
+      } else if (queryAst.pickFirst === 'throws') {
+        // Will throw if the array is empty
+        return arraySchema.pipe(Schema.headOrElse())
+      } else {
+        const fallbackValue = queryAst.pickFirst.fallback()
+        return Schema.Union(arraySchema, Schema.Tuple(Schema.Literal(fallbackValue))).pipe(
+          Schema.headOrElse(() => fallbackValue),
+        )
+      }
+    }
+    case 'CountQuery': {
+      return Schema.Struct({ count: Schema.Number }).pipe(Schema.pluck('count'), Schema.Array, Schema.headOrElse())
+    }
+    case 'InsertQuery':
+    case 'UpdateQuery':
+    case 'DeleteQuery': {
+      // For write operations with RETURNING clause, we need to return the appropriate schema
+      if (queryAst.returning && queryAst.returning.length > 0) {
+        // Create a schema for the returned columns
+        return queryAst.tableDef.rowSchema.pipe(Schema.pick(...queryAst.returning), Schema.Array)
+      }
+
+      // For write operations without RETURNING, the result is the number of affected rows
+      return Schema.Number
+    }
+    case 'RowQuery': {
+      return queryAst.tableDef.rowSchema.pipe(
+        Schema.pluck('value'),
+        Schema.annotations({ title: `${queryAst.tableDef.sqliteDef.name}.value` }),
+        Schema.Array,
+        Schema.headOrElse(),
+      )
+    }
+    default: {
+      casesHandled(queryAst)
+    }
+  }
+}

package/src/{query-builder → schema/state/sqlite/query-builder}/mod.ts

@@ -7,4 +7,11 @@ export * from './impl.js'
  * - Close abstraction to SQLite to provide a simple & convenient API with predictable behaviour
  * - Use table schema definitions to parse, map & validate query results
  * - Implementation detail: Separate type-level & AST-based runtime implementation
+ *
+ * Currently not supported (not exhaustive list):
+ * - Assumes a `id` column as primary key
+ * - Composite primary keys
+ *
+ * Other known limitations
+ * - Doesn't exclude all invalid query patterns on type level `e.g. `db.todos.returning('id')`
  */

package/src/schema/{schema-helpers.ts → state/sqlite/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 './db-schema/mod.js'
 import type { TableDef, TableDefBase } from './table-def.js'
 
 export const getDefaultValuesEncoded = <TTableDef extends TableDef>(

package/src/schema/state/sqlite/system-tables.ts

@@ -0,0 +1,117 @@
+import { Schema } from '@livestore/utils/effect'
+
+import * as EventSequenceNumber from '../../EventSequenceNumber.js'
+import { SqliteDsl } from './db-schema/mod.js'
+import { table } from './table-def.js'
+
+/// Read model DB
+
+export const SCHEMA_META_TABLE = '__livestore_schema'
+
+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 }),
+  },
+})
+
+export type SchemaMetaRow = typeof schemaMetaTable.Type
+
+export const SCHEMA_EVENT_DEFS_META_TABLE = '__livestore_schema_event_defs'
+
+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 }),
+  },
+})
+
+export type SchemaEventDefsMetaRow = typeof schemaEventDefsMetaTable.Type
+
+/**
+ * Table which stores SQLite changeset blobs which is used for rolling back
+ * read-model state during rebasing.
+ */
+export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
+
+export const sessionChangesetMetaTable = table({
+  name: SESSION_CHANGESET_META_TABLE,
+  columns: {
+    // TODO bring back primary key
+    seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    changeset: SqliteDsl.blob({ nullable: true }),
+    debug: SqliteDsl.json({ nullable: true }),
+  },
+  indexes: [{ columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_session_changeset_id' }],
+})
+
+export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
+
+export const LEADER_MERGE_COUNTER_TABLE = '__livestore_leader_merge_counter'
+
+// TODO get rid of this table in favour of client-only merge generation
+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 type LeaderMergeCounterRow = typeof leaderMergeCounterTable.Type
+
+export const stateSystemTables = [
+  schemaMetaTable,
+  schemaEventDefsMetaTable,
+  sessionChangesetMetaTable,
+  leaderMergeCounterTable,
+]
+
+export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)
+
+/// Eventlog DB
+
+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
+    seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    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)) }),
+  },
+  indexes: [
+    { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
+    { columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_eventlog_seqNum' },
+  ],
+})
+
+export type EventlogMetaRow = typeof eventlogMetaTable.Type
+
+export const SYNC_STATUS_TABLE = '__livestore_sync_status'
+
+export const syncStatusTable = table({
+  name: SYNC_STATUS_TABLE,
+  columns: {
+    head: SqliteDsl.integer({ primaryKey: true }),
+  },
+})
+
+export type SyncStatusRow = typeof syncStatusTable.Type
+
+export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable]

package/src/schema/state/sqlite/table-def.ts

@@ -0,0 +1,197 @@
+import { type Nullable } from '@livestore/utils'
+import type { Schema, Types } from '@livestore/utils/effect'
+
+import { SqliteDsl } from './db-schema/mod.js'
+import type { QueryBuilder } from './query-builder/mod.js'
+import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.js'
+
+export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
+
+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,
+> = {
+  sqliteDef: TSqliteDef
+  options: TOptions
+  // Derived from `sqliteDef`, so only exposed for convenience
+  rowSchema: SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>
+  insertSchema: SqliteDsl.InsertStructSchemaForColumns<TSqliteDef['columns']>
+}
+
+export type TableDef<
+  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
+  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, so we're redefining it here
+  TSchema = Schema.Schema<
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Type'] }
+    >,
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Encoded'] }
+    >
+  >,
+> = {
+  sqliteDef: TSqliteDef
+  options: TOptions
+  // Derived from `sqliteDef`, so only exposed for convenience
+  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[]
+}>
+
+export namespace TableDef {
+  export type Any = TableDef<any, any>
+}
+
+export type TableOptions = {
+  /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
+  readonly isClientDocumentTable: boolean
+}
+
+export const table = <
+  TName extends string,
+  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
+  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
+>(
+  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 = {
+    isClientDocumentTable: false,
+  }
+
+  const columns = (
+    SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
+  ) as SqliteDsl.Columns
+
+  const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
+
+  const rowSchema = SqliteDsl.structSchemaForTable(sqliteDef)
+  const insertSchema = SqliteDsl.insertStructSchemaForTable(sqliteDef)
+  const tableDef = {
+    sqliteDef,
+    options: options_,
+    rowSchema,
+    insertSchema,
+  } satisfies TableDefBase
+
+  const query = makeQueryBuilder(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
+  for (const key of Object.keys(query)) {
+    // @ts-expect-error TODO properly implement this
+    tableDef[key] = query[key]
+  }
+
+  // @ts-expect-error TODO properly type this
+  tableDef[QueryBuilderAstSymbol] = query[QueryBuilderAstSymbol]
+  // @ts-expect-error TODO properly type this
+  tableDef[QueryBuilderTypeId] = query[QueryBuilderTypeId]
+
+  return tableDef as any
+}
+
+export namespace FromTable {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TTableDef extends TableDefBase> = Types.Simplify<
+    Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type NullableColumnNames<TTableDef extends TableDefBase> = FromColumns.NullableColumnNames<
+    TTableDef['sqliteDef']['columns']
+  >
+
+  export type Columns<TTableDef extends TableDefBase> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
+  }
+
+  export type RowEncodeNonNullable<TTableDef extends TableDefBase> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Encoded<
+      TTableDef['sqliteDef']['columns'][K]['schema']
+    >
+  }
+
+  export type RowEncoded<TTableDef extends TableDefBase> = Types.Simplify<
+    Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type RowDecodedAll<TTableDef extends TableDefBase> = {
+    [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> = Types.Simplify<
+    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> = Types.Simplify<
+    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>
+}
+
+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