kysely 0.27.5 → 0.28.0

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

@@ -1,19 +1,17 @@
 import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
-import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
-import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, From, FromTables, TableReference, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from './parser/table-parser.js';
+import { TableExpressionOrList, SimpleTableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { InsertResult } from './query-builder/insert-result.js';
-import { DeleteResult } from './query-builder/delete-result.js';
-import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { CTEBuilderCallback } from './query-builder/cte-builder.js';
 import { CallbackSelection, SelectCallback, SelectExpression, Selection } from './parser/select-parser.js';
-import { MergeQueryBuilder } from './query-builder/merge-query-builder.js';
-import { MergeResult } from './query-builder/merge-result.js';
+import { SelectFrom } from './parser/select-from-parser.js';
+import { DeleteFrom } from './parser/delete-from-parser.js';
+import { UpdateTable } from './parser/update-parser.js';
+import { MergeInto } from './parser/merge-into-parser.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -124,11 +122,7 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, never>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
-    selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB & PickTableWithAlias<DB, TE>, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, never>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpressionOrList<DB, never>>(from: TE): SelectFrom<DB, never, TE>;
     /**
      * Creates a `select` query builder without a `from` clause.
      *
@@ -218,10 +212,14 @@ export declare class QueryCreator<DB> {
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
-     * Creates a replace query.
+     * Creates a "replace into" query.
      *
-     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
-     * that deletes and inserts values on collision instead of updating existing rows.
+     * This is only supported by some dialects like MySQL or SQLite.
+     *
+     * Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes
+     * and inserts values on collision instead of updating existing rows.
+     *
+     * An alias of SQLite's {@link InsertQueryBuilder.orReplace}.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
      * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
@@ -238,10 +236,16 @@ export declare class QueryCreator<DB> {
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      *
      * console.log(result.insertId)
      * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * replace into `person` (`first_name`, `last_name`) values (?, ?)
+     * ```
      */
     replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
@@ -293,10 +297,7 @@ export declare class QueryCreator<DB> {
      * where `person`.`id` = ?
      * ```
      */
-    deleteFrom<TR extends keyof DB & string>(from: TR[]): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
-    deleteFrom<TR extends TableReference<DB>>(tables: TR[]): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
-    deleteFrom<TR extends keyof DB & string>(from: TR): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TE extends TableExpressionOrList<DB, never>>(from: TE): DeleteFrom<DB, TE>;
     /**
      * Creates an update query.
      *
@@ -320,9 +321,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends keyof DB & string>(table: TR): UpdateQueryBuilder<DB, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
-    updateTable<TR extends AnyAliasedTable<DB>>(table: TR): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, UpdateResult>;
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
+    updateTable<TE extends TableExpressionOrList<DB, never>>(tables: TE): UpdateTable<DB, TE>;
     /**
      * Creates a merge query.
      *
@@ -406,8 +405,7 @@ export declare class QueryCreator<DB> {
      * then delete
      * ```
      */
-    mergeInto<TR extends keyof DB & string>(targetTable: TR): MergeQueryBuilder<DB, TR, MergeResult>;
-    mergeInto<TR extends AnyAliasedTable<DB>>(targetTable: TR): MergeQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, MergeResult>;
+    mergeInto<TR extends SimpleTableReference<DB>>(targetTable: TR): MergeInto<DB, TR>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/cjs/query-creator.js

@@ -23,6 +23,113 @@ class QueryCreator {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Creates a `select` query builder for the given table or tables.
+     *
+     * The tables passed to this method are built as the query's `from` clause.
+     *
+     * ### Examples
+     *
+     * Create a select query for one table:
+     *
+     * ```ts
+     * db.selectFrom('person').selectAll()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     *
+     * Create a select query for one table with an alias:
+     *
+     * ```ts
+     * const persons = await db.selectFrom('person as p')
+     *   .select(['p.id', 'first_name'])
+     *   .execute()
+     *
+     * console.log(persons[0].id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p"."id", "first_name" from "person" as "p"
+     * ```
+     *
+     * Create a select query from a subquery:
+     *
+     * ```ts
+     * const persons = await db.selectFrom(
+     *     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
+     *   )
+     *   .select('p.identifier')
+     *   .execute()
+     *
+     * console.log(persons[0].identifier)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p"."identifier",
+     * from (
+     *   select "person"."id" as "identifier" from "person"
+     * ) as p
+     * ```
+     *
+     * Create a select query from raw sql:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const items = await db
+     *   .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
+     *   .select('q.one')
+     *   .execute()
+     *
+     * console.log(items[0].one)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "q"."one",
+     * from (
+     *   select 1 as one
+     * ) as q
+     * ```
+     *
+     * When you use the `sql` tag you need to also provide the result type of the
+     * raw snippet / query so that Kysely can figure out what columns are
+     * available for the rest of the query.
+     *
+     * The `selectFrom` method also accepts an array for multiple tables. All
+     * the above examples can also be used in an array.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const items = await db.selectFrom([
+     *     'person as p',
+     *     db.selectFrom('pet').select('pet.species').as('a'),
+     *     sql<{ one: number }>`(select 1 as one)`.as('q')
+     *   ])
+     *   .select(['p.id', 'a.species', 'q.one'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p".id, "a"."species", "q"."one"
+     * from
+     *   "person" as "p",
+     *   (select "pet"."species" from "pet") as a,
+     *   (select 1 as one) as "q"
+     * ```
+     */
     selectFrom(from) {
         return (0, select_query_builder_js_1.createSelectQueryBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),
@@ -83,10 +190,14 @@ class QueryCreator {
         });
     }
     /**
-     * Creates a replace query.
+     * Creates a "replace into" query.
+     *
+     * This is only supported by some dialects like MySQL or SQLite.
+     *
+     * Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes
+     * and inserts values on collision instead of updating existing rows.
      *
-     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
-     * that deletes and inserts values on collision instead of updating existing rows.
+     * An alias of SQLite's {@link InsertQueryBuilder.orReplace}.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
      * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
@@ -103,10 +214,16 @@ class QueryCreator {
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      *
      * console.log(result.insertId)
      * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * replace into `person` (`first_name`, `last_name`) values (?, ?)
+     * ```
      */
     replaceInto(table) {
         return new insert_query_builder_js_1.InsertQueryBuilder({
@@ -115,20 +232,175 @@ class QueryCreator {
             queryNode: insert_query_node_js_1.InsertQueryNode.create((0, table_parser_js_1.parseTable)(table), this.#props.withNode, true),
         });
     }
-    deleteFrom(tables) {
+    /**
+     * Creates a delete query.
+     *
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
+     * a where clause for the delete operation.
+     *
+     * The return value of the query is an instance of {@link DeleteResult}.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("delete", "Single row", 10) -->
+     *
+     * Delete a single row:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom('person')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numDeletedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "person" where "person"."id" = $1
+     * ```
+     *
+     * Some databases such as MySQL support deleting from multiple tables:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom(['person', 'pet'])
+     *   .using('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `person`, `pet`
+     * using `person`
+     * inner join `pet` on `pet`.`owner_id` = `person`.`id`
+     * where `person`.`id` = ?
+     * ```
+     */
+    deleteFrom(from) {
         return new delete_query_builder_js_1.DeleteQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(tables), this.#props.withNode),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
         });
     }
-    updateTable(table) {
+    /**
+     * Creates an update query.
+     *
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
+     * a where clause for the update operation.
+     *
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
+     * specify the updates.
+     *
+     * The return value of the query is an {@link UpdateResult}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'Jennifer' })
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
+     * ```
+     */
+    updateTable(tables) {
         return new update_query_builder_js_1.UpdateQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            queryNode: update_query_node_js_1.UpdateQueryNode.create((0, table_parser_js_1.parseTableExpression)(table), this.#props.withNode),
+            queryNode: update_query_node_js_1.UpdateQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(tables), this.#props.withNode),
         });
     }
+    /**
+     * Creates a merge query.
+     *
+     * The return value of the query is a {@link MergeResult}.
+     *
+     * See the {@link MergeQueryBuilder.using} method for examples on how to specify
+     * the other table.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("merge", "Source row existence", 10) -->
+     *
+     * Update a target column based on the existence of a source row:
+     *
+     * ```ts
+     * const result = await db
+     *   .mergeInto('person as target')
+     *   .using('pet as source', 'source.owner_id', 'target.id')
+     *   .whenMatchedAnd('target.has_pets', '!=', 'Y')
+     *   .thenUpdateSet({ has_pets: 'Y' })
+     *   .whenNotMatchedBySourceAnd('target.has_pets', '=', 'Y')
+     *   .thenUpdateSet({ has_pets: 'N' })
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.numChangedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * when matched and "has_pets" != $1
+     * then update set "has_pets" = $2
+     * when not matched by source and "has_pets" = $3
+     * then update set "has_pets" = $4
+     * ```
+     *
+     * <!-- siteExample("merge", "Temporary changes table", 20) -->
+     *
+     * Merge new entries from a temporary changes table:
+     *
+     * ```ts
+     * const result = await db
+     *   .mergeInto('wine as target')
+     *   .using(
+     *     'wine_stock_change as source',
+     *     'source.wine_name',
+     *     'target.name',
+     *   )
+     *   .whenNotMatchedAnd('source.stock_delta', '>', 0)
+     *   .thenInsertValues(({ ref }) => ({
+     *     name: ref('source.wine_name'),
+     *     stock: ref('source.stock_delta'),
+     *   }))
+     *   .whenMatchedAnd(
+     *     (eb) => eb('target.stock', '+', eb.ref('source.stock_delta')),
+     *     '>',
+     *     0,
+     *   )
+     *   .thenUpdateSet('stock', (eb) =>
+     *     eb('target.stock', '+', eb.ref('source.stock_delta')),
+     *   )
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "wine" as "target"
+     * using "wine_stock_change" as "source"
+     * on "source"."wine_name" = "target"."name"
+     * when not matched and "source"."stock_delta" > $1
+     * then insert ("name", "stock") values ("source"."wine_name", "source"."stock_delta")
+     * when matched and "target"."stock" + "source"."stock_delta" > $2
+     * then update set "stock" = "target"."stock" + "source"."stock_delta"
+     * when matched
+     * then delete
+     * ```
+     */
     mergeInto(targetTable) {
         return new merge_query_builder_js_1.MergeQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),

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

@@ -5,6 +5,7 @@ import { RootOperationNode, QueryCompiler } from '../query-compiler/query-compil
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorBase } from './query-executor-base.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryId } from '../util/query-id.js';
 export declare class DefaultQueryExecutor extends QueryExecutorBase {
     #private;
     constructor(compiler: QueryCompiler, adapter: DialectAdapter, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
@@ -17,7 +18,7 @@ export declare class DefaultQueryExecutor extends QueryExecutorBase {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    compileQuery(node: RootOperationNode): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.

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

@@ -15,8 +15,8 @@ class DefaultQueryExecutor extends query_executor_base_js_1.QueryExecutorBase {
     get adapter() {
         return this.#adapter;
     }
-    compileQuery(node) {
-        return this.#compiler.compileQuery(node);
+    compileQuery(node, queryId) {
+        return this.#compiler.compileQuery(node, queryId);
     }
     provideConnection(consumer) {
         return this.#connectionProvider.provideConnection(consumer);

package/dist/cjs/query-executor/query-executor-base.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutorBase = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const deferred_js_1 = require("../util/deferred.js");
+const provide_controlled_connection_js_1 = require("../util/provide-controlled-connection.js");
 const log_once_js_1 = require("../util/log-once.js");
 const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
 class QueryExecutorBase {
@@ -35,28 +35,21 @@ class QueryExecutorBase {
     async executeQuery(compiledQuery, queryId) {
         return await this.provideConnection(async (connection) => {
             const result = await connection.executeQuery(compiledQuery);
-            const transformedResult = await this.#transformResult(result, queryId);
-            // TODO: remove.
-            warnOfOutdatedDriverOrPlugins(result, transformedResult);
-            return transformedResult;
+            if ('numUpdatedOrDeletedRows' in result) {
+                (0, log_once_js_1.logOnce)('kysely:warning: outdated driver/plugin detected! `QueryResult.numUpdatedOrDeletedRows` has been replaced with `QueryResult.numAffectedRows`.');
+            }
+            return await this.#transformResult(result, queryId);
         });
     }
     async *stream(compiledQuery, chunkSize, queryId) {
-        const connectionDefer = new deferred_js_1.Deferred();
-        const connectionReleaseDefer = new deferred_js_1.Deferred();
-        this.provideConnection(async (connection) => {
-            connectionDefer.resolve(connection);
-            // Lets wait until we don't need connection before returning here (returning releases connection)
-            return await connectionReleaseDefer.promise;
-        }).catch((ex) => connectionDefer.reject(ex));
-        const connection = await connectionDefer.promise;
+        const { connection, release } = await (0, provide_controlled_connection_js_1.provideControlledConnection)(this);
         try {
             for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
                 yield await this.#transformResult(result, queryId);
             }
         }
         finally {
-            connectionReleaseDefer.resolve();
+            release();
         }
     }
     async #transformResult(result, queryId) {
@@ -67,14 +60,3 @@ class QueryExecutorBase {
     }
 }
 exports.QueryExecutorBase = QueryExecutorBase;
-// TODO: remove.
-function warnOfOutdatedDriverOrPlugins(result, transformedResult) {
-    const { numAffectedRows } = result;
-    if ((numAffectedRows === undefined &&
-        result.numUpdatedOrDeletedRows === undefined) ||
-        (numAffectedRows !== undefined &&
-            transformedResult.numAffectedRows !== undefined)) {
-        return;
-    }
-    (0, log_once_js_1.logOnce)('kysely:warning: outdated driver/plugin detected! QueryResult.numUpdatedOrDeletedRows is deprecated and will be removed in a future release.');
-}

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRawBuilder = createRawBuilder;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
@@ -63,7 +62,6 @@ class RawBuilderImpl {
 function createRawBuilder(props) {
     return new RawBuilderImpl(props);
 }
-(0, prevent_await_js_1.preventAwait)(RawBuilderImpl, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
 class AliasedRawBuilderImpl {
     #rawBuilder;
     #alias;
@@ -86,4 +84,3 @@ class AliasedRawBuilderImpl {
             : identifier_node_js_1.IdentifierNode.create(this.#alias));
     }
 }
-(0, prevent_await_js_1.preventAwait)(AliasedRawBuilderImpl, "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query.");

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

@@ -199,7 +199,7 @@ export interface Sql {
      * select first_name from "person"
      * ```
      *
-     * The refefences can also include a schema on supported databases:
+     * The references can also include a schema on supported databases:
      *
      * ```ts
      * const table = 'public.person'
@@ -213,7 +213,7 @@ export interface Sql {
      * select first_name from "public"."person"
      * ```
      */
-    table(tableReference: string): RawBuilder<unknown>;
+    table<T = unknown>(tableReference: string): RawBuilder<T>;
     /**
      * This can be used to add arbitrary identifiers to SQL snippets.
      *
@@ -255,7 +255,7 @@ export interface Sql {
      * select "public"."person"."first_name" from "public"."person"
      * ```
      */
-    id(...ids: readonly string[]): RawBuilder<unknown>;
+    id<T = unknown>(...ids: readonly string[]): RawBuilder<T>;
     /**
      * This can be used to add literal values to SQL snippets.
      *
@@ -361,6 +361,6 @@ export interface Sql {
      * BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER
      * ```
      */
-    join(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
+    join<T = unknown>(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<T>;
 }
 export declare const sql: Sql;

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

@@ -62,7 +62,7 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         });
     },
     join(array, separator = (0, exports.sql) `, `) {
-        const nodes = new Array(2 * array.length - 1);
+        const nodes = new Array(Math.max(2 * array.length - 1, 0));
         const sep = separator.toOperationNode();
         for (let i = 0; i < array.length; ++i) {
             nodes[2 * i] = parseParameter(array[i]);

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

@@ -4,7 +4,6 @@ exports.AlteredColumnBuilder = exports.AlterColumnBuilder = void 0;
 const alter_column_node_js_1 = require("../operation-node/alter-column-node.js");
 const data_type_parser_js_1 = require("../parser/data-type-parser.js");
 const default_value_parser_js_1 = require("../parser/default-value-parser.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 class AlterColumnBuilder {
     #column;
     constructor(column) {
@@ -34,7 +33,6 @@ class AlterColumnBuilder {
     }
 }
 exports.AlterColumnBuilder = AlterColumnBuilder;
-(0, prevent_await_js_1.preventAwait)(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 /**
  * Allows us to force consumers to do exactly one alteration to a column.
  *
@@ -74,4 +72,3 @@ class AlteredColumnBuilder {
     }
 }
 exports.AlteredColumnBuilder = AlteredColumnBuilder;
-(0, prevent_await_js_1.preventAwait)(AlteredColumnBuilder, "don't await AlteredColumnBuilder instances");

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

@@ -11,6 +11,10 @@ export declare class AlterTableAddForeignKeyConstraintBuilder implements Foreign
     constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    deferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    notDeferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

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

@@ -4,7 +4,6 @@ exports.AlterTableAddForeignKeyConstraintBuilder = void 0;
 const add_constraint_node_js_1 = require("../operation-node/add-constraint-node.js");
 const alter_table_node_js_1 = require("../operation-node/alter-table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 class AlterTableAddForeignKeyConstraintBuilder {
     #props;
     constructor(props) {
@@ -22,6 +21,30 @@ class AlterTableAddForeignKeyConstraintBuilder {
             constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
         });
     }
+    deferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.deferrable(),
+        });
+    }
+    notDeferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.notDeferrable(),
+        });
+    }
+    initiallyDeferred() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyDeferred(),
+        });
+    }
+    initiallyImmediate() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyImmediate(),
+        });
+    }
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -42,4 +65,3 @@ class AlterTableAddForeignKeyConstraintBuilder {
     }
 }
 exports.AlterTableAddForeignKeyConstraintBuilder = AlterTableAddForeignKeyConstraintBuilder;
-(0, prevent_await_js_1.preventAwait)(AlterTableAddForeignKeyConstraintBuilder, "don't await AlterTableAddForeignKeyConstraintBuilder instances directly. To execute the query you need to call `execute`");