@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/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/esm/kysely.js"],"sourcesContent":["/// <reference types=\"./kysely.d.ts\" />\nimport { SchemaModule } from './schema/schema.js';\nimport { DynamicModule } from './dynamic/dynamic.js';\nimport { DefaultConnectionProvider } from './driver/default-connection-provider.js';\nimport { QueryCreator } from './query-creator.js';\nimport { DefaultQueryExecutor } from './query-executor/default-query-executor.js';\nimport { freeze, isObject, isUndefined } from './util/object-utils.js';\nimport { RuntimeDriver } from './driver/runtime-driver.js';\nimport { SingleConnectionProvider } from './driver/single-connection-provider.js';\nimport { validateTransactionSettings, } from './driver/driver.js';\nimport { createFunctionModule, } from './query-builder/function-module.js';\nimport { Log } from './util/log.js';\nimport { createQueryId } from './util/query-id.js';\nimport { isCompilable } from './util/compilable.js';\nimport { CaseBuilder } from './query-builder/case-builder.js';\nimport { CaseNode } from './operation-node/case-node.js';\nimport { parseExpression } from './parser/expression-parser.js';\nimport { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';\nimport { provideControlledConnection, } from './util/provide-controlled-connection.js';\nimport { logOnce } from './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 */\nexport class Kysely extends 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(args.log ?? []);\n            const runtimeDriver = new RuntimeDriver(driver, log);\n            const connectionProvider = new DefaultConnectionProvider(runtimeDriver);\n            const executor = new 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 = freeze(props);\n    }\n    /**\n     * Returns the {@link SchemaModule} module for building database schema.\n     */\n    get schema() {\n        return new 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 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 CaseBuilder({\n            node: CaseNode.create(isUndefined(value) ? undefined : 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 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 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            logOnce('Passing `queryId` in `db.executeQuery` is deprecated and will result in a compile-time error in the future.');\n        }\n        const compiledQuery = isCompilable(query) ? query.compile() : query;\n        return this.getExecutor().executeQuery(compiledQuery);\n    }\n    async [Symbol.asyncDispose]() {\n        await this.destroy();\n    }\n}\nexport class 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 WithSchemaPlugin(schema)),\n        });\n    }\n    withTables() {\n        return new Transaction({ ...this.#props });\n    }\n}\nexport function isKyselyProps(obj) {\n    return (isObject(obj) &&\n        isObject(obj.config) &&\n        isObject(obj.driver) &&\n        isObject(obj.executor) &&\n        isObject(obj.dialect));\n}\nexport class ConnectionBuilder {\n    #props;\n    constructor(props) {\n        this.#props = freeze(props);\n    }\n    async execute(callback) {\n        return this.#props.executor.provideConnection(async (connection) => {\n            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));\n            const db = new Kysely({\n                ...this.#props,\n                executor,\n            });\n            return await callback(db);\n        });\n    }\n}\nexport class TransactionBuilder {\n    #props;\n    constructor(props) {\n        this.#props = 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        validateTransactionSettings(settings);\n        return this.#props.executor.provideConnection(async (connection) => {\n            const executor = this.#props.executor.withConnectionProvider(new 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}\nexport class ControlledTransactionBuilder {\n    #props;\n    constructor(props) {\n        this.#props = 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        validateTransactionSettings(settings);\n        const connection = await 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 SingleConnectionProvider(connection.connection)),\n        });\n    }\n}\nexport class 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 = freeze(props);\n        this.#state = state;\n        const queryId = 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 WithSchemaPlugin(schema)),\n        });\n    }\n    withTables() {\n        return new ControlledTransaction({ ...this.#props });\n    }\n}\nexport class 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}\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/esm/migration/migrator.js

