kysely 0.14.0 → 0.15.2

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

@@ -1,25 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationModule = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
-const path = require("path");
-const fs_1 = require("fs");
+exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const private_symbols_js_1 = require("../util/private-symbols.js");
 exports.MIGRATION_TABLE = 'kysely_migration';
 exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 exports.MIGRATION_LOCK_ID = 'migration_lock';
 exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true });
-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'
+ *   )
+ * })
+ * ```
+ */
+class Migrator {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.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 === exports.NO_MIGRATIONS) {
                 return -1;
             }
@@ -30,16 +130,44 @@ 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) {
@@ -56,7 +184,7 @@ class MigrationModule {
     async #ensureMigrationTableExists() {
         if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
             try {
-                await this.#db.schema
+                await this.#props.db.schema
                     .createTable(exports.MIGRATION_TABLE)
                     .ifNotExists()
                     .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
@@ -78,7 +206,7 @@ class MigrationModule {
     async #ensureMigrationLockTableExists() {
         if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
             try {
-                await this.#db.schema
+                await this.#props.db.schema
                     .createTable(exports.MIGRATION_LOCK_TABLE)
                     .ifNotExists()
                     .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
@@ -98,7 +226,7 @@ class MigrationModule {
     async #ensureLockRowExists() {
         if (!(await this.#doesLockRowExists())) {
             try {
-                await this.#db
+                await this.#props.db
                     .insertInto(exports.MIGRATION_LOCK_TABLE)
                     .values({ id: exports.MIGRATION_LOCK_ID })
                     .execute();
@@ -111,28 +239,28 @@ 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(exports.MIGRATION_LOCK_TABLE)
             .where('id', '=', exports.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_symbols_js_1.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: [] };
                 }
@@ -145,18 +273,18 @@ class MigrationModule {
                 return { results: [] };
             }
             finally {
-                await this.#adapter.releaseMigrationLock(db);
+                await this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].releaseMigrationLock(db);
             }
         };
-        if (this.#adapter.supportsTransactionalDdl) {
-            return this.#db.transaction().execute(run);
+        if (this.#props.db[private_symbols_js_1.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 (0, object_utils_js_1.freeze)({
@@ -164,10 +292,8 @@ class MigrationModule {
             currentIndex: migrations.findIndex((it) => it.name === (0, object_utils_js_1.getLast)(executedMigrations)),
         });
     }
-    async #resolveMigrations(migrationsOrFolderPath) {
-        const allMigrations = (0, object_utils_js_1.isString)(migrationsOrFolderPath)
-            ? await this.#readMigrationsFromFolder(migrationsOrFolderPath)
-            : migrationsOrFolderPath;
+    async #resolveMigrations() {
+        const allMigrations = await this.#props.provider.getMigrations();
         return Object.keys(allMigrations)
             .sort()
             .map((name) => ({
@@ -175,20 +301,6 @@ class MigrationModule {
             name,
         }));
     }
-    async #readMigrationsFromFolder(migrationsFolderPath) {
-        const files = await fs_1.promises.readdir(migrationsFolderPath);
-        const migrations = {};
-        for (const file of files) {
-            if ((file.endsWith('.js') || file.endsWith('.ts')) &&
-                !file.endsWith('.d.ts')) {
-                const migration = await Promise.resolve().then(() => require(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(exports.MIGRATION_TABLE)
@@ -204,7 +316,7 @@ 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]) {
@@ -292,7 +404,7 @@ class MigrationModule {
         return { results };
     }
 }
-exports.MigrationModule = MigrationModule;
+exports.Migrator = Migrator;
 class MigrationResultSetError extends Error {
     #resultSet;
     constructor(result) {
@@ -303,6 +415,3 @@ class MigrationResultSetError extends Error {
         return this.#resultSet;
     }
 }
-function isMigration(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.up);
-}

package/dist/cjs/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/cjs/parser/insert-values-parser.js

@@ -4,7 +4,6 @@ exports.parseInsertObjectOrList = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
-const generated_placeholder_js_1 = require("../util/generated-placeholder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
@@ -24,7 +23,7 @@ function parseColumnNamesAndIndexes(rows) {
     for (const row of rows) {
         const cols = Object.keys(row);
         for (const col of cols) {
-            if (!columns.has(col) && !(0, generated_placeholder_js_1.isGeneratedPlaceholder)(row[col])) {
+            if (!columns.has(col) && row[col] !== undefined) {
                 columns.set(col, columns.size);
             }
         }
@@ -37,7 +36,7 @@ function parseRowValues(ctx, row, columns) {
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         const value = row[col];
-        if (columnIdx !== undefined && !(0, generated_placeholder_js_1.isGeneratedPlaceholder)(value)) {
+        if (columnIdx !== undefined) {
             rowValues[columnIdx] = value;
         }
     }

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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.
      *