kysely 0.17.1 → 0.18.0

package/dist/esm/query-executor/default-query-executor.d.ts

@@ -3,11 +3,14 @@ import { DatabaseConnection } from '../driver/database-connection.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode, QueryCompiler } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { QueryExecutor } from './query-executor.js';
-import { DialectAdapter } from '../index-nodeless.js';
-export declare class DefaultQueryExecutor extends QueryExecutor {
+import { QueryExecutorBase } from './query-executor-base.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
+export declare class DefaultQueryExecutor extends QueryExecutorBase {
     #private;
     constructor(compiler: QueryCompiler, adapter: DialectAdapter, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    /**
+     * Returns the adapter for the current dialect.
+     */
     get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
@@ -38,9 +41,9 @@ export declare class DefaultQueryExecutor extends QueryExecutor {
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): DefaultQueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    withoutPlugins(): QueryExecutor;
+    withoutPlugins(): DefaultQueryExecutor;
 }

package/dist/esm/query-executor/default-query-executor.js

@@ -1,6 +1,6 @@
 /// <reference types="./default-query-executor.d.ts" />
-import { QueryExecutor } from './query-executor.js';
-export class DefaultQueryExecutor extends QueryExecutor {
+import { QueryExecutorBase } from './query-executor-base.js';
+export class DefaultQueryExecutor extends QueryExecutorBase {
     #compiler;
     #adapter;
     #connectionProvider;

package/dist/esm/query-executor/noop-query-executor.d.ts

@@ -1,13 +1,16 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { QueryExecutor } from './query-executor.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryExecutorBase } from './query-executor-base.js';
 /**
  * A {@link QueryExecutor} subclass that can be used when you don't
  * have a {@link QueryCompiler}, {@link ConnectionProvider} or any
  * other needed things to actually execute queries.
  */
-export declare class NoopQueryExecutor extends QueryExecutor {
+export declare class NoopQueryExecutor extends QueryExecutorBase {
+    /**
+     * Returns the adapter for the current dialect.
+     */
     get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
@@ -23,7 +26,7 @@ export declare class NoopQueryExecutor extends QueryExecutor {
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    withConnectionProvider(): QueryExecutor;
+    withConnectionProvider(): NoopQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
@@ -42,6 +45,6 @@ export declare class NoopQueryExecutor extends QueryExecutor {
     /**
      * Returns a copy of this executor without any plugins.
      */
-    withoutPlugins(): QueryExecutor;
+    withoutPlugins(): NoopQueryExecutor;
 }
 export declare const NOOP_QUERY_EXECUTOR: NoopQueryExecutor;

package/dist/esm/query-executor/noop-query-executor.js

@@ -1,11 +1,11 @@
 /// <reference types="./noop-query-executor.d.ts" />
-import { QueryExecutor } from './query-executor.js';
+import { QueryExecutorBase } from './query-executor-base.js';
 /**
  * A {@link QueryExecutor} subclass that can be used when you don't
  * have a {@link QueryCompiler}, {@link ConnectionProvider} or any
  * other needed things to actually execute queries.
  */
-export class NoopQueryExecutor extends QueryExecutor {
+export class NoopQueryExecutor extends QueryExecutorBase {
     get adapter() {
         throw new Error('this query cannot be compiled to SQL');
     }

package/dist/esm/query-executor/query-executor-base.d.ts

@@ -0,0 +1,62 @@
+import { ConnectionProvider } from '../driver/connection-provider.js';
+import { DatabaseConnection, QueryResult } from '../driver/database-connection.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { RootOperationNode } from '../query-compiler/query-compiler.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { QueryId } from '../util/query-id.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryExecutor } from './query-executor.js';
+export declare abstract class QueryExecutorBase implements QueryExecutor {
+    #private;
+    constructor(plugins?: ReadonlyArray<KyselyPlugin>);
+    abstract get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
+    get plugins(): ReadonlyArray<KyselyPlugin>;
+    /**
+     * Given the query the user has built (expressed as an operation node tree)
+     * this method runs it through all plugins' `transformQuery` methods and
+     * returns the result.
+     */
+    transformQuery<T extends RootOperationNode>(node: T, queryId: QueryId): T;
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
+    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    abstract provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method.
+     */
+    executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
+    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
+    abstract withPlugin(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
+    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
+    abstract withoutPlugins(): QueryExecutorBase;
+}

package/dist/esm/query-executor/query-executor-base.js

@@ -0,0 +1,43 @@
+/// <reference types="./query-executor-base.d.ts" />
+import { freeze } from '../util/object-utils.js';
+const NO_PLUGINS = freeze([]);
+export class QueryExecutorBase {
+    #plugins;
+    constructor(plugins = NO_PLUGINS) {
+        this.#plugins = plugins;
+    }
+    get plugins() {
+        return this.#plugins;
+    }
+    transformQuery(node, queryId) {
+        for (const plugin of this.#plugins) {
+            const transformedNode = plugin.transformQuery({ node, queryId });
+            // We need to do a runtime check here. There is no good way
+            // to write types that enforce this constraint.
+            if (transformedNode.kind === node.kind) {
+                node = transformedNode;
+            }
+            else {
+                throw new Error([
+                    `KyselyPlugin.transformQuery must return a node`,
+                    `of the same kind that was given to it.`,
+                    `The plugin was given a ${node.kind}`,
+                    `but it returned a ${transformedNode.kind}`,
+                ].join(' '));
+            }
+        }
+        return node;
+    }
+    async executeQuery(compiledQuery, queryId) {
+        return await this.provideConnection(async (connection) => {
+            const result = await connection.executeQuery(compiledQuery);
+            return this.#transformResult(result, queryId);
+        });
+    }
+    async #transformResult(result, queryId) {
+        for (const plugin of this.#plugins) {
+            result = await plugin.transformResult({ result, queryId });
+        }
+        return result;
+    }
+}

package/dist/esm/query-executor/query-executor.d.ts

@@ -1,20 +1,24 @@
 import { ConnectionProvider } from '../driver/connection-provider.js';
-import { DatabaseConnection, QueryResult } from '../driver/database-connection.js';
+import { QueryResult } from '../driver/database-connection.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
- * This class abstracts away the details of how to compile a query into SQL
+ * This interface abstracts away the details of how to compile a query into SQL
  * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */
-export declare abstract class QueryExecutor implements ConnectionProvider {
-    #private;
-    constructor(plugins?: KyselyPlugin[]);
-    abstract get adapter(): DialectAdapter;
+export interface QueryExecutor extends ConnectionProvider {
+    /**
+     * Returns the adapter for the current dialect.
+     */
+    get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
     get plugins(): ReadonlyArray<KyselyPlugin>;
     /**
      * Given the query the user has built (expressed as an operation node tree)
@@ -27,12 +31,7 @@ export declare abstract class QueryExecutor implements ConnectionProvider {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
-    /**
-     * Provides a connection for the callback and takes care of disposing
-     * the connection after the callback has been run.
-     */
-    abstract provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method.
@@ -41,24 +40,24 @@ export declare abstract class QueryExecutor implements ConnectionProvider {
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
      */
-    abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    withPlugin(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor with a list of plugins added
      * as the last plugins.
      */
-    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
+    withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
      */
-    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
+    withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    abstract withoutPlugins(): QueryExecutor;
+    withoutPlugins(): QueryExecutor;
 }

package/dist/esm/query-executor/query-executor.js

@@ -1,58 +1,2 @@
 /// <reference types="./query-executor.d.ts" />
-import { freeze } from '../util/object-utils.js';
-const NO_PLUGINS = freeze([]);
-/**
- * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
- * and other classes that execute queries can just pass around and instance of
- * `QueryExecutor`.
- */
-export class QueryExecutor {
-    #plugins;
-    constructor(plugins) {
-        this.#plugins = plugins ?? NO_PLUGINS;
-    }
-    get plugins() {
-        return this.#plugins;
-    }
-    /**
-     * Given the query the user has built (expressed as an operation node tree)
-     * this method runs it through all plugins' `transformQuery` methods and
-     * returns the result.
-     */
-    transformQuery(node, queryId) {
-        for (const plugin of this.#plugins) {
-            const transformedNode = plugin.transformQuery({ node, queryId });
-            // We need to do a runtime check here. There is no good way
-            // to write types that enforce this constraint.
-            if (transformedNode.kind === node.kind) {
-                node = transformedNode;
-            }
-            else {
-                throw new Error([
-                    `KyselyPlugin.transformQuery must return a node`,
-                    `of the same kind that was given to it.`,
-                    `The plugin was given a ${node.kind}`,
-                    `but it returned a ${transformedNode.kind}`,
-                ].join(' '));
-            }
-        }
-        return node;
-    }
-    /**
-     * Executes a compiled query and runs the result through all plugins'
-     * `transformResult` method.
-     */
-    async executeQuery(compiledQuery, queryId) {
-        return await this.provideConnection(async (connection) => {
-            const result = await connection.executeQuery(compiledQuery);
-            return this.#transformResult(result, queryId);
-        });
-    }
-    async #transformResult(result, queryId) {
-        for (const plugin of this.#plugins) {
-            result = await plugin.transformResult({ result, queryId });
-        }
-        return result;
-    }
-}
+export {};

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -38,8 +39,37 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * select concat(first_name, ' ', last_name) as "full_name"
      * from "person"
      * ```
+     *
+     * You can also pass in a raw SQL snippet but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -67,9 +97,9 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
      * which causes this type to be equal to AliasedRawBuilder with any A
      * as long as O is the same.
      */
-    protected get alias(): A;
+    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

package/dist/esm/raw-builder/raw-builder.js

@@ -1,8 +1,10 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -14,31 +16,6 @@ export class RawBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
-    /**
-     * Returns an aliased version of the SQL expression.
-     *
-     * In addition to slapping `as "the_alias"` to the end of the SQL,
-     * this method also provides strict typing:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select(
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     *
-     * // `full_name: string` field exists in the result type.
-     * console.log(result.full_name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```ts
-     * select concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -100,7 +77,9 @@ export class AliasedRawBuilder {
         return this.#alias;
     }
     toOperationNode() {
-        return AliasNode.create(this.#rawBuilder.toOperationNode(), this.#alias);
+        return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
+            ? this.#alias.toOperationNode()
+            : IdentifierNode.create(this.#alias));
     }
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;

package/dist/esm/raw-builder/sql.d.ts

@@ -221,7 +221,7 @@ export interface Sql {
      *   sql.id('first_name')
      * ]
      *
-     * sql`BEFORE ${sql.array(things, sql`::varchar, `)} AFTER`
+     * sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER`
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -281,7 +281,7 @@ export interface Sql {
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -313,7 +313,15 @@ export interface Sql {
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

package/dist/esm/raw-builder/sql.js

@@ -56,7 +56,7 @@ import { RawBuilder } from './raw-builder.js';
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -88,7 +88,15 @@ import { RawBuilder } from './raw-builder.js';
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

package/dist/esm/schema/alter-table-builder.d.ts

@@ -23,6 +23,13 @@ export declare class AlterTableBuilder {
     alterColumn(column: string): AlterColumnBuilder;
     dropColumn(column: string): AlterTableExecutor;
     renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName: string, dataType: DataTypeExpression): AlterTableAddColumnBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
@@ -30,8 +37,21 @@ export declare class AlterTableBuilder {
      * should use the `alterColumn` method.
      */
     modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
@@ -142,7 +162,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -306,7 +327,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

package/dist/esm/schema/alter-table-builder.js

@@ -66,6 +66,13 @@ export class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName, dataType) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -83,6 +90,9 @@ export class AlterTableBuilder {
             columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName, columns) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -91,6 +101,9 @@ export class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName, checkExpression) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -99,6 +112,13 @@ export class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
         return new AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,

package/dist/esm/schema/column-definition-builder.d.ts

@@ -83,7 +83,8 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -241,7 +242,8 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

package/dist/esm/schema/create-table-builder.d.ts

@@ -136,7 +136,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

package/dist/esm/schema/create-table-builder.js

@@ -184,7 +184,7 @@ export class CreateTableBuilder {
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

package/dist/esm/util/type-utils.d.ts

@@ -74,7 +74,7 @@ export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
  *   movie: Movie
  * }
  *
- * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
  *
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```