@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/kysely.js.map

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

@@ -0,0 +1,52 @@
+import { __commonJS, __require } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_object_utils } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/file-migration-provider.js
+var require_file_migration_provider = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/file-migration-provider.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.FileMigrationProvider = void 0;
+	const object_utils_js_1 = require_object_utils();
+	/**
+	* Reads all migrations from a folder in node.js.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import { promises as fs } from 'node:fs'
+	* import path from 'node:path'
+	*
+	* new FileMigrationProvider({
+	*   fs,
+	*   path,
+	*   migrationFolder: 'path/to/migrations/folder'
+	* })
+	* ```
+	*/
+	var FileMigrationProvider = class {
+		#props;
+		constructor(props) {
+			this.#props = props;
+		}
+		async getMigrations() {
+			const migrations = {};
+			const files = await this.#props.fs.readdir(this.#props.migrationFolder);
+			for (const fileName of files) if (fileName.endsWith(".js") || fileName.endsWith(".ts") && !fileName.endsWith(".d.ts") || fileName.endsWith(".mjs") || fileName.endsWith(".mts") && !fileName.endsWith(".d.mts")) {
+				const migration = await Promise.resolve(`${this.#props.path.join(this.#props.migrationFolder, fileName)}`).then((s) => __require(s));
+				const migrationKey = fileName.substring(0, fileName.lastIndexOf("."));
+				if (isMigration(migration?.default)) migrations[migrationKey] = migration.default;
+				else if (isMigration(migration)) migrations[migrationKey] = migration;
+			}
+			return migrations;
+		}
+	};
+	exports.FileMigrationProvider = FileMigrationProvider;
+	function isMigration(obj) {
+		return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.up);
+	}
+}) });
+
+//#endregion
+export default require_file_migration_provider();
+
+export { require_file_migration_provider };
+//# sourceMappingURL=file-migration-provider.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/file-migration-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-migration-provider.js","names":["#props"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/file-migration-provider.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.FileMigrationProvider = void 0;\nconst object_utils_js_1 = require(\"../util/object-utils.js\");\n/**\n * Reads all migrations from a folder in node.js.\n *\n * ### Examples\n *\n * ```ts\n * import { promises as fs } from 'node:fs'\n * import path from 'node:path'\n *\n * new FileMigrationProvider({\n *   fs,\n *   path,\n *   migrationFolder: 'path/to/migrations/folder'\n * })\n * ```\n */\nclass FileMigrationProvider {\n    #props;\n    constructor(props) {\n        this.#props = props;\n    }\n    async getMigrations() {\n        const migrations = {};\n        const files = await this.#props.fs.readdir(this.#props.migrationFolder);\n        for (const fileName of files) {\n            if (fileName.endsWith('.js') ||\n                (fileName.endsWith('.ts') && !fileName.endsWith('.d.ts')) ||\n                fileName.endsWith('.mjs') ||\n                (fileName.endsWith('.mts') && !fileName.endsWith('.d.mts'))) {\n                const migration = await Promise.resolve(`${\n                /* webpackIgnore: true */ this.#props.path.join(this.#props.migrationFolder, fileName)}`).then(s => require(s));\n                const migrationKey = fileName.substring(0, fileName.lastIndexOf('.'));\n                // Handle esModuleInterop export's `default` prop...\n                if (isMigration(migration?.default)) {\n                    migrations[migrationKey] = migration.default;\n                }\n                else if (isMigration(migration)) {\n                    migrations[migrationKey] = migration;\n                }\n            }\n        }\n        return migrations;\n    }\n}\nexports.FileMigrationProvider = FileMigrationProvider;\nfunction isMigration(obj) {\n    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.up);\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB,KAAK;CACrC,MAAM;;;;;;;;;;;;;;;;;CAiBN,IAAM,wBAAN,MAA4B;EACxB;EACA,YAAY,OAAO;AACf,SAAKA,QAAS;;EAElB,MAAM,gBAAgB;GAClB,MAAM,aAAa,EAAE;GACrB,MAAM,QAAQ,MAAM,MAAKA,MAAO,GAAG,QAAQ,MAAKA,MAAO,gBAAgB;AACvE,QAAK,MAAM,YAAY,MACnB,KAAI,SAAS,SAAS,MAAM,IACvB,SAAS,SAAS,MAAM,IAAI,CAAC,SAAS,SAAS,QAAQ,IACxD,SAAS,SAAS,OAAO,IACxB,SAAS,SAAS,OAAO,IAAI,CAAC,SAAS,SAAS,SAAS,EAAG;IAC7D,MAAM,YAAY,MAAM,QAAQ,QAAQ,GACd,MAAKA,MAAO,KAAK,KAAK,MAAKA,MAAO,iBAAiB,SAAS,GAAG,CAAC,MAAK,gBAAa,EAAE,CAAC;IAC/G,MAAM,eAAe,SAAS,UAAU,GAAG,SAAS,YAAY,IAAI,CAAC;AAErE,QAAI,YAAY,WAAW,QAAQ,CAC/B,YAAW,gBAAgB,UAAU;aAEhC,YAAY,UAAU,CAC3B,YAAW,gBAAgB;;AAIvC,UAAO;;;AAGf,SAAQ,wBAAwB;CAChC,SAAS,YAAY,KAAK;AACtB,UAAQ,GAAG,kBAAkB,UAAU,IAAI,KAAK,GAAG,kBAAkB,YAAY,IAAI,GAAG"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/migrator.js