@@ -0,0 +1,11 @@
+import { freeze } from "../util/object-utils.js";
+import "../plugin/with-schema/with-schema-plugin.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/migration/migrator.js
+const DEFAULT_MIGRATION_TABLE = "kysely_migration";
+const DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
+const NO_MIGRATIONS = freeze({ __noMigrations__: true });
+
+//#endregion
+export { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE };
+//# sourceMappingURL=migrator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrator.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/migration/migrator.js"],"sourcesContent":["/// <reference types=\"./migrator.d.ts\" />\nimport { NoopPlugin } from '../plugin/noop-plugin.js';\nimport { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';\nimport { freeze, getLast, isObject } from '../util/object-utils.js';\nexport const DEFAULT_MIGRATION_TABLE = 'kysely_migration';\nexport const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';\nexport const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;\nexport const MIGRATION_LOCK_ID = 'migration_lock';\nexport const NO_MIGRATIONS = freeze({ __noMigrations__: true });\n/**\n * A class for running migrations.\n *\n * ### Example\n *\n * This example uses the {@link FileMigrationProvider} that reads migrations\n * files from a single folder. You can easily implement your own\n * {@link MigrationProvider} if you want to provide migrations some\n * other way.\n *\n * ```ts\n * import { promises as fs } from 'node:fs'\n * import path from 'node:path'\n * import * as Sqlite from 'better-sqlite3'\n * import {\n *   FileMigrationProvider,\n *   Kysely,\n *   Migrator,\n *   SqliteDialect\n * } from 'kysely'\n *\n * const db = new Kysely<any>({\n *   dialect: new SqliteDialect({\n *     database: Sqlite(':memory:')\n *   })\n * })\n *\n * const migrator = new Migrator({\n *   db,\n *   provider: new FileMigrationProvider({\n *     fs,\n *     // Path to the folder that contains all your migrations.\n *     migrationFolder: 'some/path/to/migrations',\n *     path,\n *   })\n * })\n * ```\n */\nexport class Migrator {\n    #props;\n    constructor(props) {\n        this.#props = freeze(props);\n    }\n    /**\n     * Returns a {@link MigrationInfo} object for each migration.\n     *\n     * The returned array is sorted by migration name.\n     */\n    async getMigrations() {\n        const tableExists = await this.#doesTableExist(this.#migrationTable);\n        const executedMigrations = tableExists\n            ? await this.#props.db\n                .withPlugin(this.#schemaPlugin)\n                .selectFrom(this.#migrationTable)\n                .select(['name', 'timestamp'])\n                .$narrowType()\n                .execute()\n            : [];\n        const migrations = await this.#resolveMigrations();\n        return migrations.map(({ name, ...migration }) => {\n            const executed = executedMigrations.find((it) => it.name === name);\n            return {\n                name,\n                migration,\n                executedAt: executed ? new Date(executed.timestamp) : undefined,\n            };\n        });\n    }\n    /**\n     * Runs all migrations that have not yet been run.\n     *\n     * This method returns a {@link MigrationResultSet} instance and _never_ throws.\n     * {@link MigrationResultSet.error} holds the error if something went wrong.\n     * {@link MigrationResultSet.results} contains information about which migrations\n     * were executed and which failed. See the examples below.\n     *\n     * This method goes through all possible migrations provided by the provider and runs the\n     * ones whose names come alphabetically after the last migration that has been run. If the\n     * list of executed migrations doesn't match the beginning of the list of possible migrations\n     * an error is returned.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { promises as fs } from 'node:fs'\n     * import path from 'node:path'\n     * import * as Sqlite from 'better-sqlite3'\n     * import { FileMigrationProvider, Migrator } from 'kysely'\n     *\n     * const migrator = new Migrator({\n     *   db,\n     *   provider: new FileMigrationProvider({\n     *     fs,\n     *     migrationFolder: 'some/path/to/migrations',\n     *     path,\n     *   })\n     * })\n     *\n     * const { error, results } = await migrator.migrateToLatest()\n     *\n     * results?.forEach((it) => {\n     *   if (it.status === 'Success') {\n     *     console.log(`migration \"${it.migrationName}\" was executed successfully`)\n     *   } else if (it.status === 'Error') {\n     *     console.error(`failed to execute migration \"${it.migrationName}\"`)\n     *   }\n     * })\n     *\n     * if (error) {\n     *   console.error('failed to run `migrateToLatest`')\n     *   console.error(error)\n     * }\n     * ```\n     */\n    async migrateToLatest() {\n        return this.#migrate(() => ({ direction: 'Up', step: Infinity }));\n    }\n    /**\n     * Migrate up/down to a specific migration.\n     *\n     * This method returns a {@link MigrationResultSet} instance and _never_ throws.\n     * {@link MigrationResultSet.error} holds the error if something went wrong.\n     * {@link MigrationResultSet.results} contains information about which migrations\n     * were executed and which failed.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { promises as fs } from 'node:fs'\n     * import path from 'node:path'\n     * import { FileMigrationProvider, Migrator } from 'kysely'\n     *\n     * const migrator = new Migrator({\n     *   db,\n     *   provider: new FileMigrationProvider({\n     *     fs,\n     *     // Path to the folder that contains all your migrations.\n     *     migrationFolder: 'some/path/to/migrations',\n     *     path,\n     *   })\n     * })\n     *\n     * await migrator.migrateTo('some_migration')\n     * ```\n     *\n     * If you specify the name of the first migration, this method migrates\n     * down to the first migration, but doesn't run the `down` method of\n     * the first migration. In case you want to migrate all the way down,\n     * you can use a special constant `NO_MIGRATIONS`:\n     *\n     * ```ts\n     * import { promises as fs } from 'node:fs'\n     * import path from 'node:path'\n     * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'\n     *\n     * const migrator = new Migrator({\n     *   db,\n     *   provider: new FileMigrationProvider({\n     *     fs,\n     *     // Path to the folder that contains all your migrations.\n     *     migrationFolder: 'some/path/to/migrations',\n     *     path,\n     *   })\n     * })\n     *\n     * await migrator.migrateTo(NO_MIGRATIONS)\n     * ```\n     */\n    async migrateTo(targetMigrationName) {\n        return this.#migrate(({ migrations, executedMigrations, pendingMigrations, }) => {\n            if (isObject(targetMigrationName) &&\n                targetMigrationName.__noMigrations__ === true) {\n                return { direction: 'Down', step: Infinity };\n            }\n            if (!migrations.find((m) => m.name === targetMigrationName)) {\n                throw new Error(`migration \"${targetMigrationName}\" doesn't exist`);\n            }\n            const executedIndex = executedMigrations.indexOf(targetMigrationName);\n            const pendingIndex = pendingMigrations.findIndex((m) => m.name === targetMigrationName);\n            if (executedIndex !== -1) {\n                return {\n                    direction: 'Down',\n                    step: executedMigrations.length - executedIndex - 1,\n                };\n            }\n            else if (pendingIndex !== -1) {\n                return { direction: 'Up', step: pendingIndex + 1 };\n            }\n            else {\n                throw new Error(`migration \"${targetMigrationName}\" isn't executed or pending`);\n            }\n        });\n    }\n    /**\n     * Migrate one step up.\n     *\n     * This method returns a {@link MigrationResultSet} instance and _never_ throws.\n     * {@link MigrationResultSet.error} holds the error if something went wrong.\n     * {@link MigrationResultSet.results} contains information about which migrations\n     * were executed and which failed.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { promises as fs } from 'node:fs'\n     * import path from 'node:path'\n     * import { FileMigrationProvider, Migrator } from 'kysely'\n     *\n     * const migrator = new Migrator({\n     *   db,\n     *   provider: new FileMigrationProvider({\n     *     fs,\n     *     // Path to the folder that contains all your migrations.\n     *     migrationFolder: 'some/path/to/migrations',\n     *     path,\n     *   })\n     * })\n     *\n     * await migrator.migrateUp()\n     * ```\n     */\n    async migrateUp() {\n        return this.#migrate(() => ({ direction: 'Up', step: 1 }));\n    }\n    /**\n     * Migrate one step down.\n     *\n     * This method returns a {@link MigrationResultSet} instance and _never_ throws.\n     * {@link MigrationResultSet.error} holds the error if something went wrong.\n     * {@link MigrationResultSet.results} contains information about which migrations\n     * were executed and which failed.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { promises as fs } from 'node:fs'\n     * import path from 'node:path'\n     * import { FileMigrationProvider, Migrator } from 'kysely'\n     *\n     * const migrator = new Migrator({\n     *   db,\n     *   provider: new FileMigrationProvider({\n     *     fs,\n     *     // Path to the folder that contains all your migrations.\n     *     migrationFolder: 'some/path/to/migrations',\n     *     path,\n     *   })\n     * })\n     *\n     * await migrator.migrateDown()\n     * ```\n     */\n    async migrateDown() {\n        return this.#migrate(() => ({ direction: 'Down', step: 1 }));\n    }\n    async #migrate(getMigrationDirectionAndStep) {\n        try {\n            await this.#ensureMigrationTableSchemaExists();\n            await this.#ensureMigrationTableExists();\n            await this.#ensureMigrationLockTableExists();\n            await this.#ensureLockRowExists();\n            return await this.#runMigrations(getMigrationDirectionAndStep);\n        }\n        catch (error) {\n            if (error instanceof MigrationResultSetError) {\n                return error.resultSet;\n            }\n            return { error };\n        }\n    }\n    get #migrationTableSchema() {\n        return this.#props.migrationTableSchema;\n    }\n    get #migrationTable() {\n        return this.#props.migrationTableName ?? DEFAULT_MIGRATION_TABLE;\n    }\n    get #migrationLockTable() {\n        return this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE;\n    }\n    get #allowUnorderedMigrations() {\n        return (this.#props.allowUnorderedMigrations ?? DEFAULT_ALLOW_UNORDERED_MIGRATIONS);\n    }\n    get #schemaPlugin() {\n        if (this.#migrationTableSchema) {\n            return new WithSchemaPlugin(this.#migrationTableSchema);\n        }\n        return new NoopPlugin();\n    }\n    async #ensureMigrationTableSchemaExists() {\n        if (!this.#migrationTableSchema) {\n            // Use default schema. Nothing to do.\n            return;\n        }\n        const schemaExists = await this.#doesSchemaExist();\n        if (schemaExists) {\n            return;\n        }\n        try {\n            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));\n        }\n        catch (error) {\n            const schemaExists = await this.#doesSchemaExist();\n            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`\n            // query doesn't throw if the schema already exits. That's why we check if\n            // the schema exist here and ignore the error if it does.\n            if (!schemaExists) {\n                throw error;\n            }\n        }\n    }\n    async #ensureMigrationTableExists() {\n        const tableExists = await this.#doesTableExist(this.#migrationTable);\n        if (tableExists) {\n            return;\n        }\n        try {\n            await this.#createIfNotExists(this.#props.db.schema\n                .withPlugin(this.#schemaPlugin)\n                .createTable(this.#migrationTable)\n                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())\n                // The migration run time as ISO string. This is not a real date type as we\n                // can't know which data type is supported by all future dialects.\n                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));\n        }\n        catch (error) {\n            const tableExists = await this.#doesTableExist(this.#migrationTable);\n            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`\n            // query doesn't throw if the table already exits. That's why we check if\n            // the table exist here and ignore the error if it does.\n            if (!tableExists) {\n                throw error;\n            }\n        }\n    }\n    async #ensureMigrationLockTableExists() {\n        const tableExists = await this.#doesTableExist(this.#migrationLockTable);\n        if (tableExists) {\n            return;\n        }\n        try {\n            await this.#createIfNotExists(this.#props.db.schema\n                .withPlugin(this.#schemaPlugin)\n                .createTable(this.#migrationLockTable)\n                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())\n                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));\n        }\n        catch (error) {\n            const tableExists = await this.#doesTableExist(this.#migrationLockTable);\n            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`\n            // query doesn't throw if the table already exits. That's why we check if\n            // the table exist here and ignore the error if it does.\n            if (!tableExists) {\n                throw error;\n            }\n        }\n    }\n    async #ensureLockRowExists() {\n        const lockRowExists = await this.#doesLockRowExists();\n        if (lockRowExists) {\n            return;\n        }\n        try {\n            await this.#props.db\n                .withPlugin(this.#schemaPlugin)\n                .insertInto(this.#migrationLockTable)\n                .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })\n                .execute();\n        }\n        catch (error) {\n            const lockRowExists = await this.#doesLockRowExists();\n            if (!lockRowExists) {\n                throw error;\n            }\n        }\n    }\n    async #doesSchemaExist() {\n        const schemas = await this.#props.db.introspection.getSchemas();\n        return schemas.some((it) => it.name === this.#migrationTableSchema);\n    }\n    async #doesTableExist(tableName) {\n        const schema = this.#migrationTableSchema;\n        const tables = await this.#props.db.introspection.getTables({\n            withInternalKyselyTables: true,\n        });\n        return tables.some((it) => it.name === tableName && (!schema || it.schema === schema));\n    }\n    async #doesLockRowExists() {\n        const lockRow = await this.#props.db\n            .withPlugin(this.#schemaPlugin)\n            .selectFrom(this.#migrationLockTable)\n            .where('id', '=', MIGRATION_LOCK_ID)\n            .select('id')\n            .executeTakeFirst();\n        return !!lockRow;\n    }\n    async #runMigrations(getMigrationDirectionAndStep) {\n        const adapter = this.#props.db.getExecutor().adapter;\n        const lockOptions = freeze({\n            lockTable: this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE,\n            lockRowId: MIGRATION_LOCK_ID,\n            lockTableSchema: this.#props.migrationTableSchema,\n        });\n        const run = async (db) => {\n            try {\n                await adapter.acquireMigrationLock(db, lockOptions);\n                const state = await this.#getState(db);\n                if (state.migrations.length === 0) {\n                    return { results: [] };\n                }\n                const { direction, step } = getMigrationDirectionAndStep(state);\n                if (step <= 0) {\n                    return { results: [] };\n                }\n                if (direction === 'Down') {\n                    return await this.#migrateDown(db, state, step);\n                }\n                else if (direction === 'Up') {\n                    return await this.#migrateUp(db, state, step);\n                }\n                return { results: [] };\n            }\n            finally {\n                await adapter.releaseMigrationLock(db, lockOptions);\n            }\n        };\n        if (adapter.supportsTransactionalDdl && !this.#props.disableTransactions) {\n            return this.#props.db.transaction().execute(run);\n        }\n        else {\n            return this.#props.db.connection().execute(run);\n        }\n    }\n    async #getState(db) {\n        const migrations = await this.#resolveMigrations();\n        const executedMigrations = await this.#getExecutedMigrations(db);\n        this.#ensureNoMissingMigrations(migrations, executedMigrations);\n        if (!this.#allowUnorderedMigrations) {\n            this.#ensureMigrationsInOrder(migrations, executedMigrations);\n        }\n        const pendingMigrations = this.#getPendingMigrations(migrations, executedMigrations);\n        return freeze({\n            migrations,\n            executedMigrations,\n            lastMigration: getLast(executedMigrations),\n            pendingMigrations,\n        });\n    }\n    #getPendingMigrations(migrations, executedMigrations) {\n        return migrations.filter((migration) => {\n            return !executedMigrations.includes(migration.name);\n        });\n    }\n    async #resolveMigrations() {\n        const allMigrations = await this.#props.provider.getMigrations();\n        return Object.keys(allMigrations)\n            .sort()\n            .map((name) => ({\n            ...allMigrations[name],\n            name,\n        }));\n    }\n    async #getExecutedMigrations(db) {\n        const executedMigrations = await db\n            .withPlugin(this.#schemaPlugin)\n            .selectFrom(this.#migrationTable)\n            .select(['name', 'timestamp'])\n            .$narrowType()\n            .execute();\n        const nameComparator = this.#props.nameComparator || ((a, b) => a.localeCompare(b));\n        return (executedMigrations\n            // https://github.com/kysely-org/kysely/issues/843\n            .sort((a, b) => {\n            if (a.timestamp === b.timestamp) {\n                return nameComparator(a.name, b.name);\n            }\n            return (new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());\n        })\n            .map((it) => it.name));\n    }\n    #ensureNoMissingMigrations(migrations, executedMigrations) {\n        // Ensure all executed migrations exist in the `migrations` list.\n        for (const executed of executedMigrations) {\n            if (!migrations.some((it) => it.name === executed)) {\n                throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);\n            }\n        }\n    }\n    #ensureMigrationsInOrder(migrations, executedMigrations) {\n        // Ensure the executed migrations are the first ones in the migration list.\n        for (let i = 0; i < executedMigrations.length; ++i) {\n            if (migrations[i].name !== executedMigrations[i]) {\n                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.`);\n            }\n        }\n    }\n    async #migrateDown(db, state, step) {\n        const migrationsToRollback = state.executedMigrations\n            .slice()\n            .reverse()\n            .slice(0, step)\n            .map((name) => {\n            return state.migrations.find((it) => it.name === name);\n        });\n        const results = migrationsToRollback.map((migration) => {\n            return {\n                migrationName: migration.name,\n                direction: 'Down',\n                status: 'NotExecuted',\n            };\n        });\n        for (let i = 0; i < results.length; ++i) {\n            const migration = migrationsToRollback[i];\n            try {\n                if (migration.down) {\n                    await migration.down(db);\n                    await db\n                        .withPlugin(this.#schemaPlugin)\n                        .deleteFrom(this.#migrationTable)\n                        .where('name', '=', migration.name)\n                        .execute();\n                    results[i] = {\n                        migrationName: migration.name,\n                        direction: 'Down',\n                        status: 'Success',\n                    };\n                }\n            }\n            catch (error) {\n                results[i] = {\n                    migrationName: migration.name,\n                    direction: 'Down',\n                    status: 'Error',\n                };\n                throw new MigrationResultSetError({\n                    error,\n                    results,\n                });\n            }\n        }\n        return { results };\n    }\n    async #migrateUp(db, state, step) {\n        const migrationsToRun = state.pendingMigrations.slice(0, step);\n        const results = migrationsToRun.map((migration) => {\n            return {\n                migrationName: migration.name,\n                direction: 'Up',\n                status: 'NotExecuted',\n            };\n        });\n        for (let i = 0; i < results.length; i++) {\n            const migration = state.pendingMigrations[i];\n            try {\n                await migration.up(db);\n                await db\n                    .withPlugin(this.#schemaPlugin)\n                    .insertInto(this.#migrationTable)\n                    .values({\n                    name: migration.name,\n                    timestamp: new Date().toISOString(),\n                })\n                    .execute();\n                results[i] = {\n                    migrationName: migration.name,\n                    direction: 'Up',\n                    status: 'Success',\n                };\n            }\n            catch (error) {\n                results[i] = {\n                    migrationName: migration.name,\n                    direction: 'Up',\n                    status: 'Error',\n                };\n                throw new MigrationResultSetError({\n                    error,\n                    results,\n                });\n            }\n        }\n        return { results };\n    }\n    async #createIfNotExists(qb) {\n        if (this.#props.db.getExecutor().adapter.supportsCreateIfNotExists) {\n            qb = qb.ifNotExists();\n        }\n        await qb.execute();\n    }\n}\nclass MigrationResultSetError extends Error {\n    #resultSet;\n    constructor(result) {\n        super();\n        this.#resultSet = result;\n    }\n    get resultSet() {\n        return this.#resultSet;\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,MAAa,0BAA0B;AACvC,MAAa,+BAA+B;AAG5C,MAAa,gBAAgB,OAAO,EAAE,kBAAkB,MAAM,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-column-node.js

