kysely 0.27.6 → 0.28.1

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

@@ -3,7 +3,6 @@ import { parseJoin, } from '../parser/join-parser.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
@@ -88,27 +87,21 @@ export class DeleteQueryBuilder {
         });
     }
     innerJoin(...args) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('InnerJoin', args)),
-        });
+        return this.#join('InnerJoin', args);
     }
     leftJoin(...args) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LeftJoin', args)),
-        });
+        return this.#join('LeftJoin', args);
     }
     rightJoin(...args) {
-        return new DeleteQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('RightJoin', args)),
-        });
+        return this.#join('RightJoin', args);
     }
     fullJoin(...args) {
+        return this.#join('FullJoin', args);
+    }
+    #join(joinType, args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args)),
         });
     }
     returning(selection) {
@@ -186,70 +179,16 @@ export class DeleteQueryBuilder {
             queryNode: DeleteQueryNode.cloneWithoutLimit(this.#props.queryNode),
         });
     }
-    /**
-     * Clears the `order by` clause from the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * await db.deleteFrom('pet')
-     *   .returningAll()
-     *   .where('name', '=', 'Max')
-     *   .orderBy('id')
-     *   .clearOrderBy()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL(PostgreSQL):
-     *
-     * ```sql
-     * delete from "pet" where "name" = "Max" returning *
-     * ```
-     */
-    clearOrderBy() {
+    orderBy(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: DeleteQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+            queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),
         });
     }
