@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/insert-query-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-query-builder.js","names":["#props"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/insert-query-builder.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InsertQueryBuilder = void 0;\nconst select_parser_js_1 = require(\"../parser/select-parser.js\");\nconst insert_values_parser_js_1 = require(\"../parser/insert-values-parser.js\");\nconst insert_query_node_js_1 = require(\"../operation-node/insert-query-node.js\");\nconst query_node_js_1 = require(\"../operation-node/query-node.js\");\nconst update_set_parser_js_1 = require(\"../parser/update-set-parser.js\");\nconst object_utils_js_1 = require(\"../util/object-utils.js\");\nconst on_duplicate_key_node_js_1 = require(\"../operation-node/on-duplicate-key-node.js\");\nconst insert_result_js_1 = require(\"./insert-result.js\");\nconst no_result_error_js_1 = require(\"./no-result-error.js\");\nconst expression_parser_js_1 = require(\"../parser/expression-parser.js\");\nconst column_node_js_1 = require(\"../operation-node/column-node.js\");\nconst on_conflict_builder_js_1 = require(\"./on-conflict-builder.js\");\nconst on_conflict_node_js_1 = require(\"../operation-node/on-conflict-node.js\");\nconst top_parser_js_1 = require(\"../parser/top-parser.js\");\nconst or_action_node_js_1 = require(\"../operation-node/or-action-node.js\");\nclass InsertQueryBuilder {\n    #props;\n    constructor(props) {\n        this.#props = (0, object_utils_js_1.freeze)(props);\n    }\n    /**\n     * Sets the values to insert for an {@link Kysely.insertInto | insert} query.\n     *\n     * This method takes an object whose keys are column names and values are\n     * values to insert. In addition to the column's type, the values can be\n     * raw {@link sql} snippets or select queries.\n     *\n     * You must provide all fields you haven't explicitly marked as nullable\n     * or optional using {@link Generated} or {@link ColumnType}.\n     *\n     * The return value of an `insert` query is an instance of {@link InsertResult}. The\n     * {@link InsertResult.insertId | insertId} field holds the auto incremented primary\n     * key if the database returned one.\n     *\n     * On PostgreSQL and some other dialects, you need to call `returning` to get\n     * something out of the query.\n     *\n     * Also see the {@link expression} method for inserting the result of a select\n     * query or any other expression.\n     *\n     * ### Examples\n     *\n     * <!-- siteExample(\"insert\", \"Single row\", 10) -->\n     *\n     * Insert a single row:\n     *\n     * ```ts\n     * const result = await db\n     *   .insertInto('person')\n     *   .values({\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston',\n     *     age: 40\n     *   })\n     *   .executeTakeFirst()\n     *\n     * // `insertId` is only available on dialects that\n     * // automatically return the id of the inserted row\n     * // such as MySQL and SQLite. On PostgreSQL, for example,\n     * // you need to add a `returning` clause to the query to\n     * // get anything out. See the \"returning data\" example.\n     * console.log(result.insertId)\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * insert into `person` (`first_name`, `last_name`, `age`) values (?, ?, ?)\n     * ```\n     *\n     * <!-- siteExample(\"insert\", \"Multiple rows\", 20) -->\n     *\n     * On dialects that support it (for example PostgreSQL) you can insert multiple\n     * rows by providing an array. Note that the return value is once again very\n     * dialect-specific. Some databases may only return the id of the *last* inserted\n     * row and some return nothing at all unless you call `returning`.\n     *\n     * ```ts\n     * await db\n     *   .insertInto('person')\n     *   .values([{\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston',\n     *     age: 40,\n     *   }, {\n     *     first_name: 'Arnold',\n     *     last_name: 'Schwarzenegger',\n     *     age: 70,\n     *   }])\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"first_name\", \"last_name\", \"age\") values (($1, $2, $3), ($4, $5, $6))\n     * ```\n     *\n     * <!-- siteExample(\"insert\", \"Returning data\", 30) -->\n     *\n     * On supported dialects like PostgreSQL you need to chain `returning` to the query to get\n     * the inserted row's columns (or any other expression) as the return value. `returning`\n     * works just like `select`. Refer to `select` method's examples and documentation for\n     * more info.\n     *\n     * ```ts\n     * const result = await db\n     *   .insertInto('person')\n     *   .values({\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston',\n     *     age: 40,\n     *   })\n     *   .returning(['id', 'first_name as name'])\n     *   .executeTakeFirstOrThrow()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"first_name\", \"last_name\", \"age\") values ($1, $2, $3) returning \"id\", \"first_name\" as \"name\"\n     * ```\n     *\n     * <!-- siteExample(\"insert\", \"Complex values\", 40) -->\n     *\n     * In addition to primitives, the values can also be arbitrary expressions.\n     * You can build the expressions by using a callback and calling the methods\n     * on the expression builder passed to it:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * const ani = \"Ani\"\n     * const ston = \"ston\"\n     *\n     * const result = await db\n     *   .insertInto('person')\n     *   .values(({ ref, selectFrom, fn }) => ({\n     *     first_name: 'Jennifer',\n     *     last_name: sql<string>`concat(${ani}, ${ston})`,\n     *     middle_name: ref('first_name'),\n     *     age: selectFrom('person')\n     *       .select(fn.avg<number>('age').as('avg_age')),\n     *   }))\n     *   .executeTakeFirst()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\n     *   \"first_name\",\n     *   \"last_name\",\n     *   \"middle_name\",\n     *   \"age\"\n     * )\n     * values (\n     *   $1,\n     *   concat($2, $3),\n     *   \"first_name\",\n     *   (select avg(\"age\") as \"avg_age\" from \"person\")\n     * )\n     * ```\n     *\n     * You can also use the callback version of subqueries or raw expressions:\n     *\n     * ```ts\n     * await db.with('jennifer', (db) => db\n     *   .selectFrom('person')\n     *   .where('first_name', '=', 'Jennifer')\n     *   .select(['id', 'first_name', 'gender'])\n     *   .limit(1)\n     * ).insertInto('pet').values((eb) => ({\n     *   owner_id: eb.selectFrom('jennifer').select('id'),\n     *   name: eb.selectFrom('jennifer').select('first_name'),\n     *   species: 'cat',\n     * }))\n     * .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * with \"jennifer\" as (\n     *   select \"id\", \"first_name\", \"gender\"\n     *   from \"person\"\n     *   where \"first_name\" = $1\n     *   limit $2\n     * )\n     * insert into \"pet\" (\"owner_id\", \"name\", \"species\")\n     * values (\n     *  (select \"id\" from \"jennifer\"),\n     *  (select \"first_name\" from \"jennifer\"),\n     *  $3\n     * )\n     * ```\n     */\n    values(insert) {\n        const [columns, values] = (0, insert_values_parser_js_1.parseInsertExpression)(insert);\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                columns,\n                values,\n            }),\n        });\n    }\n    /**\n     * Sets the columns to insert.\n     *\n     * The {@link values} method sets both the columns and the values and this method\n     * is not needed. But if you are using the {@link expression} method, you can use\n     * this method to set the columns to insert.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .columns(['first_name'])\n     *   .expression((eb) => eb.selectFrom('pet').select('pet.name'))\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"first_name\")\n     * select \"pet\".\"name\" from \"pet\"\n     * ```\n     */\n    columns(columns) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),\n            }),\n        });\n    }\n    /**\n     * Insert an arbitrary expression. For example the result of a select query.\n     *\n     * ### Examples\n     *\n     * <!-- siteExample(\"insert\", \"Insert subquery\", 50) -->\n     *\n     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method.\n     * This API doesn't follow our WYSIWYG principles and might be a bit difficult to\n     * remember. The reasons for this design stem from implementation difficulties.\n     *\n     * ```ts\n     * const result = await db.insertInto('person')\n     *   .columns(['first_name', 'last_name', 'age'])\n     *   .expression((eb) => eb\n     *     .selectFrom('pet')\n     *     .select((eb) => [\n     *       'pet.name',\n     *       eb.val('Petson').as('last_name'),\n     *       eb.lit(7).as('age'),\n     *     ])\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"first_name\", \"last_name\", \"age\")\n     * select \"pet\".\"name\", $1 as \"last_name\", 7 as \"age from \"pet\"\n     * ```\n     */\n    expression(expression) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                values: (0, expression_parser_js_1.parseExpression)(expression),\n            }),\n        });\n    }\n    /**\n     * Creates an `insert into \"person\" default values` query.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .defaultValues()\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" default values\n     * ```\n     */\n    defaultValues() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                defaultValues: true,\n            }),\n        });\n    }\n    /**\n     * This can be used to add any additional SQL to the end of the query.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.insertInto('person')\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'male',\n     *   })\n     *   .modifyEnd(sql`-- This is a comment`)\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * insert into `person` (\"first_name\", \"last_name\", \"gender\")\n     * values (?, ?, ?) -- This is a comment\n     * ```\n     */\n    modifyEnd(modifier) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode()),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert ignore into` query.\n     *\n     * This is only supported by some dialects like MySQL.\n     *\n     * To avoid a footgun, when invoked with the SQLite dialect, this method will\n     * be handled like {@link orIgnore}. See also, {@link orAbort}, {@link orFail},\n     * {@link orReplace}, and {@link orRollback}.\n     *\n     * If you use the ignore modifier, ignorable errors that occur while executing the\n     * insert statement are ignored. For example, without ignore, a row that duplicates\n     * an existing unique index or primary key value in the table causes a duplicate-key\n     * error and the statement is aborted. With ignore, the row is discarded and no error\n     * occurs.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .ignore()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or ignore into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     */\n    ignore() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('ignore'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert or ignore into` query.\n     *\n     * This is only supported by some dialects like SQLite.\n     *\n     * To avoid a footgun, when invoked with the MySQL dialect, this method will\n     * be handled like {@link ignore}.\n     *\n     * See also, {@link orAbort}, {@link orFail}, {@link orReplace}, and {@link orRollback}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .orIgnore()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or ignore into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * insert ignore into `person` (`first_name`, `last_name`, `gender`) values (?, ?, ?)\n     * ```\n     */\n    orIgnore() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('ignore'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert or abort into` query.\n     *\n     * This is only supported by some dialects like SQLite.\n     *\n     * See also, {@link orIgnore}, {@link orFail}, {@link orReplace}, and {@link orRollback}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .orAbort()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or abort into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     */\n    orAbort() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('abort'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert or fail into` query.\n     *\n     * This is only supported by some dialects like SQLite.\n     *\n     * See also, {@link orIgnore}, {@link orAbort}, {@link orReplace}, and {@link orRollback}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .orFail()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or fail into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     */\n    orFail() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('fail'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert or replace into` query.\n     *\n     * This is only supported by some dialects like SQLite.\n     *\n     * You can also use {@link Kysely.replaceInto} to achieve the same result.\n     *\n     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orRollback}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .orReplace()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or replace into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     */\n    orReplace() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('replace'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert or rollback into` query.\n     *\n     * This is only supported by some dialects like SQLite.\n     *\n     * See also, {@link orIgnore}, {@link orAbort}, {@link orFail}, and {@link orReplace}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .orRollback()\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'female',\n     *   })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * insert or rollback into \"person\" (\"first_name\", \"last_name\", \"gender\") values (?, ?, ?)\n     * ```\n     */\n    orRollback() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                orAction: or_action_node_js_1.OrActionNode.create('rollback'),\n            }),\n        });\n    }\n    /**\n     * Changes an `insert into` query to an `insert top into` query.\n     *\n     * `top` clause is only supported by some dialects like MS SQL Server.\n     *\n     * ### Examples\n     *\n     * Insert the first 5 rows:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.insertInto('person')\n     *   .top(5)\n     *   .columns(['first_name', 'gender'])\n     *   .expression(\n     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MS SQL Server):\n     *\n     * ```sql\n     * insert top(5) into \"person\" (\"first_name\", \"gender\") select \"name\", 'other' as \"gender\" from \"pet\"\n     * ```\n     *\n     * Insert the first 50 percent of rows:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db.insertInto('person')\n     *   .top(50, 'percent')\n     *   .columns(['first_name', 'gender'])\n     *   .expression(\n     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MS SQL Server):\n     *\n     * ```sql\n     * insert top(50) percent into \"person\" (\"first_name\", \"gender\") select \"name\", 'other' as \"gender\" from \"pet\"\n     * ```\n     */\n    top(expression, modifiers) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),\n        });\n    }\n    /**\n     * Adds an `on conflict` clause to the query.\n     *\n     * `on conflict` is only supported by some dialects like PostgreSQL and SQLite. On MySQL\n     * you can use {@link ignore} and {@link onDuplicateKeyUpdate} to achieve similar results.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db\n     *   .insertInto('pet')\n     *   .values({\n     *     name: 'Catto',\n     *     species: 'cat',\n     *     owner_id: 3,\n     *   })\n     *   .onConflict((oc) => oc\n     *     .column('name')\n     *     .doUpdateSet({ species: 'hamster' })\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"pet\" (\"name\", \"species\", \"owner_id\")\n     * values ($1, $2, $3)\n     * on conflict (\"name\")\n     * do update set \"species\" = $4\n     * ```\n     *\n     * You can provide the name of the constraint instead of a column name:\n     *\n     * ```ts\n     * await db\n     *   .insertInto('pet')\n     *   .values({\n     *     name: 'Catto',\n     *     species: 'cat',\n     *     owner_id: 3,\n     *   })\n     *   .onConflict((oc) => oc\n     *     .constraint('pet_name_key')\n     *     .doUpdateSet({ species: 'hamster' })\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"pet\" (\"name\", \"species\", \"owner_id\")\n     * values ($1, $2, $3)\n     * on conflict on constraint \"pet_name_key\"\n     * do update set \"species\" = $4\n     * ```\n     *\n     * You can also specify an expression as the conflict target in case\n     * the unique index is an expression index:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * await db\n     *   .insertInto('pet')\n     *   .values({\n     *     name: 'Catto',\n     *     species: 'cat',\n     *     owner_id: 3,\n     *   })\n     *   .onConflict((oc) => oc\n     *     .expression(sql<string>`lower(name)`)\n     *     .doUpdateSet({ species: 'hamster' })\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"pet\" (\"name\", \"species\", \"owner_id\")\n     * values ($1, $2, $3)\n     * on conflict (lower(name))\n     * do update set \"species\" = $4\n     * ```\n     *\n     * You can add a filter for the update statement like this:\n     *\n     * ```ts\n     * await db\n     *   .insertInto('pet')\n     *   .values({\n     *     name: 'Catto',\n     *     species: 'cat',\n     *     owner_id: 3,\n     *   })\n     *   .onConflict((oc) => oc\n     *     .column('name')\n     *     .doUpdateSet({ species: 'hamster' })\n     *     .where('excluded.name', '!=', 'Catto')\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"pet\" (\"name\", \"species\", \"owner_id\")\n     * values ($1, $2, $3)\n     * on conflict (\"name\")\n     * do update set \"species\" = $4\n     * where \"excluded\".\"name\" != $5\n     * ```\n     *\n     * You can create an `on conflict do nothing` clauses like this:\n     *\n     * ```ts\n     * await db\n     *   .insertInto('pet')\n     *   .values({\n     *     name: 'Catto',\n     *     species: 'cat',\n     *     owner_id: 3,\n     *   })\n     *   .onConflict((oc) => oc\n     *     .column('name')\n     *     .doNothing()\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"pet\" (\"name\", \"species\", \"owner_id\")\n     * values ($1, $2, $3)\n     * on conflict (\"name\") do nothing\n     * ```\n     *\n     * You can refer to the columns of the virtual `excluded` table\n     * in a type-safe way using a callback and the `ref` method of\n     * `ExpressionBuilder`:\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .values({\n     *     id: 1,\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'male',\n     *   })\n     *   .onConflict(oc => oc\n     *     .column('id')\n     *     .doUpdateSet({\n     *       first_name: (eb) => eb.ref('excluded.first_name'),\n     *       last_name: (eb) => eb.ref('excluded.last_name')\n     *     })\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"id\", \"first_name\", \"last_name\", \"gender\")\n     * values ($1, $2, $3, $4)\n     * on conflict (\"id\")\n     * do update set\n     *  \"first_name\" = \"excluded\".\"first_name\",\n     *  \"last_name\" = \"excluded\".\"last_name\"\n     * ```\n     */\n    onConflict(callback) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                onConflict: callback(new on_conflict_builder_js_1.OnConflictBuilder({\n                    onConflictNode: on_conflict_node_js_1.OnConflictNode.create(),\n                })).toOperationNode(),\n            }),\n        });\n    }\n    /**\n     * Adds `on duplicate key update` to the query.\n     *\n     * If you specify `on duplicate key update`, and a row is inserted that would cause\n     * a duplicate value in a unique index or primary key, an update of the old row occurs.\n     *\n     * This is only implemented by some dialects like MySQL. On most dialects you should\n     * use {@link onConflict} instead.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db\n     *   .insertInto('person')\n     *   .values({\n     *     id: 1,\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'male',\n     *   })\n     *   .onDuplicateKeyUpdate({ updated_at: new Date().toISOString() })\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * insert into `person` (`id`, `first_name`, `last_name`, `gender`)\n     * values (?, ?, ?, ?)\n     * on duplicate key update `updated_at` = ?\n     * ```\n     */\n    onDuplicateKeyUpdate(update) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {\n                onDuplicateKey: on_duplicate_key_node_js_1.OnDuplicateKeyNode.create((0, update_set_parser_js_1.parseUpdateObjectExpression)(update)),\n            }),\n        });\n    }\n    returning(selection) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(selection)),\n        });\n    }\n    returningAll() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),\n        });\n    }\n    output(args) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),\n        });\n    }\n    outputAll(table) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),\n        });\n    }\n    /**\n     * Clears all `returning` clauses from the query.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.insertInto('person')\n     *   .values({ first_name: 'James', last_name: 'Smith', gender: 'male' })\n     *   .returning(['first_name'])\n     *   .clearReturning()\n     *   .execute()\n     * ```\n     *\n     * The generated SQL(PostgreSQL):\n     *\n     * ```sql\n     * insert into \"person\" (\"first_name\", \"last_name\", \"gender\") values ($1, $2, $3)\n     * ```\n     */\n    clearReturning() {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithoutReturning(this.#props.queryNode),\n        });\n    }\n    /**\n     * Simply calls the provided function passing `this` as the only argument. `$call` returns\n     * what the provided function returns.\n     *\n     * If you want to conditionally call a method on `this`, see\n     * the {@link $if} method.\n     *\n     * ### Examples\n     *\n     * The next example uses a helper function `log` to log a query:\n     *\n     * ```ts\n     * import type { Compilable } from 'kysely'\n     *\n     * function log<T extends Compilable>(qb: T): T {\n     *   console.log(qb.compile())\n     *   return qb\n     * }\n     *\n     * await db.insertInto('person')\n     *   .values({ first_name: 'John', last_name: 'Doe', gender: 'male' })\n     *   .$call(log)\n     *   .execute()\n     * ```\n     */\n    $call(func) {\n        return func(this);\n    }\n    /**\n     * Call `func(this)` if `condition` is true.\n     *\n     * This method is especially handy with optional selects. Any `returning` or `returningAll`\n     * method calls add columns as optional fields to the output type when called inside\n     * the `func` callback. This is because we can't know if those selections were actually\n     * made before running the code.\n     *\n     * You can also call any other methods inside the callback.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import type { NewPerson } from 'type-editor' // imaginary module\n     *\n     * async function insertPerson(values: NewPerson, returnLastName: boolean) {\n     *   return await db\n     *     .insertInto('person')\n     *     .values(values)\n     *     .returning(['id', 'first_name'])\n     *     .$if(returnLastName, (qb) => qb.returning('last_name'))\n     *     .executeTakeFirstOrThrow()\n     * }\n     * ```\n     *\n     * Any selections added inside the `if` callback will be added as optional fields to the\n     * output type since we can't know if the selections were actually made before running\n     * the code. In the example above the return type of the `insertPerson` function is:\n     *\n     * ```ts\n     * Promise<{\n     *   id: number\n     *   first_name: string\n     *   last_name?: string\n     * }>\n     * ```\n     */\n    $if(condition, func) {\n        if (condition) {\n            return func(this);\n        }\n        return new InsertQueryBuilder({\n            ...this.#props,\n        });\n    }\n    /**\n     * Change the output type of the query.\n     *\n     * This method call doesn't change the SQL in any way. This methods simply\n     * returns a copy of this `InsertQueryBuilder` with a new output type.\n     */\n    $castTo() {\n        return new InsertQueryBuilder(this.#props);\n    }\n    /**\n     * Narrows (parts of) the output type of the query.\n     *\n     * Kysely tries to be as type-safe as possible, but in some cases we have to make\n     * compromises for better maintainability and compilation performance. At present,\n     * Kysely doesn't narrow the output type of the query based on {@link values} input\n     * when using {@link returning} or {@link returningAll}.\n     *\n     * This utility method is very useful for these situations, as it removes unncessary\n     * runtime assertion/guard code. Its input type is limited to the output type\n     * of the query, so you can't add a column that doesn't exist, or change a column's\n     * type to something that doesn't exist in its union type.\n     *\n     * ### Examples\n     *\n     * Turn this code:\n     *\n     * ```ts\n     * import type { Person } from 'type-editor' // imaginary module\n     *\n     * const person = await db.insertInto('person')\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'male',\n     *     nullable_column: 'hell yeah!'\n     *   })\n     *   .returningAll()\n     *   .executeTakeFirstOrThrow()\n     *\n     * if (isWithNoNullValue(person)) {\n     *   functionThatExpectsPersonWithNonNullValue(person)\n     * }\n     *\n     * function isWithNoNullValue(person: Person): person is Person & { nullable_column: string } {\n     *   return person.nullable_column != null\n     * }\n     * ```\n     *\n     * Into this:\n     *\n     * ```ts\n     * import type { NotNull } from 'kysely'\n     *\n     * const person = await db.insertInto('person')\n     *   .values({\n     *     first_name: 'John',\n     *     last_name: 'Doe',\n     *     gender: 'male',\n     *     nullable_column: 'hell yeah!'\n     *   })\n     *   .returningAll()\n     *   .$narrowType<{ nullable_column: NotNull }>()\n     *   .executeTakeFirstOrThrow()\n     *\n     * functionThatExpectsPersonWithNonNullValue(person)\n     * ```\n     */\n    $narrowType() {\n        return new InsertQueryBuilder(this.#props);\n    }\n    /**\n     * Asserts that query's output row type equals the given type `T`.\n     *\n     * This method can be used to simplify excessively complex types to make TypeScript happy\n     * and much faster.\n     *\n     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much\n     * for TypeScript and you get errors like this:\n     *\n     * ```\n     * error TS2589: Type instantiation is excessively deep and possibly infinite.\n     * ```\n     *\n     * In these case you can often use this method to help TypeScript a little bit. When you use this\n     * method to assert the output type of a query, Kysely can drop the complex output type that\n     * consists of multiple nested helper types and replace it with the simple asserted type.\n     *\n     * Using this method doesn't reduce type safety at all. You have to pass in a type that is\n     * structurally equal to the current type.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * import type { NewPerson, NewPet, Species } from 'type-editor' // imaginary module\n     *\n     * async function insertPersonAndPet(person: NewPerson, pet: Omit<NewPet, 'owner_id'>) {\n     *   return await db\n     *     .with('new_person', (qb) => qb\n     *       .insertInto('person')\n     *       .values(person)\n     *       .returning('id')\n     *       .$assertType<{ id: number }>()\n     *     )\n     *     .with('new_pet', (qb) => qb\n     *       .insertInto('pet')\n     *       .values((eb) => ({\n     *         owner_id: eb.selectFrom('new_person').select('id'),\n     *         ...pet\n     *       }))\n     *       .returning(['name as pet_name', 'species'])\n     *       .$assertType<{ pet_name: string, species: Species }>()\n     *     )\n     *     .selectFrom(['new_person', 'new_pet'])\n     *     .selectAll()\n     *     .executeTakeFirstOrThrow()\n     * }\n     * ```\n     */\n    $assertType() {\n        return new InsertQueryBuilder(this.#props);\n    }\n    /**\n     * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.\n     */\n    withPlugin(plugin) {\n        return new InsertQueryBuilder({\n            ...this.#props,\n            executor: this.#props.executor.withPlugin(plugin),\n        });\n    }\n    toOperationNode() {\n        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);\n    }\n    compile() {\n        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);\n    }\n    /**\n     * Executes the query and returns an array of rows.\n     *\n     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.\n     */\n    async execute() {\n        const compiledQuery = this.compile();\n        const result = await this.#props.executor.executeQuery(compiledQuery);\n        const { adapter } = this.#props.executor;\n        const query = compiledQuery.query;\n        if ((query.returning && adapter.supportsReturning) ||\n            (query.output && adapter.supportsOutput)) {\n            return result.rows;\n        }\n        return [\n            new insert_result_js_1.InsertResult(result.insertId, result.numAffectedRows ?? BigInt(0)),\n        ];\n    }\n    /**\n     * Executes the query and returns the first result or undefined if\n     * the query returned no result.\n     */\n    async executeTakeFirst() {\n        const [result] = await this.execute();\n        return result;\n    }\n    /**\n     * Executes the query and returns the first result or throws if\n     * the query returned no result.\n     *\n     * By default an instance of {@link NoResultError} is thrown, but you can\n     * provide a custom error class, or callback as the only argument to throw a different\n     * error.\n     */\n    async executeTakeFirstOrThrow(errorConstructor = no_result_error_js_1.NoResultError) {\n        const result = await this.executeTakeFirst();\n        if (result === undefined) {\n            const error = (0, no_result_error_js_1.isNoResultErrorConstructor)(errorConstructor)\n                ? new errorConstructor(this.toOperationNode())\n                : errorConstructor(this.toOperationNode());\n            throw error;\n        }\n        return result;\n    }\n    async *stream(chunkSize = 100) {\n        const compiledQuery = this.compile();\n        const stream = this.#props.executor.stream(compiledQuery, chunkSize);\n        for await (const item of stream) {\n            yield* item.rows;\n        }\n    }\n    async explain(format, options) {\n        const builder = new InsertQueryBuilder({\n            ...this.#props,\n            queryNode: query_node_js_1.QueryNode.cloneWithExplain(this.#props.queryNode, format, options),\n        });\n        return await builder.execute();\n    }\n}\nexports.InsertQueryBuilder = InsertQueryBuilder;\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/query-builder/insert-result.js

