kysely 0.27.3 → 0.27.4

package/dist/cjs/parser/partition-by-parser.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePartitionBy = void 0;
+exports.parsePartitionBy = parsePartitionBy;
 const partition_by_item_node_js_1 = require("../operation-node/partition-by-item-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 function parsePartitionBy(partitionBy) {
     return (0, reference_parser_js_1.parseReferenceExpressionOrList)(partitionBy).map(partition_by_item_node_js_1.PartitionByItemNode.create);
 }
-exports.parsePartitionBy = parsePartitionBy;

package/dist/cjs/parser/reference-parser.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOrderedColumnName = exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseJSONReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = exports.parseSimpleReferenceExpression = void 0;
+exports.parseSimpleReferenceExpression = parseSimpleReferenceExpression;
+exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
+exports.parseReferenceExpression = parseReferenceExpression;
+exports.parseJSONReference = parseJSONReference;
+exports.parseStringReference = parseStringReference;
+exports.parseAliasedStringReference = parseAliasedStringReference;
+exports.parseColumnName = parseColumnName;
+exports.parseOrderedColumnName = parseOrderedColumnName;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const reference_node_js_1 = require("../operation-node/reference-node.js");
@@ -19,7 +26,6 @@ function parseSimpleReferenceExpression(exp) {
     }
     return exp.toOperationNode();
 }
-exports.parseSimpleReferenceExpression = parseSimpleReferenceExpression;
 function parseReferenceExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -28,14 +34,12 @@ function parseReferenceExpressionOrList(arg) {
         return [parseReferenceExpression(arg)];
     }
 }
-exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
 function parseReferenceExpression(exp) {
     if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
         return (0, expression_parser_js_1.parseExpression)(exp);
     }
     return parseSimpleReferenceExpression(exp);
 }
-exports.parseReferenceExpression = parseReferenceExpression;
 function parseJSONReference(ref, op) {
     const referenceNode = parseStringReference(ref);
     if ((0, operator_node_js_1.isJSONOperator)(op)) {
@@ -47,7 +51,6 @@ function parseJSONReference(ref, op) {
     }
     throw new Error(`Invalid JSON operator: ${op}`);
 }
-exports.parseJSONReference = parseJSONReference;
 function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';
     if (!ref.includes(COLUMN_SEPARATOR)) {
@@ -62,7 +65,6 @@ function parseStringReference(ref) {
     }
     throw new Error(`invalid column reference ${ref}`);
 }
-exports.parseStringReference = parseStringReference;
 function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
@@ -73,11 +75,9 @@ function parseAliasedStringReference(ref) {
         return parseStringReference(ref);
     }
 }
-exports.parseAliasedStringReference = parseAliasedStringReference;
 function parseColumnName(column) {
     return column_node_js_1.ColumnNode.create(column);
 }
-exports.parseColumnName = parseColumnName;
 function parseOrderedColumnName(column) {
     const ORDER_SEPARATOR = ' ';
     if (column.includes(ORDER_SEPARATOR)) {
@@ -91,7 +91,6 @@ function parseOrderedColumnName(column) {
         return parseColumnName(column);
     }
 }
-exports.parseOrderedColumnName = parseOrderedColumnName;
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
     return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.createWithSchema(schema, table));

package/dist/cjs/parser/returning-parser.d.ts

@@ -1,7 +1,8 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
+import { MergeResult } from '../query-builder/merge-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
-export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
-export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult ? CallbackSelection<DB, TB, CB> : O extends DeleteResult ? CallbackSelection<DB, TB, CB> : O extends UpdateResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
-export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;
+export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
+export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

package/dist/cjs/parser/select-parser.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSelectAll = exports.parseSelectArg = void 0;
+exports.parseSelectArg = parseSelectArg;
+exports.parseSelectAll = parseSelectAll;
 const object_utils_js_1 = require("../util/object-utils.js");
 const selection_node_js_1 = require("../operation-node/selection-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
@@ -19,7 +20,6 @@ function parseSelectArg(selection) {
         return [parseSelectExpression(selection)];
     }
 }
-exports.parseSelectArg = parseSelectArg;
 function parseSelectExpression(selection) {
     if ((0, object_utils_js_1.isString)(selection)) {
         return selection_node_js_1.SelectionNode.create((0, reference_parser_js_1.parseAliasedStringReference)(selection));
@@ -42,7 +42,6 @@ function parseSelectAll(table) {
         return [parseSelectAllArg(table)];
     }
 }
-exports.parseSelectAll = parseSelectAll;
 function parseSelectAllArg(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return selection_node_js_1.SelectionNode.createSelectAllFromTable((0, table_parser_js_1.parseTable)(table));

package/dist/cjs/parser/set-operation-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSetOperations = void 0;
+exports.parseSetOperations = parseSetOperations;
 const expression_builder_js_1 = require("../expression/expression-builder.js");
 const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -14,4 +14,3 @@ function parseSetOperations(operator, expression, all) {
     }
     return expression.map((expr) => set_operation_node_js_1.SetOperationNode.create(operator, (0, expression_parser_js_1.parseExpression)(expr), all));
 }
-exports.parseSetOperations = parseSetOperations;

package/dist/cjs/parser/table-parser.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression = exports.parseTableExpressionOrList = void 0;
+exports.parseTableExpressionOrList = parseTableExpressionOrList;
+exports.parseTableExpression = parseTableExpression;
+exports.parseAliasedTable = parseAliasedTable;
+exports.parseTable = parseTable;
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
@@ -14,7 +17,6 @@ function parseTableExpressionOrList(table) {
         return [parseTableExpression(table)];
     }
 }
-exports.parseTableExpressionOrList = parseTableExpressionOrList;
 function parseTableExpression(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
@@ -23,7 +25,6 @@ function parseTableExpression(table) {
         return (0, expression_parser_js_1.parseAliasedExpression)(table);
     }
 }
-exports.parseTableExpression = parseTableExpression;
 function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
@@ -34,7 +35,6 @@ function parseAliasedTable(from) {
         return parseTable(from);
     }
 }
-exports.parseAliasedTable = parseAliasedTable;
 function parseTable(from) {
     const SCHEMA_SEPARATOR = '.';
     if (from.includes(SCHEMA_SEPARATOR)) {
@@ -45,7 +45,6 @@ function parseTable(from) {
         return table_node_js_1.TableNode.create(from);
     }
 }
-exports.parseTable = parseTable;
 function trim(str) {
     return str.trim();
 }

package/dist/cjs/parser/top-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTop = void 0;
+exports.parseTop = parseTop;
 const top_node_js_1 = require("../operation-node/top-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 function parseTop(expression, modifiers) {
@@ -12,7 +12,6 @@ function parseTop(expression, modifiers) {
     }
     return top_node_js_1.TopNode.create(expression, modifiers);
 }
-exports.parseTop = parseTop;
 function isTopModifiers(modifiers) {
     return (modifiers === 'percent' ||
         modifiers === 'with ties' ||

package/dist/cjs/parser/unary-operation-parser.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUnaryOperation = exports.parseNotExists = exports.parseExists = void 0;
+exports.parseExists = parseExists;
+exports.parseNotExists = parseNotExists;
+exports.parseUnaryOperation = parseUnaryOperation;
 const operator_node_js_1 = require("../operation-node/operator-node.js");
 const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 function parseExists(operand) {
     return parseUnaryOperation('exists', operand);
 }
-exports.parseExists = parseExists;
 function parseNotExists(operand) {
     return parseUnaryOperation('not exists', operand);
 }
-exports.parseNotExists = parseNotExists;
 function parseUnaryOperation(operator, operand) {
     return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(operator), (0, reference_parser_js_1.parseReferenceExpression)(operand));
 }
-exports.parseUnaryOperation = parseUnaryOperation;

package/dist/cjs/parser/update-set-parser.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUpdateObjectExpression = exports.parseUpdate = void 0;
+exports.parseUpdate = parseUpdate;
+exports.parseUpdateObjectExpression = parseUpdateObjectExpression;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
 const expression_builder_js_1 = require("../expression/expression-builder.js");
@@ -15,7 +16,6 @@ function parseUpdate(...args) {
     }
     return parseUpdateObjectExpression(args[0]);
 }
-exports.parseUpdate = parseUpdate;
 function parseUpdateObjectExpression(update) {
     const updateObj = (0, object_utils_js_1.isFunction)(update) ? update((0, expression_builder_js_1.expressionBuilder)()) : update;
     return Object.entries(updateObj)
@@ -24,4 +24,3 @@ function parseUpdateObjectExpression(update) {
         return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(value));
     });
 }
-exports.parseUpdateObjectExpression = parseUpdateObjectExpression;

