kysely 0.27.3 → 0.27.4

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

@@ -7,6 +7,7 @@ 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 { TableExpression } from '../parser/table-parser.js';
 import { ExtractUpdateTypeFromReferenceExpression, UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
@@ -17,8 +18,9 @@ import { QueryId } from '../util/query-id.js';
 import { ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 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 { UpdateQueryBuilder } from './update-query-builder.js';
-export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> {
+export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements OutputInterface<DB, TT, O> {
     #private;
     constructor(props: MergeQueryBuilderProps);
     /**
@@ -96,13 +98,94 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> {
      */
     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 MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, TT>>(selections: readonly OE[]): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TT>>(callback: CB): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TT>>(selection: OE): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: OutputPrefix): MergeQueryBuilder<DB, TT, ReturningAllRow<DB, TT, O>>;
 }
 export interface MergeQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: MergeQueryNode;
     readonly executor: QueryExecutor;
 }
-export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST extends keyof DB, O> implements Compilable<O>, OperationNodeSource {
+export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST extends keyof DB, O> implements Compilable<O>, OutputInterface<DB, TT, O>, OperationNodeSource {
     #private;
     constructor(props: MergeQueryBuilderProps);
     /**
@@ -275,6 +358,87 @@ 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 MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, TT>>(selections: readonly OE[]): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TT>>(callback: CB): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TT>>(selection: OE): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: OutputPrefix): WheneableMergeQueryBuilder<DB, TT, ST, ReturningAllRow<DB, TT, O>>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -337,7 +501,7 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      */
     $if<O2>(condition: boolean, func: (qb: this) => WheneableMergeQueryBuilder<any, any, any, O2>): O2 extends MergeResult ? WheneableMergeQueryBuilder<DB, TT, ST, MergeResult> : O2 extends O & infer E ? WheneableMergeQueryBuilder<DB, TT, ST, O & Partial<E>> : WheneableMergeQueryBuilder<DB, TT, ST, Partial<O2>>;
     toOperationNode(): MergeQueryNode;
-    compile(): CompiledQuery<never>;
+    compile(): CompiledQuery<O>;
     /**
      * Executes the query and returns an array of rows.
      *

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

@@ -6,6 +6,7 @@ import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseInsertExpression, } from '../parser/insert-values-parser.js';
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseMergeThen, parseMergeWhen } from '../parser/merge-parser.js';
+import { parseSelectAll, parseSelectArg } from '../parser/select-parser.js';
 import { parseTop } from '../parser/top-parser.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { freeze } from '../util/object-utils.js';
@@ -77,6 +78,18 @@ export class MergeQueryBuilder {
             queryNode: MergeQueryNode.cloneWithUsing(this.#props.queryNode, parseJoin('Using', args)),
         });
     }
+    output(args) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),
+        });
+    }
+    outputAll(table) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),
+        });
+    }
 }
 preventAwait(MergeQueryBuilder, "don't await MergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");
 export class WheneableMergeQueryBuilder {
@@ -214,6 +227,18 @@ export class WheneableMergeQueryBuilder {
     whenNotMatchedBySourceAndRef(lhs, op, rhs) {
         return this.#whenNotMatched([lhs, op, rhs], true, true);
     }
+    output(args) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),
+        });
+    }
+    outputAll(table) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),
+        });
+    }
     #whenNotMatched(args, refRight = false, bySource = false) {
         const props = {
             ...this.#props,
@@ -298,7 +323,7 @@ export class WheneableMergeQueryBuilder {
         return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
     }
     compile() {
-        return this.#props.executor.compileQuery(this.#props.queryNode, this.#props.queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     /**
      * Executes the query and returns an array of rows.
@@ -308,6 +333,10 @@ export 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) {
+            return result.rows;
+        }
         return [new MergeResult(result.numAffectedRows)];
     }
     /**

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -303,7 +303,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -767,7 +767,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )

package/dist/esm/query-builder/output-interface.d.ts

@@ -0,0 +1,95 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
+import { AliasedExpressionOrFactory } from '../parser/expression-parser.js';
+import { ReturningAllRow, ReturningRow } from '../parser/returning-parser.js';
+import { AnyAliasedColumnWithTable, AnyColumnWithTable } from '../util/type-utils.js';
+export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPrefix = OutputPrefix> {
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, TB, OP>>(selections: ReadonlyArray<OE>): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>, OP>;
+    output<CB extends OutputCallback<DB, TB, OP>>(callback: CB): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>, OP>;
+    output<OE extends OutputExpression<DB, TB, OP>>(selection: OE): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>, OP>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: OP): OutputInterface<DB, TB, ReturningAllRow<DB, TB, O>, OP>;
+}
+export type OutputPrefix = 'deleted' | 'inserted';
+export type OutputDatabase<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix> = {
+    [K in OP]: DB[TB];
+};
+export type OutputExpression<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix, ODB = OutputDatabase<DB, TB, OP>, OTB extends keyof ODB = keyof ODB> = AnyAliasedColumnWithTable<ODB, OTB> | AnyColumnWithTable<ODB, OTB> | AliasedExpressionOrFactory<ODB, OTB>;
+export type OutputCallback<DB, TB extends keyof DB, OP extends OutputPrefix = OutputPrefix> = (eb: ExpressionBuilder<OutputDatabase<DB, TB, OP>, OP>) => ReadonlyArray<OutputExpression<DB, TB, OP>>;
+export type SelectExpressionFromOutputExpression<OE> = OE extends `${OutputPrefix}.${infer C}` ? C : OE;
+export type SelectExpressionFromOutputCallback<CB> = CB extends (eb: ExpressionBuilder<any, any>) => ReadonlyArray<infer OE> ? SelectExpressionFromOutputExpression<OE> : never;

package/dist/esm/query-builder/output-interface.js

@@ -0,0 +1,2 @@
+/// <reference types="./output-interface.d.ts" />
+export {};

package/dist/esm/query-builder/returning-interface.d.ts

@@ -67,6 +67,8 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll(): ReturningInterface<DB, TB, Selectable<DB[TB]>>;
 }

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

@@ -291,7 +291,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -542,6 +542,45 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * In case you use the {@link sql} tag you need to specify the type of the expression
      * (in this example `string`).
      *
+     *  <!-- siteExample("select", "Not null", 51) -->
+     *
+     * Sometimes you can be sure something's not null, but Kysely isn't able to infer
+     * it. For example calling `where('last_name', 'is not', null)` doesn't make
+     * `last_name` not null in the result type, but unless you have other where statements
+     * you can be sure it's never null.
+     *
+     * Kysely has a couple of helpers for dealing with these cases: `$notNull()` and `$narrowType`.
+     * Both are used in the following example:
+     *
+     * ```ts
+     * import { NotNull } from 'kysely'
+     * import { jsonObjectFrom } from 'kysely/helpers/postgres'
+     *
+     * const persons = db
+     *   .selectFrom('person')
+     *   .select((eb) => [
+     *     'last_name',
+     *      // Let's assume we know the person has at least one
+     *      // pet. We can use the `.$notNull()` method to make
+     *      // the expression not null. You could just as well
+     *      // add `pet` to the `$narrowType` call below.
+     *      jsonObjectFrom(
+     *        eb.selectFrom('pet')
+     *          .selectAll()
+     *          .limit(1)
+     *          .whereRef('person.id', '=', 'pet.owner_id')
+     *      ).$notNull().as('pet')
+     *   ])
+     *   .where('last_name', 'is not', null)
+     *   // $narrowType can be used to narrow the output type.
+     *   // The special `NotNull` type can be used to make a
+     *   // selection not null. You could add `pet: NotNull`
+     *   // here and omit the `$notNull()` call on it.
+     *   // Use whichever way you prefer.
+     *   .$narrowType<{ last_name: NotNull }>()
+     *   .execute()
+     * ```
+     *
      * All the examples above assume you know the column names at compile time.
      * While it's better to build your code like that (that way you also know
      * the types) sometimes it's not possible or you just prefer to write more
@@ -824,7 +863,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *     (join) => join
      *       .onRef('pet.owner_id', '=', 'person.id')
      *       .on('pet.name', '=', 'Doggo')
-     *       .on((eb) => eb.or([eb("person.age", ">", 18), eb("person.age", "<", 100)]))
+     *       .on((eb) => eb.or([
+     *         eb('person.age', '>', 18),
+     *         eb('person.age', '<', 100)
+     *       ]))
      *   )
      *   .selectAll()
      *   .execute()
@@ -838,6 +880,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * inner join "pet"
      * on "pet"."owner_id" = "person"."id"
      * and "pet"."name" = $1
+     * and (
+     *   "person"."age" > $2
+     *   OR "person"."age" < $3
+     * )
      * ```
      *
      * <!-- siteExample("join", "Subquery join", 40) -->
@@ -997,7 +1043,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *     .limit(1)
      *   )
      *   .orderBy(
-     *     sql`concat(first_name, last_name)`
+     *     sql<string>`concat(first_name, last_name)`
      *   )
      *   .execute()
      * ```
@@ -1056,7 +1102,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy('first_name')
      *   .execute()
@@ -1080,7 +1126,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
      *     'first_name',
@@ -1108,10 +1154,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     sql`max(id)`.as('max_id')
+     *     sql<string>`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
-     *     sql`concat(first_name, last_name)`,
+     *     sql<string>`concat(first_name, last_name)`,
      *     (qb) => qb.selectFrom('pet').select('id').limit(1)
      *   ])
      *   .execute()
@@ -1552,6 +1598,25 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ```
      */
     clearOrderBy(): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Clears `group by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .groupBy('id')
+     *   .clearGroupBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearGroupBy(): SelectQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -1579,7 +1644,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Call `func(this)` if `condition` is true.
      *
-     * NOTE: This method has an impact on typescript performance and it should only be used
+     * NOTE: This method has an impact on TypeScript performance and it should only be used
      * when necessary. Remember that you can call most methods like `where` conditionally
      * like this:
      *
@@ -1757,17 +1822,17 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *

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

@@ -269,6 +269,12 @@ class SelectQueryBuilderImpl {
             queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
+    clearGroupBy() {
+        return new SelectQueryBuilderImpl({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithoutGroupBy(this.#props.queryNode),
+        });
+    }
     $call(func) {
         return func(this);
     }