@@ -0,0 +1,21 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-column-node.js
+/**
+* @internal
+*/
+const AddColumnNode = freeze({
+	is(node) {
+		return node.kind === "AddColumnNode";
+	},
+	create(column) {
+		return freeze({
+			kind: "AddColumnNode",
+			column
+		});
+	}
+});
+
+//#endregion
+export { AddColumnNode };
+//# sourceMappingURL=add-column-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-column-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-column-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-column-node.js"],"sourcesContent":["/// <reference types=\"./add-column-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const AddColumnNode = freeze({\n    is(node) {\n        return node.kind === 'AddColumnNode';\n    },\n    create(column) {\n        return freeze({\n            kind: 'AddColumnNode',\n            column,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,gBAAgB,OAAO;CAChC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,QAAQ;AACX,SAAO,OAAO;GACV,MAAM;GACN;GACH,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-constraint-node.js

@@ -0,0 +1,21 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-constraint-node.js
+/**
+* @internal
+*/
+const AddConstraintNode = freeze({
+	is(node) {
+		return node.kind === "AddConstraintNode";
+	},
+	create(constraint) {
+		return freeze({
+			kind: "AddConstraintNode",
+			constraint
+		});
+	}
+});
+
+//#endregion
+export { AddConstraintNode };
+//# sourceMappingURL=add-constraint-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-constraint-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-constraint-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-constraint-node.js"],"sourcesContent":["/// <reference types=\"./add-constraint-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const AddConstraintNode = freeze({\n    is(node) {\n        return node.kind === 'AddConstraintNode';\n    },\n    create(constraint) {\n        return freeze({\n            kind: 'AddConstraintNode',\n            constraint,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,oBAAoB,OAAO;CACpC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,YAAY;AACf,SAAO,OAAO;GACV,MAAM;GACN;GACH,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-index-node.js

