kysely 0.24.2 → 0.26.0

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

@@ -4,7 +4,7 @@ import { SelectExpression, SelectArg } from '../parser/select-parser.js';
 import { InsertObjectOrList, InsertObjectOrListFactory } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { MergePartial, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
+import { NarrowPartial, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
 import { UpdateExpression } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -15,7 +15,7 @@ import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
-import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
+import { OnConflictBuilder, OnConflictDatabase, OnConflictDoNothingBuilder, OnConflictTables, OnConflictUpdateBuilder } from './on-conflict-builder.js';
 import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
@@ -46,23 +46,31 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
-     * Insert a row into `person`:
+     * <!-- siteExample("insert", "Single row", 10) -->
+     *
+     * Insert a single row:
+     *
      * ```ts
      * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40
      *   })
-     *   .executeTakeFirstOrThrow()
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values ($1, $2)
+     * insert into "person" ("first_name", "last_name", "age") values ($1, $2, $3)
      * ```
      *
+     * <!-- siteExample("insert", "Multiple rows", 20) -->
+     *
      * On dialects that support it (for example PostgreSQL) you can insert multiple
      * rows by providing an array. Note that the return value is once again very
      * dialect-specific. Some databases may only return the id of the *last* inserted
@@ -73,10 +81,12 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .insertInto('person')
      *   .values([{
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40,
      *   }, {
      *     first_name: 'Arnold',
      *     last_name: 'Schwarzenegger',
+     *     age: 70,
      *   }])
      *   .execute()
      * ```
@@ -84,56 +94,61 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values (($1, $2), ($3, $4))
+     * insert into "person" ("first_name", "last_name", "age") values (($1, $2, $3), ($4, $5, $6))
      * ```
      *
-     * On PostgreSQL you need to chain `returning` to the query to get
-     * the inserted row's columns (or any other expression) as the
-     * return value:
+     * <!-- siteExample("insert", "Returning data", 30) -->
+     *
+     * On supported dialects like PostgreSQL you need to chain `returning` to the query to get
+     * the inserted row's columns (or any other expression) as the return value. `returning`
+     * works just like `select`. Refer to `select` method's examples and documentation for
+     * more info.
      *
      * ```ts
-     * const row = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     age: 40,
      *   })
-     *   .returning('id')
+     *   .returning(['id', 'first_name as name'])
      *   .executeTakeFirstOrThrow()
-     *
-     * row.id
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "last_name") values ($1, $2) returning "id"
+     * insert into "person" ("first_name", "last_name", "age") values ($1, $2, $3) returning "id", "first_name" as "name"
      * ```
      *
-     * In addition to primitives, the values can also be raw sql expressions or
-     * select queries:
+     * <!-- siteExample("insert", "Complex values", 40) -->
+     *
+     * In addition to primitives, the values can also be arbitrary expressions.
+     * You can build the expressions by using a callback and calling the methods
+     * on the expression builder passed to it:
      *
      * ```ts
      * import { sql } from 'kysely'
      *
      * const result = await db
      *   .insertInto('person')
-     *   .values((eb) => ({
+     *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
      *     last_name: sql`${'Ani'} || ${'ston'}`,
-     *     middle_name: eb.ref('first_name'),
-     *     age: eb.selectFrom('person').select(sql`avg(age)`),
+     *     middle_name: ref('first_name'),
+     *     age: selectFrom('person')
+     *       .select(fn.avg<number>('age')
+     *       .as('avg_age')),
      *   }))
      *   .executeTakeFirst()
-     *
-     * console.log(result.insertId)
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
      * insert into "person" ("first_name", "last_name", "age")
-     * values ($1, $2 || $3, (select avg(age) from "person"))
+     * values ($1, $2 || $3, (select avg("age") as "avg_age" from "person"))
      * ```
      *
      * You can also use the callback version of subqueries or raw expressions:
@@ -181,17 +196,29 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * ### Examples
      *
+     * <!-- siteExample("insert", "Insert subquery", 50) -->
+     *
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .columns(['first_name'])
-     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))
+     * const result = await db.insertInto('person')
+     *   .columns(['first_name', 'last_name', 'age'])
+     *   .expression((eb) => eb
+     *     .selectFrom('pet')
+     *     .select((eb) => [
+     *       'pet.name',
+     *       eb.val('Petson').as('last_name'),
+     *       eb.val(7).as('age'),
+     *     ])
+     *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name")
-     * select "pet"."name" from "pet"
+     * insert into "person" ("first_name", "last_name", "age")
+     * select "pet"."name", $1 as "first_name", $2 as "last_name" from "pet"
      * ```
      */
     expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
@@ -368,7 +395,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   )
      * ```
      */
-    onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictDoNothingBuilder<DB, TB> | OnConflictUpdateBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onConflict(callback: (builder: OnConflictBuilder<DB, TB>) => OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>> | OnConflictDoNothingBuilder<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Adds `on duplicate key update` to the query.
      *
@@ -439,7 +466,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .returning(eb => [
+     *   .returning((eb) => [
      *     'id as id',
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
      *     eb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
@@ -477,10 +504,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     $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.
      *
@@ -516,11 +539,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * }
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): InsertQueryBuilder<DB, TB, O2 extends InsertResult ? InsertResult : O extends InsertResult ? Partial<O2> : MergePartial<O, O2>>;
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): InsertQueryBuilder<DB, TB, O2 extends InsertResult ? InsertResult : O extends InsertResult ? Partial<O2> : MergePartial<O, O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): O2 extends InsertResult ? InsertQueryBuilder<DB, TB, InsertResult> : O2 extends O & infer E ? InsertQueryBuilder<DB, TB, O & Partial<E>> : InsertQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *
@@ -529,9 +548,46 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      */
     $castTo<T>(): InsertQueryBuilder<DB, TB, T>;
     /**
-     * @deprecated Use `$castTo` instead.
+     * 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 values} input
+     * when using {@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.insertInto('person')
+     *   .values({ ...inputPerson, nullable_column: 'hell yeah!' })
+     *   .returningAll()
+     *   .executeTakeFirstOrThrow()
+     *
+     * if (nullable_column) {
+     *   functionThatExpectsPersonWithNonNullValue(person)
+     * }
+     * ```
+     *
+     * Into this:
+     *
+     * ```ts
+     * const person = await db.insertInto('person')
+     *   .values({ ...inputPerson, nullable_column: 'hell yeah!' })
+     *   .returningAll()
+     *   .$narrowType<{ nullable_column: string }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
      */
-    castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    $narrowType<T>(): InsertQueryBuilder<DB, TB, NarrowPartial<O, T>>;
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
@@ -574,10 +630,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     $assertType<T extends O>(): O extends T ? InsertQueryBuilder<DB, 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 ? InsertQueryBuilder<DB, 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 InsertQueryBuilder instance with the given plugin installed.
      */

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

@@ -63,17 +63,29 @@ export class InsertQueryBuilder {
      *
      * ### Examples
      *
+     * <!-- siteExample("insert", "Insert subquery", 50) -->
+     *
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .columns(['first_name'])
-     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))
+     * const result = await db.insertInto('person')
+     *   .columns(['first_name', 'last_name', 'age'])
+     *   .expression((eb) => eb
+     *     .selectFrom('pet')
+     *     .select((eb) => [
+     *       'pet.name',
+     *       eb.val('Petson').as('last_name'),
+     *       eb.val(7).as('age'),
+     *     ])
+     *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name")
-     * select "pet"."name" from "pet"
+     * insert into "person" ("first_name", "last_name", "age")
+     * select "pet"."name", $1 as "first_name", $2 as "last_name" from "pet"
      * ```
      */
     expression(expression) {
@@ -338,12 +350,6 @@ export class InsertQueryBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -387,12 +393,6 @@ export class InsertQueryBuilder {
             ...this.#props,
         });
     }
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if(condition, func) {
-        return this.$if(condition, func);
-    }
     /**
      * Change the output type of the query.
      *
@@ -403,10 +403,47 @@ export class InsertQueryBuilder {
         return new InsertQueryBuilder(this.#props);
     }
     /**
-     * @deprecated Use `$castTo` instead.
+     * 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 values} input
+     * when using {@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.insertInto('person')
+     *   .values({ ...inputPerson, nullable_column: 'hell yeah!' })
+     *   .returningAll()
+     *   .executeTakeFirstOrThrow()
+     *
+     * if (nullable_column) {
+     *   functionThatExpectsPersonWithNonNullValue(person)
+     * }
+     * ```
+     *
+     * Into this:
+     *
+     * ```ts
+     * const person = await db.insertInto('person')
+     *   .values({ ...inputPerson, nullable_column: 'hell yeah!' })
+     *   .returningAll()
+     *   .$narrowType<{ nullable_column: string }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
      */
-    castTo() {
-        return this.$castTo();
+    $narrowType() {
+        return new InsertQueryBuilder(this.#props);
     }
     /**
      * Asserts that query's output row type equals the given type `T`.
@@ -452,12 +489,6 @@ export class InsertQueryBuilder {
     $assertType() {
         return new InsertQueryBuilder(this.#props);
     }
-    /**
-     * @deprecated Use `$assertType` instead.
-     */
-    assertType() {
-        return new InsertQueryBuilder(this.#props);
-    }
     /**
      * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
      */

package/dist/esm/query-builder/insert-result.d.ts

@@ -22,14 +22,13 @@
  * ```
  */
 export declare class InsertResult {
-    #private;
-    constructor(insertId: bigint | undefined, numInsertedOrUpdatedRows: bigint | undefined);
     /**
      * The auto incrementing primary key
      */
-    get insertId(): bigint | undefined;
+    readonly insertId: bigint | undefined;
     /**
      * Affected rows count.
      */
-    get numInsertedOrUpdatedRows(): bigint | undefined;
+    readonly numInsertedOrUpdatedRows: bigint | undefined;
+    constructor(insertId: bigint | undefined, numInsertedOrUpdatedRows: bigint | undefined);
 }

package/dist/esm/query-builder/insert-result.js

@@ -23,25 +23,16 @@
  * ```
  */
 export class InsertResult {
-    #insertId;
-    #numInsertedOrUpdatedRows;
-    constructor(insertId, numInsertedOrUpdatedRows) {
-        this.#insertId = insertId;
-        this.#numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
-    }
     /**
      * The auto incrementing primary key
      */
-    get insertId() {
-        return this.#insertId;
-    }
+    insertId;
     /**
      * Affected rows count.
      */
-    get numInsertedOrUpdatedRows() {
-        return this.#numInsertedOrUpdatedRows;
+    numInsertedOrUpdatedRows;
+    constructor(insertId, numInsertedOrUpdatedRows) {
+        this.insertId = insertId;
+        this.numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
     }
 }
-for (const property of ['insertId', 'numInsertedOrUpdatedRows']) {
-    Object.defineProperty(InsertResult.prototype, property, { enumerable: true });
-}

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

@@ -1,11 +1,10 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { Expression } from '../expression/expression.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { OnExpressionBuilder } from './deprecated-on-expression-builder.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;
     constructor(props: JoinBuilderProps);
@@ -18,18 +17,6 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     on(factory: OnExpressionFactory<DB, TB>): JoinBuilder<DB, TB>;
     on(expression: Expression<any>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOn(factory: OnExpressionFactory<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOn(expression: Expression<any>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
@@ -37,26 +24,6 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.whereRef} for documentation and examples.
      */
     onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    onExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    onNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Adds `on true`.
      */
@@ -71,5 +38,5 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
 }
-declare type OnExpressionFactory<DB, TB extends keyof DB> = (eb: OnExpressionBuilder<DB, TB>) => Expression<SqlBool> | OnExpressionBuilder<DB, TB>;
+type OnExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;
 export {};

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

@@ -1,8 +1,7 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseOn, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
-import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
+import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
@@ -13,16 +12,7 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOn(args)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOn(...args) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOn(args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseFilter(args)),
         });
     }
     /**
@@ -37,51 +27,6 @@ export class JoinBuilder {
             joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnRef(lhs, op, rhs) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferentialComparison(lhs, op, rhs)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    onExists(arg) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    onNotExists(arg) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnExists(arg) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orOnNotExists(arg) {
-        return new JoinBuilder({
-            ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExists(arg)),
-        });
-    }
     /**
      * Adds `on true`.
      */