@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/merge-query-builder.js

@@ -0,0 +1,628 @@
+import { freeze } from "../util/object-utils.js";
+import { InsertQueryNode } from "../operation-node/insert-query-node.js";
+import { UpdateQueryNode } from "../operation-node/update-query-node.js";
+import { MergeQueryNode } from "../operation-node/merge-query-node.js";
+import { QueryNode } from "../operation-node/query-node.js";
+import { parseSelectAll, parseSelectArg } from "../parser/select-parser.js";
+import { parseInsertExpression } from "../parser/insert-values-parser.js";
+import { NoResultError, isNoResultErrorConstructor } from "./no-result-error.js";
+import { parseTop } from "../parser/top-parser.js";
+import { UpdateQueryBuilder } from "./update-query-builder.js";
+import { parseMergeThen, parseMergeWhen } from "../parser/merge-parser.js";
+import { NOOP_QUERY_EXECUTOR } from "../query-executor/noop-query-executor.js";
+import { MergeResult } from "./merge-result.js";
+import { parseJoin } from "../parser/join-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/merge-query-builder.js
+var MergeQueryBuilder = class MergeQueryBuilder {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	/**
+	* This can be used to add any additional SQL to the end of the query.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import { sql } from 'kysely'
+	*
+	* await db
+	*   .mergeInto('person')
+	*   .using('pet', 'pet.owner_id', 'person.id')
+	*   .whenMatched()
+	*   .thenDelete()
+	*   .modifyEnd(sql.raw('-- this is a comment'))
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (PostgreSQL):
+	*
+	* ```sql
+	* merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+	* ```
+	*/
+	modifyEnd(modifier) {
+		return new MergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
+		});
+	}
+	/**
+	* 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: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
+		});
+	}
+	using(...args) {
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: MergeQueryNode.cloneWithUsing(this.#props.queryNode, parseJoin("Using", args))
+		});
+	}
+	returning(args) {
+		return new MergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(args))
+		});
+	}
+	returningAll(table) {
+		return new MergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
+		});
+	}
+	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))
+		});
+	}
+};
+var WheneableMergeQueryBuilder = class WheneableMergeQueryBuilder {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	/**
+	* This can be used to add any additional SQL to the end of the query.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import { sql } from 'kysely'
+	*
+	* await db
+	*   .mergeInto('person')
+	*   .using('pet', 'pet.owner_id', 'person.id')
+	*   .whenMatched()
+	*   .thenDelete()
+	*   .modifyEnd(sql.raw('-- this is a comment'))
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (PostgreSQL):
+	*
+	* ```sql
+	* merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+	* ```
+	*/
+	modifyEnd(modifier) {
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
+		});
+	}
+	/**
+	* See {@link MergeQueryBuilder.top}.
+	*/
+	top(expression, modifiers) {
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithTop(this.#props.queryNode, 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: MergeQueryNode.cloneWithWhen(this.#props.queryNode, 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);
+	}
+	returning(args) {
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(args))
+		});
+	}
+	returningAll(table) {
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
+		});
+	}
+	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,
+			queryNode: MergeQueryNode.cloneWithWhen(this.#props.queryNode, parseMergeWhen({
+				isMatched: false,
+				bySource
+			}, args, refRight))
+		};
+		return new (bySource ? MatchedThenableMergeQueryBuilder : NotMatchedThenableMergeQueryBuilder)(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
+	* import type { Compilable } from 'kysely'
+	*
+	* function log<T extends Compilable>(qb: T): T {
+	*   console.log(qb.compile())
+	*   return qb
+	* }
+	*
+	* await db.updateTable('person')
+	*   .set({ first_name: 'John' })
+	*   .$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
+	* import type { PersonUpdate } from 'type-editor' // imaginary module
+	*
+	* async function updatePerson(id: number, updates: PersonUpdate, 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
+	* Promise<{
+	*   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);
+		const { adapter } = this.#props.executor;
+		const query = compiledQuery.query;
+		if (query.returning && adapter.supportsReturning || query.output && adapter.supportsOutput) return result.rows;
+		return [new 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 = NoResultError) {
+		const result = await this.executeTakeFirst();
+		if (result === void 0) throw isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
+		return result;
+	}
+};
+var MatchedThenableMergeQueryBuilder = class {
+	#props;
+	constructor(props) {
+		this.#props = 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: MergeQueryNode.cloneWithThen(this.#props.queryNode, 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: MergeQueryNode.cloneWithThen(this.#props.queryNode, 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: new Date().toISOString(),
+	*     })
+	*   )
+	*   .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: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen(set(new UpdateQueryBuilder({
+				queryId: this.#props.queryId,
+				executor: NOOP_QUERY_EXECUTOR,
+				queryNode: UpdateQueryNode.createWithoutTable()
+			}))))
+		});
+	}
+	thenUpdateSet(...args) {
+		return this.thenUpdate((ub) => ub.set(...args));
+	}
+};
+var NotMatchedThenableMergeQueryBuilder = class {
+	#props;
+	constructor(props) {
+		this.#props = 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: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen("do nothing"))
+		});
+	}
+	thenInsertValues(insert) {
+		const [columns, values] = parseInsertExpression(insert);
+		return new WheneableMergeQueryBuilder({
+			...this.#props,
+			queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen(InsertQueryNode.cloneWith(InsertQueryNode.createWithoutInto(), {
+				columns,
+				values
+			})))
+		});
+	}
+};
+
+//#endregion
+export { MatchedThenableMergeQueryBuilder, MergeQueryBuilder, NotMatchedThenableMergeQueryBuilder, WheneableMergeQueryBuilder };
+//# sourceMappingURL=merge-query-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/merge-query-builder.js.map

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

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/merge-result.js

@@ -0,0 +1,11 @@
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/merge-result.js
+var MergeResult = class {
+	numChangedRows;
+	constructor(numChangedRows) {
+		this.numChangedRows = numChangedRows;
+	}
+};
+
+//#endregion
+export { MergeResult };
+//# sourceMappingURL=merge-result.js.map