package/dist/cjs/parser/value-parser.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSafeImmediateValue = exports.isSafeImmediateValue = exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
+exports.parseValueExpressionOrList = parseValueExpressionOrList;
+exports.parseValueExpression = parseValueExpression;
+exports.isSafeImmediateValue = isSafeImmediateValue;
+exports.parseSafeImmediateValue = parseSafeImmediateValue;
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
@@ -12,25 +15,21 @@ function parseValueExpressionOrList(arg) {
     }
     return parseValueExpression(arg);
 }
-exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(exp) {
     if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
         return (0, expression_parser_js_1.parseExpression)(exp);
     }
     return value_node_js_1.ValueNode.create(exp);
 }
-exports.parseValueExpression = parseValueExpression;
 function isSafeImmediateValue(value) {
     return (0, object_utils_js_1.isNumber)(value) || (0, object_utils_js_1.isBoolean)(value) || (0, object_utils_js_1.isNull)(value);
 }
-exports.isSafeImmediateValue = isSafeImmediateValue;
 function parseSafeImmediateValue(value) {
     if (!isSafeImmediateValue(value)) {
         throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
     }
     return value_node_js_1.ValueNode.createImmediate(value);
 }
-exports.parseSafeImmediateValue = parseSafeImmediateValue;
 function parseValueExpressionList(arg) {
     if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));

package/dist/cjs/parser/with-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCommonTableExpression = void 0;
+exports.parseCommonTableExpression = parseCommonTableExpression;
 const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
 const parse_utils_js_1 = require("./parse-utils.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -13,7 +13,6 @@ function parseCommonTableExpression(nameOrBuilderCallback, expression) {
     }
     return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
 }
-exports.parseCommonTableExpression = parseCommonTableExpression;
 function cteBuilderFactory(expressionNode) {
     return (name) => {
         return new cte_builder_js_1.CTEBuilder({

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -35,7 +35,7 @@ export interface CamelCasePluginOptions {
 }
 /**
  * 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
@@ -75,7 +75,7 @@ export interface CamelCasePluginOptions {
  * ```
  *
  * 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/cjs/plugin/camel-case/camel-case-plugin.js

@@ -6,7 +6,7 @@ const camel_case_transformer_js_1 = require("./camel-case-transformer.js");
 const camel_case_js_1 = require("./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
@@ -46,7 +46,7 @@ const camel_case_js_1 = require("./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/cjs/plugin/camel-case/camel-case.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCamelCaseMapper = exports.createSnakeCaseMapper = void 0;
+exports.createSnakeCaseMapper = createSnakeCaseMapper;
+exports.createCamelCaseMapper = createCamelCaseMapper;
 /**
  * Creates a function that transforms camel case strings to snake case.
  */
@@ -52,7 +53,6 @@ function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = fal
         }
     });
 }
-exports.createSnakeCaseMapper = createSnakeCaseMapper;
 /**
  * Creates a function that transforms snake case strings to camel case.
  */
@@ -83,7 +83,6 @@ function createCamelCaseMapper({ upperCase = false, } = {}) {
         return out;
     });
 }
-exports.createCamelCaseMapper = createCamelCaseMapper;
 function isAllUpperCaseSnakeCase(str) {
     for (let i = 1, l = str.length; i < l; ++i) {
         const char = str[i];

package/dist/cjs/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/cjs/plugin/parse-json-results/parse-json-results-plugin.js

@@ -16,6 +16,12 @@ const object_utils_js_1 = require("../../util/object-utils.js");
  * ```
  */
 class ParseJSONResultsPlugin {
+    opt;
+    #objectStrategy;
+    constructor(opt = {}) {
+        this.opt = opt;
+        this.#objectStrategy = opt.objectStrategy || 'in-place';
+    }
     // noop
     transformQuery(args) {
         return args.node;
@@ -23,33 +29,34 @@ class ParseJSONResultsPlugin {
     async transformResult(args) {
         return {
             ...args.result,
-            rows: parseArray(args.result.rows),
+            rows: parseArray(args.result.rows, this.#objectStrategy),
         };
     }
 }
 exports.ParseJSONResultsPlugin = ParseJSONResultsPlugin;
-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 ((0, object_utils_js_1.isString)(obj)) {
         return parseString(obj);
     }
     if (Array.isArray(obj)) {
-        return parseArray(obj);
+        return parseArray(obj, objectStrategy);
     }
     if ((0, object_utils_js_1.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.
@@ -60,9 +67,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/cjs/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/cjs/query-builder/delete-query-builder.js

@@ -125,6 +125,18 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
         });
     }
+    output(args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    outputAll(table) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -387,17 +399,17 @@ 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.
      *
@@ -450,9 +462,11 @@ 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 [