@@ -0,0 +1,499 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_object_utils } from "../util/object-utils.js";
+import { require_with_schema_plugin } from "../plugin/with-schema/with-schema-plugin.js";
+import { require_noop_plugin } from "../plugin/noop-plugin.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/migrator.js
+var require_migrator = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/migration/migrator.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.DEFAULT_ALLOW_UNORDERED_MIGRATIONS = exports.DEFAULT_MIGRATION_LOCK_TABLE = exports.DEFAULT_MIGRATION_TABLE = void 0;
+	const noop_plugin_js_1 = require_noop_plugin();
+	const with_schema_plugin_js_1 = require_with_schema_plugin();
+	const object_utils_js_1 = require_object_utils();
+	exports.DEFAULT_MIGRATION_TABLE = "kysely_migration";
+	exports.DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
+	exports.DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
+	exports.MIGRATION_LOCK_ID = "migration_lock";
+	exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true });
+	/**
+	* A class for running migrations.
+	*
+	* ### Example
+	*
+	* This example uses the {@link FileMigrationProvider} that reads migrations
+	* files from a single folder. You can easily implement your own
+	* {@link MigrationProvider} if you want to provide migrations some
+	* other way.
+	*
+	* ```ts
+	* import { promises as fs } from 'node:fs'
+	* import path from 'node:path'
+	* import * as Sqlite from 'better-sqlite3'
+	* import {
+	*   FileMigrationProvider,
+	*   Kysely,
+	*   Migrator,
+	*   SqliteDialect
+	* } from 'kysely'
+	*
+	* const db = new Kysely<any>({
+	*   dialect: new SqliteDialect({
+	*     database: Sqlite(':memory:')
+	*   })
+	* })
+	*
+	* const migrator = new Migrator({
+	*   db,
+	*   provider: new FileMigrationProvider({
+	*     fs,
+	*     // Path to the folder that contains all your migrations.
+	*     migrationFolder: 'some/path/to/migrations',
+	*     path,
+	*   })
+	* })
+	* ```
+	*/
+	var Migrator = class {
+		#props;
+		constructor(props) {
+			this.#props = (0, object_utils_js_1.freeze)(props);
+		}
+		/**
+		* Returns a {@link MigrationInfo} object for each migration.
+		*
+		* The returned array is sorted by migration name.
+		*/
+		async getMigrations() {
+			const executedMigrations = await this.#doesTableExist(this.#migrationTable) ? await this.#props.db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationTable).select(["name", "timestamp"]).$narrowType().execute() : [];
+			return (await this.#resolveMigrations()).map(({ name,...migration }) => {
+				const executed = executedMigrations.find((it) => it.name === name);
+				return {
+					name,
+					migration,
+					executedAt: executed ? new Date(executed.timestamp) : void 0
+				};
+			});
+		}
+		/**
+		* Runs all migrations that have not yet been run.
+		*
+		* This method returns a {@link MigrationResultSet} instance and _never_ throws.
+		* {@link MigrationResultSet.error} holds the error if something went wrong.
+		* {@link MigrationResultSet.results} contains information about which migrations
+		* were executed and which failed. See the examples below.
+		*
+		* This method goes through all possible migrations provided by the provider and runs the
+		* ones whose names come alphabetically after the last migration that has been run. If the
+		* list of executed migrations doesn't match the beginning of the list of possible migrations
+		* an error is returned.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { promises as fs } from 'node:fs'
+		* import path from 'node:path'
+		* import * as Sqlite from 'better-sqlite3'
+		* import { FileMigrationProvider, Migrator } from 'kysely'
+		*
+		* const migrator = new Migrator({
+		*   db,
+		*   provider: new FileMigrationProvider({
+		*     fs,
+		*     migrationFolder: 'some/path/to/migrations',
+		*     path,
+		*   })
+		* })
+		*
+		* const { error, results } = await migrator.migrateToLatest()
+		*
+		* results?.forEach((it) => {
+		*   if (it.status === 'Success') {
+		*     console.log(`migration "${it.migrationName}" was executed successfully`)
+		*   } else if (it.status === 'Error') {
+		*     console.error(`failed to execute migration "${it.migrationName}"`)
+		*   }
+		* })
+		*
+		* if (error) {
+		*   console.error('failed to run `migrateToLatest`')
+		*   console.error(error)
+		* }
+		* ```
+		*/
+		async migrateToLatest() {
+			return this.#migrate(() => ({
+				direction: "Up",
+				step: Infinity
+			}));
+		}
+		/**
+		* Migrate up/down to a specific migration.
+		*
+		* This method returns a {@link MigrationResultSet} instance and _never_ throws.
+		* {@link MigrationResultSet.error} holds the error if something went wrong.
+		* {@link MigrationResultSet.results} contains information about which migrations
+		* were executed and which failed.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { promises as fs } from 'node:fs'
+		* import path from 'node:path'
+		* import { FileMigrationProvider, Migrator } from 'kysely'
+		*
+		* const migrator = new Migrator({
+		*   db,
+		*   provider: new FileMigrationProvider({
+		*     fs,
+		*     // Path to the folder that contains all your migrations.
+		*     migrationFolder: 'some/path/to/migrations',
+		*     path,
+		*   })
+		* })
+		*
+		* await migrator.migrateTo('some_migration')
+		* ```
+		*
+		* If you specify the name of the first migration, this method migrates
+		* down to the first migration, but doesn't run the `down` method of
+		* the first migration. In case you want to migrate all the way down,
+		* you can use a special constant `NO_MIGRATIONS`:
+		*
+		* ```ts
+		* import { promises as fs } from 'node:fs'
+		* import path from 'node:path'
+		* import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'
+		*
+		* const migrator = new Migrator({
+		*   db,
+		*   provider: new FileMigrationProvider({
+		*     fs,
+		*     // Path to the folder that contains all your migrations.
+		*     migrationFolder: 'some/path/to/migrations',
+		*     path,
+		*   })
+		* })
+		*
+		* await migrator.migrateTo(NO_MIGRATIONS)
+		* ```
+		*/
+		async migrateTo(targetMigrationName) {
+			return this.#migrate(({ migrations, executedMigrations, pendingMigrations }) => {
+				if ((0, object_utils_js_1.isObject)(targetMigrationName) && targetMigrationName.__noMigrations__ === true) return {
+					direction: "Down",
+					step: Infinity
+				};
+				if (!migrations.find((m) => m.name === targetMigrationName)) throw new Error(`migration "${targetMigrationName}" doesn't exist`);
+				const executedIndex = executedMigrations.indexOf(targetMigrationName);
+				const pendingIndex = pendingMigrations.findIndex((m) => m.name === targetMigrationName);
+				if (executedIndex !== -1) return {
+					direction: "Down",
+					step: executedMigrations.length - executedIndex - 1
+				};
+				else if (pendingIndex !== -1) return {
+					direction: "Up",
+					step: pendingIndex + 1
+				};
+				else throw new Error(`migration "${targetMigrationName}" isn't executed or pending`);
+			});
+		}
+		/**
+		* Migrate one step up.
+		*
+		* This method returns a {@link MigrationResultSet} instance and _never_ throws.
+		* {@link MigrationResultSet.error} holds the error if something went wrong.
+		* {@link MigrationResultSet.results} contains information about which migrations
+		* were executed and which failed.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { promises as fs } from 'node:fs'
+		* import path from 'node:path'
+		* import { FileMigrationProvider, Migrator } from 'kysely'
+		*
+		* const migrator = new Migrator({
+		*   db,
+		*   provider: new FileMigrationProvider({
+		*     fs,
+		*     // Path to the folder that contains all your migrations.
+		*     migrationFolder: 'some/path/to/migrations',
+		*     path,
+		*   })
+		* })
+		*
+		* await migrator.migrateUp()
+		* ```
+		*/
+		async migrateUp() {
+			return this.#migrate(() => ({
+				direction: "Up",
+				step: 1
+			}));
+		}
+		/**
+		* Migrate one step down.
+		*
+		* This method returns a {@link MigrationResultSet} instance and _never_ throws.
+		* {@link MigrationResultSet.error} holds the error if something went wrong.
+		* {@link MigrationResultSet.results} contains information about which migrations
+		* were executed and which failed.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* import { promises as fs } from 'node:fs'
+		* import path from 'node:path'
+		* import { FileMigrationProvider, Migrator } from 'kysely'
+		*
+		* const migrator = new Migrator({
+		*   db,
+		*   provider: new FileMigrationProvider({
+		*     fs,
+		*     // Path to the folder that contains all your migrations.
+		*     migrationFolder: 'some/path/to/migrations',
+		*     path,
+		*   })
+		* })
+		*
+		* await migrator.migrateDown()
+		* ```
+		*/
+		async migrateDown() {
+			return this.#migrate(() => ({
+				direction: "Down",
+				step: 1
+			}));
+		}
+		async #migrate(getMigrationDirectionAndStep) {
+			try {
+				await this.#ensureMigrationTableSchemaExists();
+				await this.#ensureMigrationTableExists();
+				await this.#ensureMigrationLockTableExists();
+				await this.#ensureLockRowExists();
+				return await this.#runMigrations(getMigrationDirectionAndStep);
+			} catch (error) {
+				if (error instanceof MigrationResultSetError) return error.resultSet;
+				return { error };
+			}
+		}
+		get #migrationTableSchema() {
+			return this.#props.migrationTableSchema;
+		}
+		get #migrationTable() {
+			return this.#props.migrationTableName ?? exports.DEFAULT_MIGRATION_TABLE;
+		}
+		get #migrationLockTable() {
+			return this.#props.migrationLockTableName ?? exports.DEFAULT_MIGRATION_LOCK_TABLE;
+		}
+		get #allowUnorderedMigrations() {
+			return this.#props.allowUnorderedMigrations ?? exports.DEFAULT_ALLOW_UNORDERED_MIGRATIONS;
+		}
+		get #schemaPlugin() {
+			if (this.#migrationTableSchema) return new with_schema_plugin_js_1.WithSchemaPlugin(this.#migrationTableSchema);
+			return new noop_plugin_js_1.NoopPlugin();
+		}
+		async #ensureMigrationTableSchemaExists() {
+			if (!this.#migrationTableSchema) return;
+			if (await this.#doesSchemaExist()) return;
+			try {
+				await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+			} catch (error) {
+				if (!await this.#doesSchemaExist()) throw error;
+			}
+		}
+		async #ensureMigrationTableExists() {
+			if (await this.#doesTableExist(this.#migrationTable)) return;
+			try {
+				await this.#createIfNotExists(this.#props.db.schema.withPlugin(this.#schemaPlugin).createTable(this.#migrationTable).addColumn("name", "varchar(255)", (col) => col.notNull().primaryKey()).addColumn("timestamp", "varchar(255)", (col) => col.notNull()));
+			} catch (error) {
+				if (!await this.#doesTableExist(this.#migrationTable)) throw error;
+			}
+		}
+		async #ensureMigrationLockTableExists() {
+			if (await this.#doesTableExist(this.#migrationLockTable)) return;
+			try {
+				await this.#createIfNotExists(this.#props.db.schema.withPlugin(this.#schemaPlugin).createTable(this.#migrationLockTable).addColumn("id", "varchar(255)", (col) => col.notNull().primaryKey()).addColumn("is_locked", "integer", (col) => col.notNull().defaultTo(0)));
+			} catch (error) {
+				if (!await this.#doesTableExist(this.#migrationLockTable)) throw error;
+			}
+		}
+		async #ensureLockRowExists() {
+			if (await this.#doesLockRowExists()) return;
+			try {
+				await this.#props.db.withPlugin(this.#schemaPlugin).insertInto(this.#migrationLockTable).values({
+					id: exports.MIGRATION_LOCK_ID,
+					is_locked: 0
+				}).execute();
+			} catch (error) {
+				if (!await this.#doesLockRowExists()) throw error;
+			}
+		}
+		async #doesSchemaExist() {
+			return (await this.#props.db.introspection.getSchemas()).some((it) => it.name === this.#migrationTableSchema);
+		}
+		async #doesTableExist(tableName) {
+			const schema = this.#migrationTableSchema;
+			return (await this.#props.db.introspection.getTables({ withInternalKyselyTables: true })).some((it) => it.name === tableName && (!schema || it.schema === schema));
+		}
+		async #doesLockRowExists() {
+			return !!await this.#props.db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationLockTable).where("id", "=", exports.MIGRATION_LOCK_ID).select("id").executeTakeFirst();
+		}
+		async #runMigrations(getMigrationDirectionAndStep) {
+			const adapter = this.#props.db.getExecutor().adapter;
+			const lockOptions = (0, object_utils_js_1.freeze)({
+				lockTable: this.#props.migrationLockTableName ?? exports.DEFAULT_MIGRATION_LOCK_TABLE,
+				lockRowId: exports.MIGRATION_LOCK_ID,
+				lockTableSchema: this.#props.migrationTableSchema
+			});
+			const run = async (db) => {
+				try {
+					await adapter.acquireMigrationLock(db, lockOptions);
+					const state = await this.#getState(db);
+					if (state.migrations.length === 0) return { results: [] };
+					const { direction, step } = getMigrationDirectionAndStep(state);
+					if (step <= 0) return { results: [] };
+					if (direction === "Down") return await this.#migrateDown(db, state, step);
+					else if (direction === "Up") return await this.#migrateUp(db, state, step);
+					return { results: [] };
+				} finally {
+					await adapter.releaseMigrationLock(db, lockOptions);
+				}
+			};
+			if (adapter.supportsTransactionalDdl && !this.#props.disableTransactions) return this.#props.db.transaction().execute(run);
+			else return this.#props.db.connection().execute(run);
+		}
+		async #getState(db) {
+			const migrations = await this.#resolveMigrations();
+			const executedMigrations = await this.#getExecutedMigrations(db);
+			this.#ensureNoMissingMigrations(migrations, executedMigrations);
+			if (!this.#allowUnorderedMigrations) this.#ensureMigrationsInOrder(migrations, executedMigrations);
+			const pendingMigrations = this.#getPendingMigrations(migrations, executedMigrations);
+			return (0, object_utils_js_1.freeze)({
+				migrations,
+				executedMigrations,
+				lastMigration: (0, object_utils_js_1.getLast)(executedMigrations),
+				pendingMigrations
+			});
+		}
+		#getPendingMigrations(migrations, executedMigrations) {
+			return migrations.filter((migration) => {
+				return !executedMigrations.includes(migration.name);
+			});
+		}
+		async #resolveMigrations() {
+			const allMigrations = await this.#props.provider.getMigrations();
+			return Object.keys(allMigrations).sort().map((name) => ({
+				...allMigrations[name],
+				name
+			}));
+		}
+		async #getExecutedMigrations(db) {
+			const executedMigrations = await db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationTable).select(["name", "timestamp"]).$narrowType().execute();
+			const nameComparator = this.#props.nameComparator || ((a, b) => a.localeCompare(b));
+			return executedMigrations.sort((a, b) => {
+				if (a.timestamp === b.timestamp) return nameComparator(a.name, b.name);
+				return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
+			}).map((it) => it.name);
+		}
+		#ensureNoMissingMigrations(migrations, executedMigrations) {
+			for (const executed of executedMigrations) if (!migrations.some((it) => it.name === executed)) throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);
+		}
+		#ensureMigrationsInOrder(migrations, executedMigrations) {
+			for (let i = 0; i < executedMigrations.length; ++i) if (migrations[i].name !== executedMigrations[i]) throw new Error(`corrupted migrations: expected previously executed migration ${executedMigrations[i]} to be at index ${i} but ${migrations[i].name} was found in its place. New migrations must always have a name that comes alphabetically after the last executed migration.`);
+		}
+		async #migrateDown(db, state, step) {
+			const migrationsToRollback = state.executedMigrations.slice().reverse().slice(0, step).map((name) => {
+				return state.migrations.find((it) => it.name === name);
+			});
+			const results = migrationsToRollback.map((migration) => {
+				return {
+					migrationName: migration.name,
+					direction: "Down",
+					status: "NotExecuted"
+				};
+			});
+			for (let i = 0; i < results.length; ++i) {
+				const migration = migrationsToRollback[i];
+				try {
+					if (migration.down) {
+						await migration.down(db);
+						await db.withPlugin(this.#schemaPlugin).deleteFrom(this.#migrationTable).where("name", "=", migration.name).execute();
+						results[i] = {
+							migrationName: migration.name,
+							direction: "Down",
+							status: "Success"
+						};
+					}
+				} catch (error) {
+					results[i] = {
+						migrationName: migration.name,
+						direction: "Down",
+						status: "Error"
+					};
+					throw new MigrationResultSetError({
+						error,
+						results
+					});
+				}
+			}
+			return { results };
+		}
+		async #migrateUp(db, state, step) {
+			const results = state.pendingMigrations.slice(0, step).map((migration) => {
+				return {
+					migrationName: migration.name,
+					direction: "Up",
+					status: "NotExecuted"
+				};
+			});
+			for (let i = 0; i < results.length; i++) {
+				const migration = state.pendingMigrations[i];
+				try {
+					await migration.up(db);
+					await db.withPlugin(this.#schemaPlugin).insertInto(this.#migrationTable).values({
+						name: migration.name,
+						timestamp: (/* @__PURE__ */ new Date()).toISOString()
+					}).execute();
+					results[i] = {
+						migrationName: migration.name,
+						direction: "Up",
+						status: "Success"
+					};
+				} catch (error) {
+					results[i] = {
+						migrationName: migration.name,
+						direction: "Up",
+						status: "Error"
+					};
+					throw new MigrationResultSetError({
+						error,
+						results
+					});
+				}
+			}
+			return { results };
+		}
+		async #createIfNotExists(qb) {
+			if (this.#props.db.getExecutor().adapter.supportsCreateIfNotExists) qb = qb.ifNotExists();
+			await qb.execute();
+		}
+	};
+	exports.Migrator = Migrator;
+	var MigrationResultSetError = class extends Error {
+		#resultSet;
+		constructor(result) {
+			super();
+			this.#resultSet = result;
+		}
+		get resultSet() {
+			return this.#resultSet;
+		}
+	};
+}) });
+
+//#endregion
+export default require_migrator();
+
+export { require_migrator };
+//# sourceMappingURL=migrator.js.map