kysely 0.27.6 → 0.28.1

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

@@ -6,7 +6,6 @@ const insert_values_parser_js_1 = require("../parser/insert-values-parser.js");
 const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const update_set_parser_js_1 = require("../parser/update-set-parser.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
 const insert_result_js_1 = require("./insert-result.js");
@@ -16,6 +15,7 @@ const column_node_js_1 = require("../operation-node/column-node.js");
 const on_conflict_builder_js_1 = require("./on-conflict-builder.js");
 const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
 const top_parser_js_1 = require("../parser/top-parser.js");
+const or_action_node_js_1 = require("../operation-node/or-action-node.js");
 class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -338,15 +338,18 @@ 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
@@ -363,14 +366,201 @@ 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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                ignore: true,
+                orAction: or_action_node_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: or_action_node_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: or_action_node_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: or_action_node_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: or_action_node_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                orAction: or_action_node_js_1.OrActionNode.create('rollback'),
             }),
         });
     }
@@ -923,9 +1113,7 @@ class InsertQueryBuilder {
             return result.rows;
         }
         return [
-            new insert_result_js_1.InsertResult(result.insertId, 
-            // TODO: remove numUpdatedOrDeletedRows.
-            result.numAffectedRows ?? result.numUpdatedOrDeletedRows),
+            new insert_result_js_1.InsertResult(result.insertId, result.numAffectedRows ?? BigInt(0)),
         ];
     }
     /**
@@ -970,4 +1158,3 @@ class InsertQueryBuilder {
     }
 }
 exports.InsertQueryBuilder = InsertQueryBuilder;
-(0, prevent_await_js_1.preventAwait)(InsertQueryBuilder, "don't await InsertQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -5,7 +5,6 @@ const join_node_js_1 = require("../operation-node/join-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 class JoinBuilder {
     #props;
     constructor(props) {
@@ -50,4 +49,3 @@ class JoinBuilder {
     }
 }
 exports.JoinBuilder = JoinBuilder;
-(0, prevent_await_js_1.preventAwait)(JoinBuilder, "don't await JoinBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -7,7 +7,8 @@ import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { InsertObjectOrList, InsertObjectOrListFactory } from '../parser/insert-values-parser.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ReturningAllRow, ReturningRow } from '../parser/returning-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { SelectCallback, SelectExpression } from '../parser/select-parser.js';
 import { TableExpression } from '../parser/table-parser.js';
 import { ExtractUpdateTypeFromReferenceExpression, UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
@@ -19,8 +20,9 @@ import { ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '..
 import { MergeResult } from './merge-result.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { OutputCallback, OutputExpression, OutputInterface, OutputPrefix, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+import { MultiTableReturningInterface } from './returning-interface.js';
 import { UpdateQueryBuilder } from './update-query-builder.js';
-export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements OutputInterface<DB, TT, O> {
+export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements MultiTableReturningInterface<DB, TT, O>, OutputInterface<DB, TT, O> {
     #private;
     constructor(props: MergeQueryBuilderProps);
     /**
@@ -122,6 +124,76 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Ou
      */
     using<TE extends TableExpression<DB, TT>, K1 extends JoinReferenceExpression<DB, TT, TE>, K2 extends JoinReferenceExpression<DB, TT, TE>>(sourceTable: TE, k1: K1, k2: K2): ExtractWheneableMergeQueryBuilder<DB, TT, TE, O>;
     using<TE extends TableExpression<DB, TT>, FN extends JoinCallbackExpression<DB, TT, TE>>(sourceTable: TE, callback: FN): ExtractWheneableMergeQueryBuilder<DB, TT, TE, O>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like PostgreSQL, this method can be chained to
+     * `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.
+     * For example `.returning('id as id')`.
+     *
+     * Also see the {@link returningAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning('id')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, last_name } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning(['id', 'last_name'])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name, first_pet_id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning((eb) => [
+     *     'id as id',
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
+     *     eb.selectFrom('pet').select('pet.id').limit(1).as('first_pet_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    returning<SE extends SelectExpression<DB, TT>>(selections: ReadonlyArray<SE>): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SE>>;
+    returning<CB extends SelectCallback<DB, TT>>(callback: CB): MergeQueryBuilder<DB, TT, ReturningCallbackRow<DB, TT, O, CB>>;
+    returning<SE extends SelectExpression<DB, TT>>(selection: SE): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SE>>;
+    /**
+     * Adds a `returning *` or `returning table.*` to an insert/update/delete/merge
+     * query on databases that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TT>(table: T): MergeQueryBuilder<DB, TT, ReturningAllRow<DB, T, O>>;
+    returningAll(): MergeQueryBuilder<DB, TT, ReturningAllRow<DB, TT, O>>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -252,7 +324,7 @@ export interface MergeQueryBuilderProps {
     readonly queryNode: MergeQueryNode;
     readonly executor: QueryExecutor;
 }
-export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST extends keyof DB, O> implements Compilable<O>, OutputInterface<DB, TT, O>, OperationNodeSource {
+export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST extends keyof DB, O> implements Compilable<O>, MultiTableReturningInterface<DB, TT | ST, O>, OutputInterface<DB, TT, O>, OperationNodeSource {
     #private;
     constructor(props: MergeQueryBuilderProps);
     /**
@@ -449,6 +521,76 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * the target table, and not from source table and returns a {@link MatchedThenableMergeQueryBuilder}.
      */
     whenNotMatchedBySourceAndRef<LRE extends ReferenceExpression<DB, TT>, RRE extends ReferenceExpression<DB, TT>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): MatchedThenableMergeQueryBuilder<DB, TT, ST, TT, O>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like PostgreSQL, this method can be chained to
+     * `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.
+     * For example `.returning('id as id')`.
+     *
+     * Also see the {@link returningAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning('id')
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, last_name } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning(['id', 'last_name'])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name, first_pet_id } = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .returning((eb) => [
+     *     'id as id',
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
+     *     eb.selectFrom('pet').select('pet.id').limit(1).as('first_pet_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     */
+    returning<SE extends SelectExpression<DB, TT | ST>>(selections: ReadonlyArray<SE>): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT | ST, O, SE>>;
+    returning<CB extends SelectCallback<DB, TT | ST>>(callback: CB): WheneableMergeQueryBuilder<DB, TT, ST, ReturningCallbackRow<DB, TT | ST, O, CB>>;
+    returning<SE extends SelectExpression<DB, TT | ST>>(selection: SE): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT | ST, O, SE>>;
+    /**
+     * Adds a `returning *` or `returning table.*` to an insert/update/delete/merge
+     * query on databases that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TT | ST>(table: T): WheneableMergeQueryBuilder<DB, TT, ST, ReturningAllRow<DB, T, O>>;
+    returningAll(): WheneableMergeQueryBuilder<DB, TT, ST, ReturningAllRow<DB, TT | ST, O>>;
     /**
      * Allows you to return data from modified rows.
      *

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

@@ -12,7 +12,6 @@ const select_parser_js_1 = require("../parser/select-parser.js");
 const top_parser_js_1 = require("../parser/top-parser.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 const merge_result_js_1 = require("./merge-result.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const update_query_builder_js_1 = require("./update-query-builder.js");
@@ -109,6 +108,18 @@ class MergeQueryBuilder {
             queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithUsing(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('Using', args)),
         });
     }
+    returning(args) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    returningAll(table) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
     output(args) {
         return new MergeQueryBuilder({
             ...this.#props,
@@ -123,7 +134,6 @@ class MergeQueryBuilder {
     }
 }
 exports.MergeQueryBuilder = MergeQueryBuilder;
-(0, prevent_await_js_1.preventAwait)(MergeQueryBuilder, "don't await MergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");
 class WheneableMergeQueryBuilder {
     #props;
     constructor(props) {
@@ -288,6 +298,18 @@ class WheneableMergeQueryBuilder {
     whenNotMatchedBySourceAndRef(lhs, op, rhs) {
         return this.#whenNotMatched([lhs, op, rhs], true, true);
     }
+    returning(args) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    returningAll(table) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
     output(args) {
         return new WheneableMergeQueryBuilder({
             ...this.#props,
@@ -398,8 +420,10 @@ class WheneableMergeQueryBuilder {
     async execute() {
         const compiledQuery = this.compile();
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
-        if (compiledQuery.query.output &&
-            this.#props.executor.adapter.supportsOutput) {
+        const { adapter } = this.#props.executor;
+        const query = compiledQuery.query;
+        if ((query.returning && adapter.supportsReturning) ||
+            (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
         return [new merge_result_js_1.MergeResult(result.numAffectedRows)];
@@ -432,7 +456,6 @@ class WheneableMergeQueryBuilder {
     }
 }
 exports.WheneableMergeQueryBuilder = WheneableMergeQueryBuilder;
-(0, prevent_await_js_1.preventAwait)(WheneableMergeQueryBuilder, "don't await WheneableMergeQueryBuilder instances directly. To execute the query you need to call `execute`.");
 class MatchedThenableMergeQueryBuilder {
     #props;
     constructor(props) {
@@ -556,7 +579,6 @@ class MatchedThenableMergeQueryBuilder {
     }
 }
 exports.MatchedThenableMergeQueryBuilder = MatchedThenableMergeQueryBuilder;
-(0, prevent_await_js_1.preventAwait)(MatchedThenableMergeQueryBuilder, "don't await MatchedThenableMergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");
 class NotMatchedThenableMergeQueryBuilder {
     #props;
     constructor(props) {
@@ -606,4 +628,3 @@ class NotMatchedThenableMergeQueryBuilder {
     }
 }
 exports.NotMatchedThenableMergeQueryBuilder = NotMatchedThenableMergeQueryBuilder;
-(0, prevent_await_js_1.preventAwait)(NotMatchedThenableMergeQueryBuilder, "don't await NotMatchedThenableMergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");

package/dist/cjs/query-builder/on-conflict-builder.js

@@ -7,7 +7,6 @@ const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const update_set_parser_js_1 = require("../parser/update-set-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 class OnConflictBuilder {
     #props;
     constructor(props) {
@@ -208,7 +207,6 @@ class OnConflictBuilder {
     }
 }
 exports.OnConflictBuilder = OnConflictBuilder;
-(0, prevent_await_js_1.preventAwait)(OnConflictBuilder, "don't await OnConflictBuilder instances.");
 class OnConflictDoNothingBuilder {
     #props;
     constructor(props) {
@@ -219,7 +217,6 @@ class OnConflictDoNothingBuilder {
     }
 }
 exports.OnConflictDoNothingBuilder = OnConflictDoNothingBuilder;
-(0, prevent_await_js_1.preventAwait)(OnConflictDoNothingBuilder, "don't await OnConflictDoNothingBuilder instances.");
 class OnConflictUpdateBuilder {
     #props;
     constructor(props) {
@@ -260,4 +257,3 @@ class OnConflictUpdateBuilder {
     }
 }
 exports.OnConflictUpdateBuilder = OnConflictUpdateBuilder;
-(0, prevent_await_js_1.preventAwait)(OnConflictUpdateBuilder, "don't await OnConflictUpdateBuilder instances.");