@@ -0,0 +1,34 @@
+import { freeze } from "../util/object-utils.js";
+import { IdentifierNode } from "./identifier-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-index-node.js
+/**
+* @internal
+*/
+const AddIndexNode = freeze({
+	is(node) {
+		return node.kind === "AddIndexNode";
+	},
+	create(name) {
+		return freeze({
+			kind: "AddIndexNode",
+			name: IdentifierNode.create(name)
+		});
+	},
+	cloneWith(node, props) {
+		return freeze({
+			...node,
+			...props
+		});
+	},
+	cloneWithColumns(node, columns) {
+		return freeze({
+			...node,
+			columns: [...node.columns || [], ...columns]
+		});
+	}
+});
+
+//#endregion
+export { AddIndexNode };
+//# sourceMappingURL=add-index-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-index-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-index-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/add-index-node.js"],"sourcesContent":["/// <reference types=\"./add-index-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { IdentifierNode } from './identifier-node.js';\n/**\n * @internal\n */\nexport const AddIndexNode = freeze({\n    is(node) {\n        return node.kind === 'AddIndexNode';\n    },\n    create(name) {\n        return freeze({\n            kind: 'AddIndexNode',\n            name: IdentifierNode.create(name),\n        });\n    },\n    cloneWith(node, props) {\n        return freeze({\n            ...node,\n            ...props,\n        });\n    },\n    cloneWithColumns(node, columns) {\n        return freeze({\n            ...node,\n            columns: [...(node.columns || []), ...columns],\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,MAAa,eAAe,OAAO;CAC/B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,MAAM;AACT,SAAO,OAAO;GACV,MAAM;GACN,MAAM,eAAe,OAAO,KAAK;GACpC,CAAC;;CAEN,UAAU,MAAM,OAAO;AACnB,SAAO,OAAO;GACV,GAAG;GACH,GAAG;GACN,CAAC;;CAEN,iBAAiB,MAAM,SAAS;AAC5B,SAAO,OAAO;GACV,GAAG;GACH,SAAS,CAAC,GAAI,KAAK,WAAW,EAAE,EAAG,GAAG,QAAQ;GACjD,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/aggregate-function-node.js

@@ -0,0 +1,55 @@
+import { freeze } from "../util/object-utils.js";
+import { OrderByNode } from "./order-by-node.js";
+import { WhereNode } from "./where-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/aggregate-function-node.js
+/**
+* @internal
+*/
+const AggregateFunctionNode = freeze({
+	is(node) {
+		return node.kind === "AggregateFunctionNode";
+	},
+	create(aggregateFunction, aggregated = []) {
+		return freeze({
+			kind: "AggregateFunctionNode",
+			func: aggregateFunction,
+			aggregated
+		});
+	},
+	cloneWithDistinct(aggregateFunctionNode) {
+		return freeze({
+			...aggregateFunctionNode,
+			distinct: true
+		});
+	},
+	cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
+		const prop = withinGroup ? "withinGroup" : "orderBy";
+		return freeze({
+			...aggregateFunctionNode,
+			[prop]: aggregateFunctionNode[prop] ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems) : OrderByNode.create(orderItems)
+		});
+	},
+	cloneWithFilter(aggregateFunctionNode, filter) {
+		return freeze({
+			...aggregateFunctionNode,
+			filter: aggregateFunctionNode.filter ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, "And", filter) : WhereNode.create(filter)
+		});
+	},
+	cloneWithOrFilter(aggregateFunctionNode, filter) {
+		return freeze({
+			...aggregateFunctionNode,
+			filter: aggregateFunctionNode.filter ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, "Or", filter) : WhereNode.create(filter)
+		});
+	},
+	cloneWithOver(aggregateFunctionNode, over) {
+		return freeze({
+			...aggregateFunctionNode,
+			over
+		});
+	}
+});
+
+//#endregion
+export { AggregateFunctionNode };
+//# sourceMappingURL=aggregate-function-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/aggregate-function-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-function-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/aggregate-function-node.js"],"sourcesContent":["/// <reference types=\"./aggregate-function-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { WhereNode } from './where-node.js';\nimport { OrderByNode } from './order-by-node.js';\n/**\n * @internal\n */\nexport const AggregateFunctionNode = freeze({\n    is(node) {\n        return node.kind === 'AggregateFunctionNode';\n    },\n    create(aggregateFunction, aggregated = []) {\n        return freeze({\n            kind: 'AggregateFunctionNode',\n            func: aggregateFunction,\n            aggregated,\n        });\n    },\n    cloneWithDistinct(aggregateFunctionNode) {\n        return freeze({\n            ...aggregateFunctionNode,\n            distinct: true,\n        });\n    },\n    cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {\n        const prop = withinGroup ? 'withinGroup' : 'orderBy';\n        return freeze({\n            ...aggregateFunctionNode,\n            [prop]: aggregateFunctionNode[prop]\n                ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems)\n                : OrderByNode.create(orderItems),\n        });\n    },\n    cloneWithFilter(aggregateFunctionNode, filter) {\n        return freeze({\n            ...aggregateFunctionNode,\n            filter: aggregateFunctionNode.filter\n                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)\n                : WhereNode.create(filter),\n        });\n    },\n    cloneWithOrFilter(aggregateFunctionNode, filter) {\n        return freeze({\n            ...aggregateFunctionNode,\n            filter: aggregateFunctionNode.filter\n                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)\n                : WhereNode.create(filter),\n        });\n    },\n    cloneWithOver(aggregateFunctionNode, over) {\n        return freeze({\n            ...aggregateFunctionNode,\n            over,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAOA,MAAa,wBAAwB,OAAO;CACxC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,mBAAmB,aAAa,EAAE,EAAE;AACvC,SAAO,OAAO;GACV,MAAM;GACN,MAAM;GACN;GACH,CAAC;;CAEN,kBAAkB,uBAAuB;AACrC,SAAO,OAAO;GACV,GAAG;GACH,UAAU;GACb,CAAC;;CAEN,iBAAiB,uBAAuB,YAAY,cAAc,OAAO;EACrE,MAAM,OAAO,cAAc,gBAAgB;AAC3C,SAAO,OAAO;GACV,GAAG;IACF,OAAO,sBAAsB,QACxB,YAAY,eAAe,sBAAsB,OAAO,WAAW,GACnE,YAAY,OAAO,WAAW;GACvC,CAAC;;CAEN,gBAAgB,uBAAuB,QAAQ;AAC3C,SAAO,OAAO;GACV,GAAG;GACH,QAAQ,sBAAsB,SACxB,UAAU,mBAAmB,sBAAsB,QAAQ,OAAO,OAAO,GACzE,UAAU,OAAO,OAAO;GACjC,CAAC;;CAEN,kBAAkB,uBAAuB,QAAQ;AAC7C,SAAO,OAAO;GACV,GAAG;GACH,QAAQ,sBAAsB,SACxB,UAAU,mBAAmB,sBAAsB,QAAQ,MAAM,OAAO,GACxE,UAAU,OAAO,OAAO;GACjC,CAAC;;CAEN,cAAc,uBAAuB,MAAM;AACvC,SAAO,OAAO;GACV,GAAG;GACH;GACH,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,22 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alias-node.js
+/**
+* @internal
+*/
+const AliasNode = freeze({
+	is(node) {
+		return node.kind === "AliasNode";
+	},
+	create(node, alias) {
+		return freeze({
+			kind: "AliasNode",
+			node,
+			alias
+		});
+	}
+});
+
+//#endregion
+export { AliasNode };
+//# sourceMappingURL=alias-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alias-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alias-node.js"],"sourcesContent":["/// <reference types=\"./alias-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const AliasNode = freeze({\n    is(node) {\n        return node.kind === 'AliasNode';\n    },\n    create(node, alias) {\n        return freeze({\n            kind: 'AliasNode',\n            node,\n            alias,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,YAAY,OAAO;CAC5B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,MAAM,OAAO;AAChB,SAAO,OAAO;GACV,MAAM;GACN;GACA;GACH,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-column-node.js

