@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/kysely.js

@@ -0,0 +1,899 @@
+import { freeze, isObject, isUndefined } from "./util/object-utils.js";
+import { logOnce } from "./util/log-once.js";
+import { createQueryId } from "./util/query-id.js";
+import { WithSchemaPlugin } from "./plugin/with-schema/with-schema-plugin.js";
+import { provideControlledConnection } from "./util/provide-controlled-connection.js";
+import { QueryCreator } from "./query-creator.js";
+import { createFunctionModule } from "./query-builder/function-module.js";
+import { CaseNode } from "./operation-node/case-node.js";
+import { CaseBuilder } from "./query-builder/case-builder.js";
+import { parseExpression } from "./parser/expression-parser.js";
+import { SchemaModule } from "./schema/schema.js";
+import { DynamicModule } from "./dynamic/dynamic.js";
+import { DefaultConnectionProvider } from "./driver/default-connection-provider.js";
+import { DefaultQueryExecutor } from "./query-executor/default-query-executor.js";
+import { RuntimeDriver } from "./driver/runtime-driver.js";
+import { SingleConnectionProvider } from "./driver/single-connection-provider.js";
+import { validateTransactionSettings } from "./driver/driver.js";
+import { Log } from "./util/log.js";
+import { isCompilable } from "./util/compilable.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/kysely.js
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
+/**
+* The main Kysely class.
+*
+* You should create one instance of `Kysely` per database using the {@link Kysely}
+* constructor. Each `Kysely` instance maintains its own connection pool.
+*
+* ### Examples
+*
+* This example assumes your database has a "person" table:
+*
+* ```ts
+* import * as Sqlite from 'better-sqlite3'
+* import { type Generated, Kysely, SqliteDialect } from 'kysely'
+*
+* interface Database {
+*   person: {
+*     id: Generated<number>
+*     first_name: string
+*     last_name: string | null
+*   }
+* }
+*
+* const db = new Kysely<Database>({
+*   dialect: new SqliteDialect({
+*     database: new Sqlite(':memory:'),
+*   })
+* })
+* ```
+*
+* @typeParam DB - The database interface type. Keys of this type must be table names
+*    in the database and values must be interfaces that describe the rows in those
+*    tables. See the examples above.
+*/
+var Kysely = class Kysely extends QueryCreator {
+	#props;
+	constructor(args) {
+		let superProps;
+		let props;
+		if (isKyselyProps(args)) {
+			superProps = { executor: args.executor };
+			props = { ...args };
+		} else {
+			const dialect = args.dialect;
+			const driver = dialect.createDriver();
+			const compiler = dialect.createQueryCompiler();
+			const adapter = dialect.createAdapter();
+			const runtimeDriver = new RuntimeDriver(driver, new Log(args.log ?? []));
+			const executor = new DefaultQueryExecutor(compiler, adapter, new DefaultConnectionProvider(runtimeDriver), args.plugins ?? []);
+			superProps = { executor };
+			props = {
+				config: args,
+				executor,
+				dialect,
+				driver: runtimeDriver
+			};
+		}
+		super(superProps);
+		this.#props = freeze(props);
+	}
+	/**
+	* Returns the {@link SchemaModule} module for building database schema.
+	*/
+	get schema() {
+		return new SchemaModule(this.#props.executor);
+	}
+	/**
+	* Returns a the {@link DynamicModule} module.
+	*
+	* The {@link DynamicModule} module can be used to bypass strict typing and
+	* passing in dynamic values for the queries.
+	*/
+	get dynamic() {
+		return new DynamicModule();
+	}
+	/**
+	* Returns a {@link DatabaseIntrospector | database introspector}.
+	*/
+	get introspection() {
+		return this.#props.dialect.createIntrospector(this.withoutPlugins());
+	}
+	case(value) {
+		return new CaseBuilder({ node: CaseNode.create(isUndefined(value) ? void 0 : parseExpression(value)) });
+	}
+	/**
+	* Returns a {@link FunctionModule} that can be used to write somewhat type-safe function
+	* calls.
+	*
+	* ```ts
+	* const { count } = db.fn
+	*
+	* await db.selectFrom('person')
+	*   .innerJoin('pet', 'pet.owner_id', 'person.id')
+	*   .select([
+	*     'id',
+	*     count('pet.id').as('person_count'),
+	*   ])
+	*   .groupBy('person.id')
+	*   .having(count('pet.id'), '>', 10)
+	*   .execute()
+	* ```
+	*
+	* The generated SQL (PostgreSQL):
+	*
+	* ```sql
+	* select "person"."id", count("pet"."id") as "person_count"
+	* from "person"
+	* inner join "pet" on "pet"."owner_id" = "person"."id"
+	* group by "person"."id"
+	* having count("pet"."id") > $1
+	* ```
+	*
+	* Why "somewhat" type-safe? Because the function calls are not bound to the
+	* current query context. They allow you to reference columns and tables that
+	* are not in the current query. E.g. remove the `innerJoin` from the previous
+	* query and TypeScript won't even complain.
+	*
+	* If you want to make the function calls fully type-safe, you can use the
+	* {@link ExpressionBuilder.fn} getter for a query context-aware, stricter {@link FunctionModule}.
+	*
+	* ```ts
+	* await db.selectFrom('person')
+	*   .innerJoin('pet', 'pet.owner_id', 'person.id')
+	*   .select((eb) => [
+	*     'person.id',
+	*     eb.fn.count('pet.id').as('pet_count')
+	*   ])
+	*   .groupBy('person.id')
+	*   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+	*   .execute()
+	* ```
+	*/
+	get fn() {
+		return createFunctionModule();
+	}
+	/**
+	* Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
+	*
+	* The returned {@link TransactionBuilder} can be used to configure the transaction. The
+	* {@link TransactionBuilder.execute} method can then be called to run the transaction.
+	* {@link TransactionBuilder.execute} takes a function that is run inside the
+	* transaction. If the function throws an exception,
+	* 1. the exception is caught,
+	* 2. the transaction is rolled back, and
+	* 3. the exception is thrown again.
+	* Otherwise the transaction is committed.
+	*
+	* The callback function passed to the {@link TransactionBuilder.execute | execute}
+	* method gets the transaction object as its only argument. The transaction is
+	* of type {@link Transaction} which inherits {@link Kysely}. Any query
+	* started through the transaction object is executed inside the transaction.
+	*
+	* To run a controlled transaction, allowing you to commit and rollback manually,
+	* use {@link startTransaction} instead.
+	*
+	* ### Examples
+	*
+	* <!-- siteExample("transactions", "Simple transaction", 10) -->
+	*
+	* This example inserts two rows in a transaction. If an exception is thrown inside
+	* the callback passed to the `execute` method,
+	* 1. the exception is caught,
+	* 2. the transaction is rolled back, and
+	* 3. the exception is thrown again.
+	* Otherwise the transaction is committed.
+	*
+	* ```ts
+	* const catto = await db.transaction().execute(async (trx) => {
+	*   const jennifer = await trx.insertInto('person')
+	*     .values({
+	*       first_name: 'Jennifer',
+	*       last_name: 'Aniston',
+	*       age: 40,
+	*     })
+	*     .returning('id')
+	*     .executeTakeFirstOrThrow()
+	*
+	*   return await trx.insertInto('pet')
+	*     .values({
+	*       owner_id: jennifer.id,
+	*       name: 'Catto',
+	*       species: 'cat',
+	*       is_favorite: false,
+	*     })
+	*     .returningAll()
+	*     .executeTakeFirst()
+	* })
+	* ```
+	*
+	* Setting the isolation level:
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	*
+	* await db
+	*   .transaction()
+	*   .setIsolationLevel('serializable')
+	*   .execute(async (trx) => {
+	*     await doStuff(trx)
+	*   })
+	*
+	* async function doStuff(kysely: typeof db) {
+	*   // ...
+	* }
+	* ```
+	*/
+	transaction() {
+		return new TransactionBuilder({ ...this.#props });
+	}
+	/**
+	* Creates a {@link ControlledTransactionBuilder} that can be used to run queries inside a controlled transaction.
+	*
+	* The returned {@link ControlledTransactionBuilder} can be used to configure the transaction.
+	* The {@link ControlledTransactionBuilder.execute} method can then be called
+	* to start the transaction and return a {@link ControlledTransaction}.
+	*
+	* A {@link ControlledTransaction} allows you to commit and rollback manually,
+	* execute savepoint commands. It extends {@link Transaction} which extends {@link Kysely},
+	* so you can run queries inside the transaction. Once the transaction is committed,
+	* or rolled back, it can't be used anymore - all queries will throw an error.
+	* This is to prevent accidentally running queries outside the transaction - where
+	* atomicity is not guaranteed anymore.
+	*
+	* ### Examples
+	*
+	* <!-- siteExample("transactions", "Controlled transaction", 11) -->
+	*
+	* A controlled transaction allows you to commit and rollback manually, execute
+	* savepoint commands, and queries in general.
+	*
+	* In this example we start a transaction, use it to insert two rows and then commit
+	* the transaction. If an error is thrown, we catch it and rollback the transaction.
+	*
+	* ```ts
+	* const trx = await db.startTransaction().execute()
+	*
+	* try {
+	*   const jennifer = await trx.insertInto('person')
+	*     .values({
+	*       first_name: 'Jennifer',
+	*       last_name: 'Aniston',
+	*       age: 40,
+	*     })
+	*     .returning('id')
+	*     .executeTakeFirstOrThrow()
+	*
+	*   const catto = await trx.insertInto('pet')
+	*     .values({
+	*       owner_id: jennifer.id,
+	*       name: 'Catto',
+	*       species: 'cat',
+	*       is_favorite: false,
+	*     })
+	*     .returningAll()
+	*     .executeTakeFirstOrThrow()
+	*
+	*   await trx.commit().execute()
+	*
+	*   // ...
+	* } catch (error) {
+	*   await trx.rollback().execute()
+	* }
+	* ```
+	*
+	* <!-- siteExample("transactions", "Controlled transaction /w savepoints", 12) -->
+	*
+	* A controlled transaction allows you to commit and rollback manually, execute
+	* savepoint commands, and queries in general.
+	*
+	* In this example we start a transaction, insert a person, create a savepoint,
+	* try inserting a toy and a pet, and if an error is thrown, we rollback to the
+	* savepoint. Eventually we release the savepoint, insert an audit record and
+	* commit the transaction. If an error is thrown, we catch it and rollback the
+	* transaction.
+	*
+	* ```ts
+	* const trx = await db.startTransaction().execute()
+	*
+	* try {
+	*   const jennifer = await trx
+	*     .insertInto('person')
+	*     .values({
+	*       first_name: 'Jennifer',
+	*       last_name: 'Aniston',
+	*       age: 40,
+	*     })
+	*     .returning('id')
+	*     .executeTakeFirstOrThrow()
+	*
+	*   const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+	*
+	*   try {
+	*     const catto = await trxAfterJennifer
+	*       .insertInto('pet')
+	*       .values({
+	*         owner_id: jennifer.id,
+	*         name: 'Catto',
+	*         species: 'cat',
+	*       })
+	*       .returning('id')
+	*       .executeTakeFirstOrThrow()
+	*
+	*     await trxAfterJennifer
+	*       .insertInto('toy')
+	*       .values({ name: 'Bone', price: 1.99, pet_id: catto.id })
+	*       .execute()
+	*   } catch (error) {
+	*     await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+	*   }
+	*
+	*   await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+	*
+	*   await trx.insertInto('audit').values({ action: 'added Jennifer' }).execute()
+	*
+	*   await trx.commit().execute()
+	* } catch (error) {
+	*   await trx.rollback().execute()
+	* }
+	* ```
+	*/
+	startTransaction() {
+		return new ControlledTransactionBuilder({ ...this.#props });
+	}
+	/**
+	* Provides a kysely instance bound to a single database connection.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* await db
+	*   .connection()
+	*   .execute(async (db) => {
+	*     // `db` is an instance of `Kysely` that's bound to a single
+	*     // database connection. All queries executed through `db` use
+	*     // the same connection.
+	*     await doStuff(db)
+	*   })
+	*
+	* async function doStuff(kysely: typeof db) {
+	*   // ...
+	* }
+	* ```
+	*/
+	connection() {
+		return new ConnectionBuilder({ ...this.#props });
+	}
+	/**
+	* Returns a copy of this Kysely instance with the given plugin installed.
+	*/
+	withPlugin(plugin) {
+		return new Kysely({
+			...this.#props,
+			executor: this.#props.executor.withPlugin(plugin)
+		});
+	}
+	/**
+	* Returns a copy of this Kysely instance without any plugins.
+	*/
+	withoutPlugins() {
+		return new Kysely({
+			...this.#props,
+			executor: this.#props.executor.withoutPlugins()
+		});
+	}
+	/**
+	* @override
+	*/
+	withSchema(schema) {
+		return new Kysely({
+			...this.#props,
+			executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
+		});
+	}
+	/**
+	* Returns a copy of this Kysely instance with tables added to its
+	* database type.
+	*
+	* This method only modifies the types and doesn't affect any of the
+	* executed queries in any way.
+	*
+	* ### Examples
+	*
+	* The following example adds and uses a temporary table:
+	*
+	* ```ts
+	* await db.schema
+	*   .createTable('temp_table')
+	*   .temporary()
+	*   .addColumn('some_column', 'integer')
+	*   .execute()
+	*
+	* const tempDb = db.withTables<{
+	*   temp_table: {
+	*     some_column: number
+	*   }
+	* }>()
+	*
+	* await tempDb
+	*   .insertInto('temp_table')
+	*   .values({ some_column: 100 })
+	*   .execute()
+	* ```
+	*/
+	withTables() {
+		return new Kysely({ ...this.#props });
+	}
+	/**
+	* Releases all resources and disconnects from the database.
+	*
+	* You need to call this when you are done using the `Kysely` instance.
+	*/
+	async destroy() {
+		await this.#props.driver.destroy();
+	}
+	/**
+	* Returns true if this `Kysely` instance is a transaction.
+	*
+	* You can also use `db instanceof Transaction`.
+	*/
+	get isTransaction() {
+		return false;
+	}
+	/**
+	* @internal
+	* @private
+	*/
+	getExecutor() {
+		return this.#props.executor;
+	}
+	/**
+	* Executes a given compiled query or query builder.
+	*
+	* See {@link https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0004-splitting-query-building-and-execution.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+	*/
+	executeQuery(query, queryId) {
+		if (queryId !== void 0) logOnce("Passing `queryId` in `db.executeQuery` is deprecated and will result in a compile-time error in the future.");
+		const compiledQuery = isCompilable(query) ? query.compile() : query;
+		return this.getExecutor().executeQuery(compiledQuery);
+	}
+	async [Symbol.asyncDispose]() {
+		await this.destroy();
+	}
+};
+var Transaction = class Transaction extends Kysely {
+	#props;
+	constructor(props) {
+		super(props);
+		this.#props = props;
+	}
+	get isTransaction() {
+		return true;
+	}
+	transaction() {
+		throw new Error("calling the transaction method for a Transaction is not supported");
+	}
+	connection() {
+		throw new Error("calling the connection method for a Transaction is not supported");
+	}
+	async destroy() {
+		throw new Error("calling the destroy method for a Transaction is not supported");
+	}
+	withPlugin(plugin) {
+		return new Transaction({
+			...this.#props,
+			executor: this.#props.executor.withPlugin(plugin)
+		});
+	}
+	withoutPlugins() {
+		return new Transaction({
+			...this.#props,
+			executor: this.#props.executor.withoutPlugins()
+		});
+	}
+	withSchema(schema) {
+		return new Transaction({
+			...this.#props,
+			executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
+		});
+	}
+	withTables() {
+		return new Transaction({ ...this.#props });
+	}
+};
+function isKyselyProps(obj) {
+	return isObject(obj) && isObject(obj.config) && isObject(obj.driver) && isObject(obj.executor) && isObject(obj.dialect);
+}
+var ConnectionBuilder = class {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	async execute(callback) {
+		return this.#props.executor.provideConnection(async (connection) => {
+			const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+			return await callback(new Kysely({
+				...this.#props,
+				executor
+			}));
+		});
+	}
+};
+var TransactionBuilder = class TransactionBuilder {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	setAccessMode(accessMode) {
+		return new TransactionBuilder({
+			...this.#props,
+			accessMode
+		});
+	}
+	setIsolationLevel(isolationLevel) {
+		return new TransactionBuilder({
+			...this.#props,
+			isolationLevel
+		});
+	}
+	async execute(callback) {
+		const { isolationLevel, accessMode,...kyselyProps } = this.#props;
+		const settings = {
+			isolationLevel,
+			accessMode
+		};
+		validateTransactionSettings(settings);
+		return this.#props.executor.provideConnection(async (connection) => {
+			const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+			const transaction = new Transaction({
+				...kyselyProps,
+				executor
+			});
+			let transactionBegun = false;
+			try {
+				await this.#props.driver.beginTransaction(connection, settings);
+				transactionBegun = true;
+				const result = await callback(transaction);
+				await this.#props.driver.commitTransaction(connection);
+				return result;
+			} catch (error) {
+				if (transactionBegun) await this.#props.driver.rollbackTransaction(connection);
+				throw error;
+			}
+		});
+	}
+};
+var ControlledTransactionBuilder = class ControlledTransactionBuilder {
+	#props;
+	constructor(props) {
+		this.#props = freeze(props);
+	}
+	setAccessMode(accessMode) {
+		return new ControlledTransactionBuilder({
+			...this.#props,
+			accessMode
+		});
+	}
+	setIsolationLevel(isolationLevel) {
+		return new ControlledTransactionBuilder({
+			...this.#props,
+			isolationLevel
+		});
+	}
+	async execute() {
+		const { isolationLevel, accessMode,...props } = this.#props;
+		const settings = {
+			isolationLevel,
+			accessMode
+		};
+		validateTransactionSettings(settings);
+		const connection = await provideControlledConnection(this.#props.executor);
+		await this.#props.driver.beginTransaction(connection.connection, settings);
+		return new ControlledTransaction({
+			...props,
+			connection,
+			executor: this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection.connection))
+		});
+	}
+};
+var ControlledTransaction = class ControlledTransaction extends Transaction {
+	#props;
+	#compileQuery;
+	#state;
+	constructor(props) {
+		const state = {
+			isCommitted: false,
+			isRolledBack: false
+		};
+		props = {
+			...props,
+			executor: new NotCommittedOrRolledBackAssertingExecutor(props.executor, state)
+		};
+		const { connection,...transactionProps } = props;
+		super(transactionProps);
+		this.#props = freeze(props);
+		this.#state = state;
+		const queryId = createQueryId();
+		this.#compileQuery = (node) => props.executor.compileQuery(node, queryId);
+	}
+	get isCommitted() {
+		return this.#state.isCommitted;
+	}
+	get isRolledBack() {
+		return this.#state.isRolledBack;
+	}
+	/**
+	* Commits the transaction.
+	*
+	* See {@link rollback}.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const trx = await db.startTransaction().execute()
+	*
+	* try {
+	*   await doSomething(trx)
+	*
+	*   await trx.commit().execute()
+	* } catch (error) {
+	*   await trx.rollback().execute()
+	* }
+	*
+	* async function doSomething(kysely: Kysely<Database>) {}
+	* ```
+	*/
+	commit() {
+		assertNotCommittedOrRolledBack(this.#state);
+		return new Command(async () => {
+			await this.#props.driver.commitTransaction(this.#props.connection.connection);
+			this.#state.isCommitted = true;
+			this.#props.connection.release();
+		});
+	}
+	/**
+	* Rolls back the transaction.
+	*
+	* See {@link commit} and {@link rollbackToSavepoint}.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const trx = await db.startTransaction().execute()
+	*
+	* try {
+	*   await doSomething(trx)
+	*
+	*   await trx.commit().execute()
+	* } catch (error) {
+	*   await trx.rollback().execute()
+	* }
+	*
+	* async function doSomething(kysely: Kysely<Database>) {}
+	* ```
+	*/
+	rollback() {
+		assertNotCommittedOrRolledBack(this.#state);
+		return new Command(async () => {
+			await this.#props.driver.rollbackTransaction(this.#props.connection.connection);
+			this.#state.isRolledBack = true;
+			this.#props.connection.release();
+		});
+	}
+	/**
+	* Creates a savepoint with a given name.
+	*
+	* See {@link rollbackToSavepoint} and {@link releaseSavepoint}.
+	*
+	* For a type-safe experience, you should use the returned instance from now on.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const trx = await db.startTransaction().execute()
+	*
+	* await insertJennifer(trx)
+	*
+	* const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+	*
+	* try {
+	*   await doSomething(trxAfterJennifer)
+	* } catch (error) {
+	*   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+	* }
+	*
+	* async function insertJennifer(kysely: Kysely<Database>) {}
+	* async function doSomething(kysely: Kysely<Database>) {}
+	* ```
+	*/
+	savepoint(savepointName) {
+		assertNotCommittedOrRolledBack(this.#state);
+		return new Command(async () => {
+			await this.#props.driver.savepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+			return new ControlledTransaction({ ...this.#props });
+		});
+	}
+	/**
+	* Rolls back to a savepoint with a given name.
+	*
+	* See {@link savepoint} and {@link releaseSavepoint}.
+	*
+	* You must use the same instance returned by {@link savepoint}, or
+	* escape the type-check by using `as any`.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const trx = await db.startTransaction().execute()
+	*
+	* await insertJennifer(trx)
+	*
+	* const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+	*
+	* try {
+	*   await doSomething(trxAfterJennifer)
+	* } catch (error) {
+	*   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+	* }
+	*
+	* async function insertJennifer(kysely: Kysely<Database>) {}
+	* async function doSomething(kysely: Kysely<Database>) {}
+	* ```
+	*/
+	rollbackToSavepoint(savepointName) {
+		assertNotCommittedOrRolledBack(this.#state);
+		return new Command(async () => {
+			await this.#props.driver.rollbackToSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+			return new ControlledTransaction({ ...this.#props });
+		});
+	}
+	/**
+	* Releases a savepoint with a given name.
+	*
+	* See {@link savepoint} and {@link rollbackToSavepoint}.
+	*
+	* You must use the same instance returned by {@link savepoint}, or
+	* escape the type-check by using `as any`.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { Kysely } from 'kysely'
+	* import type { Database } from 'type-editor' // imaginary module
+	*
+	* const trx = await db.startTransaction().execute()
+	*
+	* await insertJennifer(trx)
+	*
+	* const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+	*
+	* try {
+	*   await doSomething(trxAfterJennifer)
+	* } catch (error) {
+	*   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+	* }
+	*
+	* await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+	*
+	* await doSomethingElse(trx)
+	*
+	* async function insertJennifer(kysely: Kysely<Database>) {}
+	* async function doSomething(kysely: Kysely<Database>) {}
+	* async function doSomethingElse(kysely: Kysely<Database>) {}
+	* ```
+	*/
+	releaseSavepoint(savepointName) {
+		assertNotCommittedOrRolledBack(this.#state);
+		return new Command(async () => {
+			await this.#props.driver.releaseSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+			return new ControlledTransaction({ ...this.#props });
+		});
+	}
+	withPlugin(plugin) {
+		return new ControlledTransaction({
+			...this.#props,
+			executor: this.#props.executor.withPlugin(plugin)
+		});
+	}
+	withoutPlugins() {
+		return new ControlledTransaction({
+			...this.#props,
+			executor: this.#props.executor.withoutPlugins()
+		});
+	}
+	withSchema(schema) {
+		return new ControlledTransaction({
+			...this.#props,
+			executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
+		});
+	}
+	withTables() {
+		return new ControlledTransaction({ ...this.#props });
+	}
+};
+var Command = class {
+	#cb;
+	constructor(cb) {
+		this.#cb = cb;
+	}
+	/**
+	* Executes the command.
+	*/
+	async execute() {
+		return await this.#cb();
+	}
+};
+function assertNotCommittedOrRolledBack(state) {
+	if (state.isCommitted) throw new Error("Transaction is already committed");
+	if (state.isRolledBack) throw new Error("Transaction is already rolled back");
+}
+/**
+* An executor wrapper that asserts that the transaction state is not committed
+* or rolled back when a query is executed.
+*
+* @internal
+*/
+var NotCommittedOrRolledBackAssertingExecutor = class NotCommittedOrRolledBackAssertingExecutor {
+	#executor;
+	#state;
+	constructor(executor, state) {
+		if (executor instanceof NotCommittedOrRolledBackAssertingExecutor) this.#executor = executor.#executor;
+		else this.#executor = executor;
+		this.#state = state;
+	}
+	get adapter() {
+		return this.#executor.adapter;
+	}
+	get plugins() {
+		return this.#executor.plugins;
+	}
+	transformQuery(node, queryId) {
+		return this.#executor.transformQuery(node, queryId);
+	}
+	compileQuery(node, queryId) {
+		return this.#executor.compileQuery(node, queryId);
+	}
+	provideConnection(consumer) {
+		return this.#executor.provideConnection(consumer);
+	}
+	executeQuery(compiledQuery) {
+		assertNotCommittedOrRolledBack(this.#state);
+		return this.#executor.executeQuery(compiledQuery);
+	}
+	stream(compiledQuery, chunkSize) {
+		assertNotCommittedOrRolledBack(this.#state);
+		return this.#executor.stream(compiledQuery, chunkSize);
+	}
+	withConnectionProvider(connectionProvider) {
+		return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withConnectionProvider(connectionProvider), this.#state);
+	}
+	withPlugin(plugin) {
+		return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugin(plugin), this.#state);
+	}
+	withPlugins(plugins) {
+		return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugins(plugins), this.#state);
+	}
+	withPluginAtFront(plugin) {
+		return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPluginAtFront(plugin), this.#state);
+	}
+	withoutPlugins() {
+		return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withoutPlugins(), this.#state);
+	}
+};
+
+//#endregion
+export { Command, ConnectionBuilder, ControlledTransaction, ControlledTransactionBuilder, Kysely, Transaction, TransactionBuilder, isKyselyProps };
+//# sourceMappingURL=kysely.js.map