@livestore/common 0.3.0-dev.5 → 0.3.0-dev.50

package/src/schema/state/sqlite/db-schema/dsl/__snapshots__/field-defs.test.ts.snap

@@ -0,0 +1,206 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`FieldDefs > boolean 1`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 2`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 3`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 4`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 5`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 6`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 7`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 8`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": {
+      "name": "Bob",
+    },
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 9`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 10`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 11`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": null,
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 12`] = `
+{
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": 2022-02-02T00:00:00.000Z,
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 13`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 14`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "None",
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;
+
+exports[`FieldDefs > boolean 15`] = `
+{
+  "columnType": "integer",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": false,
+  },
+  "nullable": false,
+  "primaryKey": false,
+  "schema": [Function],
+}
+`;

package/src/schema/state/sqlite/db-schema/dsl/field-defs.test.ts

@@ -0,0 +1,35 @@
+import { Schema } from '@livestore/utils/effect'
+import { describe, expect, test } from 'vitest'
+
+import * as F from './field-defs.js'
+
+describe.concurrent('FieldDefs', () => {
+  test('text', () => {
+    expect(F.text()).toMatchSnapshot()
+    expect(F.text({})).toMatchSnapshot()
+    expect(F.text({ default: null, nullable: true })).toMatchSnapshot()
+    expect(F.text({ schema: Schema.Literal('foo'), nullable: true, default: 'foo' })).toMatchSnapshot()
+    expect(F.text({ schema: Schema.Union(Schema.Literal('foo')), nullable: true, default: 'foo' })).toMatchSnapshot()
+  })
+
+  test('json', () => {
+    expect(F.json()).toMatchSnapshot()
+    expect(F.json({ default: null, nullable: true })).toMatchSnapshot()
+    expect(
+      F.json({ schema: Schema.Struct({ name: Schema.String }), default: { name: 'Bob' }, nullable: true }),
+    ).toMatchSnapshot()
+  })
+
+  test('datetime', () => {
+    expect(F.datetime()).toMatchSnapshot()
+    expect(F.datetime({})).toMatchSnapshot()
+    expect(F.datetime({ default: null, nullable: true })).toMatchSnapshot()
+    expect(F.datetime({ default: new Date('2022-02-02') })).toMatchSnapshot()
+  })
+
+  test('boolean', () => {
+    expect(F.boolean()).toMatchSnapshot()
+    expect(F.boolean({})).toMatchSnapshot()
+    expect(F.boolean({ default: false })).toMatchSnapshot()
+  })
+})

package/src/schema/state/sqlite/db-schema/dsl/field-defs.ts

@@ -0,0 +1,242 @@
+import { casesHandled } from '@livestore/utils'
+import { Option, Schema } from '@livestore/utils/effect'
+
+export type ColumnDefinition<TEncoded, TDecoded> = {
+  readonly columnType: FieldColumnType
+  readonly schema: Schema.Schema<TDecoded, TEncoded>
+  readonly default: Option.Option<TEncoded>
+  /** @default false */
+  readonly nullable: boolean
+  /** @default false */
+  readonly primaryKey: boolean
+}
+
+export const isColumnDefinition = (value: unknown): value is ColumnDefinition<any, any> => {
+  const validColumnTypes = ['text', 'integer', 'real', 'blob'] as const
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'columnType' in value &&
+    validColumnTypes.includes(value['columnType'] as any)
+  )
+}
+
+export type ColumnDefinitionInput = {
+  readonly schema?: Schema.Schema<unknown>
+  readonly default?: unknown | NoDefault
+  readonly nullable?: boolean
+  readonly primaryKey?: boolean
+}
+
+export const NoDefault = Symbol.for('NoDefault')
+export type NoDefault = typeof NoDefault
+
+export type SqlDefaultValue = {
+  readonly sql: string
+}
+
+export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
+  return typeof value === 'object' && value !== null && 'sql' in value && typeof value['sql'] === 'string'
+}
+
+export type ColDefFn<TColumnType extends FieldColumnType> = {
+  (): {
+    columnType: TColumnType
+    schema: Schema.Schema<DefaultEncodedForColumnType<TColumnType>>
+    default: Option.None<never>
+    nullable: false
+    primaryKey: false
+  }
+  <
+    TEncoded extends DefaultEncodedForColumnType<TColumnType>,
+    TDecoded = DefaultEncodedForColumnType<TColumnType>,
+    const TNullable extends boolean = false,
+    const TDefault extends TDecoded | SqlDefaultValue | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TPrimaryKey extends boolean = false,
+  >(args: {
+    schema?: Schema.Schema<TDecoded, TEncoded>
+    default?: TDefault
+    nullable?: TNullable
+    primaryKey?: TPrimaryKey
+  }): {
+    columnType: TColumnType
+    schema: TNullable extends true
+      ? Schema.Schema<NoInfer<TDecoded> | null, NoInfer<TEncoded> | null>
+      : Schema.Schema<NoInfer<TDecoded>, NoInfer<TEncoded>>
+    default: TDefault extends NoDefault ? Option.None<never> : Option.Some<NoInfer<TDefault>>
+    nullable: NoInfer<TNullable>
+    primaryKey: NoInfer<TPrimaryKey>
+  }
+}
+
+const makeColDef =
+  <TColumnType extends FieldColumnType>(columnType: TColumnType): ColDefFn<TColumnType> =>
+  (def?: ColumnDefinitionInput) => {
+    const nullable = def?.nullable ?? false
+    const schemaWithoutNull: Schema.Schema<any> = def?.schema ?? defaultSchemaForColumnType(columnType)
+    const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
+    const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
+
+    return {
+      columnType,
+      schema,
+      default: default_,
+      nullable,
+      primaryKey: def?.primaryKey ?? false,
+    } as any
+  }
+
+export const column = <TColumnType extends FieldColumnType>(columnType: TColumnType): ColDefFn<TColumnType> =>
+  makeColDef(columnType)
+
+/// Column definitions
+
+export const text: ColDefFn<'text'> = makeColDef('text')
+export const integer: ColDefFn<'integer'> = makeColDef('integer')
+export const real: ColDefFn<'real'> = makeColDef('real')
+export const blob: ColDefFn<'blob'> = makeColDef('blob')
+
+/**
+ * `NoInfer` is needed for some generics to work properly in certain cases.
+ * See full explanation here: https://gist.github.com/schickling/a15e96819826530492b41a10d79d3c04?permalink_comment_id=4805120#gistcomment-4805120
+ *
+ * Big thanks to @andarist for their help with this!
+ */
+type NoInfer<T> = [T][T extends any ? 0 : never]
+
+export type SpecializedColDefFn<
+  TColumnType extends FieldColumnType,
+  TAllowsCustomSchema extends boolean,
+  TBaseDecoded,
+> = {
+  (): {
+    columnType: TColumnType
+    schema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    default: Option.None<never>
+    nullable: false
+    primaryKey: false
+  }
+  <
+    TDecoded = TBaseDecoded,
+    const TNullable extends boolean = false,
+    const TDefault extends TDecoded | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TPrimaryKey extends boolean = false,
+  >(
+    args: TAllowsCustomSchema extends true
+      ? {
+          schema?: Schema.Schema<TDecoded, any>
+          default?: TDefault
+          nullable?: TNullable
+          primaryKey?: TPrimaryKey
+        }
+      : {
+          default?: TDefault
+          nullable?: TNullable
+          primaryKey?: TPrimaryKey
+        },
+  ): {
+    columnType: TColumnType
+    schema: TNullable extends true
+      ? Schema.Schema<NoInfer<TDecoded> | null, DefaultEncodedForColumnType<TColumnType> | null>
+      : Schema.Schema<NoInfer<TDecoded>, DefaultEncodedForColumnType<TColumnType>>
+    default: TDefault extends NoDefault ? Option.None<never> : Option.Some<TDefault>
+    nullable: NoInfer<TNullable>
+    primaryKey: NoInfer<TPrimaryKey>
+  }
+}
+
+type MakeSpecializedColDefFn = {
+  <TColumnType extends FieldColumnType, TBaseDecoded>(
+    columnType: TColumnType,
+    opts: {
+      _tag: 'baseSchema'
+      baseSchema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    },
+  ): SpecializedColDefFn<TColumnType, false, TBaseDecoded>
+  <TColumnType extends FieldColumnType, TBaseDecoded>(
+    columnType: TColumnType,
+    opts: {
+      _tag: 'baseSchemaFn'
+      baseSchemaFn: <TDecoded>(
+        customSchema: Schema.Schema<TDecoded, TBaseDecoded> | undefined,
+      ) => Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    },
+  ): SpecializedColDefFn<TColumnType, true, TBaseDecoded>
+}
+
+const makeSpecializedColDef: MakeSpecializedColDefFn = (columnType, opts) => (def?: ColumnDefinitionInput) => {
+  const nullable = def?.nullable ?? false
+  const schemaWithoutNull = opts._tag === 'baseSchemaFn' ? opts.baseSchemaFn(def?.schema as any) : opts.baseSchema
+  const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
+  const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
+
+  return {
+    columnType,
+    schema,
+    default: default_,
+    nullable,
+    primaryKey: def?.primaryKey ?? false,
+  } as any
+}
+
+export const json: SpecializedColDefFn<'text', true, unknown> = makeSpecializedColDef('text', {
+  _tag: 'baseSchemaFn',
+  baseSchemaFn: (customSchema) => Schema.parseJson(customSchema ?? Schema.Any),
+})
+
+export const datetime: SpecializedColDefFn<'text', false, Date> = makeSpecializedColDef('text', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.Date,
+})
+
+export const datetimeInteger: SpecializedColDefFn<'integer', false, Date> = makeSpecializedColDef('integer', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.transform(Schema.Number, Schema.DateFromSelf, {
+    decode: (ms) => new Date(ms),
+    encode: (date) => date.getTime(),
+  }),
+})
+
+export const boolean: SpecializedColDefFn<'integer', false, boolean> = makeSpecializedColDef('integer', {
+  _tag: 'baseSchema',
+  baseSchema: Schema.transform(Schema.Number, Schema.Boolean, {
+    decode: (_) => _ === 1,
+    encode: (_) => (_ ? 1 : 0),
+  }),
+})
+
+export type FieldColumnType = 'text' | 'integer' | 'real' | 'blob'
+
+export type DefaultEncodedForColumnType<TColumnType extends FieldColumnType> = TColumnType extends 'text'
+  ? string
+  : TColumnType extends 'integer'
+    ? number
+    : TColumnType extends 'real'
+      ? number
+      : TColumnType extends 'blob'
+        ? Uint8Array
+        : never
+
+export const defaultSchemaForColumnType = <TColumnType extends FieldColumnType>(
+  columnType: TColumnType,
+): Schema.Schema<DefaultEncodedForColumnType<TColumnType>> => {
+  type T = DefaultEncodedForColumnType<TColumnType>
+
+  switch (columnType) {
+    case 'text': {
+      return Schema.String as any as Schema.Schema<T>
+    }
+    case 'integer': {
+      return Schema.Number as any as Schema.Schema<T>
+    }
+    case 'real': {
+      return Schema.Number as any as Schema.Schema<T>
+    }
+    case 'blob': {
+      return Schema.Uint8ArrayFromSelf as any as Schema.Schema<T>
+    }
+    default: {
+      return casesHandled(columnType)
+    }
+  }
+}

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

@@ -0,0 +1,222 @@
+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, FromColumns.RowDecoded<TCols>>,
+  AnyIfConstained<TCols, FromColumns.RowEncoded<TCols>>
+>
+
+export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<
+  AnyIfConstained<TCols, FromColumns.InsertRowDecoded<TCols>>,
+  AnyIfConstained<TCols, FromColumns.InsertRowEncoded<TCols>>
+>
+
+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
+
+export const insertStructSchemaForTable = <TTableDefinition extends TableDefinition<any, any>>(
+  tableDef: TTableDefinition,
+): InsertStructSchemaForColumns<TTableDefinition['columns']> =>
+  Schema.Struct(
+    Object.fromEntries(
+      tableDef.ast.columns.map((column) => [
+        column.name,
+        column.nullable === true || column.default._tag === 'Some' ? Schema.optional(column.schema) : 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 RowEncodedAll<TColumns extends Columns> = {
+    readonly [K in keyof TColumns]: Schema.Schema.Encoded<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>>>
+  >
+
+  export type InsertRowEncoded<TColumns extends Columns> = Types.Simplify<
+    Pick<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &
+      Partial<Omit<RowEncodedAll<TColumns>, RequiredInsertColumnNames<TColumns>>>
+  >
+}