@@ -0,0 +1,63 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/insert-result.js
+var require_insert_result = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/insert-result.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.InsertResult = void 0;
+	/**
+	* The result of an insert query.
+	*
+	* If the table has an auto incrementing primary key {@link insertId} will hold
+	* the generated id on dialects that support it. For example PostgreSQL doesn't
+	* return the id by default and {@link insertId} is undefined. On PostgreSQL you
+	* need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
+	* to get out the inserted id.
+	*
+	* {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.
+	* On MySQL, updated rows are counted twice when using `on duplicate key update`.
+	*
+	* ### Examples
+	*
+	* ```ts
+	* import type { NewPerson } from 'type-editor' // imaginary module
+	*
+	* async function insertPerson(person: NewPerson) {
+	*   const result = await db
+	*     .insertInto('person')
+	*     .values(person)
+	*     .executeTakeFirstOrThrow()
+	*
+	*   console.log(result.insertId) // relevant on MySQL
+	*   console.log(result.numInsertedOrUpdatedRows) // always relevant
+	* }
+	* ```
+	*/
+	var InsertResult = class {
+		/**
+		* The auto incrementing primary key of the inserted row.
+		*
+		* This property can be undefined when the query contains an `on conflict`
+		* clause that makes the query succeed even when nothing gets inserted.
+		*
+		* This property is always undefined on dialects like PostgreSQL that
+		* don't return the inserted id by default. On those dialects you need
+		* to use the {@link ReturningInterface.returning | returning} method.
+		*/
+		insertId;
+		/**
+		* Affected rows count.
+		*/
+		numInsertedOrUpdatedRows;
+		constructor(insertId, numInsertedOrUpdatedRows) {
+			this.insertId = insertId;
+			this.numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
+		}
+	};
+	exports.InsertResult = InsertResult;
+}) });
+
+//#endregion
+export default require_insert_result();
+
+export { require_insert_result };
+//# sourceMappingURL=insert-result.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insert-result.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/insert-result.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InsertResult = void 0;\n/**\n * The result of an insert query.\n *\n * If the table has an auto incrementing primary key {@link insertId} will hold\n * the generated id on dialects that support it. For example PostgreSQL doesn't\n * return the id by default and {@link insertId} is undefined. On PostgreSQL you\n * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}\n * to get out the inserted id.\n *\n * {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.\n * On MySQL, updated rows are counted twice when using `on duplicate key update`.\n *\n * ### Examples\n *\n * ```ts\n * import type { NewPerson } from 'type-editor' // imaginary module\n *\n * async function insertPerson(person: NewPerson) {\n *   const result = await db\n *     .insertInto('person')\n *     .values(person)\n *     .executeTakeFirstOrThrow()\n *\n *   console.log(result.insertId) // relevant on MySQL\n *   console.log(result.numInsertedOrUpdatedRows) // always relevant\n * }\n * ```\n */\nclass InsertResult {\n    /**\n     * The auto incrementing primary key of the inserted row.\n     *\n     * This property can be undefined when the query contains an `on conflict`\n     * clause that makes the query succeed even when nothing gets inserted.\n     *\n     * This property is always undefined on dialects like PostgreSQL that\n     * don't return the inserted id by default. On those dialects you need\n     * to use the {@link ReturningInterface.returning | returning} method.\n     */\n    insertId;\n    /**\n     * Affected rows count.\n     */\n    numInsertedOrUpdatedRows;\n    constructor(insertId, numInsertedOrUpdatedRows) {\n        this.insertId = insertId;\n        this.numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;\n    }\n}\nexports.InsertResult = InsertResult;\n"],"x_google_ignoreList":[0],"mappings":";;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,eAAe,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B5B,IAAM,eAAN,MAAmB;;;;;;;;;;;EAWf;;;;EAIA;EACA,YAAY,UAAU,0BAA0B;AAC5C,QAAK,WAAW;AAChB,QAAK,2BAA2B;;;AAGxC,SAAQ,eAAe"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/join-builder.js