@@ -0,0 +1,23 @@
+import { freeze } from "../util/object-utils.js";
+import { ColumnNode } from "./column-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-column-node.js
+/**
+* @internal
+*/
+const AlterColumnNode = freeze({
+	is(node) {
+		return node.kind === "AlterColumnNode";
+	},
+	create(column, prop, value) {
+		return freeze({
+			kind: "AlterColumnNode",
+			column: ColumnNode.create(column),
+			[prop]: value
+		});
+	}
+});
+
+//#endregion
+export { AlterColumnNode };
+//# sourceMappingURL=alter-column-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-column-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-column-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-column-node.js"],"sourcesContent":["/// <reference types=\"./alter-column-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { ColumnNode } from './column-node.js';\n/**\n * @internal\n */\nexport const AlterColumnNode = freeze({\n    is(node) {\n        return node.kind === 'AlterColumnNode';\n    },\n    create(column, prop, value) {\n        return freeze({\n            kind: 'AlterColumnNode',\n            column: ColumnNode.create(column),\n            [prop]: value,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,MAAa,kBAAkB,OAAO;CAClC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,QAAQ,MAAM,OAAO;AACxB,SAAO,OAAO;GACV,MAAM;GACN,QAAQ,WAAW,OAAO,OAAO;IAChC,OAAO;GACX,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-table-node.js

