@fragno-dev/workflows 0.0.1

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

@@ -0,0 +1,498 @@
+import { freeze } from "../util/object-utils.js";
+import { parseOrderBy } from "../parser/order-by-parser.js";
+import { parseValueExpression } from "../parser/value-parser.js";
+import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression } from "../parser/binary-operation-parser.js";
+import { UpdateQueryNode } from "../operation-node/update-query-node.js";
+import { QueryNode } from "../operation-node/query-node.js";
+import { parseSelectAll, parseSelectArg } from "../parser/select-parser.js";
+import { parseUpdate } from "../parser/update-set-parser.js";
+import { NoResultError, isNoResultErrorConstructor } from "./no-result-error.js";
+import { parseTop } from "../parser/top-parser.js";
+import { LimitNode } from "../operation-node/limit-node.js";
+import { UpdateResult } from "./update-result.js";
+import { parseJoin } from "../parser/join-parser.js";
+import { parseTableExpressionOrList } from "../parser/table-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/update-query-builder.js
+var UpdateQueryBuilder = class UpdateQueryBuilder {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	where(...args) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args))
+		});
+	}
+	whereRef(lhs, op, rhs) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs))
+		});
+	}
+	clearWhere() {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode)
+		});
+	}
+	/**
+	* Changes an `update` query into a `update top` query.
+	*
+	* `top` clause is only supported by some dialects like MS SQL Server.
+	*
+	* ### Examples
+	*
+	* Update the first row:
+	*
+	* ```ts
+	* await db.updateTable('person')
+	*   .top(1)
+	*   .set({ first_name: 'Foo' })
+	*   .where('age', '>', 18)
+	*   .executeTakeFirstOrThrow()
+	* ```
+	*
+	* The generated SQL (MS SQL Server):
+	*
+	* ```sql
+	* update top(1) "person" set "first_name" = @1 where "age" > @2
+	* ```
+	*
+	* Update the 50% first rows:
+	*
+	* ```ts
+	* await db.updateTable('person')
+	*   .top(50, 'percent')
+	*   .set({ first_name: 'Foo' })
+	*   .where('age', '>', 18)
+	*   .executeTakeFirstOrThrow()
+	* ```
+	*
+	* The generated SQL (MS SQL Server):
+	*
+	* ```sql
+	* update top(50) percent "person" set "first_name" = @1 where "age" > @2
+	* ```
+	*/
+	top(expression, modifiers) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
+		});
+	}
+	from(from) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, parseTableExpressionOrList(from))
+		});
+	}
+	innerJoin(...args) {
+		return this.#join("InnerJoin", args);
+	}
+	leftJoin(...args) {
+		return this.#join("LeftJoin", args);
+	}
+	rightJoin(...args) {
+		return this.#join("RightJoin", args);
+	}
+	fullJoin(...args) {
+		return this.#join("FullJoin", args);
+	}
+	#join(joinType, args) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args))
+		});
+	}
+	orderBy(...args) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args))
+		});
+	}
+	clearOrderBy() {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode)
+		});
+	}
+	/**
+	* Adds a limit clause to the update query for supported databases, such as MySQL.
+	*
+	* ### Examples
+	*
+	* Update the first 2 rows in the 'person' table:
+	*
+	* ```ts
+	* await db
+	*   .updateTable('person')
+	*   .set({ first_name: 'Foo' })
+	*   .limit(2)
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (MySQL):
+	*
+	* ```sql
+	* update `person` set `first_name` = ? limit ?
+	* ```
+	*/
+	limit(limit) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: UpdateQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit)))
+		});
+	}
+	set(...args) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdate(...args))
+		});
+	}
+	returning(selection) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection))
+		});
+	}
+	returningAll(table) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
+		});
+	}
+	output(args) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
+		});
+	}
+	outputAll(table) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
+		});
+	}
+	/**
+	* This can be used to add any additional SQL to the end of the query.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import { sql } from 'kysely'
+	*
+	* await db.updateTable('person')
+	*   .set({ age: 39 })
+	*   .where('first_name', '=', 'John')
+	*   .modifyEnd(sql.raw('-- This is a comment'))
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (MySQL):
+	*
+	* ```sql
+	* update `person`
+	* set `age` = 39
+	* where `first_name` = "John" -- This is a comment
+	* ```
+	*/
+	modifyEnd(modifier) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
+		});
+	}
+	/**
+	* Clears all `returning` clauses from the query.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* db.updateTable('person')
+	*   .returningAll()
+	*   .set({ age: 39 })
+	*   .where('first_name', '=', 'John')
+	*   .clearReturning()
+	* ```
+	*
+	* The generated SQL(PostgreSQL):
+	*
+	* ```sql
+	* update "person" set "age" = 39 where "first_name" = "John"
+	* ```
+	*/
+	clearReturning() {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode)
+		});
+	}
+	/**
+	* 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'
+	* import type { PersonUpdate } from 'type-editor' // imaginary module
+	*
+	* function log<T extends Compilable>(qb: T): T {
+	*   console.log(qb.compile())
+	*   return qb
+	* }
+	*
+	* const values = {
+	*   first_name: 'John',
+	* } satisfies PersonUpdate
+	*
+	* 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
+	* 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 UpdateQueryBuilder({ ...this.#props });
+	}
+	/**
+	* Change the output type of the query.
+	*
+	* This method call doesn't change the SQL in any way. This methods simply
+	* returns a copy of this `UpdateQueryBuilder` with a new output type.
+	*/
+	$castTo() {
+		return new UpdateQueryBuilder(this.#props);
+	}
+	/**
+	* Narrows (parts of) the output type of the query.
+	*
+	* Kysely tries to be as type-safe as possible, but in some cases we have to make
+	* compromises for better maintainability and compilation performance. At present,
+	* Kysely doesn't narrow the output type of the query based on {@link set} input
+	* when using {@link where} and/or {@link returning} or {@link returningAll}.
+	*
+	* This utility method is very useful for these situations, as it removes unncessary
+	* runtime assertion/guard code. Its input type is limited to the output type
+	* of the query, so you can't add a column that doesn't exist, or change a column's
+	* type to something that doesn't exist in its union type.
+	*
+	* ### Examples
+	*
+	* Turn this code:
+	*
+	* ```ts
+	* import type { Person } from 'type-editor' // imaginary module
+	*
+	* const id = 1
+	* const now = new Date().toISOString()
+	*
+	* const person = await db.updateTable('person')
+	*   .set({ deleted_at: now })
+	*   .where('id', '=', id)
+	*   .where('nullable_column', 'is not', null)
+	*   .returningAll()
+	*   .executeTakeFirstOrThrow()
+	*
+	* if (isWithNoNullValue(person)) {
+	*   functionThatExpectsPersonWithNonNullValue(person)
+	* }
+	*
+	* function isWithNoNullValue(person: Person): person is Person & { nullable_column: string } {
+	*   return person.nullable_column != null
+	* }
+	* ```
+	*
+	* Into this:
+	*
+	* ```ts
+	* import type { NotNull } from 'kysely'
+	*
+	* const id = 1
+	* const now = new Date().toISOString()
+	*
+	* const person = await db.updateTable('person')
+	*   .set({ deleted_at: now })
+	*   .where('id', '=', id)
+	*   .where('nullable_column', 'is not', null)
+	*   .returningAll()
+	*   .$narrowType<{ deleted_at: Date; nullable_column: NotNull }>()
+	*   .executeTakeFirstOrThrow()
+	*
+	* functionThatExpectsPersonWithNonNullValue(person)
+	* ```
+	*/
+	$narrowType() {
+		return new UpdateQueryBuilder(this.#props);
+	}
+	/**
+	* Asserts that query's output row type equals the given type `T`.
+	*
+	* This method can be used to simplify excessively complex types to make TypeScript happy
+	* and much faster.
+	*
+	* Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
+	* for TypeScript and you get errors like this:
+	*
+	* ```
+	* error TS2589: Type instantiation is excessively deep and possibly infinite.
+	* ```
+	*
+	* In these case you can often use this method to help TypeScript a little bit. When you use this
+	* method to assert the output type of a query, Kysely can drop the complex output type that
+	* consists of multiple nested helper types and replace it with the simple asserted type.
+	*
+	* Using this method doesn't reduce type safety at all. You have to pass in a type that is
+	* structurally equal to the current type.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { PersonUpdate, PetUpdate, Species } from 'type-editor' // imaginary module
+	*
+	* const person = {
+	*   id: 1,
+	*   gender: 'other',
+	* } satisfies PersonUpdate
+	*
+	* const pet = {
+	*   name: 'Fluffy',
+	* } satisfies PetUpdate
+	*
+	* const result = await db
+	*   .with('updated_person', (qb) => qb
+	*     .updateTable('person')
+	*     .set(person)
+	*     .where('id', '=', person.id)
+	*     .returning('first_name')
+	*     .$assertType<{ first_name: string }>()
+	*   )
+	*   .with('updated_pet', (qb) => qb
+	*     .updateTable('pet')
+	*     .set(pet)
+	*     .where('owner_id', '=', person.id)
+	*     .returning(['name as pet_name', 'species'])
+	*     .$assertType<{ pet_name: string, species: Species }>()
+	*   )
+	*   .selectFrom(['updated_person', 'updated_pet'])
+	*   .selectAll()
+	*   .executeTakeFirstOrThrow()
+	* ```
+	*/
+	$assertType() {
+		return new UpdateQueryBuilder(this.#props);
+	}
+	/**
+	* Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
+	*/
+	withPlugin(plugin) {
+		return new UpdateQueryBuilder({
+			...this.#props,
+			executor: this.#props.executor.withPlugin(plugin)
+		});
+	}
+	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 UpdateResult(result.numAffectedRows ?? BigInt(0), result.numChangedRows)];
+	}
+	/**
+	* 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;
+	}
+	async *stream(chunkSize = 100) {
+		const compiledQuery = this.compile();
+		const stream = this.#props.executor.stream(compiledQuery, chunkSize);
+		for await (const item of stream) yield* item.rows;
+	}
+	async explain(format, options) {
+		return await new UpdateQueryBuilder({
+			...this.#props,
+			queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options)
+		}).execute();
+	}
+};
+
+//#endregion
+export { UpdateQueryBuilder };
+//# sourceMappingURL=update-query-builder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-query-builder.js","names":["#props","#join"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/update-query-builder.js"],"sourcesContent":["/// <reference types=\"./update-query-builder.d.ts\" />\nimport { parseJoin, } from '../parser/join-parser.js';\nimport { parseTableExpressionOrList, } from '../parser/table-parser.js';\nimport { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';\nimport { QueryNode } from '../operation-node/query-node.js';\nimport { UpdateQueryNode } from '../operation-node/update-query-node.js';\nimport { parseUpdate, } from '../parser/update-set-parser.js';\nimport { freeze } from '../util/object-utils.js';\nimport { UpdateResult } from './update-result.js';\nimport { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';\nimport { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';\nimport { parseValueExpression, } from '../parser/value-parser.js';\nimport { LimitNode } from '../operation-node/limit-node.js';\nimport { parseTop } from '../parser/top-parser.js';\nimport { parseOrderBy, } from '../parser/order-by-parser.js';\nexport class UpdateQueryBuilder {\n    #props;\n    constructor(props) {\n        this.#props = freeze(props);\n    }\n    where(...args) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args)),\n        });\n    }\n    whereRef(lhs, op, rhs) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs)),\n        });\n    }\n    clearWhere() {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),\n        });\n    }\n    /**\n     * Changes an `update` query into a `update top` query.\n     *\n     * `top` clause is only supported by some dialects like MS SQL Server.\n     *\n     * ### Examples\n     *\n     * Update the first row:\n     *\n     * ```ts\n     * await db.updateTable('person')\n     *   .top(1)\n     *   .set({ first_name: 'Foo' })\n     *   .where('age', '>', 18)\n     *   .executeTakeFirstOrThrow()\n     * ```\n     *\n     * The generated SQL (MS SQL Server):\n     *\n     * ```sql\n     * update top(1) \"person\" set \"first_name\" = @1 where \"age\" > @2\n     * ```\n     *\n     * Update the 50% first rows:\n     *\n     * ```ts\n     * await db.updateTable('person')\n     *   .top(50, 'percent')\n     *   .set({ first_name: 'Foo' })\n     *   .where('age', '>', 18)\n     *   .executeTakeFirstOrThrow()\n     * ```\n     *\n     * The generated SQL (MS SQL Server):\n     *\n     * ```sql\n     * update top(50) percent \"person\" set \"first_name\" = @1 where \"age\" > @2\n     * ```\n     */\n    top(expression, modifiers) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers)),\n        });\n    }\n    from(from) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, parseTableExpressionOrList(from)),\n        });\n    }\n    innerJoin(...args) {\n        return this.#join('InnerJoin', args);\n    }\n    leftJoin(...args) {\n        return this.#join('LeftJoin', args);\n    }\n    rightJoin(...args) {\n        return this.#join('RightJoin', args);\n    }\n    fullJoin(...args) {\n        return this.#join('FullJoin', args);\n    }\n    #join(joinType, args) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args)),\n        });\n    }\n    orderBy(...args) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),\n        });\n    }\n    clearOrderBy() {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode),\n        });\n    }\n    /**\n     * Adds a limit clause to the update query for supported databases, such as MySQL.\n     *\n     * ### Examples\n     *\n     * Update the first 2 rows in the 'person' table:\n     *\n     * ```ts\n     * await db\n     *   .updateTable('person')\n     *   .set({ first_name: 'Foo' })\n     *   .limit(2)\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * update `person` set `first_name` = ? limit ?\n     * ```\n     */\n    limit(limit) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: UpdateQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit))),\n        });\n    }\n    set(...args) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdate(...args)),\n        });\n    }\n    returning(selection) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection)),\n        });\n    }\n    returningAll(table) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table)),\n        });\n    }\n    output(args) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),\n        });\n    }\n    outputAll(table) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),\n        });\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.updateTable('person')\n     *   .set({ age: 39 })\n     *   .where('first_name', '=', 'John')\n     *   .modifyEnd(sql.raw('-- This is a comment'))\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * update `person`\n     * set `age` = 39\n     * where `first_name` = \"John\" -- This is a comment\n     * ```\n     */\n    modifyEnd(modifier) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode()),\n        });\n    }\n    /**\n     * Clears all `returning` clauses from the query.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * db.updateTable('person')\n     *   .returningAll()\n     *   .set({ age: 39 })\n     *   .where('first_name', '=', 'John')\n     *   .clearReturning()\n     * ```\n     *\n     * The generated SQL(PostgreSQL):\n     *\n     * ```sql\n     * update \"person\" set \"age\" = 39 where \"first_name\" = \"John\"\n     * ```\n     */\n    clearReturning() {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode),\n        });\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     * import type { PersonUpdate } from 'type-editor' // imaginary module\n     *\n     * function log<T extends Compilable>(qb: T): T {\n     *   console.log(qb.compile())\n     *   return qb\n     * }\n     *\n     * const values = {\n     *   first_name: 'John',\n     * } satisfies PersonUpdate\n     *\n     * db.updateTable('person')\n     *   .set(values)\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 UpdateQueryBuilder({\n            ...this.#props,\n        });\n    }\n    /**\n     * Change the output type of the query.\n     *\n     * This method call doesn't change the SQL in any way. This methods simply\n     * returns a copy of this `UpdateQueryBuilder` with a new output type.\n     */\n    $castTo() {\n        return new UpdateQueryBuilder(this.#props);\n    }\n    /**\n     * Narrows (parts of) the output type of the query.\n     *\n     * Kysely tries to be as type-safe as possible, but in some cases we have to make\n     * compromises for better maintainability and compilation performance. At present,\n     * Kysely doesn't narrow the output type of the query based on {@link set} input\n     * when using {@link where} and/or {@link returning} or {@link returningAll}.\n     *\n     * This utility method is very useful for these situations, as it removes unncessary\n     * runtime assertion/guard code. Its input type is limited to the output type\n     * of the query, so you can't add a column that doesn't exist, or change a column's\n     * type to something that doesn't exist in its union type.\n     *\n     * ### Examples\n     *\n     * Turn this code:\n     *\n     * ```ts\n     * import type { Person } from 'type-editor' // imaginary module\n     *\n     * const id = 1\n     * const now = new Date().toISOString()\n     *\n     * const person = await db.updateTable('person')\n     *   .set({ deleted_at: now })\n     *   .where('id', '=', id)\n     *   .where('nullable_column', 'is not', null)\n     *   .returningAll()\n     *   .executeTakeFirstOrThrow()\n     *\n     * if (isWithNoNullValue(person)) {\n     *   functionThatExpectsPersonWithNonNullValue(person)\n     * }\n     *\n     * function isWithNoNullValue(person: Person): person is Person & { nullable_column: string } {\n     *   return person.nullable_column != null\n     * }\n     * ```\n     *\n     * Into this:\n     *\n     * ```ts\n     * import type { NotNull } from 'kysely'\n     *\n     * const id = 1\n     * const now = new Date().toISOString()\n     *\n     * const person = await db.updateTable('person')\n     *   .set({ deleted_at: now })\n     *   .where('id', '=', id)\n     *   .where('nullable_column', 'is not', null)\n     *   .returningAll()\n     *   .$narrowType<{ deleted_at: Date; nullable_column: NotNull }>()\n     *   .executeTakeFirstOrThrow()\n     *\n     * functionThatExpectsPersonWithNonNullValue(person)\n     * ```\n     */\n    $narrowType() {\n        return new UpdateQueryBuilder(this.#props);\n    }\n    /**\n     * Asserts that query's output row type equals the given type `T`.\n     *\n     * This method can be used to simplify excessively complex types to make TypeScript happy\n     * and much faster.\n     *\n     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much\n     * for TypeScript and you get errors like this:\n     *\n     * ```\n     * error TS2589: Type instantiation is excessively deep and possibly infinite.\n     * ```\n     *\n     * In these case you can often use this method to help TypeScript a little bit. When you use this\n     * method to assert the output type of a query, Kysely can drop the complex output type that\n     * consists of multiple nested helper types and replace it with the simple asserted type.\n     *\n     * Using this method doesn't reduce type safety at all. You have to pass in a type that is\n     * structurally equal to the current type.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import type { PersonUpdate, PetUpdate, Species } from 'type-editor' // imaginary module\n     *\n     * const person = {\n     *   id: 1,\n     *   gender: 'other',\n     * } satisfies PersonUpdate\n     *\n     * const pet = {\n     *   name: 'Fluffy',\n     * } satisfies PetUpdate\n     *\n     * const result = await db\n     *   .with('updated_person', (qb) => qb\n     *     .updateTable('person')\n     *     .set(person)\n     *     .where('id', '=', person.id)\n     *     .returning('first_name')\n     *     .$assertType<{ first_name: string }>()\n     *   )\n     *   .with('updated_pet', (qb) => qb\n     *     .updateTable('pet')\n     *     .set(pet)\n     *     .where('owner_id', '=', person.id)\n     *     .returning(['name as pet_name', 'species'])\n     *     .$assertType<{ pet_name: string, species: Species }>()\n     *   )\n     *   .selectFrom(['updated_person', 'updated_pet'])\n     *   .selectAll()\n     *   .executeTakeFirstOrThrow()\n     * ```\n     */\n    $assertType() {\n        return new UpdateQueryBuilder(this.#props);\n    }\n    /**\n     * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.\n     */\n    withPlugin(plugin) {\n        return new UpdateQueryBuilder({\n            ...this.#props,\n            executor: this.#props.executor.withPlugin(plugin),\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 [\n            new UpdateResult(result.numAffectedRows ?? BigInt(0), result.numChangedRows),\n        ];\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    async *stream(chunkSize = 100) {\n        const compiledQuery = this.compile();\n        const stream = this.#props.executor.stream(compiledQuery, chunkSize);\n        for await (const item of stream) {\n            yield* item.rows;\n        }\n    }\n    async explain(format, options) {\n        const builder = new UpdateQueryBuilder({\n            ...this.#props,\n            queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options),\n        });\n        return await builder.execute();\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/update-result.js

@@ -0,0 +1,22 @@
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/update-result.js
+var UpdateResult = class {
+	/**
+	* The number of rows the update query updated (even if not changed).
+	*/
+	numUpdatedRows;
+	/**
+	* The number of rows the update query changed.
+	*
+	* This is **optional** and only supported in dialects such as MySQL.
+	* You would probably use {@link numUpdatedRows} in most cases.
+	*/
+	numChangedRows;
+	constructor(numUpdatedRows, numChangedRows) {
+		this.numUpdatedRows = numUpdatedRows;
+		this.numChangedRows = numChangedRows;
+	}
+};
+
+//#endregion
+export { UpdateResult };
+//# sourceMappingURL=update-result.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-result.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-builder/update-result.js"],"sourcesContent":["/// <reference types=\"./update-result.d.ts\" />\nexport class UpdateResult {\n    /**\n     * The number of rows the update query updated (even if not changed).\n     */\n    numUpdatedRows;\n    /**\n     * The number of rows the update query changed.\n     *\n     * This is **optional** and only supported in dialects such as MySQL.\n     * You would probably use {@link numUpdatedRows} in most cases.\n     */\n    numChangedRows;\n    constructor(numUpdatedRows, numChangedRows) {\n        this.numUpdatedRows = numUpdatedRows;\n        this.numChangedRows = numChangedRows;\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";AACA,IAAa,eAAb,MAA0B;;;;CAItB;;;;;;;CAOA;CACA,YAAY,gBAAgB,gBAAgB;AACxC,OAAK,iBAAiB;AACtB,OAAK,iBAAiB"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-compiler/compiled-query.js

@@ -0,0 +1,17 @@
+import { freeze } from "../util/object-utils.js";
+import { RawNode } from "../operation-node/raw-node.js";
+import { createQueryId } from "../util/query-id.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-compiler/compiled-query.js
+const CompiledQuery = freeze({ raw(sql, parameters = []) {
+	return freeze({
+		sql,
+		query: RawNode.createWithSql(sql),
+		parameters: freeze(parameters),
+		queryId: createQueryId()
+	});
+} });
+
+//#endregion
+export { CompiledQuery };
+//# sourceMappingURL=compiled-query.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-compiler/compiled-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiled-query.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-compiler/compiled-query.js"],"sourcesContent":["/// <reference types=\"./compiled-query.d.ts\" />\nimport { RawNode } from '../operation-node/raw-node.js';\nimport { freeze } from '../util/object-utils.js';\nimport { createQueryId } from '../util/query-id.js';\nexport const CompiledQuery = freeze({\n    raw(sql, parameters = []) {\n        return freeze({\n            sql,\n            query: RawNode.createWithSql(sql),\n            parameters: freeze(parameters),\n            queryId: createQueryId(),\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAIA,MAAa,gBAAgB,OAAO,EAChC,IAAI,KAAK,aAAa,EAAE,EAAE;AACtB,QAAO,OAAO;EACV;EACA,OAAO,QAAQ,cAAc,IAAI;EACjC,YAAY,OAAO,WAAW;EAC9B,SAAS,eAAe;EAC3B,CAAC;GAET,CAAC"}