@@ -0,0 +1,65 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_object_utils } from "../util/object-utils.js";
+import { require_join_node } from "../operation-node/join-node.js";
+import { require_raw_node } from "../operation-node/raw-node.js";
+import { require_binary_operation_parser } from "../parser/binary-operation-parser.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/join-builder.js
+var require_join_builder = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/join-builder.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.JoinBuilder = void 0;
+	const join_node_js_1 = require_join_node();
+	const raw_node_js_1 = require_raw_node();
+	const binary_operation_parser_js_1 = require_binary_operation_parser();
+	const object_utils_js_1 = require_object_utils();
+	var JoinBuilder = class JoinBuilder {
+		#props;
+		constructor(props) {
+			this.#props = (0, object_utils_js_1.freeze)(props);
+		}
+		on(...args) {
+			return new JoinBuilder({
+				...this.#props,
+				joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args))
+			});
+		}
+		/**
+		* Just like {@link WhereInterface.whereRef} but adds an item to the join's
+		* `on` clause instead.
+		*
+		* See {@link WhereInterface.whereRef} for documentation and examples.
+		*/
+		onRef(lhs, op, rhs) {
+			return new JoinBuilder({
+				...this.#props,
+				joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs))
+			});
+		}
+		/**
+		* Adds `on true`.
+		*/
+		onTrue() {
+			return new JoinBuilder({
+				...this.#props,
+				joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, raw_node_js_1.RawNode.createWithSql("true"))
+			});
+		}
+		/**
+		* Simply calls the provided function passing `this` as the only argument. `$call` returns
+		* what the provided function returns.
+		*/
+		$call(func) {
+			return func(this);
+		}
+		toOperationNode() {
+			return this.#props.joinNode;
+		}
+	};
+	exports.JoinBuilder = JoinBuilder;
+}) });
+
+//#endregion
+export default require_join_builder();
+
+export { require_join_builder };
+//# sourceMappingURL=join-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/join-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-builder.js","names":["#props"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/join-builder.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.JoinBuilder = void 0;\nconst join_node_js_1 = require(\"../operation-node/join-node.js\");\nconst raw_node_js_1 = require(\"../operation-node/raw-node.js\");\nconst binary_operation_parser_js_1 = require(\"../parser/binary-operation-parser.js\");\nconst object_utils_js_1 = require(\"../util/object-utils.js\");\nclass JoinBuilder {\n    #props;\n    constructor(props) {\n        this.#props = (0, object_utils_js_1.freeze)(props);\n    }\n    on(...args) {\n        return new JoinBuilder({\n            ...this.#props,\n            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),\n        });\n    }\n    /**\n     * Just like {@link WhereInterface.whereRef} but adds an item to the join's\n     * `on` clause instead.\n     *\n     * See {@link WhereInterface.whereRef} for documentation and examples.\n     */\n    onRef(lhs, op, rhs) {\n        return new JoinBuilder({\n            ...this.#props,\n            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),\n        });\n    }\n    /**\n     * Adds `on true`.\n     */\n    onTrue() {\n        return new JoinBuilder({\n            ...this.#props,\n            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, raw_node_js_1.RawNode.createWithSql('true')),\n        });\n    }\n    /**\n     * Simply calls the provided function passing `this` as the only argument. `$call` returns\n     * what the provided function returns.\n     */\n    $call(func) {\n        return func(this);\n    }\n    toOperationNode() {\n        return this.#props.joinNode;\n    }\n}\nexports.JoinBuilder = JoinBuilder;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,cAAc,KAAK;CAC3B,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,IAAM,cAAN,MAAM,YAAY;EACd;EACA,YAAY,OAAO;AACf,SAAKA,SAAU,GAAG,kBAAkB,QAAQ,MAAM;;EAEtD,GAAG,GAAG,MAAM;AACR,UAAO,IAAI,YAAY;IACnB,GAAG,MAAKA;IACR,UAAU,eAAe,SAAS,YAAY,MAAKA,MAAO,WAAW,GAAG,6BAA6B,uCAAuC,KAAK,CAAC;IACrJ,CAAC;;;;;;;;EAQN,MAAM,KAAK,IAAI,KAAK;AAChB,UAAO,IAAI,YAAY;IACnB,GAAG,MAAKA;IACR,UAAU,eAAe,SAAS,YAAY,MAAKA,MAAO,WAAW,GAAG,6BAA6B,iCAAiC,KAAK,IAAI,IAAI,CAAC;IACvJ,CAAC;;;;;EAKN,SAAS;AACL,UAAO,IAAI,YAAY;IACnB,GAAG,MAAKA;IACR,UAAU,eAAe,SAAS,YAAY,MAAKA,MAAO,UAAU,cAAc,QAAQ,cAAc,OAAO,CAAC;IACnH,CAAC;;;;;;EAMN,MAAM,MAAM;AACR,UAAO,KAAK,KAAK;;EAErB,kBAAkB;AACd,UAAO,MAAKA,MAAO;;;AAG3B,SAAQ,cAAc"}

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/json-path-builder.js

@@ -0,0 +1,210 @@
+import { __commonJS } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_identifier_node } from "../operation-node/identifier-node.js";
+import { require_alias_node } from "../operation-node/alias-node.js";
+import { require_operation_node_source } from "../operation-node/operation-node-source.js";
+import { require_json_reference_node } from "../operation-node/json-reference-node.js";
+import { require_json_operator_chain_node } from "../operation-node/json-operator-chain-node.js";
+import { require_json_path_node } from "../operation-node/json-path-node.js";
+import { require_value_node } from "../operation-node/value-node.js";
+import { require_json_path_leg_node } from "../operation-node/json-path-leg-node.js";
+
+//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/json-path-builder.js
+var require_json_path_builder = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/json-path-builder.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AliasedJSONPathBuilder = exports.TraversedJSONPathBuilder = exports.JSONPathBuilder = void 0;
+	const alias_node_js_1 = require_alias_node();
+	const identifier_node_js_1 = require_identifier_node();
+	const json_operator_chain_node_js_1 = require_json_operator_chain_node();
+	const json_path_leg_node_js_1 = require_json_path_leg_node();
+	const json_path_node_js_1 = require_json_path_node();
+	const json_reference_node_js_1 = require_json_reference_node();
+	const operation_node_source_js_1 = require_operation_node_source();
+	const value_node_js_1 = require_value_node();
+	var JSONPathBuilder = class {
+		#node;
+		constructor(node) {
+			this.#node = node;
+		}
+		/**
+		* Access an element of a JSON array in a specific location.
+		*
+		* Since there's no guarantee an element exists in the given array location, the
+		* resulting type is always nullable. If you're sure the element exists, you
+		* should use {@link SelectQueryBuilder.$assertType} to narrow the type safely.
+		*
+		* See also {@link key} to access properties of JSON objects.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* await db.selectFrom('person')
+		*   .select(eb =>
+		*     eb.ref('nicknames', '->').at(0).as('primary_nickname')
+		*   )
+		*   .execute()
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* select "nicknames"->0 as "primary_nickname" from "person"
+		*```
+		*
+		* Combined with {@link key}:
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('experience', '->').at(0).key('role').as('first_role')
+		* )
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* select "experience"->0->'role' as "first_role" from "person"
+		* ```
+		*
+		* You can use `'last'` to access the last element of the array in MySQL:
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('nicknames', '->$').at('last').as('last_nickname')
+		* )
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* select `nicknames`->'$[last]' as `last_nickname` from `person`
+		* ```
+		*
+		* Or `'#-1'` in SQLite:
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('nicknames', '->>$').at('#-1').as('last_nickname')
+		* )
+		* ```
+		*
+		* The generated SQL (SQLite):
+		*
+		* ```sql
+		* select "nicknames"->>'$[#-1]' as `last_nickname` from `person`
+		* ```
+		*/
+		at(index) {
+			return this.#createBuilderWithPathLeg("ArrayLocation", index);
+		}
+		/**
+		* Access a property of a JSON object.
+		*
+		* If a field is optional, the resulting type will be nullable.
+		*
+		* See also {@link at} to access elements of JSON arrays.
+		*
+		* ### Examples
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('address', '->').key('city').as('city')
+		* )
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* select "address"->'city' as "city" from "person"
+		* ```
+		*
+		* Going deeper:
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('profile', '->$').key('website').key('url').as('website_url')
+		* )
+		* ```
+		*
+		* The generated SQL (MySQL):
+		*
+		* ```sql
+		* select `profile`->'$.website.url' as `website_url` from `person`
+		* ```
+		*
+		* Combined with {@link at}:
+		*
+		* ```ts
+		* db.selectFrom('person').select(eb =>
+		*   eb.ref('profile', '->').key('addresses').at(0).key('city').as('city')
+		* )
+		* ```
+		*
+		* The generated SQL (PostgreSQL):
+		*
+		* ```sql
+		* select "profile"->'addresses'->0->'city' as "city" from "person"
+		* ```
+		*/
+		key(key) {
+			return this.#createBuilderWithPathLeg("Member", key);
+		}
+		#createBuilderWithPathLeg(legType, value) {
+			if (json_reference_node_js_1.JSONReferenceNode.is(this.#node)) return new TraversedJSONPathBuilder(json_reference_node_js_1.JSONReferenceNode.cloneWithTraversal(this.#node, json_path_node_js_1.JSONPathNode.is(this.#node.traversal) ? json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node.traversal, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value)) : json_operator_chain_node_js_1.JSONOperatorChainNode.cloneWithValue(this.#node.traversal, value_node_js_1.ValueNode.createImmediate(value))));
+			return new TraversedJSONPathBuilder(json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value)));
+		}
+	};
+	exports.JSONPathBuilder = JSONPathBuilder;
+	var TraversedJSONPathBuilder = class TraversedJSONPathBuilder extends JSONPathBuilder {
+		#node;
+		constructor(node) {
+			super(node);
+			this.#node = node;
+		}
+		/** @private */
+		get expressionType() {}
+		as(alias) {
+			return new AliasedJSONPathBuilder(this, alias);
+		}
+		/**
+		* Change the output type of the json path.
+		*
+		* This method call doesn't change the SQL in any way. This methods simply
+		* returns a copy of this `JSONPathBuilder` with a new output type.
+		*/
+		$castTo() {
+			return new TraversedJSONPathBuilder(this.#node);
+		}
+		$notNull() {
+			return new TraversedJSONPathBuilder(this.#node);
+		}
+		toOperationNode() {
+			return this.#node;
+		}
+	};
+	exports.TraversedJSONPathBuilder = TraversedJSONPathBuilder;
+	var AliasedJSONPathBuilder = class {
+		#jsonPath;
+		#alias;
+		constructor(jsonPath, alias) {
+			this.#jsonPath = jsonPath;
+			this.#alias = alias;
+		}
+		/** @private */
+		get expression() {
+			return this.#jsonPath;
+		}
+		/** @private */
+		get alias() {
+			return this.#alias;
+		}
+		toOperationNode() {
+			return alias_node_js_1.AliasNode.create(this.#jsonPath.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias) ? this.#alias.toOperationNode() : identifier_node_js_1.IdentifierNode.create(this.#alias));
+		}
+	};
+	exports.AliasedJSONPathBuilder = AliasedJSONPathBuilder;
+}) });
+
+//#endregion
+export default require_json_path_builder();
+
+export { require_json_path_builder };
+//# sourceMappingURL=json-path-builder.js.map

package/dist/node/node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/json-path-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-path-builder.js","names":["#node","#createBuilderWithPathLeg","#jsonPath","#alias"],"sources":["../../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/cjs/query-builder/json-path-builder.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AliasedJSONPathBuilder = exports.TraversedJSONPathBuilder = exports.JSONPathBuilder = void 0;\nconst alias_node_js_1 = require(\"../operation-node/alias-node.js\");\nconst identifier_node_js_1 = require(\"../operation-node/identifier-node.js\");\nconst json_operator_chain_node_js_1 = require(\"../operation-node/json-operator-chain-node.js\");\nconst json_path_leg_node_js_1 = require(\"../operation-node/json-path-leg-node.js\");\nconst json_path_node_js_1 = require(\"../operation-node/json-path-node.js\");\nconst json_reference_node_js_1 = require(\"../operation-node/json-reference-node.js\");\nconst operation_node_source_js_1 = require(\"../operation-node/operation-node-source.js\");\nconst value_node_js_1 = require(\"../operation-node/value-node.js\");\nclass JSONPathBuilder {\n    #node;\n    constructor(node) {\n        this.#node = node;\n    }\n    /**\n     * Access an element of a JSON array in a specific location.\n     *\n     * Since there's no guarantee an element exists in the given array location, the\n     * resulting type is always nullable. If you're sure the element exists, you\n     * should use {@link SelectQueryBuilder.$assertType} to narrow the type safely.\n     *\n     * See also {@link key} to access properties of JSON objects.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * await db.selectFrom('person')\n     *   .select(eb =>\n     *     eb.ref('nicknames', '->').at(0).as('primary_nickname')\n     *   )\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"nicknames\"->0 as \"primary_nickname\" from \"person\"\n     *```\n     *\n     * Combined with {@link key}:\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('experience', '->').at(0).key('role').as('first_role')\n     * )\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"experience\"->0->'role' as \"first_role\" from \"person\"\n     * ```\n     *\n     * You can use `'last'` to access the last element of the array in MySQL:\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('nicknames', '->$').at('last').as('last_nickname')\n     * )\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * select `nicknames`->'$[last]' as `last_nickname` from `person`\n     * ```\n     *\n     * Or `'#-1'` in SQLite:\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('nicknames', '->>$').at('#-1').as('last_nickname')\n     * )\n     * ```\n     *\n     * The generated SQL (SQLite):\n     *\n     * ```sql\n     * select \"nicknames\"->>'$[#-1]' as `last_nickname` from `person`\n     * ```\n     */\n    at(index) {\n        return this.#createBuilderWithPathLeg('ArrayLocation', index);\n    }\n    /**\n     * Access a property of a JSON object.\n     *\n     * If a field is optional, the resulting type will be nullable.\n     *\n     * See also {@link at} to access elements of JSON arrays.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('address', '->').key('city').as('city')\n     * )\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"address\"->'city' as \"city\" from \"person\"\n     * ```\n     *\n     * Going deeper:\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('profile', '->$').key('website').key('url').as('website_url')\n     * )\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * select `profile`->'$.website.url' as `website_url` from `person`\n     * ```\n     *\n     * Combined with {@link at}:\n     *\n     * ```ts\n     * db.selectFrom('person').select(eb =>\n     *   eb.ref('profile', '->').key('addresses').at(0).key('city').as('city')\n     * )\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"profile\"->'addresses'->0->'city' as \"city\" from \"person\"\n     * ```\n     */\n    key(key) {\n        return this.#createBuilderWithPathLeg('Member', key);\n    }\n    #createBuilderWithPathLeg(legType, value) {\n        if (json_reference_node_js_1.JSONReferenceNode.is(this.#node)) {\n            return new TraversedJSONPathBuilder(json_reference_node_js_1.JSONReferenceNode.cloneWithTraversal(this.#node, json_path_node_js_1.JSONPathNode.is(this.#node.traversal)\n                ? json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node.traversal, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value))\n                : json_operator_chain_node_js_1.JSONOperatorChainNode.cloneWithValue(this.#node.traversal, value_node_js_1.ValueNode.createImmediate(value))));\n        }\n        return new TraversedJSONPathBuilder(json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value)));\n    }\n}\nexports.JSONPathBuilder = JSONPathBuilder;\nclass TraversedJSONPathBuilder extends JSONPathBuilder {\n    #node;\n    constructor(node) {\n        super(node);\n        this.#node = node;\n    }\n    /** @private */\n    get expressionType() {\n        return undefined;\n    }\n    as(alias) {\n        return new AliasedJSONPathBuilder(this, alias);\n    }\n    /**\n     * Change the output type of the json path.\n     *\n     * This method call doesn't change the SQL in any way. This methods simply\n     * returns a copy of this `JSONPathBuilder` with a new output type.\n     */\n    $castTo() {\n        return new TraversedJSONPathBuilder(this.#node);\n    }\n    $notNull() {\n        return new TraversedJSONPathBuilder(this.#node);\n    }\n    toOperationNode() {\n        return this.#node;\n    }\n}\nexports.TraversedJSONPathBuilder = TraversedJSONPathBuilder;\nclass AliasedJSONPathBuilder {\n    #jsonPath;\n    #alias;\n    constructor(jsonPath, alias) {\n        this.#jsonPath = jsonPath;\n        this.#alias = alias;\n    }\n    /** @private */\n    get expression() {\n        return this.#jsonPath;\n    }\n    /** @private */\n    get alias() {\n        return this.#alias;\n    }\n    toOperationNode() {\n        return alias_node_js_1.AliasNode.create(this.#jsonPath.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)\n            ? this.#alias.toOperationNode()\n            : identifier_node_js_1.IdentifierNode.create(this.#alias));\n    }\n}\nexports.AliasedJSONPathBuilder = AliasedJSONPathBuilder;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,yBAAyB,QAAQ,2BAA2B,QAAQ,kBAAkB,KAAK;CACnG,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACN,IAAM,kBAAN,MAAsB;EAClB;EACA,YAAY,MAAM;AACd,SAAKA,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqEjB,GAAG,OAAO;AACN,UAAO,MAAKC,yBAA0B,iBAAiB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDjE,IAAI,KAAK;AACL,UAAO,MAAKA,yBAA0B,UAAU,IAAI;;EAExD,0BAA0B,SAAS,OAAO;AACtC,OAAI,yBAAyB,kBAAkB,GAAG,MAAKD,KAAM,CACzD,QAAO,IAAI,yBAAyB,yBAAyB,kBAAkB,mBAAmB,MAAKA,MAAO,oBAAoB,aAAa,GAAG,MAAKA,KAAM,UAAU,GACjK,oBAAoB,aAAa,aAAa,MAAKA,KAAM,WAAW,wBAAwB,gBAAgB,OAAO,SAAS,MAAM,CAAC,GACnI,8BAA8B,sBAAsB,eAAe,MAAKA,KAAM,WAAW,gBAAgB,UAAU,gBAAgB,MAAM,CAAC,CAAC,CAAC;AAEtJ,UAAO,IAAI,yBAAyB,oBAAoB,aAAa,aAAa,MAAKA,MAAO,wBAAwB,gBAAgB,OAAO,SAAS,MAAM,CAAC,CAAC;;;AAGtK,SAAQ,kBAAkB;CAC1B,IAAM,2BAAN,MAAM,iCAAiC,gBAAgB;EACnD;EACA,YAAY,MAAM;AACd,SAAM,KAAK;AACX,SAAKA,OAAQ;;;EAGjB,IAAI,iBAAiB;EAGrB,GAAG,OAAO;AACN,UAAO,IAAI,uBAAuB,MAAM,MAAM;;;;;;;;EAQlD,UAAU;AACN,UAAO,IAAI,yBAAyB,MAAKA,KAAM;;EAEnD,WAAW;AACP,UAAO,IAAI,yBAAyB,MAAKA,KAAM;;EAEnD,kBAAkB;AACd,UAAO,MAAKA;;;AAGpB,SAAQ,2BAA2B;CACnC,IAAM,yBAAN,MAA6B;EACzB;EACA;EACA,YAAY,UAAU,OAAO;AACzB,SAAKE,WAAY;AACjB,SAAKC,QAAS;;;EAGlB,IAAI,aAAa;AACb,UAAO,MAAKD;;;EAGhB,IAAI,QAAQ;AACR,UAAO,MAAKC;;EAEhB,kBAAkB;AACd,UAAO,gBAAgB,UAAU,OAAO,MAAKD,SAAU,iBAAiB,GAAG,GAAG,2BAA2B,uBAAuB,MAAKC,MAAO,GACtI,MAAKA,MAAO,iBAAiB,GAC7B,qBAAqB,eAAe,OAAO,MAAKA,MAAO,CAAC;;;AAGtE,SAAQ,yBAAyB"}