kysely 0.23.3 → 0.23.4

package/dist/cjs/query-builder/select-query-builder.js

@@ -581,6 +581,28 @@ class SelectQueryBuilder {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, (0, set_operation_parser_js_1.parseSetOperation)('except', expression, true)),
         });
     }
+    /**
+     * Gives an alias for the query. This method is only useful for sub queries.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const pets = await db.selectFrom('pet')
+     *   .selectAll('pet')
+     *   .select(
+     *     (qb) => qb.selectFrom('person')
+     *       .select('first_name')
+     *       .whereRef('pet.owner_id', '=', 'person.id')
+     *       .as('owner_first_name')
+     *   )
+     *   .execute()
+     *
+     * pets[0].owner_first_name
+     * ```
+     */
+    as(alias) {
+        return new AliasedSelectQueryBuilder(this, alias);
+    }
     /**
      * Clears all select clauses from the query.
      *
@@ -688,7 +710,7 @@ class SelectQueryBuilder {
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -702,13 +724,19 @@ class SelectQueryBuilder {
      *
      * db.selectFrom('person')
      *   .selectAll()
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -726,7 +754,7 @@ class SelectQueryBuilder {
      *   return await db
      *     .selectFrom('person')
      *     .select(['id', 'first_name'])
-     *     .if(withLastName, (qb) => qb.select('last_name'))
+     *     .$if(withLastName, (qb) => qb.select('last_name'))
      *     .where('id', '=', id)
      *     .executeTakeFirstOrThrow()
      * }
@@ -751,15 +779,15 @@ class SelectQueryBuilder {
      *
      * db.selectFrom('person')
      *   .select('person.id')
-     *   .if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
-     *   .if(filterByPetCount, (qb) => qb
+     *   .$if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
+     *   .$if(filterByPetCount, (qb) => qb
      *     .innerJoin('pet', 'pet.owner_id', 'person.id')
      *     .having(count('pet.id'), '>', petCountLimit)
      *     .groupBy('person.id')
      *   )
      * ```
      */
-    if(condition, func) {
+    $if(condition, func) {
         if (condition) {
             return func(this);
         }
@@ -768,26 +796,10 @@ class SelectQueryBuilder {
         });
     }
     /**
-     * Gives an alias for the query. This method is only useful for sub queries.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const pets = await db.selectFrom('pet')
-     *   .selectAll('pet')
-     *   .select(
-     *     (qb) => qb.selectFrom('person')
-     *       .select('first_name')
-     *       .whereRef('pet.owner_id', '=', 'person.id')
-     *       .as('owner_first_name')
-     *   )
-     *   .execute()
-     *
-     * pets[0].owner_first_name
-     * ```
+     * @deprecated Use `$if` instead
      */
-    as(alias) {
-        return new AliasedSelectQueryBuilder(this, alias);
+    if(condition, func) {
+        return this.$if(condition, func);
     }
     /**
      * Change the output type of the query.
@@ -795,9 +807,15 @@ class SelectQueryBuilder {
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
-    castTo() {
+    $castTo() {
         return new SelectQueryBuilder(this.#props);
     }
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
+    castTo() {
+        return this.$castTo();
+    }
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
@@ -825,18 +843,24 @@ class SelectQueryBuilder {
      *   .with('first_and_last', (qb) => qb
      *     .selectFrom('person')
      *     .select(['first_name', 'last_name'])
-     *     .assertType<{ first_name: string, last_name: string }>()
+     *     .$assertType<{ first_name: string, last_name: string }>()
      *   )
      *   .with('age', (qb) => qb
      *     .selectFrom('person')
      *     .select('age')
-     *     .assertType<{ age: number }>()
+     *     .$assertType<{ age: number }>()
      *   )
      *   .selectFrom(['first_and_last', 'age'])
      *   .selectAll()
      *   .executeTakeFirstOrThrow()
      * ```
      */
+    $assertType() {
+        return new SelectQueryBuilder(this.#props);
+    }
+    /**
+     * @deprecated Use `$assertType` instead.
+     */
     assertType() {
         return new SelectQueryBuilder(this.#props);
     }

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

@@ -741,7 +741,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -755,10 +755,14 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *
      * db.updateTable('person')
      *   .set(values)
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
+     */
     call<T>(func: (qb: this) => T): T;
     /**
      * Call `func(this)` if `condition` is true.
@@ -779,7 +783,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *     .set(updates)
      *     .where('id', '=', id)
      *     .returning(['id', 'first_name'])
-     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
      *     .executeTakeFirstOrThrow()
      * }
      * ```
@@ -796,6 +800,10 @@ 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>>;
+    /**
+     * @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>>;
     /**
      * Change the output type of the query.
@@ -803,6 +811,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
+    $castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
     castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
     /**
      * Asserts that query's output row type equals the given type `T`.
@@ -833,20 +845,24 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *     .set(person)
      *     .where('id', '=', person.id)
      *     .returning('first_name')
-     *     .assertType<{ first_name: string }>()
+     *     .$assertType<{ first_name: string }>()
      *   )
      *   .with('updated_pet', (qb) => qb
      *     .updateTable('pet')
      *     .set(pet)
      *     .where('owner_id', '=', person.id)
      *     .returning(['name as pet_name', 'species'])
-     *     .assertType<{ pet_name: string, species: Species }>()
+     *     .$assertType<{ pet_name: string, species: Species }>()
      *   )
      *   .selectFrom(['updated_person', 'updated_pet'])
      *   .selectAll()
      *   .executeTakeFirstOrThrow()
      * ```
      */
+    $assertType<T extends O>(): O extends T ? UpdateQueryBuilder<DB, UT, TB, T> : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`>;
+    /**
+     * @deprecated Use `$assertType` instead.
+     */
     assertType<T extends O>(): O extends T ? UpdateQueryBuilder<DB, UT, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.

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

@@ -212,7 +212,7 @@ class UpdateQueryBuilder {
      * Simply calls the given function passing `this` as the only argument.
      *
      * If you want to conditionally call a method on `this`, see
-     * the {@link if} method.
+     * the {@link $if} method.
      *
      * ### Examples
      *
@@ -226,13 +226,19 @@ class UpdateQueryBuilder {
      *
      * db.updateTable('person')
      *   .set(values)
-     *   .call(log)
+     *   .$call(log)
      *   .execute()
      * ```
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -252,7 +258,7 @@ class UpdateQueryBuilder {
      *     .set(updates)
      *     .where('id', '=', id)
      *     .returning(['id', 'first_name'])
-     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
      *     .executeTakeFirstOrThrow()
      * }
      * ```
@@ -269,7 +275,7 @@ class UpdateQueryBuilder {
      * }
      * ```
      */
-    if(condition, func) {
+    $if(condition, func) {
         if (condition) {
             return func(this);
         }
@@ -277,15 +283,27 @@ class UpdateQueryBuilder {
             ...this.#props,
         });
     }
+    /**
+     * @deprecated Use `$if` instead
+     */
+    if(condition, func) {
+        return this.$if(condition, func);
+    }
     /**
      * Change the output type of the query.
      *
      * You should only use this method as the last resort if the types
      * don't support your use case.
      */
-    castTo() {
+    $castTo() {
         return new UpdateQueryBuilder(this.#props);
     }
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
+    castTo() {
+        return this.$castTo();
+    }
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
@@ -315,20 +333,26 @@ class UpdateQueryBuilder {
      *     .set(person)
      *     .where('id', '=', person.id)
      *     .returning('first_name')
-     *     .assertType<{ first_name: string }>()
+     *     .$assertType<{ first_name: string }>()
      *   )
      *   .with('updated_pet', (qb) => qb
      *     .updateTable('pet')
      *     .set(pet)
      *     .where('owner_id', '=', person.id)
      *     .returning(['name as pet_name', 'species'])
-     *     .assertType<{ pet_name: string, species: Species }>()
+     *     .$assertType<{ pet_name: string, species: Species }>()
      *   )
      *   .selectFrom(['updated_person', 'updated_pet'])
      *   .selectAll()
      *   .executeTakeFirstOrThrow()
      * ```
      */
+    $assertType() {
+        return new UpdateQueryBuilder(this.#props);
+    }
+    /**
+     * @deprecated Use `$assertType` instead.
+     */
     assertType() {
         return new UpdateQueryBuilder(this.#props);
     }

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

@@ -79,6 +79,7 @@ import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
 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';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -165,6 +166,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitPartitionByItem(node: PartitionByItemNode): void;
     protected visitBinaryOperation(node: BinaryOperationNode): void;
     protected visitUnaryOperation(node: UnaryOperationNode): void;
+    protected visitUsing(node: UsingNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -191,6 +191,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         }
         this.append('delete ');
         this.visitNode(node.from);
+        if (node.using) {
+            this.append(' ');
+            this.visitNode(node.using);
+        }
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');
@@ -531,6 +535,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append('unique ');
         }
         this.append('index ');
+        if (node.ifNotExists) {
+            this.append('if not exists ');
+        }
         this.visitNode(node.name);
         if (node.table) {
             this.append(' on ');
@@ -901,6 +908,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append(' ');
         this.visitNode(node.operand);
     }
+    visitUsing(node) {
+        this.append('using ');
+        this.compileList(node.tables);
+    }
     append(str) {
         this.#sql += str;
     }

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

@@ -93,6 +93,10 @@ export declare class RawBuilder<O> implements Expression<O> {
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `RawBuilder` with a new output type.
      */
+    $castTo<T>(): RawBuilder<T>;
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
     castTo<T>(): RawBuilder<T>;
     /**
      * Adds a plugin for this SQL snippet.

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

@@ -31,9 +31,15 @@ class RawBuilder {
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `RawBuilder` with a new output type.
      */
-    castTo() {
+    $castTo() {
         return new RawBuilder({ ...this.#props });
     }
+    /**
+     * @deprecated Use `$castTo` instead.
+     */
+    castTo() {
+        return this.$castTo();
+    }
     /**
      * Adds a plugin for this SQL snippet.
      */
@@ -68,7 +74,7 @@ exports.RawBuilder = RawBuilder;
 function isRawBuilder(obj) {
     return ((0, object_utils_js_1.isObject)(obj) &&
         (0, object_utils_js_1.isFunction)(obj.as) &&
-        (0, object_utils_js_1.isFunction)(obj.castTo) &&
+        (0, object_utils_js_1.isFunction)(obj.$castTo) &&
         (0, object_utils_js_1.isFunction)(obj.withPlugin) &&
         (0, object_utils_js_1.isFunction)(obj.toOperationNode) &&
         (0, object_utils_js_1.isFunction)(obj.execute));

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

@@ -52,7 +52,11 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
     /**
      * Calls the given function passing `this` as the only argument.
      *
-     * See {@link CreateTableBuilder.call}
+     * See {@link CreateTableBuilder.$call}
+     */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
      */
     call<T>(func: (qb: this) => T): T;
 }

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

@@ -128,11 +128,17 @@ class AlterTableBuilder {
     /**
      * Calls the given function passing `this` as the only argument.
      *
-     * See {@link CreateTableBuilder.call}
+     * See {@link CreateTableBuilder.$call}
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
 }
 exports.AlterTableBuilder = AlterTableBuilder;
 class AlterTableColumnAlteringBuilder {

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

@@ -8,6 +8,12 @@ import { Expression } from '../expression/expression.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
+    /**
+     * Adds the "if not exists" modifier.
+     *
+     * If the index already exists, no error is thrown if this method has been called.
+     */
+    ifNotExists(): CreateIndexBuilder;
     /**
      * Makes the index unique.
      */

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

@@ -13,6 +13,19 @@ class CreateIndexBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Adds the "if not exists" modifier.
+     *
+     * If the index already exists, no error is thrown if this method has been called.
+     */
+    ifNotExists() {
+        return new CreateIndexBuilder({
+            ...this.#props,
+            node: create_index_node_js_1.CreateIndexNode.cloneWith(this.#props.node, {
+                ifNotExists: true,
+            }),
+        });
+    }
     /**
      * Makes the index unique.
      */

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

@@ -211,7 +211,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -231,10 +231,14 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
+     */
     call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;

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

@@ -278,7 +278,7 @@ class CreateTableBuilder {
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -298,13 +298,19 @@ class CreateTableBuilder {
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
-    call(func) {
+    $call(func) {
         return func(this);
     }
+    /**
+     * @deprecated Use `$call` instead
+     */
+    call(func) {
+        return this.$call(func);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

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

@@ -96,9 +96,21 @@ export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
  * Extracts the item type of an array.
  */
 export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+/**
+ * Any select query builder.
+ */
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
+/**
+ * Given a query output type `O` evaluates to the output type of a `executeTakeFirst` call.
+ */
 export declare type SingleResultType<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O | undefined;
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
 export declare type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
@@ -123,5 +135,11 @@ export declare type Nullable<T> = {
  * // { name: string, age: number, species?: 'cat' | 'dog' }
  */
 export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
+/**
+ * Evaluates to `true` if `T` is `never`.
+ */
 export declare type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
 export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

package/dist/esm/dialect/dialect-adapter-base.d.ts

@@ -25,12 +25,38 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise