kysely 0.24.2 → 0.25.0

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

@@ -6,7 +6,7 @@ import { SelectExpression, SelectArg } from '../parser/select-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { MergePartial, Nullable, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
+import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -533,10 +533,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *
      * const result = await db
      *   .updateTable('person')
-     *   .set(({ selectFrom, ref, fn }) => ({
-     *     first_name: 'Jennifer',
+     *   .set(({ selectFrom, ref, fn, bxp }) => ({
+     *     first_name: selectFrom('person').select('first_name').limit(1),
      *     middle_name: ref('first_name'),
-     *     age: selectFrom('person').select(fn.avg('age')),
+     *     age: bxp('age', '+', 1),
      *     last_name: sql`${'Ani'} || ${'ston'}`,
      *   }))
      *   .where('id', '=', 1)
@@ -549,11 +549,11 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *
      * ```sql
      * update "person" set
-     * "first_name" = $1,
+     * "first_name" = (select "first_name" from "person" limit $1),
      * "middle_name" = "first_name",
-     * "age" = (select avg(age) from "person"),
-     * "last_name" = $2 || $3
-     * where "id" = $4
+     * "age" = "age" + $2,
+     * "last_name" = $3 || $4
+     * where "id" = $5
      * ```
      */
     set(update: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
@@ -687,11 +687,11 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * }
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): UpdateQueryBuilder<DB, UT, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
     /**
      * @deprecated Use `$if` instead
      */
-    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): UpdateQueryBuilder<DB, UT, TB, O2 extends UpdateResult ? UpdateResult : O extends UpdateResult ? Partial<O2> : MergePartial<O, O2>>;
+    if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *
@@ -703,6 +703,51 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * @deprecated Use `$castTo` instead.
      */
     castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    /**
+     * Narrows (parts of) the output type of the query.
+     *
+     * Kysely tries to be as type-safe as possible, but in some cases we have to make
+     * compromises for better maintainability and compilation performance. At present,
+     * Kysely doesn't narrow the output type of the query based on {@link set} input
+     * when using {@link where} and/or {@link returning} or {@link returningAll}.
+     *
+     * This utility method is very useful for these situations, as it removes unncessary
+     * runtime assertion/guard code. Its input type is limited to the output type
+     * of the query, so you can't add a column that doesn't exist, or change a column's
+     * type to something that doesn't exist in its union type.
+     *
+     * ### Examples
+     *
+     * Turn this code:
+     *
+     * ```ts
+     * const person = await db.updateTable('person')
+     *   .set({ deletedAt: now })
+     *   .where('id', '=', id)
+     *   .where('nullable_column', 'is not', null)
+     *   .returningAll()
+     *   .executeTakeFirstOrThrow()
+     *
+     * if (person.nullable_column) {
+     *   functionThatExpectsPersonWithNonNullValue(person)
+     * }
+     * ```
+     *
+     * Into this:
+     *
+     * ```ts
+     * const person = await db.updateTable('person')
+     *   .set({ deletedAt: now })
+     *   .where('id', '=', id)
+     *   .where('nullable_column', 'is not', null)
+     *   .returningAll()
+     *   .$narrowType<{ deletedAt: Date; nullable_column: string }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
+     */
+    $narrowType<T>(): UpdateQueryBuilder<DB, UT, TB, NarrowPartial<O, T>>;
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
@@ -847,23 +892,23 @@ export interface UpdateQueryBuilderProps {
     readonly executor: QueryExecutor;
 }
 export declare type UpdateQueryBuilderWithInnerJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? UpdateQueryBuilder<DB, UT, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
-declare type InnerJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? UpdateQueryBuilder<InnerJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, R>, UT, TB | A, O>;
-declare type InnerJoinedDB<DB, A extends string, R> = {
+declare type InnerJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? UpdateQueryBuilder<InnerJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & ShallowRecord<A, R>, UT, TB | A, O>;
+declare type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
-};
+}>;
 export declare type UpdateQueryBuilderWithLeftJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
-declare type LeftJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? UpdateQueryBuilder<LeftJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, Nullable<R>>, UT, TB | A, O>;
-declare type LeftJoinedDB<DB, A extends keyof any, R> = {
+declare type LeftJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? UpdateQueryBuilder<LeftJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & ShallowRecord<A, Nullable<R>>, UT, TB | A, O>;
+declare type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
-};
+}>;
 export declare type UpdateQueryBuilderWithRightJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type RightJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<RightJoinedDB<DB, TB, A, R>, UT, TB | A, O>;
-declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
-};
+}>;
 export declare type UpdateQueryBuilderWithFullJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : never;
 declare type OuterJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, UT, TB | A, O>;
-declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
+declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
-};
+}>;
 export {};

package/dist/esm/query-builder/update-query-builder.js

@@ -215,6 +215,53 @@ export class UpdateQueryBuilder {
     castTo() {
         return this.$castTo();
     }
+    /**
+     * Narrows (parts of) the output type of the query.
+     *
+     * Kysely tries to be as type-safe as possible, but in some cases we have to make
+     * compromises for better maintainability and compilation performance. At present,
+     * Kysely doesn't narrow the output type of the query based on {@link set} input
+     * when using {@link where} and/or {@link returning} or {@link returningAll}.
+     *
+     * This utility method is very useful for these situations, as it removes unncessary
+     * runtime assertion/guard code. Its input type is limited to the output type
+     * of the query, so you can't add a column that doesn't exist, or change a column's
+     * type to something that doesn't exist in its union type.
+     *
+     * ### Examples
+     *
+     * Turn this code:
+     *
+     * ```ts
+     * const person = await db.updateTable('person')
+     *   .set({ deletedAt: now })
+     *   .where('id', '=', id)
+     *   .where('nullable_column', 'is not', null)
+     *   .returningAll()
+     *   .executeTakeFirstOrThrow()
+     *
+     * if (person.nullable_column) {
+     *   functionThatExpectsPersonWithNonNullValue(person)
+     * }
+     * ```
+     *
+     * Into this:
+     *
+     * ```ts
+     * const person = await db.updateTable('person')
+     *   .set({ deletedAt: now })
+     *   .where('id', '=', id)
+     *   .where('nullable_column', 'is not', null)
+     *   .returningAll()
+     *   .$narrowType<{ deletedAt: Date; nullable_column: string }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
+     */
+    $narrowType() {
+        return new UpdateQueryBuilder(this.#props);
+    }
     /**
      * Asserts that query's output row type equals the given type `T`.
      *

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

@@ -81,6 +81,8 @@ import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 import { UsingNode } from '../operation-node/using-node.js';
 import { FunctionNode } from '../operation-node/function-node.js';
+import { CaseNode } from '../operation-node/case-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -170,6 +172,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected isMinusOperator(node: OperationNode): node is OperatorNode;
     protected visitUsing(node: UsingNode): void;
     protected visitFunction(node: FunctionNode): void;
+    protected visitCase(node: CaseNode): void;
+    protected visitWhen(node: WhenNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -546,9 +546,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' using ');
             this.visitNode(node.using);
         }
-        if (node.expression) {
+        if (node.columns) {
             this.append(' (');
-            this.visitNode(node.expression);
+            this.compileList(node.columns);
             this.append(')');
         }
         if (node.where) {
@@ -867,7 +867,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.distinct) {
             this.append('distinct ');
         }
-        this.visitNode(node.aggregated);
+        this.compileList(node.aggregated);
         this.append(')');
         if (node.filter) {
             this.append(' filter(');
@@ -926,6 +926,33 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.compileList(node.arguments);
         this.append(')');
     }
+    visitCase(node) {
+        this.append('case');
+        if (node.value) {
+            this.append(' ');
+            this.visitNode(node.value);
+        }
+        if (node.when) {
+            this.append(' ');
+            this.compileList(node.when, ' ');
+        }
+        if (node.else) {
+            this.append(' else ');
+            this.visitNode(node.else);
+        }
+        this.append(' end');
+        if (node.isStatement) {
+            this.append(' case');
+        }
+    }
+    visitWhen(node) {
+        this.append('when ');
+        this.visitNode(node.condition);
+        if (node.result) {
+            this.append(' then ');
+            this.visitNode(node.result);
+        }
+    }
     append(str) {
         this.#sql += str;
     }

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

@@ -1,11 +1,11 @@
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export declare class AlterColumnBuilder {
     protected readonly alterColumnNode: AlterColumnNode;
     constructor(alterColumnNode: AlterColumnNode);
-    setDataType(dataType: ColumnDataType): AlteredColumnBuilder;
+    setDataType(dataType: DataTypeExpression): AlteredColumnBuilder;
     setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
     dropDefault(): AlteredColumnBuilder;
     setNotNull(): AlteredColumnBuilder;

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

@@ -1,6 +1,6 @@
 /// <reference types="./alter-column-builder.d.ts" />
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
-import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 export class AlterColumnBuilder {
     alterColumnNode;
@@ -9,7 +9,7 @@ export class AlterColumnBuilder {
     }
     setDataType(dataType) {
         return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            dataType: DataTypeNode.create(dataType),
+            dataType: parseDataTypeExpression(dataType),
         }));
     }
     setDefault(value) {

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

@@ -1,5 +1,6 @@
 import { CreateIndexNode, IndexType } from '../operation-node/create-index-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ExtractColumnNameFromOrderedColumnName, OrderedColumnName } from '../parser/reference-parser.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -7,7 +8,7 @@ import { QueryId } from '../util/query-id.js';
 import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression } from '../parser/binary-operation-parser.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { SqlBool } from '../util/type-utils.js';
+import { ShallowRecord, SqlBool } from '../util/type-utils.js';
 export declare class CreateIndexBuilder<C = never> implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
@@ -26,17 +27,52 @@ export declare class CreateIndexBuilder<C = never> implements OperationNodeSourc
      */
     on(table: string): CreateIndexBuilder<C>;
     /**
-     * Specifies the column for the index.
+     * Adds a column to the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .column('first_name')
+     *         .column('age desc')
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
-    column<CL extends string>(column: CL): CreateIndexBuilder<C | CL>;
+    column<CL extends string>(column: OrderedColumnName<CL>): CreateIndexBuilder<C | ExtractColumnNameFromOrderedColumnName<CL>>;
     /**
      * Specifies a list of columns for the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .columns(['first_name', 'age desc'])
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
-    columns<CL extends string>(columns: CL[]): CreateIndexBuilder<C | CL>;
+    columns<CL extends string>(columns: OrderedColumnName<CL>[]): CreateIndexBuilder<C | ExtractColumnNameFromOrderedColumnName<CL>>;
     /**
      * Specifies an arbitrary expression for the index.
      *
@@ -51,6 +87,12 @@ export declare class CreateIndexBuilder<C = never> implements OperationNodeSourc
      *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_index" on "person" (first_name COLLATE "fi_FI")
+     * ```
      */
     expression(expression: Expression<any>): CreateIndexBuilder<C>;
     /**
@@ -90,7 +132,7 @@ export declare class CreateIndexBuilder<C = never> implements OperationNodeSourc
      * Parameters are always sent as literals due to database restrictions.
      */
     where(lhs: C | Expression<any>, op: ComparisonOperatorExpression, rhs: unknown): CreateIndexBuilder<C>;
-    where(factory: (qb: ExpressionBuilder<Record<string, Record<C & string, any>>, string>) => Expression<SqlBool>): CreateIndexBuilder<C>;
+    where(factory: (qb: ExpressionBuilder<ShallowRecord<string, ShallowRecord<C & string, any>>, string>) => Expression<SqlBool>): CreateIndexBuilder<C>;
     where(expression: Expression<any>): CreateIndexBuilder<C>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns

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

@@ -1,8 +1,7 @@
 /// <reference types="./create-index-builder.d.ts" />
 import { CreateIndexNode, } from '../operation-node/create-index-node.js';
-import { ListNode } from '../operation-node/list-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseColumnName } from '../parser/reference-parser.js';
+import { parseOrderedColumnName, } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
@@ -50,29 +49,62 @@ export class CreateIndexBuilder {
         });
     }
     /**
-     * Specifies the column for the index.
+     * Adds a column to the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .column('first_name')
+     *         .column('age desc')
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     column(column) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: parseColumnName(column),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, [
+                parseOrderedColumnName(column),
+            ]),
         });
     }
     /**
      * Specifies a list of columns for the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .columns(['first_name', 'age desc'])
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     columns(columns) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: ListNode.create(columns.map(parseColumnName)),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, columns.map(parseOrderedColumnName)),
         });
     }
     /**
@@ -89,13 +121,19 @@ export class CreateIndexBuilder {
      *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_index" on "person" (first_name COLLATE "fi_FI")
+     * ```
      */
     expression(expression) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: expression.toOperationNode(),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, [
+                expression.toOperationNode(),
+            ]),
         });
     }
     using(indexType) {

package/dist/esm/schema/schema.js

@@ -200,7 +200,7 @@ export class SchemaModule {
         return new AlterTableBuilder({
             queryId: createQueryId(),
             executor: this.#executor,
-            node: AlterTableNode.create(table),
+            node: AlterTableNode.create(parseTable(table)),
         });
     }
     /**

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

@@ -1,3 +1,4 @@
+import { DrainOuterGeneric } from './type-utils.js';
 /**
  * This type can be used to specify a different type for
  * select, insert and update operations.
@@ -118,9 +119,9 @@ export declare type UpdateKeys<R> = {
  * // }
  * ```
  */
-export declare type Selectable<R> = {
+export declare type Selectable<R> = DrainOuterGeneric<{
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
-};
+}>;
 /**
  * Given a table interface, extracts the insert type from all
  * {@link ColumnType} types.

package/dist/esm/util/log.d.ts

@@ -14,12 +14,12 @@ export interface ErrorLogEvent {
     readonly queryDurationMillis: number;
 }
 export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
-export declare type Logger = (event: LogEvent) => void;
+export declare type Logger = (event: LogEvent) => void | Promise<void>;
 export declare type LogConfig = ReadonlyArray<LogLevel> | Logger;
 export declare class Log {
     #private;
     constructor(config: LogConfig);
     isLevelEnabled(level: LogLevel): boolean;
-    query(getEvent: () => QueryLogEvent): void;
-    error(getEvent: () => ErrorLogEvent): void;
+    query(getEvent: () => QueryLogEvent): Promise<void>;
+    error(getEvent: () => ErrorLogEvent): Promise<void>;
 }

package/dist/esm/util/log.js

@@ -23,14 +23,14 @@ export class Log {
     isLevelEnabled(level) {
         return this.#levels[level];
     }
-    query(getEvent) {
+    async query(getEvent) {
         if (this.#levels.query) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
-    error(getEvent) {
+    async error(getEvent) {
         if (this.#levels.error) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
 }

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

@@ -1,3 +1,4 @@
+import { ShallowRecord } from './type-utils.js';
 export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isUndefined(obj: unknown): obj is undefined;
 export declare function isString(obj: unknown): obj is string;
@@ -10,7 +11,7 @@ export declare function isBuffer(obj: unknown): obj is {
     length: number;
 };
 export declare function isFunction(obj: unknown): obj is Function;
-export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
 export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;