kysely 0.14.0 → 0.15.2

package/dist/esm/migration/{migration.js → migrator.js}

@@ -1,22 +1,122 @@
-import * as path from 'path';
-import { promises as fs } from 'fs';
-import { freeze, getLast, isFunction, isObject, isString, } from '../util/object-utils.js';
+import { freeze, getLast } from '../util/object-utils.js';
+import { PRIVATE_ADAPTER } from '../util/private-symbols.js';
 export const MIGRATION_TABLE = 'kysely_migration';
 export const MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 export const MIGRATION_LOCK_ID = 'migration_lock';
 export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
-export class MigrationModule {
-    #db;
-    #adapter;
-    constructor(db, adapter) {
-        this.#db = db;
-        this.#adapter = adapter;
+/**
+ * A class for running migrations.
+ *
+ * ### Example
+ *
+ * This example uses the {@link FileMigrationProvider} that reads migrations
+ * files from a single folder. You can easily implement your own
+ * {@link MigrationProvider} if you want to provide migrations some
+ * other way.
+ *
+ * ```ts
+ * const migrator = new Migrator({
+ *   db,
+ *   // The constructor signature of FileMigrationProvider is a
+ *   // bit weird to keep Kysely independent of node.js or any
+ *   // other environment.
+ *   provider: new FileMigrationProvider(
+ *     fs.readdir,
+ *     path.join,
+ *     // Path to the folder that contains all your migrations.
+ *     'migrations'
+ *   )
+ * })
+ * ```
+ */
+export class Migrator {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
-    async migrateToLatest(migrationsOrFolderPath) {
-        return this.#migrate(migrationsOrFolderPath, ({ migrations }) => migrations.length - 1);
+    /**
+     * Runs all migrations that have not yet been run.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed. See the examples below.
+     *
+     * This method goes through all possible migrations provided by the provider and runs the
+     * ones whose names come alphabetically after the last migration that has been run. If the
+     * list of executed migrations doesn't match the beginning of the list of possible migrations
+     * an error is thrown.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import * as path from 'path'
+     * import * as fs from 'fs/promises'
+     *
+     * const db = new Kysely<Database>({
+     *   dialect: new PostgresDialect({
+     *     host: 'localhost',
+     *     database: 'kysely_test',
+     *   }),
+     * })
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   // The constructor signature of FileMigrationProvider is a
+     *   // bit weird to keep Kysely independent of node.js or any
+     *   // other environment.
+     *   provider: new FileMigrationProvider(
+     *     fs.readdir,
+     *     path.join,
+     *     // Path to the folder that contains all your migrations.
+     *     'migrations'
+     *   )
+     * })
+     *
+     * const { error, results } = await migrator.migrateToLatest()
+     *
+     * results?.forEach((it) => {
+     *   if (it.status === 'Success') {
+     *     console.log(`migration "${it.migrationName}" was executed successfully`)
+     *   } else if (it.status === 'Error') {
+     *     console.error(`failed to execute migration "${it.migrationName}"`)
+     *   }
+     * })
+     *
+     * if (error) {
+     *   console.error('failed to run `migrateToLatest`')
+     *   console.error(error)
+     * }
+     * ```
+     */
+    async migrateToLatest() {
+        return this.#migrate(({ migrations }) => migrations.length - 1);
     }
-    async migrateTo(migrationsOrFolderPath, targetMigrationName) {
-        return this.#migrate(migrationsOrFolderPath, ({ migrations }) => {
+    /**
+     * Migrate up/down to a specific migration.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateTo('some_migration')
+     * ```
+     *
+     * If you specify the name of the first migration, this method migrates
+     * down to the first migration, but doesn't run the `down` method of
+     * the first migration. In case you want to migrate all the way down,
+     * you can use a special constant `NO_MIGRATIONS`:
+     *
+     * ```ts
+     * await migrator.migrateTo(NO_MIGRATIONS)
+     * ```
+     */
+    async migrateTo(targetMigrationName) {
+        return this.#migrate(({ migrations }) => {
             if (targetMigrationName === NO_MIGRATIONS) {
                 return -1;
             }
@@ -27,16 +127,44 @@ export class MigrationModule {
             return index;
         });
     }
-    async migrateUp(migrationsOrFolderPath) {
-        return this.#migrate(migrationsOrFolderPath, ({ currentIndex, migrations }) => Math.min(currentIndex + 1, migrations.length - 1));
+    /**
+     * Migrate one step up.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateUp()
+     * ```
+     */
+    async migrateUp() {
+        return this.#migrate(({ currentIndex, migrations }) => Math.min(currentIndex + 1, migrations.length - 1));
     }
-    async migrateDown(migrationsOrFolderPath) {
-        return this.#migrate(migrationsOrFolderPath, ({ currentIndex }) => Math.max(currentIndex - 1, -1));
+    /**
+     * Migrate one step down.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateDown()
+     * ```
+     */
+    async migrateDown() {
+        return this.#migrate(({ currentIndex }) => Math.max(currentIndex - 1, -1));
     }
-    async #migrate(migrationsOrFolderPath, getTargetMigration) {
+    async #migrate(getTargetMigrationIndex) {
         try {
             await this.#ensureMigrationTablesExists();
-            return await this.#runMigrations(migrationsOrFolderPath, getTargetMigration);
+            return await this.#runMigrations(getTargetMigrationIndex);
         }
         catch (error) {
             if (error instanceof MigrationResultSetError) {
@@ -53,7 +181,7 @@ export class MigrationModule {
     async #ensureMigrationTableExists() {
         if (!(await this.#doesTableExists(MIGRATION_TABLE))) {
             try {
-                await this.#db.schema
+                await this.#props.db.schema
                     .createTable(MIGRATION_TABLE)
                     .ifNotExists()
                     .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
@@ -75,7 +203,7 @@ export class MigrationModule {
     async #ensureMigrationLockTableExists() {
         if (!(await this.#doesTableExists(MIGRATION_LOCK_TABLE))) {
             try {
-                await this.#db.schema
+                await this.#props.db.schema
                     .createTable(MIGRATION_LOCK_TABLE)
                     .ifNotExists()
                     .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
@@ -95,7 +223,7 @@ export class MigrationModule {
     async #ensureLockRowExists() {
         if (!(await this.#doesLockRowExists())) {
             try {
-                await this.#db
+                await this.#props.db
                     .insertInto(MIGRATION_LOCK_TABLE)
                     .values({ id: MIGRATION_LOCK_ID })
                     .execute();
@@ -108,28 +236,28 @@ export class MigrationModule {
         }
     }
     async #doesTableExists(tableName) {
-        const metadata = await this.#db.introspection.getMetadata({
+        const metadata = await this.#props.db.introspection.getMetadata({
             withInternalKyselyTables: true,
         });
         return !!metadata.tables.find((it) => it.name === tableName);
     }
     async #doesLockRowExists() {
-        const lockRow = await this.#db
+        const lockRow = await this.#props.db
             .selectFrom(MIGRATION_LOCK_TABLE)
             .where('id', '=', MIGRATION_LOCK_ID)
             .select('id')
             .executeTakeFirst();
         return !!lockRow;
     }
-    async #runMigrations(migrationsOrFolderPath, getTargetMigration) {
+    async #runMigrations(getTargetMigrationIndex) {
         const run = async (db) => {
             try {
-                await this.#adapter.acquireMigrationLock(db);
-                const state = await this.#getState(db, migrationsOrFolderPath);
+                await this.#props.db[PRIVATE_ADAPTER].acquireMigrationLock(db);
+                const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
                 }
-                const targetIndex = getTargetMigration(state);
+                const targetIndex = getTargetMigrationIndex(state);
                 if (targetIndex === undefined) {
                     return { results: [] };
                 }
@@ -142,18 +270,18 @@ export class MigrationModule {
                 return { results: [] };
             }
             finally {
-                await this.#adapter.releaseMigrationLock(db);
+                await this.#props.db[PRIVATE_ADAPTER].releaseMigrationLock(db);
             }
         };
-        if (this.#adapter.supportsTransactionalDdl) {
-            return this.#db.transaction().execute(run);
+        if (this.#props.db[PRIVATE_ADAPTER].supportsTransactionalDdl) {
+            return this.#props.db.transaction().execute(run);
         }
         else {
-            return this.#db.connection().execute(run);
+            return this.#props.db.connection().execute(run);
         }
     }
-    async #getState(db, migrationsOrFolderPath) {
-        const migrations = await this.#resolveMigrations(migrationsOrFolderPath);
+    async #getState(db) {
+        const migrations = await this.#resolveMigrations();
         const executedMigrations = await this.#getExecutedMigrations(db);
         this.#ensureMigrationsNotCorrupted(migrations, executedMigrations);
         return freeze({
@@ -161,10 +289,8 @@ export class MigrationModule {
             currentIndex: migrations.findIndex((it) => it.name === getLast(executedMigrations)),
         });
     }
-    async #resolveMigrations(migrationsOrFolderPath) {
-        const allMigrations = isString(migrationsOrFolderPath)
-            ? await this.#readMigrationsFromFolder(migrationsOrFolderPath)
-            : migrationsOrFolderPath;
+    async #resolveMigrations() {
+        const allMigrations = await this.#props.provider.getMigrations();
         return Object.keys(allMigrations)
             .sort()
             .map((name) => ({
@@ -172,20 +298,6 @@ export class MigrationModule {
             name,
         }));
     }
-    async #readMigrationsFromFolder(migrationsFolderPath) {
-        const files = await fs.readdir(migrationsFolderPath);
-        const migrations = {};
-        for (const file of files) {
-            if ((file.endsWith('.js') || file.endsWith('.ts')) &&
-                !file.endsWith('.d.ts')) {
-                const migration = await import(path.join(migrationsFolderPath, file));
-                if (isMigration(migration)) {
-                    migrations[file.substring(0, file.length - 3)] = migration;
-                }
-            }
-        }
-        return migrations;
-    }
     async #getExecutedMigrations(db) {
         const executedMigrations = await db
             .selectFrom(MIGRATION_TABLE)
@@ -201,7 +313,7 @@ export class MigrationModule {
             }
         }
         // Now we know all executed migrations exist in the `migrations` list.
-        // Next we need to make sure that the executed migrations are the first
+        // Next we need to make sure that the executed migratiosns are the first
         // ones in the migration list.
         for (let i = 0; i < executedMigrations.length; ++i) {
             if (migrations[i].name !== executedMigrations[i]) {
@@ -299,6 +411,3 @@ class MigrationResultSetError extends Error {
         return this.#resultSet;
     }
 }
-function isMigration(obj) {
-    return isObject(obj) && isFunction(obj.up);
-}

package/dist/esm/parser/insert-values-parser.d.ts

@@ -1,12 +1,12 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { GeneratedPlaceholder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
+import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]: InsertValueExpression<DB, TB, DB[TB][C]>;
+    [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
+} & {
+    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-declare type InsertValueExpression<DB, TB extends keyof DB, T> = ValueExpression<DB, TB, T> | GeneratedPlaceholder;
 export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
-export {};

package/dist/esm/parser/insert-values-parser.js

@@ -1,7 +1,6 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
-import { isGeneratedPlaceholder } from '../util/generated-placeholder.js';
 import { freeze, isPrimitive } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
@@ -20,7 +19,7 @@ function parseColumnNamesAndIndexes(rows) {
     for (const row of rows) {
         const cols = Object.keys(row);
         for (const col of cols) {
-            if (!columns.has(col) && !isGeneratedPlaceholder(row[col])) {
+            if (!columns.has(col) && row[col] !== undefined) {
                 columns.set(col, columns.size);
             }
         }
@@ -33,7 +32,7 @@ function parseRowValues(ctx, row, columns) {
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         const value = row[col];
-        if (columnIdx !== undefined && !isGeneratedPlaceholder(value)) {
+        if (columnIdx !== undefined) {
             rowValues[columnIdx] = value;
         }
     }

package/dist/esm/parser/reference-parser.d.ts

@@ -3,17 +3,18 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ParseContext } from './parse-context.js';
 import { ComplexExpression } from './complex-expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { SelectType } from '../util/column-type.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, R = RowType<DB, TB>> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends keyof R ? R[RE] : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;

package/dist/esm/parser/select-parser.d.ts

@@ -1,10 +1,11 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 import { AliasedComplexExpression } from './complex-expression-parser.js';
+import { Selectable, SelectType } from '../util/column-type.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
@@ -15,14 +16,19 @@ export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, SE> =
 /**
  * `selectAll` output query builder type.
  */
-export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & RowType<DB, S>>;
+export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & AllSelection<DB, S>>;
 export declare type Selection<DB, TB extends keyof DB, SE> = {
-    [A in ExtractAliasFromSelectExpression<SE>]: ExtractTypeFromSelectExpression<DB, TB, SE, A>;
+    [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
 declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
-declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any, R = RowType<DB, TB>> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends keyof R ? R[SE] : never : never;
+declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
+declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+    [C in AnyColumn<DB, TB>]: {
+        [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+    }[TB];
+}>;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,7 +1,8 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ParseContext } from './parse-context.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]?: ValueExpression<DB, TB, DB[TB][C]>;
+    [C in UpdateKeys<DB[TB]>]?: ValueExpression<DB, TB, UpdateType<DB[TB][C]>>;
 };
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/query-builder/delete-query-builder.d.ts

@@ -17,6 +17,7 @@ import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
+import { Selectable } from '../util/column-type.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -539,7 +540,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -553,7 +553,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, first_name } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -569,7 +568,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -587,7 +585,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): DeleteQueryBuilder<DB, TB, DB[TB]>;
+    returningAll(): DeleteQueryBuilder<DB, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *

package/dist/esm/query-builder/insert-query-builder.d.ts

@@ -15,6 +15,7 @@ import { NoResultErrorConstructor } from './no-result-error.js';
 import { ComplexExpression } from '../parser/complex-expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
 import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
+import { Selectable } from '../util/column-type.js';
 export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: InsertQueryBuilderProps);
@@ -23,13 +24,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * This method takes an object whose keys are column names and values are
      * values to insert. In addition to the column's type, the values can be
-     * {@link Kysely.raw | raw} instances, select queries or the
-     * {@link Kysely.generated | generated} placeholder.
+     * {@link Kysely.raw | raw} instances or select queries.
      *
-     * You must provide all values defined by the interface of the table you
-     * are inserting into. Values that are generated by the database like auto incrementing
-     * identifiers can be marked with the {@link Kysely.generated} placeholder unless you
-     * want to insert a specific value instead of the generated default.
+     * You must provide all fields you haven't explicitly marked as nullable
+     * or optional using {@link Generated} or {@link ColumnType}.
      *
      * The return value of an `insert` query is an instance of {@link InsertResult}. The
      * {@link InsertResult.insertId | insertId} field holds the auto incremented primary
@@ -48,7 +46,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const id = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -70,11 +67,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('person')
      *   .values([{
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   }, {
-     *     id: db.generated,
      *     first_name: 'Arnold',
      *     last_name: 'Schwarzenegger',
      *   }])
@@ -95,7 +90,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const row = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -118,7 +112,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const result = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: db.raw('? || ?', ['Ani', 'ston']),
      *     age: db.selectFrom('person').select(raw('avg(age)')),
@@ -144,7 +137,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .select(['id', 'first_name', 'gender'])
      *   .limit(1)
      * ).insertInto('pet').values({
-     *   id: db.generated,
      *   owner_id: (eb) => eb.selectFrom('jennifer').select('id'),
      *   name: (eb) => eb.selectFrom('jennifer').select('first_name'),
      *   species: 'cat',
@@ -229,7 +221,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
@@ -255,7 +246,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
@@ -283,7 +273,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
@@ -309,7 +298,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
@@ -337,7 +325,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * await db
      *   .insertInto('pet')
      *   .values({
-     *     id: db.generated,
      *     name: 'Catto',
      *     species: 'cat',
      *   })
@@ -396,7 +383,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -410,7 +396,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id, first_name } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -426,7 +411,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
-     *     id: db.generated,
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
@@ -444,7 +428,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
      */
-    returningAll(): InsertQueryBuilder<DB, TB, DB[TB]>;
+    returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *