kysely 0.27.2 → 0.27.4

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

@@ -0,0 +1,547 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotMatchedThenableMergeQueryBuilder = exports.MatchedThenableMergeQueryBuilder = exports.WheneableMergeQueryBuilder = exports.MergeQueryBuilder = void 0;
+const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
+const merge_query_node_js_1 = require("../operation-node/merge-query-node.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+const update_query_node_js_1 = require("../operation-node/update-query-node.js");
+const insert_values_parser_js_1 = require("../parser/insert-values-parser.js");
+const join_parser_js_1 = require("../parser/join-parser.js");
+const merge_parser_js_1 = require("../parser/merge-parser.js");
+const select_parser_js_1 = require("../parser/select-parser.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const merge_result_js_1 = require("./merge-result.js");
+const no_result_error_js_1 = require("./no-result-error.js");
+const update_query_builder_js_1 = require("./update-query-builder.js");
+class MergeQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Changes a `merge into` query to an `merge top into` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Affect 5 matched rows at most:
+     *
+     * ```ts
+     * await db.mergeInto('person')
+     *   .top(5)
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * merge top(5) into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   delete
+     * ```
+     *
+     * Affect 50% of matched rows:
+     *
+     * ```ts
+     * await db.mergeInto('person')
+     *   .top(50, 'percent')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * merge top(50) percent into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   delete
+     * ```
+     */
+    top(expression, modifiers) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
+    using(...args) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithUsing(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('Using', args)),
+        });
+    }
+    output(args) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    outputAll(table) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
+}
+exports.MergeQueryBuilder = MergeQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(MergeQueryBuilder, "don't await MergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");
+class WheneableMergeQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * See {@link MergeQueryBuilder.top}.
+     */
+    top(expression, modifiers) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
+    /**
+     * Adds a simple `when matched` clause to the query.
+     *
+     * For a `when matched` clause with an `and` condition, see {@link whenMatchedAnd}.
+     *
+     * For a simple `when not matched` clause, see {@link whenNotMatched}.
+     *
+     * For a `when not matched` clause with an `and` condition, see {@link whenNotMatchedAnd}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   delete
+     * ```
+     */
+    whenMatched() {
+        return this.#whenMatched([]);
+    }
+    whenMatchedAnd(...args) {
+        return this.#whenMatched(args);
+    }
+    /**
+     * Adds the `when matched` clause to the query with an `and` condition. But unlike
+     * {@link whenMatchedAnd}, this method accepts a column reference as the 3rd argument.
+     *
+     * This method is similar to {@link SelectQueryBuilder.whereRef}, so see the documentation
+     * for that method for more examples.
+     */
+    whenMatchedAndRef(lhs, op, rhs) {
+        return this.#whenMatched([lhs, op, rhs], true);
+    }
+    #whenMatched(args, refRight) {
+        return new MatchedThenableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithWhen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeWhen)({ isMatched: true }, args, refRight)),
+        });
+    }
+    /**
+     * Adds a simple `when not matched` clause to the query.
+     *
+     * For a `when not matched` clause with an `and` condition, see {@link whenNotMatchedAnd}.
+     *
+     * For a simple `when matched` clause, see {@link whenMatched}.
+     *
+     * For a `when matched` clause with an `and` condition, see {@link whenMatchedAnd}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when not matched then
+     *   insert ("first_name", "last_name") values ($1, $2)
+     * ```
+     */
+    whenNotMatched() {
+        return this.#whenNotMatched([]);
+    }
+    whenNotMatchedAnd(...args) {
+        return this.#whenNotMatched(args);
+    }
+    /**
+     * Adds the `when not matched` clause to the query with an `and` condition. But unlike
+     * {@link whenNotMatchedAnd}, this method accepts a column reference as the 3rd argument.
+     *
+     * Unlike {@link whenMatchedAndRef}, you cannot reference columns from the target table.
+     *
+     * This method is similar to {@link SelectQueryBuilder.whereRef}, so see the documentation
+     * for that method for more examples.
+     */
+    whenNotMatchedAndRef(lhs, op, rhs) {
+        return this.#whenNotMatched([lhs, op, rhs], true);
+    }
+    /**
+     * Adds a simple `when not matched by source` clause to the query.
+     *
+     * Supported in MS SQL Server.
+     *
+     * Similar to {@link whenNotMatched}, but returns a {@link MatchedThenableMergeQueryBuilder}.
+     */
+    whenNotMatchedBySource() {
+        return this.#whenNotMatched([], false, true);
+    }
+    whenNotMatchedBySourceAnd(...args) {
+        return this.#whenNotMatched(args, false, true);
+    }
+    /**
+     * Adds the `when not matched by source` clause to the query with an `and` condition.
+     *
+     * Similar to {@link whenNotMatchedAndRef}, but you can reference columns from
+     * the target table, and not from source table and returns a {@link MatchedThenableMergeQueryBuilder}.
+     */
+    whenNotMatchedBySourceAndRef(lhs, op, rhs) {
+        return this.#whenNotMatched([lhs, op, rhs], true, true);
+    }
+    output(args) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    outputAll(table) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
+    #whenNotMatched(args, refRight = false, bySource = false) {
+        const props = {
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithWhen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeWhen)({ isMatched: false, bySource }, args, refRight)),
+        };
+        const Builder = bySource
+            ? MatchedThenableMergeQueryBuilder
+            : NotMatchedThenableMergeQueryBuilder;
+        return new Builder(props);
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     *
+     * If you want to conditionally call a method on `this`, see
+     * the {@link $if} method.
+     *
+     * ### Examples
+     *
+     * The next example uses a helper function `log` to log a query:
+     *
+     * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.updateTable('person')
+     *   .set(values)
+     *   .$call(log)
+     *   .execute()
+     * ```
+     */
+    $call(func) {
+        return func(this);
+    }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .updateTable('person')
+     *     .set(updates)
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .$if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `updatePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    $if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    /**
+     * Executes the query and returns an array of rows.
+     *
+     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
+     */
+    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 merge_result_js_1.MergeResult(result.numAffectedRows)];
+    }
+    /**
+     * Executes the query and returns the first result or undefined if
+     * the query returned no result.
+     */
+    async executeTakeFirst() {
+        const [result] = await this.execute();
+        return result;
+    }
+    /**
+     * Executes the query and returns the first result or throws if
+     * the query returned no result.
+     *
+     * By default an instance of {@link NoResultError} is thrown, but you can
+     * provide a custom error class, or callback as the only argument to throw a different
+     * error.
+     */
+    async executeTakeFirstOrThrow(errorConstructor = no_result_error_js_1.NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            const error = (0, no_result_error_js_1.isNoResultErrorConstructor)(errorConstructor)
+                ? new errorConstructor(this.toOperationNode())
+                : errorConstructor(this.toOperationNode());
+            throw error;
+        }
+        return result;
+    }
+}
+exports.WheneableMergeQueryBuilder = WheneableMergeQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(WheneableMergeQueryBuilder, "don't await WheneableMergeQueryBuilder instances directly. To execute the query you need to call `execute`.");
+class MatchedThenableMergeQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Performs the `delete` action.
+     *
+     * To perform the `do nothing` action, see {@link thenDoNothing}.
+     *
+     * To perform the `update` action, see {@link thenUpdate} or {@link thenUpdateSet}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   delete
+     * ```
+     */
+    thenDelete() {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithThen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeThen)('delete')),
+        });
+    }
+    /**
+     * Performs the `do nothing` action.
+     *
+     * This is supported in PostgreSQL.
+     *
+     * To perform the `delete` action, see {@link thenDelete}.
+     *
+     * To perform the `update` action, see {@link thenUpdate} or {@link thenUpdateSet}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenDoNothing()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   do nothing
+     * ```
+     */
+    thenDoNothing() {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithThen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeThen)('do nothing')),
+        });
+    }
+    /**
+     * Perform an `update` operation with a full-fledged {@link UpdateQueryBuilder}.
+     * This is handy when multiple `set` invocations are needed.
+     *
+     * For a shorthand version of this method, see {@link thenUpdateSet}.
+     *
+     * To perform the `delete` action, see {@link thenDelete}.
+     *
+     * To perform the `do nothing` action, see {@link thenDoNothing}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenMatched()
+     *   .thenUpdate((ub) => ub
+     *     .set(sql`metadata['has_pets']`, 'Y')
+     *     .set({
+     *       updated_at: Date.now(),
+     *     })
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when matched then
+     *   update set metadata['has_pets'] = $1, "updated_at" = $2
+     * ```
+     */
+    thenUpdate(set) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithThen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeThen)(set(new update_query_builder_js_1.UpdateQueryBuilder({
+                queryId: this.#props.queryId,
+                executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+                queryNode: update_query_node_js_1.UpdateQueryNode.createWithoutTable(),
+            })))),
+        });
+    }
+    thenUpdateSet(...args) {
+        // @ts-ignore not sure how to type this so it won't complain about set(...args).
+        return this.thenUpdate((ub) => ub.set(...args));
+    }
+}
+exports.MatchedThenableMergeQueryBuilder = MatchedThenableMergeQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(MatchedThenableMergeQueryBuilder, "don't await MatchedThenableMergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");
+class NotMatchedThenableMergeQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Performs the `do nothing` action.
+     *
+     * This is supported in PostgreSQL.
+     *
+     * To perform the `insert` action, see {@link thenInsertValues}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db.mergeInto('person')
+     *   .using('pet', 'person.id', 'pet.owner_id')
+     *   .whenNotMatched()
+     *   .thenDoNothing()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "person"."id" = "pet"."owner_id"
+     * when not matched then
+     *   do nothing
+     * ```
+     */
+    thenDoNothing() {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithThen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeThen)('do nothing')),
+        });
+    }
+    thenInsertValues(insert) {
+        const [columns, values] = (0, insert_values_parser_js_1.parseInsertExpression)(insert);
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: merge_query_node_js_1.MergeQueryNode.cloneWithThen(this.#props.queryNode, (0, merge_parser_js_1.parseMergeThen)(insert_query_node_js_1.InsertQueryNode.cloneWith(insert_query_node_js_1.InsertQueryNode.createWithoutInto(), {
+                columns,
+                values,
+            }))),
+        });
+    }
+}
+exports.NotMatchedThenableMergeQueryBuilder = NotMatchedThenableMergeQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(NotMatchedThenableMergeQueryBuilder, "don't await NotMatchedThenableMergeQueryBuilder instances directly. To execute the query you need to call `execute` when available.");

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

@@ -0,0 +1,4 @@
+export declare class MergeResult {
+    readonly numChangedRows: bigint | undefined;
+    constructor(numChangedRows: bigint | undefined);
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeResult = void 0;
+class MergeResult {
+    numChangedRows;
+    constructor(numChangedRows) {
+        this.numChangedRows = numChangedRows;
+    }
+}
+exports.MergeResult = MergeResult;

package/dist/cjs/query-builder/no-result-error.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNoResultErrorConstructor = exports.NoResultError = void 0;
+exports.NoResultError = void 0;
+exports.isNoResultErrorConstructor = isNoResultErrorConstructor;
 class NoResultError extends Error {
     /**
      * The operation node tree of the query that was executed.
@@ -15,4 +16,3 @@ exports.NoResultError = NoResultError;
 function isNoResultErrorConstructor(fn) {
     return Object.prototype.hasOwnProperty.call(fn, 'prototype');
 }
-exports.isNoResultErrorConstructor = isNoResultErrorConstructor;

package/dist/cjs/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/cjs/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/cjs/query-builder/output-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });