kysely 0.27.3 → 0.27.4

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -4,7 +4,7 @@ import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
@@ -44,7 +44,7 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -2,6 +2,20 @@ import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
 import { UnknownRow } from '../../util/type-utils.js';
 import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+export interface ParseJSONResultsPluginOptions {
+    /**
+     * When `'in-place'`, arrays' and objects' values are parsed in-place. This is
+     * the most time and space efficient option.
+     *
+     * This can result in runtime errors if some objects/arrays are readonly.
+     *
+     * When `'create'`, new arrays and objects are created to avoid such errors.
+     *
+     * Defaults to `'in-place'`.
+     */
+    objectStrategy?: ObjectStrategy;
+}
+type ObjectStrategy = 'in-place' | 'create';
 /**
  * Parses JSON strings in query results into JSON objects.
  *
@@ -16,6 +30,9 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
  * ```
  */
 export declare class ParseJSONResultsPlugin implements KyselyPlugin {
+    #private;
+    readonly opt: ParseJSONResultsPluginOptions;
+    constructor(opt?: ParseJSONResultsPluginOptions);
     /**
      * This is called for each query before it is executed. You can modify the query by
      * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
@@ -53,3 +70,4 @@ export declare class ParseJSONResultsPlugin implements KyselyPlugin {
      */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
+export {};

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.js

@@ -14,6 +14,12 @@ import { isPlainObject, isString } from '../../util/object-utils.js';
  * ```
  */
 export class ParseJSONResultsPlugin {
+    opt;
+    #objectStrategy;
+    constructor(opt = {}) {
+        this.opt = opt;
+        this.#objectStrategy = opt.objectStrategy || 'in-place';
+    }
     // noop
     transformQuery(args) {
         return args.node;
@@ -21,32 +27,33 @@ export class ParseJSONResultsPlugin {
     async transformResult(args) {
         return {
             ...args.result,
-            rows: parseArray(args.result.rows),
+            rows: parseArray(args.result.rows, this.#objectStrategy),
         };
     }
 }
-function parseArray(arr) {
+function parseArray(arr, objectStrategy) {
+    const target = objectStrategy === 'create' ? new Array(arr.length) : arr;
     for (let i = 0; i < arr.length; ++i) {
-        arr[i] = parse(arr[i]);
+        target[i] = parse(arr[i], objectStrategy);
     }
-    return arr;
+    return target;
 }
-function parse(obj) {
+function parse(obj, objectStrategy) {
     if (isString(obj)) {
         return parseString(obj);
     }
     if (Array.isArray(obj)) {
-        return parseArray(obj);
+        return parseArray(obj, objectStrategy);
     }
     if (isPlainObject(obj)) {
-        return parseObject(obj);
+        return parseObject(obj, objectStrategy);
     }
     return obj;
 }
 function parseString(str) {
     if (maybeJson(str)) {
         try {
-            return parse(JSON.parse(str));
+            return parse(JSON.parse(str), 'in-place');
         }
         catch (err) {
             // this catch block is intentionally empty.
@@ -57,9 +64,10 @@ function parseString(str) {
 function maybeJson(value) {
     return value.match(/^[\[\{]/) != null;
 }
-function parseObject(obj) {
+function parseObject(obj, objectStrategy) {
+    const target = objectStrategy === 'create' ? {} : obj;
     for (const key in obj) {
-        obj[key] = parse(obj[key]);
+        target[key] = parse(obj[key], objectStrategy);
     }
-    return obj;
+    return target;
 }

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

@@ -24,7 +24,8 @@ import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
-export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O, 'deleted'>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
@@ -289,7 +290,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -799,9 +800,92 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll<T extends TB>(table: T): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, T, O>>;
     returningAll(): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, 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, TB, 'deleted'>>(selections: readonly OE[]): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB, 'deleted'>>(callback: CB): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB, 'deleted'>>(selection: OE): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, 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: 'deleted'): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -1026,17 +1110,17 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * 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/delete-query-builder.js

@@ -123,6 +123,18 @@ export class DeleteQueryBuilder {
             queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table)),
         });
     }
+    output(args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),
+        });
+    }
+    outputAll(table) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),
+        });
+    }
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -385,17 +397,17 @@ export class DeleteQueryBuilder {
     /**
      * 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.
      *
@@ -448,9 +460,11 @@ export class DeleteQueryBuilder {
      */
     async execute() {
         const compiledQuery = this.compile();
-        const query = compiledQuery.query;
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
-        if (this.#props.executor.adapter.supportsReturning && query.returning) {
+        const { adapter } = this.#props.executor;
+        const query = compiledQuery.query;
+        if ((query.returning && adapter.supportsReturning) ||
+            (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
         return [

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

@@ -106,7 +106,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ```ts
      * db.selectFrom('person')
      *   .selectAll('person')
-     *   .where(sql`upper(first_name)`, '=', 'JENNIFER')
+     *   .where(sql<string>`upper(first_name)`, '=', 'JENNIFER')
      * ```
      */
     <O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): ExpressionWrapper<DB, TB, O>;
@@ -173,7 +173,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string` by default. This is because Kysely can't know the
      * type the db driver outputs. Sometimes the output can be larger than the largest
-     * javascript number and a string is returned instead. Most drivers allow you
+     * JavaScript number and a string is returned instead. Most drivers allow you
      * to configure the output type of large numbers and Kysely can't know if you've
      * done so.
      *
@@ -292,7 +292,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string | bigint` by default. This is because
      * Kysely can't know the type the db driver outputs. Sometimes the output can
-     * be larger than the largest javascript number and a string is returned instead.
+     * be larger than the largest JavaScript number and a string is returned instead.
      * Most drivers allow you to configure the output type of large numbers and Kysely
      * can't know if you've done so.
      *
@@ -344,7 +344,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this is used in a `select` statement, the type of the selected expression
      * will be `number | string | bigint` by default. This is because Kysely
      * can't know the type the db driver outputs. Sometimes the output can be larger
-     * than the largest javascript number and a string is returned instead. Most
+     * than the largest JavaScript number and a string is returned instead. Most
      * drivers allow you to configure the output type of large numbers and Kysely
      * can't know if you've done so.
      *
@@ -513,7 +513,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string` by default. This is because Kysely can't know the
      * type the db driver outputs. Sometimes the output can be larger than the largest
-     * javascript number and a string is returned instead. Most drivers allow you
+     * JavaScript number and a string is returned instead. Most drivers allow you
      * to configure the output type of large numbers and Kysely can't know if you've
      * done so.
      *

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

@@ -11,7 +11,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
@@ -21,7 +21,8 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
-export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O, 'inserted'>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: InsertQueryBuilderProps);
     /**
@@ -143,11 +144,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .insertInto('person')
      *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
-     *     last_name: sql`concat(${ani}, ${ston})`,
+     *     last_name: sql<string>`>concat(${ani}, ${ston})`,
      *     middle_name: ref('first_name'),
      *     age: selectFrom('person')
-     *       .select(fn.avg<number>('age')
-     *       .as('avg_age')),
+     *       .select(fn.avg<number>('age').as('avg_age')),
      *   }))
      *   .executeTakeFirst()
      * ```
@@ -215,7 +215,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * <!-- siteExample("insert", "Insert subquery", 50) -->
      *
-     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method.
+     * This API doesn't follow our WYSIWYG principles and might be a bit difficult to
+     * remember. The reasons for this design stem from implementation difficulties.
      *
      * ```ts
      * const result = await db.insertInto('person')
@@ -386,7 +388,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(sql`lower(name)`)
+     *     .expression(sql<string>`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -553,8 +555,91 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    /**
+     * 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, 'inserted'>>(selections: readonly OE[]): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB, 'inserted'>>(callback: CB): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB, 'inserted'>>(selection: OE): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, 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: 'inserted'): InsertQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -685,17 +770,17 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * 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/insert-query-builder.js

@@ -138,11 +138,10 @@ export class InsertQueryBuilder {
      *   .insertInto('person')
      *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
-     *     last_name: sql`concat(${ani}, ${ston})`,
+     *     last_name: sql<string>`>concat(${ani}, ${ston})`,
      *     middle_name: ref('first_name'),
      *     age: selectFrom('person')
-     *       .select(fn.avg<number>('age')
-     *       .as('avg_age')),
+     *       .select(fn.avg<number>('age').as('avg_age')),
      *   }))
      *   .executeTakeFirst()
      * ```
@@ -226,7 +225,9 @@ export class InsertQueryBuilder {
      *
      * <!-- siteExample("insert", "Insert subquery", 50) -->
      *
-     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method.
+     * This API doesn't follow our WYSIWYG principles and might be a bit difficult to
+     * remember. The reasons for this design stem from implementation difficulties.
      *
      * ```ts
      * const result = await db.insertInto('person')
@@ -423,7 +424,7 @@ export class InsertQueryBuilder {
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(sql`lower(name)`)
+     *     .expression(sql<string>`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -553,6 +554,18 @@ export class InsertQueryBuilder {
             queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
         });
     }
+    output(args) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),
+        });
+    }
+    outputAll(table) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),
+        });
+    }
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -701,17 +714,17 @@ export class InsertQueryBuilder {
     /**
      * 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.
      *
@@ -764,9 +777,11 @@ export class InsertQueryBuilder {
      */
     async execute() {
         const compiledQuery = this.compile();
-        const query = compiledQuery.query;
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
-        if (this.#props.executor.adapter.supportsReturning && query.returning) {
+        const { adapter } = this.#props.executor;
+        const query = compiledQuery.query;
+        if ((query.returning && adapter.supportsReturning) ||
+            (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
         return [