@@ -0,0 +1,33 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-table-node.js
+/**
+* @internal
+*/
+const AlterTableNode = freeze({
+	is(node) {
+		return node.kind === "AlterTableNode";
+	},
+	create(table) {
+		return freeze({
+			kind: "AlterTableNode",
+			table
+		});
+	},
+	cloneWithTableProps(node, props) {
+		return freeze({
+			...node,
+			...props
+		});
+	},
+	cloneWithColumnAlteration(node, columnAlteration) {
+		return freeze({
+			...node,
+			columnAlterations: node.columnAlterations ? [...node.columnAlterations, columnAlteration] : [columnAlteration]
+		});
+	}
+});
+
+//#endregion
+export { AlterTableNode };
+//# sourceMappingURL=alter-table-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-table-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-table-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/alter-table-node.js"],"sourcesContent":["/// <reference types=\"./alter-table-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const AlterTableNode = freeze({\n    is(node) {\n        return node.kind === 'AlterTableNode';\n    },\n    create(table) {\n        return freeze({\n            kind: 'AlterTableNode',\n            table,\n        });\n    },\n    cloneWithTableProps(node, props) {\n        return freeze({\n            ...node,\n            ...props,\n        });\n    },\n    cloneWithColumnAlteration(node, columnAlteration) {\n        return freeze({\n            ...node,\n            columnAlterations: node.columnAlterations\n                ? [...node.columnAlterations, columnAlteration]\n                : [columnAlteration],\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,iBAAiB,OAAO;CACjC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,OAAO;AACV,SAAO,OAAO;GACV,MAAM;GACN;GACH,CAAC;;CAEN,oBAAoB,MAAM,OAAO;AAC7B,SAAO,OAAO;GACV,GAAG;GACH,GAAG;GACN,CAAC;;CAEN,0BAA0B,MAAM,kBAAkB;AAC9C,SAAO,OAAO;GACV,GAAG;GACH,mBAAmB,KAAK,oBAClB,CAAC,GAAG,KAAK,mBAAmB,iBAAiB,GAC7C,CAAC,iBAAiB;GAC3B,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,22 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/and-node.js
+/**
+* @internal
+*/
+const AndNode = freeze({
+	is(node) {
+		return node.kind === "AndNode";
+	},
+	create(left, right) {
+		return freeze({
+			kind: "AndNode",
+			left,
+			right
+		});
+	}
+});
+
+//#endregion
+export { AndNode };
+//# sourceMappingURL=and-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/and-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"and-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/and-node.js"],"sourcesContent":["/// <reference types=\"./and-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const AndNode = freeze({\n    is(node) {\n        return node.kind === 'AndNode';\n    },\n    create(left, right) {\n        return freeze({\n            kind: 'AndNode',\n            left,\n            right,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,UAAU,OAAO;CAC1B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,MAAM,OAAO;AAChB,SAAO,OAAO;GACV,MAAM;GACN;GACA;GACH,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,23 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/binary-operation-node.js
+/**
+* @internal
+*/
+const BinaryOperationNode = freeze({
+	is(node) {
+		return node.kind === "BinaryOperationNode";
+	},
+	create(leftOperand, operator, rightOperand) {
+		return freeze({
+			kind: "BinaryOperationNode",
+			leftOperand,
+			operator,
+			rightOperand
+		});
+	}
+});
+
+//#endregion
+export { BinaryOperationNode };
+//# sourceMappingURL=binary-operation-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/binary-operation-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-operation-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/binary-operation-node.js"],"sourcesContent":["/// <reference types=\"./binary-operation-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const BinaryOperationNode = freeze({\n    is(node) {\n        return node.kind === 'BinaryOperationNode';\n    },\n    create(leftOperand, operator, rightOperand) {\n        return freeze({\n            kind: 'BinaryOperationNode',\n            leftOperand,\n            operator,\n            rightOperand,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,sBAAsB,OAAO;CACtC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,aAAa,UAAU,cAAc;AACxC,SAAO,OAAO;GACV,MAAM;GACN;GACA;GACA;GACH,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,40 @@
+import { freeze } from "../util/object-utils.js";
+import { WhenNode } from "./when-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/case-node.js
+/**
+* @internal
+*/
+const CaseNode = freeze({
+	is(node) {
+		return node.kind === "CaseNode";
+	},
+	create(value) {
+		return freeze({
+			kind: "CaseNode",
+			value
+		});
+	},
+	cloneWithWhen(caseNode, when) {
+		return freeze({
+			...caseNode,
+			when: freeze(caseNode.when ? [...caseNode.when, when] : [when])
+		});
+	},
+	cloneWithThen(caseNode, then) {
+		return freeze({
+			...caseNode,
+			when: caseNode.when ? freeze([...caseNode.when.slice(0, -1), WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then)]) : void 0
+		});
+	},
+	cloneWith(caseNode, props) {
+		return freeze({
+			...caseNode,
+			...props
+		});
+	}
+});
+
+//#endregion
+export { CaseNode };
+//# sourceMappingURL=case-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/case-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/case-node.js"],"sourcesContent":["/// <reference types=\"./case-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { WhenNode } from './when-node.js';\n/**\n * @internal\n */\nexport const CaseNode = freeze({\n    is(node) {\n        return node.kind === 'CaseNode';\n    },\n    create(value) {\n        return freeze({\n            kind: 'CaseNode',\n            value,\n        });\n    },\n    cloneWithWhen(caseNode, when) {\n        return freeze({\n            ...caseNode,\n            when: freeze(caseNode.when ? [...caseNode.when, when] : [when]),\n        });\n    },\n    cloneWithThen(caseNode, then) {\n        return freeze({\n            ...caseNode,\n            when: caseNode.when\n                ? freeze([\n                    ...caseNode.when.slice(0, -1),\n                    WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then),\n                ])\n                : undefined,\n        });\n    },\n    cloneWith(caseNode, props) {\n        return freeze({\n            ...caseNode,\n            ...props,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,MAAa,WAAW,OAAO;CAC3B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,OAAO;AACV,SAAO,OAAO;GACV,MAAM;GACN;GACH,CAAC;;CAEN,cAAc,UAAU,MAAM;AAC1B,SAAO,OAAO;GACV,GAAG;GACH,MAAM,OAAO,SAAS,OAAO,CAAC,GAAG,SAAS,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC;GAClE,CAAC;;CAEN,cAAc,UAAU,MAAM;AAC1B,SAAO,OAAO;GACV,GAAG;GACH,MAAM,SAAS,OACT,OAAO,CACL,GAAG,SAAS,KAAK,MAAM,GAAG,GAAG,EAC7B,SAAS,gBAAgB,SAAS,KAAK,SAAS,KAAK,SAAS,IAAI,KAAK,CAC1E,CAAC,GACA;GACT,CAAC;;CAEN,UAAU,UAAU,OAAO;AACvB,SAAO,OAAO;GACV,GAAG;GACH,GAAG;GACN,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,22 @@
+import { freeze } from "../util/object-utils.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/cast-node.js
+/**
+* @internal
+*/
+const CastNode = freeze({
+	is(node) {
+		return node.kind === "CastNode";
+	},
+	create(expression, dataType) {
+		return freeze({
+			kind: "CastNode",
+			expression,
+			dataType
+		});
+	}
+});
+
+//#endregion
+export { CastNode };
+//# sourceMappingURL=cast-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/cast-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/cast-node.js"],"sourcesContent":["/// <reference types=\"./cast-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\n/**\n * @internal\n */\nexport const CastNode = freeze({\n    is(node) {\n        return node.kind === 'CastNode';\n    },\n    create(expression, dataType) {\n        return freeze({\n            kind: 'CastNode',\n            expression,\n            dataType,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,MAAa,WAAW,OAAO;CAC3B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,YAAY,UAAU;AACzB,SAAO,OAAO;GACV,MAAM;GACN;GACA;GACH,CAAC;;CAET,CAAC"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/check-constraint-node.js