-    /**
-     * Adds an `order by` clause to the query.
-     *
-     * `orderBy` calls are additive. To order by multiple columns, call `orderBy`
-     * multiple times.
-     *
-     * The first argument is the expression to order by and the second is the
-     * order (`asc` or `desc`).
-     *
-     * An `order by` clause in a delete query is only supported by some dialects
-     * like MySQL.
-     *
-     * See {@link SelectQueryBuilder.orderBy} for more examples.
-     *
-     * ### Examples
-     *
-     * Delete 5 oldest items in a table:
-     *
-     * ```ts
-     * await db
-     *   .deleteFrom('pet')
-     *   .orderBy('created_at')
-     *   .limit(5)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (MySQL):
-     *
-     * ```sql
-     * delete from `pet`
-     * order by `created_at`
-     * limit ?
-     * ```
-     */
-    orderBy(orderBy, direction) {
+    clearOrderBy() {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: DeleteQueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy([orderBy, direction])),
+            queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
     /**
@@ -517,11 +456,7 @@ export class DeleteQueryBuilder {
             (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
-        return [
-            new DeleteResult(
-            // TODO: remove numUpdatedOrDeletedRows.
-            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? BigInt(0)),
-        ];
+        return [new DeleteResult(result.numAffectedRows ?? BigInt(0))];
     }
     /**
      * Executes the query and returns the first result or undefined if
@@ -564,4 +499,3 @@ export class DeleteQueryBuilder {
         return await builder.execute();
     }
 }
-preventAwait(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/esm/query-builder/function-module.d.ts

@@ -393,7 +393,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    max<O extends number | string | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | bigint> : O>;
+    max<O extends number | string | Date | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | Date | bigint> : O>;
     /**
      * Calls the `min` function for the column or expression given as the argument.
      *
@@ -432,7 +432,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    min<O extends number | string | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | bigint> : O>;
+    min<O extends number | string | Date | bigint | null = never, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE): AggregateFunctionBuilder<DB, TB, IsNever<O> extends true ? ExtractTypeFromReferenceExpression<DB, TB, RE, number | string | Date | bigint> : O>;
     /**
      * Calls the `sum` function for the column or expression given as the argument.
      *
@@ -518,9 +518,13 @@ export interface FunctionModule<DB, TB extends keyof DB> {
     any<T>(subquery: SelectQueryBuilderExpression<Record<string, T>>): ExpressionWrapper<DB, TB, T>;
     any<T>(expr: Expression<ReadonlyArray<T>>): ExpressionWrapper<DB, TB, T>;
     /**
-     * Creates a json_agg function call.
+     * Creates a `json_agg` function call.
      *
-     * This function is only available on PostgreSQL.
+     * This is only supported by some dialects like PostgreSQL.
+     *
+     * ### Examples
+     *
+     * You can use it on table expressions:
      *
      * ```ts
      * await db.selectFrom('person')
@@ -538,8 +542,31 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * inner join "pet" on "pet"."owner_id" = "person"."id"
      * group by "person"."first_name"
      * ```
+     *
+     * or on columns:
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => [
+     *     'first_name',
+     *     eb.fn.jsonAgg('pet.name').as('pet_names'),
+     *   ])
+     *   .groupBy('person.first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name", json_agg("pet"."name") AS "pet_names"
+     * from "person"
+     * inner join "pet" ON "pet"."owner_id" = "person"."id"
+     * group by "person"."first_name"
+     * ```
      */
     jsonAgg<T extends (TB & string) | Expression<unknown>>(table: T): AggregateFunctionBuilder<DB, TB, T extends TB ? Selectable<DB[T]>[] : T extends Expression<infer O> ? O[] : never>;
+    jsonAgg<RE extends StringReference<DB, TB>>(column: RE): AggregateFunctionBuilder<DB, TB, ExtractTypeFromStringReference<DB, TB, RE>[] | null>;
     /**
      * Creates a to_json function call.
      *

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

@@ -307,15 +307,18 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
+     * This is only supported by some dialects like MySQL.
+     *
+     * To avoid a footgun, when invoked with the SQLite dialect, this method will
+     * be handled like {@link orIgnore}. See also, {@link orAbort}, {@link orFail},
+     * {@link orReplace}, and {@link orRollback}.
+     *
      * If you use the ignore modifier, ignorable errors that occur while executing the
      * insert statement are ignored. For example, without ignore, a row that duplicates
      * an existing unique index or primary key value in the table causes a duplicate-key
      * error and the statement is aborted. With ignore, the row is discarded and no error
      * occurs.
      *
-     * This is only supported on some dialects like MySQL. On most dialects you should
-     * use the {@link onConflict} method.
-     *
      * ### Examples
      *
      * ```ts
@@ -332,10 +335,162 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * The generated SQL (MySQL):
      *
      * ```sql
-     * insert ignore into `person` ("first_name", "last_name", "gender") values (?, ?, ?)
+     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or ignore into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
      * ```
      */
     ignore(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert or ignore into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * To avoid a footgun, when invoked with the MySQL dialect, this method will
+     * be handled like {@link ignore}.
+     *
+     * See also, {@link orAbort}, {@link orFail}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orIgnore()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or ignore into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)
+     * ```
+     */
+    orIgnore(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert or abort into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orFail}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orAbort()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or abort into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orAbort(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert or fail into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orFail()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or fail into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orFail(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert or replace into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * You can also use {@link Kysely.replaceInto} to achieve the same result.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orReplace()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or replace into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orReplace(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert or rollback into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orReplace}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orRollback()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or rollback into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orRollback(): InsertQueryBuilder<DB, TB, O>;
     /**
      * Changes an `insert into` query to an `insert top into` query.
      *
@@ -595,7 +750,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * Allows you to return data from modified rows.
      *
      * On supported databases like PostgreSQL, this method can be chained to
-     * `insert`, `update` and `delete` queries to return data.
+     * `insert`, `update`, `delete` and `merge` queries to return data.
      *
      * Note that on SQLite you need to give aliases for the expressions to avoid
      * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
@@ -654,7 +809,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     returning<CB extends SelectCallback<DB, TB>>(callback: CB): InsertQueryBuilder<DB, TB, ReturningCallbackRow<DB, TB, O, CB>>;
     returning<SE extends SelectExpression<DB, TB>>(selection: SE): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SE>>;
     /**
-     * Adds a `returning *` to an insert/update/delete query on databases
+     * Adds a `returning *` to an insert/update/delete/merge query on databases
      * that support `returning` such as PostgreSQL.
      *
      * Also see the {@link returning} method.

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

@@ -4,7 +4,6 @@ import { parseInsertExpression, } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { parseUpdateObjectExpression, } from '../parser/update-set-parser.js';
-import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 import { InsertResult } from './insert-result.js';
@@ -14,6 +13,7 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { OnConflictBuilder, } from './on-conflict-builder.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { parseTop } from '../parser/top-parser.js';
+import { OrActionNode } from '../operation-node/or-action-node.js';
 export class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -336,15 +336,18 @@ export class InsertQueryBuilder {
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
+     * This is only supported by some dialects like MySQL.
+     *
+     * To avoid a footgun, when invoked with the SQLite dialect, this method will
+     * be handled like {@link orIgnore}. See also, {@link orAbort}, {@link orFail},
+     * {@link orReplace}, and {@link orRollback}.
+     *
      * If you use the ignore modifier, ignorable errors that occur while executing the
      * insert statement are ignored. For example, without ignore, a row that duplicates
      * an existing unique index or primary key value in the table causes a duplicate-key
      * error and the statement is aborted. With ignore, the row is discarded and no error
      * occurs.
      *
-     * This is only supported on some dialects like MySQL. On most dialects you should
-     * use the {@link onConflict} method.
-     *
      * ### Examples
      *
      * ```ts
@@ -361,14 +364,201 @@ export class InsertQueryBuilder {
      * The generated SQL (MySQL):
      *
      * ```sql
-     * insert ignore into `person` ("first_name", "last_name", "gender") values (?, ?, ?)
+     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or ignore into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
      * ```
      */
     ignore() {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                ignore: true,
+                orAction: OrActionNode.create('ignore'),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert or ignore into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * To avoid a footgun, when invoked with the MySQL dialect, this method will
+     * be handled like {@link ignore}.
+     *
+     * See also, {@link orAbort}, {@link orFail}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orIgnore()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or ignore into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)
+     * ```
+     */
+    orIgnore() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: OrActionNode.create('ignore'),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert or abort into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orFail}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orAbort()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or abort into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orAbort() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: OrActionNode.create('abort'),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert or fail into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orReplace}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orFail()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or fail into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orFail() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: OrActionNode.create('fail'),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert or replace into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * You can also use {@link Kysely.replaceInto} to achieve the same result.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orRollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orReplace()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or replace into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orReplace() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: OrActionNode.create('replace'),
+            }),
+        });
+    }
+    /**
+     * Changes an `insert into` query to an `insert or rollback into` query.
+     *
+     * This is only supported by some dialects like SQLite.
+     *
+     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orReplace}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .orRollback()
+     *   .values({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'female',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * insert or rollback into "person" ("first_name", "last_name", "gender") values (?, ?, ?)
+     * ```
+     */
+    orRollback() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: OrActionNode.create('rollback'),
             }),
         });
     }
@@ -921,9 +1111,7 @@ export class InsertQueryBuilder {
             return result.rows;
         }
         return [
-            new InsertResult(result.insertId, 
-            // TODO: remove numUpdatedOrDeletedRows.
-            result.numAffectedRows ?? result.numUpdatedOrDeletedRows),
+            new InsertResult(result.insertId, result.numAffectedRows ?? BigInt(0)),
         ];
     }
     /**
@@ -967,4 +1155,3 @@ export class InsertQueryBuilder {
         return await builder.execute();
     }
 }
-preventAwait(InsertQueryBuilder, "don't await InsertQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -3,7 +3,6 @@ import { JoinNode } from '../operation-node/join-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { freeze } from '../util/object-utils.js';
-import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
     #props;
     constructor(props) {
@@ -47,4 +46,3 @@ export class JoinBuilder {
         return this.#props.joinNode;
     }
 }
-preventAwait(JoinBuilder, "don't await JoinBuilder instances. They are never executed directly and are always just a part of a query.");