kysely 0.23.4 → 0.24.0

package/dist/cjs/query-creator.d.ts

@@ -2,7 +2,7 @@ import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, From, FromTables, TableReference } from './parser/table-parser.js';
+import { TableExpression, From, FromTables, TableReference, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
@@ -120,7 +120,10 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
+    selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
+    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
@@ -198,6 +201,8 @@ export declare class QueryCreator<DB> {
      *
      * ### Examples
      *
+     * Deleting person with id 1:
+     *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
@@ -206,7 +211,36 @@ export declare class QueryCreator<DB> {
      *
      * console.log(result.numDeletedRows)
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "person" where "person"."id" = $1
+     * ```
+     *
+     * Some databases such as MySQL support deleting from multiple tables:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom(['person', 'pet'])
+     *   .using('person')
+     *   .innerJoin('pet', 'pet.owner_id', '=', 'person.id')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `person`, `pet`
+     * using `person`
+     * inner join `pet` on `pet`.`owner_id` = `person`.`id`
+     * where `person`.`id` = ?
+     * ```
      */
+    deleteFrom<TR extends keyof DB & string>(from: TR[]): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
+    deleteFrom<TR extends TableReference<DB>>(tables: TR[]): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TR extends keyof DB & string>(from: TR): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
     deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
@@ -231,6 +265,8 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
+    updateTable<TR extends keyof DB & string>(table: TR): UpdateQueryBuilder<DB, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
+    updateTable<TR extends AnyAliasedTable<DB>>(table: TR): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
     updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
@@ -295,7 +331,7 @@ export declare class QueryCreator<DB> {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
-     * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
+     * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/schemas.md)
      * for a more detailed explanation.
      *
      * ### Examples

package/dist/cjs/query-creator.js

@@ -105,55 +105,13 @@ class QueryCreator {
             queryNode: insert_query_node_js_1.InsertQueryNode.create((0, table_parser_js_1.parseTable)(table), this.#props.withNode, true),
         });
     }
-    /**
-     * Creates a delete query.
-     *
-     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
-     * a where clause for the delete operation.
-     *
-     * The return value of the query is an instance of {@link DeleteResult}.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = await db
-     *   .deleteFrom('person')
-     *   .where('person.id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numDeletedRows)
-     * ```
-     */
-    deleteFrom(table) {
+    deleteFrom(tables) {
         return new delete_query_builder_js_1.DeleteQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpression)(table), this.#props.withNode),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(tables), this.#props.withNode),
         });
     }
-    /**
-     * Creates an update query.
-     *
-     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
-     * a where clause for the update operation.
-     *
-     * See the {@link UpdateQueryBuilder.set} method for examples on how to
-     * specify the updates.
-     *
-     * The return value of the query is an {@link UpdateResult}.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = await db
-     *   .updateTable('person')
-     *   .set({ first_name: 'Jennifer' })
-     *   .where('person.id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
-     * ```
-     */
     updateTable(table) {
         return new update_query_builder_js_1.UpdateQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
@@ -250,7 +208,7 @@ class QueryCreator {
      * This only affects the query created through the builder returned from
      * this method and doesn't modify the `db` instance.
      *
-     * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
+     * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/schemas.md)
      * for a more detailed explanation.
      *
      * ### Examples

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

@@ -31,18 +31,18 @@ export interface QueryExecutor extends ConnectionProvider {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    compileQuery<R = unknown>(node: RootOperationNode, queryId: QueryId): CompiledQuery<R>;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method.
      */
-    executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    executeQuery<R>(compiledQuery: CompiledQuery<R>, queryId: QueryId): Promise<QueryResult<R>>;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method. Results are streamead instead of loaded
      * at once.
      */
-    stream<R>(compiledQuery: CompiledQuery, 
+    stream<R>(compiledQuery: CompiledQuery<R>, 
     /**
      * How many rows should be pulled from the database at once. Supported
      * only by the postgres driver.

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

@@ -1,6 +1,7 @@
 import { QueryResult } from '../driver/database-connection.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
@@ -86,7 +87,7 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
-    as<A extends string = never>(alias: Expression<any>): AliasedRawBuilder<O, A>;
+    as<A extends string>(alias: Expression<any>): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -117,6 +118,7 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     toOperationNode(): RawNode;
+    compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>;
     execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
 }
 export declare function isRawBuilder(obj: unknown): obj is RawBuilder<unknown>;
@@ -125,7 +127,7 @@ export declare function isRawBuilder(obj: unknown): obj is RawBuilder<unknown>;
  */
 export declare class AliasedRawBuilder<O = unknown, A extends string = never> implements AliasedExpression<O, A> {
     #private;
-    constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<any>);
+    constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<unknown>);
     /** @private */
     /**
      * Returns the aliased expression.
@@ -135,7 +137,7 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
     /**
      * Returns the alias.
      */
-    get alias(): A;
+    get alias(): A | Expression<unknown>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      */

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

@@ -52,17 +52,23 @@ class RawBuilder {
         });
     }
     toOperationNode() {
-        const executor = this.#props.plugins !== undefined
-            ? noop_query_executor_js_1.NOOP_QUERY_EXECUTOR.withPlugins(this.#props.plugins)
-            : noop_query_executor_js_1.NOOP_QUERY_EXECUTOR;
-        return this.#toOperationNode(executor);
+        return this.#toOperationNode(this.#getExecutor());
+    }
+    compile(executorProvider) {
+        return this.#compile(this.#getExecutor(executorProvider));
     }
     async execute(executorProvider) {
-        const executor = this.#props.plugins !== undefined
-            ? executorProvider.getExecutor().withPlugins(this.#props.plugins)
-            : executorProvider.getExecutor();
+        const executor = this.#getExecutor(executorProvider);
         return executor.executeQuery(this.#compile(executor), this.#props.queryId);
     }
+    #getExecutor(executorProvider) {
+        const executor = executorProvider !== undefined
+            ? executorProvider.getExecutor()
+            : noop_query_executor_js_1.NOOP_QUERY_EXECUTOR;
+        return this.#props.plugins !== undefined
+            ? executor.withPlugins(this.#props.plugins)
+            : executor;
+    }
     #toOperationNode(executor) {
         return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
     }

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

@@ -18,7 +18,7 @@ export interface Sql {
      *
      * If you need your substitutions to be interpreted as identifiers, value literals or
      * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
-     * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
+     * {@link Sql.lit}, {@link Sql.raw} and {@link Sql.join} functions.
      *
      * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
      * something can't be done using the Kysely API, you should be able to drop down to
@@ -98,13 +98,17 @@ export interface Sql {
      */
     <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
     /**
-     * `sql.value(value)` is a shortcut for:
+     * `sql.val(value)` is a shortcut for:
      *
      * ```ts
      * sql<ValueType>`${value}`
      * ```
      */
-    value<T>(value: T): RawBuilder<T>;
+    val<V>(value: V): RawBuilder<V>;
+    /**
+     * @deprecated Use {@link Sql.val} instead.
+     */
+    value<V>(value: V): RawBuilder<V>;
     /**
      * This can be used to add runtime column references to SQL snippets.
      *
@@ -155,7 +159,7 @@ export interface Sql {
      * select "public"."person"."first_name" from person
      * ```
      */
-    ref(columnReference: string): RawBuilder<unknown>;
+    ref<R = unknown>(columnReference: string): RawBuilder<R>;
     /**
      * This can be used to add runtime table references to SQL snippets.
      *
@@ -246,7 +250,7 @@ export interface Sql {
      * ```ts
      * const firstName = 'first_name'
      *
-     * sql`select * from person where first_name = ${sql.literal(firstName)}`
+     * sql`select * from person where first_name = ${sql.lit(firstName)}`
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -259,7 +263,11 @@ export interface Sql {
      * the SQL string instead of as a parameter. Only use this function when
      * something can't be sent as a parameter.
      */
-    literal(value: unknown): RawBuilder<unknown>;
+    lit<V>(value: V): RawBuilder<V>;
+    /**
+     * @deprecated Use {@link lit} instead.
+     */
+    literal<V>(value: V): RawBuilder<V>;
     /**
      * This can be used to add arbitrary runtime SQL to SQL snippets.
      *
@@ -278,11 +286,11 @@ export interface Sql {
      * select * from person where first_name = 'first_name'
      * ```
      *
-     * Note that the difference to `sql.literal` is that this function
+     * Note that the difference to `sql.lit` is that this function
      * doesn't assume the inputs are values. The input to this function
      * can be any sql and it's simply glued to the parent string as-is.
      */
-    raw(anySql: string): RawBuilder<unknown>;
+    raw<R = unknown>(anySql: string): RawBuilder<R>;
     /**
      * This can be used to add lists of things to SQL snippets.
      *
@@ -321,7 +329,7 @@ export interface Sql {
      *   123,
      *   sql`(1 == 1)`,
      *   db.selectFrom('person').selectAll(),
-     *   sql.literal(false),
+     *   sql.lit(false),
      *   sql.id('first_name')
      * ]
      *

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

@@ -21,12 +21,15 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
             rawNode: raw_node_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(columnReference)),
         });
     },
-    value(value) {
+    val(value) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild((0, value_parser_js_1.parseValueExpression)(value)),
         });
     },
+    value(value) {
+        return this.val(value);
+    },
     table(tableReference) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
@@ -42,12 +45,15 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
             rawNode: raw_node_js_1.RawNode.create(fragments, ids.map(identifier_node_js_1.IdentifierNode.create)),
         });
     },
-    literal(value) {
+    lit(value) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             rawNode: raw_node_js_1.RawNode.createWithChild(value_node_js_1.ValueNode.createImmediate(value)),
         });
     },
+    literal(value) {
+        return this.lit(value);
+    },
     raw(sql) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),

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

@@ -10,6 +10,11 @@ export declare class AlterColumnBuilder {
     dropDefault(): AlteredColumnBuilder;
     setNotNull(): AlteredColumnBuilder;
     dropNotNull(): AlteredColumnBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
 }
 /**
  * Allows us to force consumers to do something, anything, when altering a column.

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

@@ -34,6 +34,13 @@ class AlterColumnBuilder {
             dropNotNull: true,
         }));
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
 }
 exports.AlterColumnBuilder = AlterColumnBuilder;
 /**

package/dist/cjs/schema/alter-table-add-foreign-key-constraint-builder.d.ts

@@ -11,6 +11,11 @@ export declare class AlterTableAddForeignKeyConstraintBuilder implements Foreign
     constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/cjs/schema/alter-table-add-foreign-key-constraint-builder.js

@@ -22,6 +22,13 @@ class AlterTableAddForeignKeyConstraintBuilder {
             constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
         });
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
             addConstraint: add_constraint_node_js_1.AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),

package/dist/cjs/schema/alter-table-drop-constraint-builder.d.ts

@@ -10,6 +10,11 @@ export declare class AlterTableDropConstraintBuilder implements OperationNodeSou
     ifExists(): AlterTableDropConstraintBuilder;
     cascade(): AlterTableDropConstraintBuilder;
     restrict(): AlterTableDropConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/cjs/schema/alter-table-drop-constraint-builder.js

@@ -40,6 +40,13 @@ class AlterTableDropConstraintBuilder {
             }),
         });
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

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

@@ -191,7 +191,7 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
      * ```ts
      * db.schema.createTable('person')
      *  .addColumn('id', 'integer', col => col.primaryKey())
-     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.literal('it is not polite to ask a woman her age')}`))
+     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.lit('it is not polite to ask a woman her age')}`))
      *  .execute()
      * ```
      *
@@ -205,6 +205,11 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
      * ```
      */
     modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): ColumnDefinitionNode;
 }
 export declare type ColumnDefinitionBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;

package/dist/cjs/schema/column-definition-builder.js

@@ -267,7 +267,7 @@ class ColumnDefinitionBuilder {
      * ```ts
      * db.schema.createTable('person')
      *  .addColumn('id', 'integer', col => col.primaryKey())
-     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.literal('it is not polite to ask a woman her age')}`))
+     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.lit('it is not polite to ask a woman her age')}`))
      *  .execute()
      * ```
      *
@@ -283,6 +283,13 @@ class ColumnDefinitionBuilder {
     modifyEnd(modifier) {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWithEndModifier(this.#node, modifier.toOperationNode()));
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -5,7 +5,10 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { Expression } from '../expression/expression.js';
-export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
+import { ComparisonOperatorExpression } from '../parser/binary-operation-parser.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
+import { SqlBool } from '../util/type-utils.js';
+export declare class CreateIndexBuilder<C = never> implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
     /**
@@ -13,27 +16,27 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
      *
      * If the index already exists, no error is thrown if this method has been called.
      */
-    ifNotExists(): CreateIndexBuilder;
+    ifNotExists(): CreateIndexBuilder<C>;
     /**
      * Makes the index unique.
      */
-    unique(): CreateIndexBuilder;
+    unique(): CreateIndexBuilder<C>;
     /**
      * Specifies the table for the index.
      */
-    on(table: string): CreateIndexBuilder;
+    on(table: string): CreateIndexBuilder<C>;
     /**
      * Specifies the column for the index.
      *
      * Also see the `expression` for specifying an arbitrary expression.
      */
-    column(column: string): CreateIndexBuilder;
+    column<CL extends string>(column: CL): CreateIndexBuilder<C | CL>;
     /**
      * Specifies a list of columns for the index.
      *
      * Also see the `expression` for specifying an arbitrary expression.
      */
-    columns(columns: string[]): CreateIndexBuilder;
+    columns<CL extends string>(columns: CL[]): CreateIndexBuilder<C | CL>;
     /**
      * Specifies an arbitrary expression for the index.
      *
@@ -49,12 +52,51 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
      *   .execute()
      * ```
      */
-    expression(expression: Expression<any>): CreateIndexBuilder;
+    expression(expression: Expression<any>): CreateIndexBuilder<C>;
     /**
      * Specifies the index type.
      */
-    using(indexType: IndexType): CreateIndexBuilder;
-    using(indexType: string): CreateIndexBuilder;
+    using(indexType: IndexType): CreateIndexBuilder<C>;
+    using(indexType: string): CreateIndexBuilder<C>;
+    /**
+     * Adds a where clause to the query. This Effectively turns the index partial.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *    .createIndex('orders_unbilled_index')
+     *    .on('orders')
+     *    .column('order_nr')
+     *    .where(sql.ref('billed'), 'is not', true)
+     *    .where('order_nr', 'like', '123%')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "orders_unbilled_index" on "orders" ("order_nr") where "billed" is not true and "order_nr" like '123%'
+     * ```
+     *
+     * Column names specified in {@link column} or {@link columns} are known at compile-time
+     * and can be referred to in the current query and context.
+     *
+     * Sometimes you may want to refer to columns that exist in the table but are not
+     * part of the current index. In that case you can refer to them using {@link sql}
+     * expressions.
+     *
+     * 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(expression: Expression<any>): CreateIndexBuilder<C>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateIndexNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -8,6 +8,9 @@ const reference_parser_js_1 = require("../parser/reference-parser.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+const immediate_value_transformer_js_1 = require("../plugin/immediate-value/immediate-value-transformer.js");
 class CreateIndexBuilder {
     #props;
     constructor(props) {
@@ -105,6 +108,20 @@ class CreateIndexBuilder {
             }),
         });
     }
+    where(...args) {
+        const transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
+        return new CreateIndexBuilder({
+            ...this.#props,
+            node: query_node_js_1.QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode((0, binary_operation_parser_js_1.parseWhere)(args))),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

package/dist/cjs/schema/create-schema-builder.d.ts

@@ -8,6 +8,11 @@ export declare class CreateSchemaBuilder implements OperationNodeSource, Compila
     #private;
     constructor(props: CreateSchemaBuilderProps);
     ifNotExists(): CreateSchemaBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/cjs/schema/create-schema-builder.js

@@ -15,6 +15,13 @@ class CreateSchemaBuilder {
             node: create_schema_node_js_1.CreateSchemaNode.cloneWith(this.#props.node, { ifNotExists: true }),
         });
     }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }