@fragno-dev/workflows 0.0.1 → 0.0.3

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

@@ -1,628 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,11 +0,0 @@
-//#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