@@ -0,0 +1,23 @@
+import { freeze } from "../util/object-utils.js";
+import { IdentifierNode } from "./identifier-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/check-constraint-node.js
+/**
+* @internal
+*/
+const CheckConstraintNode = freeze({
+	is(node) {
+		return node.kind === "CheckConstraintNode";
+	},
+	create(expression, constraintName) {
+		return freeze({
+			kind: "CheckConstraintNode",
+			expression,
+			name: constraintName ? IdentifierNode.create(constraintName) : void 0
+		});
+	}
+});
+
+//#endregion
+export { CheckConstraintNode };
+//# sourceMappingURL=check-constraint-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/check-constraint-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-constraint-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/check-constraint-node.js"],"sourcesContent":["/// <reference types=\"./check-constraint-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { IdentifierNode } from './identifier-node.js';\n/**\n * @internal\n */\nexport const CheckConstraintNode = freeze({\n    is(node) {\n        return node.kind === 'CheckConstraintNode';\n    },\n    create(expression, constraintName) {\n        return freeze({\n            kind: 'CheckConstraintNode',\n            expression,\n            name: constraintName\n                ? IdentifierNode.create(constraintName)\n                : undefined,\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,MAAa,sBAAsB,OAAO;CACtC,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,YAAY,gBAAgB;AAC/B,SAAO,OAAO;GACV,MAAM;GACN;GACA,MAAM,iBACA,eAAe,OAAO,eAAe,GACrC;GACT,CAAC;;CAET,CAAC"}

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

@@ -0,0 +1,22 @@
+import { freeze } from "../util/object-utils.js";
+import { IdentifierNode } from "./identifier-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/collate-node.js
+/**
+* @internal
+*/
+const CollateNode = freeze({
+	is(node) {
+		return node.kind === "CollateNode";
+	},
+	create(collation) {
+		return freeze({
+			kind: "CollateNode",
+			collation: IdentifierNode.create(collation)
+		});
+	}
+});
+
+//#endregion
+export { CollateNode };
+//# sourceMappingURL=collate-node.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/collate-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collate-node.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/operation-node/collate-node.js"],"sourcesContent":["/// <reference types=\"./collate-node.d.ts\" />\nimport { freeze } from '../util/object-utils.js';\nimport { IdentifierNode } from './identifier-node.js';\n/**\n * @internal\n */\nexport const CollateNode = freeze({\n    is(node) {\n        return node.kind === 'CollateNode';\n    },\n    create(collation) {\n        return freeze({\n            kind: 'CollateNode',\n            collation: IdentifierNode.create(collation),\n        });\n    },\n});\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAMA,MAAa,cAAc,OAAO;CAC9B,GAAG,MAAM;AACL,SAAO,KAAK,SAAS;;CAEzB,OAAO,WAAW;AACd,SAAO,OAAO;GACV,MAAM;GACN,WAAW,eAAe,OAAO,UAAU;GAC9C,CAAC;;CAET,CAAC"}