@fragno-dev/workflows 0.0.1 → 0.0.3

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

@@ -1,620 +0,0 @@
-import { freeze } from "./util/object-utils.js";
-import { InsertQueryNode } from "./operation-node/insert-query-node.js";
-import { UpdateQueryNode } from "./operation-node/update-query-node.js";
-import { DeleteQueryNode } from "./operation-node/delete-query-node.js";
-import { MergeQueryNode } from "./operation-node/merge-query-node.js";
-import { SelectQueryNode } from "./operation-node/select-query-node.js";
-import { parseSelectArg } from "./parser/select-parser.js";
-import { InsertQueryBuilder } from "./query-builder/insert-query-builder.js";
-import { DeleteQueryBuilder } from "./query-builder/delete-query-builder.js";
-import { UpdateQueryBuilder } from "./query-builder/update-query-builder.js";
-import { parseCommonTableExpression } from "./parser/with-parser.js";
-import { WithNode } from "./operation-node/with-node.js";
-import { createQueryId } from "./util/query-id.js";
-import { WithSchemaPlugin } from "./plugin/with-schema/with-schema-plugin.js";
-import { MergeQueryBuilder } from "./query-builder/merge-query-builder.js";
-import { createSelectQueryBuilder } from "./query-builder/select-query-builder.js";
-import { parseAliasedTable, parseTable, parseTableExpressionOrList } from "./parser/table-parser.js";
-
-//#region ../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-creator.js
-var QueryCreator = class QueryCreator {
-	#props;
-	constructor(props) {
-		this.#props = freeze(props);
-	}
-	/**
-	* Creates a `select` query builder for the given table or tables.
-	*
-	* The tables passed to this method are built as the query's `from` clause.
-	*
-	* ### Examples
-	*
-	* Create a select query for one table:
-	*
-	* ```ts
-	* db.selectFrom('person').selectAll()
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select * from "person"
-	* ```
-	*
-	* Create a select query for one table with an alias:
-	*
-	* ```ts
-	* const persons = await db.selectFrom('person as p')
-	*   .select(['p.id', 'first_name'])
-	*   .execute()
-	*
-	* console.log(persons[0].id)
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select "p"."id", "first_name" from "person" as "p"
-	* ```
-	*
-	* Create a select query from a subquery:
-	*
-	* ```ts
-	* const persons = await db.selectFrom(
-	*     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
-	*   )
-	*   .select('p.identifier')
-	*   .execute()
-	*
-	* console.log(persons[0].identifier)
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select "p"."identifier",
-	* from (
-	*   select "person"."id" as "identifier" from "person"
-	* ) as p
-	* ```
-	*
-	* Create a select query from raw sql:
-	*
-	* ```ts
-	* import { sql } from 'kysely'
-	*
-	* const items = await db
-	*   .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
-	*   .select('q.one')
-	*   .execute()
-	*
-	* console.log(items[0].one)
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select "q"."one",
-	* from (
-	*   select 1 as one
-	* ) as q
-	* ```
-	*
-	* When you use the `sql` tag you need to also provide the result type of the
-	* raw snippet / query so that Kysely can figure out what columns are
-	* available for the rest of the query.
-	*
-	* The `selectFrom` method also accepts an array for multiple tables. All
-	* the above examples can also be used in an array.
-	*
-	* ```ts
-	* import { sql } from 'kysely'
-	*
-	* const items = await db.selectFrom([
-	*     'person as p',
-	*     db.selectFrom('pet').select('pet.species').as('a'),
-	*     sql<{ one: number }>`(select 1 as one)`.as('q')
-	*   ])
-	*   .select(['p.id', 'a.species', 'q.one'])
-	*   .execute()
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select "p".id, "a"."species", "q"."one"
-	* from
-	*   "person" as "p",
-	*   (select "pet"."species" from "pet") as a,
-	*   (select 1 as one) as "q"
-	* ```
-	*/
-	selectFrom(from) {
-		return createSelectQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(from), this.#props.withNode)
-		});
-	}
-	selectNoFrom(selection) {
-		return createSelectQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(this.#props.withNode), parseSelectArg(selection))
-		});
-	}
-	/**
-	* Creates an insert query.
-	*
-	* The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-	* has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
-	* the inserted row if the db returned one.
-	*
-	* See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see
-	* the {@link ReturningInterface.returning | returning} method for a way to return columns
-	* on supported databases like PostgreSQL.
-	*
-	* ### Examples
-	*
-	* ```ts
-	* const result = await db
-	*   .insertInto('person')
-	*   .values({
-	*     first_name: 'Jennifer',
-	*     last_name: 'Aniston'
-	*   })
-	*   .executeTakeFirst()
-	*
-	* console.log(result.insertId)
-	* ```
-	*
-	* Some databases like PostgreSQL support the `returning` method:
-	*
-	* ```ts
-	* const { id } = await db
-	*   .insertInto('person')
-	*   .values({
-	*     first_name: 'Jennifer',
-	*     last_name: 'Aniston'
-	*   })
-	*   .returning('id')
-	*   .executeTakeFirstOrThrow()
-	* ```
-	*/
-	insertInto(table) {
-		return new InsertQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode)
-		});
-	}
-	/**
-	* Creates a "replace into" query.
-	*
-	* This is only supported by some dialects like MySQL or SQLite.
-	*
-	* Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes
-	* and inserts values on collision instead of updating existing rows.
-	*
-	* An alias of SQLite's {@link InsertQueryBuilder.orReplace}.
-	*
-	* The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
-	* has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
-	* the inserted row if the db returned one.
-	*
-	* See the {@link InsertQueryBuilder.values | values} method for more info and examples.
-	*
-	* ### Examples
-	*
-	* ```ts
-	* const result = await db
-	*   .replaceInto('person')
-	*   .values({
-	*     first_name: 'Jennifer',
-	*     last_name: 'Aniston'
-	*   })
-	*   .executeTakeFirstOrThrow()
-	*
-	* console.log(result.insertId)
-	* ```
-	*
-	* The generated SQL (MySQL):
-	*
-	* ```sql
-	* replace into `person` (`first_name`, `last_name`) values (?, ?)
-	* ```
-	*/
-	replaceInto(table) {
-		return new InsertQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true)
-		});
-	}
-	/**
-	* Creates a delete query.
-	*
-	* See the {@link DeleteQueryBuilder.where} method for examples on how to specify
-	* a where clause for the delete operation.
-	*
-	* The return value of the query is an instance of {@link DeleteResult}.
-	*
-	* ### Examples
-	*
-	* <!-- siteExample("delete", "Single row", 10) -->
-	*
-	* Delete a single row:
-	*
-	* ```ts
-	* const result = await db
-	*   .deleteFrom('person')
-	*   .where('person.id', '=', 1)
-	*   .executeTakeFirst()
-	*
-	* console.log(result.numDeletedRows)
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* delete from "person" where "person"."id" = $1
-	* ```
-	*
-	* Some databases such as MySQL support deleting from multiple tables:
-	*
-	* ```ts
-	* const result = await db
-	*   .deleteFrom(['person', 'pet'])
-	*   .using('person')
-	*   .innerJoin('pet', 'pet.owner_id', 'person.id')
-	*   .where('person.id', '=', 1)
-	*   .executeTakeFirst()
-	* ```
-	*
-	* The generated SQL (MySQL):
-	*
-	* ```sql
-	* delete from `person`, `pet`
-	* using `person`
-	* inner join `pet` on `pet`.`owner_id` = `person`.`id`
-	* where `person`.`id` = ?
-	* ```
-	*/
-	deleteFrom(from) {
-		return new DeleteQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: DeleteQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode)
-		});
-	}
-	/**
-	* Creates an update query.
-	*
-	* See the {@link UpdateQueryBuilder.where} method for examples on how to specify
-	* a where clause for the update operation.
-	*
-	* See the {@link UpdateQueryBuilder.set} method for examples on how to
-	* specify the updates.
-	*
-	* The return value of the query is an {@link UpdateResult}.
-	*
-	* ### Examples
-	*
-	* ```ts
-	* const result = await db
-	*   .updateTable('person')
-	*   .set({ first_name: 'Jennifer' })
-	*   .where('person.id', '=', 1)
-	*   .executeTakeFirst()
-	*
-	* console.log(result.numUpdatedRows)
-	* ```
-	*/
-	updateTable(tables) {
-		return new UpdateQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: UpdateQueryNode.create(parseTableExpressionOrList(tables), this.#props.withNode)
-		});
-	}
-	/**
-	* Creates a merge query.
-	*
-	* The return value of the query is a {@link MergeResult}.
-	*
-	* See the {@link MergeQueryBuilder.using} method for examples on how to specify
-	* the other table.
-	*
-	* ### Examples
-	*
-	* <!-- siteExample("merge", "Source row existence", 10) -->
-	*
-	* Update a target column based on the existence of a source row:
-	*
-	* ```ts
-	* const result = await db
-	*   .mergeInto('person as target')
-	*   .using('pet as source', 'source.owner_id', 'target.id')
-	*   .whenMatchedAnd('target.has_pets', '!=', 'Y')
-	*   .thenUpdateSet({ has_pets: 'Y' })
-	*   .whenNotMatchedBySourceAnd('target.has_pets', '=', 'Y')
-	*   .thenUpdateSet({ has_pets: 'N' })
-	*   .executeTakeFirstOrThrow()
-	*
-	* console.log(result.numChangedRows)
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* merge into "person"
-	* using "pet"
-	* on "pet"."owner_id" = "person"."id"
-	* when matched and "has_pets" != $1
-	* then update set "has_pets" = $2
-	* when not matched by source and "has_pets" = $3
-	* then update set "has_pets" = $4
-	* ```
-	*
-	* <!-- siteExample("merge", "Temporary changes table", 20) -->
-	*
-	* Merge new entries from a temporary changes table:
-	*
-	* ```ts
-	* const result = await db
-	*   .mergeInto('wine as target')
-	*   .using(
-	*     'wine_stock_change as source',
-	*     'source.wine_name',
-	*     'target.name',
-	*   )
-	*   .whenNotMatchedAnd('source.stock_delta', '>', 0)
-	*   .thenInsertValues(({ ref }) => ({
-	*     name: ref('source.wine_name'),
-	*     stock: ref('source.stock_delta'),
-	*   }))
-	*   .whenMatchedAnd(
-	*     (eb) => eb('target.stock', '+', eb.ref('source.stock_delta')),
-	*     '>',
-	*     0,
-	*   )
-	*   .thenUpdateSet('stock', (eb) =>
-	*     eb('target.stock', '+', eb.ref('source.stock_delta')),
-	*   )
-	*   .whenMatched()
-	*   .thenDelete()
-	*   .executeTakeFirstOrThrow()
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* merge into "wine" as "target"
-	* using "wine_stock_change" as "source"
-	* on "source"."wine_name" = "target"."name"
-	* when not matched and "source"."stock_delta" > $1
-	* then insert ("name", "stock") values ("source"."wine_name", "source"."stock_delta")
-	* when matched and "target"."stock" + "source"."stock_delta" > $2
-	* then update set "stock" = "target"."stock" + "source"."stock_delta"
-	* when matched
-	* then delete
-	* ```
-	*/
-	mergeInto(targetTable) {
-		return new MergeQueryBuilder({
-			queryId: createQueryId(),
-			executor: this.#props.executor,
-			queryNode: MergeQueryNode.create(parseAliasedTable(targetTable), this.#props.withNode)
-		});
-	}
-	/**
-	* Creates a `with` query (Common Table Expression).
-	*
-	* ### Examples
-	*
-	* <!-- siteExample("cte", "Simple selects", 10) -->
-	*
-	* Common table expressions (CTE) are a great way to modularize complex queries.
-	* Essentially they allow you to run multiple separate queries within a
-	* single roundtrip to the DB.
-	*
-	* Since CTEs are a part of the main query, query optimizers inside DB
-	* engines are able to optimize the overall query. For example, postgres
-	* is able to inline the CTEs inside the using queries if it decides it's
-	* faster.
-	*
-	* ```ts
-	* const result = await db
-	*   // Create a CTE called `jennifers` that selects all
-	*   // persons named 'Jennifer'.
-	*   .with('jennifers', (db) => db
-	*     .selectFrom('person')
-	*     .where('first_name', '=', 'Jennifer')
-	*     .select(['id', 'age'])
-	*   )
-	*   // Select all rows from the `jennifers` CTE and
-	*   // further filter it.
-	*   .with('adult_jennifers', (db) => db
-	*     .selectFrom('jennifers')
-	*     .where('age', '>', 18)
-	*     .select(['id', 'age'])
-	*   )
-	*   // Finally select all adult jennifers that are
-	*   // also younger than 60.
-	*   .selectFrom('adult_jennifers')
-	*   .where('age', '<', 60)
-	*   .selectAll()
-	*   .execute()
-	* ```
-	*
-	* <!-- siteExample("cte", "Inserts, updates and deletions", 20) -->
-	*
-	* Some databases like postgres also allow you to run other queries than selects
-	* in CTEs. On these databases CTEs are extremely powerful:
-	*
-	* ```ts
-	* const result = await db
-	*   .with('new_person', (db) => db
-	*     .insertInto('person')
-	*     .values({
-	*       first_name: 'Jennifer',
-	*       age: 35,
-	*     })
-	*     .returning('id')
-	*   )
-	*   .with('new_pet', (db) => db
-	*     .insertInto('pet')
-	*     .values({
-	*       name: 'Doggo',
-	*       species: 'dog',
-	*       is_favorite: true,
-	*       // Use the id of the person we just inserted.
-	*       owner_id: db
-	*         .selectFrom('new_person')
-	*         .select('id')
-	*     })
-	*     .returning('id')
-	*   )
-	*   .selectFrom(['new_person', 'new_pet'])
-	*   .select([
-	*     'new_person.id as person_id',
-	*     'new_pet.id as pet_id'
-	*   ])
-	*   .execute()
-	* ```
-	*
-	* The CTE name can optionally specify column names in addition to
-	* a name. In that case Kysely requires the expression to retun
-	* rows with the same columns.
-	*
-	* ```ts
-	* await db
-	*   .with('jennifers(id, age)', (db) => db
-	*     .selectFrom('person')
-	*     .where('first_name', '=', 'Jennifer')
-	*     // This is ok since we return columns with the same
-	*     // names as specified by `jennifers(id, age)`.
-	*     .select(['id', 'age'])
-	*   )
-	*   .selectFrom('jennifers')
-	*   .selectAll()
-	*   .execute()
-	* ```
-	*
-	* The first argument can also be a callback. The callback is passed
-	* a `CTEBuilder` instance that can be used to configure the CTE:
-	*
-	* ```ts
-	* await db
-	*   .with(
-	*     (cte) => cte('jennifers').materialized(),
-	*     (db) => db
-	*       .selectFrom('person')
-	*       .where('first_name', '=', 'Jennifer')
-	*       .select(['id', 'age'])
-	*   )
-	*   .selectFrom('jennifers')
-	*   .selectAll()
-	*   .execute()
-	* ```
-	*/
-	with(nameOrBuilder, expression) {
-		const cte = parseCommonTableExpression(nameOrBuilder, expression);
-		return new QueryCreator({
-			...this.#props,
-			withNode: this.#props.withNode ? WithNode.cloneWithExpression(this.#props.withNode, cte) : WithNode.create(cte)
-		});
-	}
-	/**
-	* Creates a recursive `with` query (Common Table Expression).
-	*
-	* Note that recursiveness is a property of the whole `with` statement.
-	* You cannot have recursive and non-recursive CTEs in a same `with` statement.
-	* Therefore the recursiveness is determined by the **first** `with` or
-	* `withRecusive` call you make.
-	*
-	* See the {@link with} method for examples and more documentation.
-	*/
-	withRecursive(nameOrBuilder, expression) {
-		const cte = parseCommonTableExpression(nameOrBuilder, expression);
-		return new QueryCreator({
-			...this.#props,
-			withNode: this.#props.withNode ? WithNode.cloneWithExpression(this.#props.withNode, cte) : WithNode.create(cte, { recursive: true })
-		});
-	}
-	/**
-	* Returns a copy of this query creator instance with the given plugin installed.
-	*/
-	withPlugin(plugin) {
-		return new QueryCreator({
-			...this.#props,
-			executor: this.#props.executor.withPlugin(plugin)
-		});
-	}
-	/**
-	* Returns a copy of this query creator instance without any plugins.
-	*/
-	withoutPlugins() {
-		return new QueryCreator({
-			...this.#props,
-			executor: this.#props.executor.withoutPlugins()
-		});
-	}
-	/**
-	* Sets the schema to be used for all table references that don't explicitly
-	* specify a schema.
-	*
-	* This only affects the query created through the builder returned from
-	* this method and doesn't modify the `db` instance.
-	*
-	* See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0007-schemas.md)
-	* for a more detailed explanation.
-	*
-	* ### Examples
-	*
-	* ```
-	* await db
-	*   .withSchema('mammals')
-	*   .selectFrom('pet')
-	*   .selectAll()
-	*   .innerJoin('public.person', 'public.person.id', 'pet.owner_id')
-	*   .execute()
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select * from "mammals"."pet"
-	* inner join "public"."person"
-	* on "public"."person"."id" = "mammals"."pet"."owner_id"
-	* ```
-	*
-	* `withSchema` is smart enough to not add schema for aliases,
-	* common table expressions or other places where the schema
-	* doesn't belong to:
-	*
-	* ```
-	* await db
-	*   .withSchema('mammals')
-	*   .selectFrom('pet as p')
-	*   .select('p.name')
-	*   .execute()
-	* ```
-	*
-	* The generated SQL (PostgreSQL):
-	*
-	* ```sql
-	* select "p"."name" from "mammals"."pet" as "p"
-	* ```
-	*/
-	withSchema(schema) {
-		return new QueryCreator({
-			...this.#props,
-			executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
-		});
-	}
-};
-
-//#endregion
-export { QueryCreator };
-//# sourceMappingURL=query-creator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"query-creator.js","names":["#props"],"sources":["../../../../../../../../../../../node_modules/.pnpm/kysely@0.28.10/node_modules/kysely/dist/esm/query-creator.js"],"sourcesContent":["/// <reference types=\"./query-creator.d.ts\" />\nimport { createSelectQueryBuilder, } from './query-builder/select-query-builder.js';\nimport { InsertQueryBuilder } from './query-builder/insert-query-builder.js';\nimport { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';\nimport { UpdateQueryBuilder } from './query-builder/update-query-builder.js';\nimport { DeleteQueryNode } from './operation-node/delete-query-node.js';\nimport { InsertQueryNode } from './operation-node/insert-query-node.js';\nimport { SelectQueryNode } from './operation-node/select-query-node.js';\nimport { UpdateQueryNode } from './operation-node/update-query-node.js';\nimport { parseTable, parseTableExpressionOrList, parseAliasedTable, } from './parser/table-parser.js';\nimport { parseCommonTableExpression, } from './parser/with-parser.js';\nimport { WithNode } from './operation-node/with-node.js';\nimport { createQueryId } from './util/query-id.js';\nimport { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';\nimport { freeze } from './util/object-utils.js';\nimport { parseSelectArg, } from './parser/select-parser.js';\nimport { MergeQueryBuilder } from './query-builder/merge-query-builder.js';\nimport { MergeQueryNode } from './operation-node/merge-query-node.js';\nexport class QueryCreator {\n    #props;\n    constructor(props) {\n        this.#props = freeze(props);\n    }\n    /**\n     * Creates a `select` query builder for the given table or tables.\n     *\n     * The tables passed to this method are built as the query's `from` clause.\n     *\n     * ### Examples\n     *\n     * Create a select query for one table:\n     *\n     * ```ts\n     * db.selectFrom('person').selectAll()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select * from \"person\"\n     * ```\n     *\n     * Create a select query for one table with an alias:\n     *\n     * ```ts\n     * const persons = await db.selectFrom('person as p')\n     *   .select(['p.id', 'first_name'])\n     *   .execute()\n     *\n     * console.log(persons[0].id)\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"p\".\"id\", \"first_name\" from \"person\" as \"p\"\n     * ```\n     *\n     * Create a select query from a subquery:\n     *\n     * ```ts\n     * const persons = await db.selectFrom(\n     *     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')\n     *   )\n     *   .select('p.identifier')\n     *   .execute()\n     *\n     * console.log(persons[0].identifier)\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"p\".\"identifier\",\n     * from (\n     *   select \"person\".\"id\" as \"identifier\" from \"person\"\n     * ) as p\n     * ```\n     *\n     * Create a select query from raw sql:\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * const items = await db\n     *   .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))\n     *   .select('q.one')\n     *   .execute()\n     *\n     * console.log(items[0].one)\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"q\".\"one\",\n     * from (\n     *   select 1 as one\n     * ) as q\n     * ```\n     *\n     * When you use the `sql` tag you need to also provide the result type of the\n     * raw snippet / query so that Kysely can figure out what columns are\n     * available for the rest of the query.\n     *\n     * The `selectFrom` method also accepts an array for multiple tables. All\n     * the above examples can also be used in an array.\n     *\n     * ```ts\n     * import { sql } from 'kysely'\n     *\n     * const items = await db.selectFrom([\n     *     'person as p',\n     *     db.selectFrom('pet').select('pet.species').as('a'),\n     *     sql<{ one: number }>`(select 1 as one)`.as('q')\n     *   ])\n     *   .select(['p.id', 'a.species', 'q.one'])\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"p\".id, \"a\".\"species\", \"q\".\"one\"\n     * from\n     *   \"person\" as \"p\",\n     *   (select \"pet\".\"species\" from \"pet\") as a,\n     *   (select 1 as one) as \"q\"\n     * ```\n     */\n    selectFrom(from) {\n        return createSelectQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(from), this.#props.withNode),\n        });\n    }\n    selectNoFrom(selection) {\n        return createSelectQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(this.#props.withNode), parseSelectArg(selection)),\n        });\n    }\n    /**\n     * Creates an insert query.\n     *\n     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}\n     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of\n     * the inserted row if the db returned one.\n     *\n     * See the {@link InsertQueryBuilder.values | values} method for more info and examples. Also see\n     * the {@link ReturningInterface.returning | returning} method for a way to return columns\n     * on supported databases like PostgreSQL.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * const result = await db\n     *   .insertInto('person')\n     *   .values({\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston'\n     *   })\n     *   .executeTakeFirst()\n     *\n     * console.log(result.insertId)\n     * ```\n     *\n     * Some databases like PostgreSQL support the `returning` method:\n     *\n     * ```ts\n     * const { id } = await db\n     *   .insertInto('person')\n     *   .values({\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston'\n     *   })\n     *   .returning('id')\n     *   .executeTakeFirstOrThrow()\n     * ```\n     */\n    insertInto(table) {\n        return new InsertQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),\n        });\n    }\n    /**\n     * Creates a \"replace into\" query.\n     *\n     * This is only supported by some dialects like MySQL or SQLite.\n     *\n     * Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes\n     * and inserts values on collision instead of updating existing rows.\n     *\n     * An alias of SQLite's {@link InsertQueryBuilder.orReplace}.\n     *\n     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}\n     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of\n     * the inserted row if the db returned one.\n     *\n     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * const result = await db\n     *   .replaceInto('person')\n     *   .values({\n     *     first_name: 'Jennifer',\n     *     last_name: 'Aniston'\n     *   })\n     *   .executeTakeFirstOrThrow()\n     *\n     * console.log(result.insertId)\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * replace into `person` (`first_name`, `last_name`) values (?, ?)\n     * ```\n     */\n    replaceInto(table) {\n        return new InsertQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true),\n        });\n    }\n    /**\n     * Creates a delete query.\n     *\n     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify\n     * a where clause for the delete operation.\n     *\n     * The return value of the query is an instance of {@link DeleteResult}.\n     *\n     * ### Examples\n     *\n     * <!-- siteExample(\"delete\", \"Single row\", 10) -->\n     *\n     * Delete a single row:\n     *\n     * ```ts\n     * const result = await db\n     *   .deleteFrom('person')\n     *   .where('person.id', '=', 1)\n     *   .executeTakeFirst()\n     *\n     * console.log(result.numDeletedRows)\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * delete from \"person\" where \"person\".\"id\" = $1\n     * ```\n     *\n     * Some databases such as MySQL support deleting from multiple tables:\n     *\n     * ```ts\n     * const result = await db\n     *   .deleteFrom(['person', 'pet'])\n     *   .using('person')\n     *   .innerJoin('pet', 'pet.owner_id', 'person.id')\n     *   .where('person.id', '=', 1)\n     *   .executeTakeFirst()\n     * ```\n     *\n     * The generated SQL (MySQL):\n     *\n     * ```sql\n     * delete from `person`, `pet`\n     * using `person`\n     * inner join `pet` on `pet`.`owner_id` = `person`.`id`\n     * where `person`.`id` = ?\n     * ```\n     */\n    deleteFrom(from) {\n        return new DeleteQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: DeleteQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode),\n        });\n    }\n    /**\n     * Creates an update query.\n     *\n     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify\n     * a where clause for the update operation.\n     *\n     * See the {@link UpdateQueryBuilder.set} method for examples on how to\n     * specify the updates.\n     *\n     * The return value of the query is an {@link UpdateResult}.\n     *\n     * ### Examples\n     *\n     * ```ts\n     * const result = await db\n     *   .updateTable('person')\n     *   .set({ first_name: 'Jennifer' })\n     *   .where('person.id', '=', 1)\n     *   .executeTakeFirst()\n     *\n     * console.log(result.numUpdatedRows)\n     * ```\n     */\n    updateTable(tables) {\n        return new UpdateQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: UpdateQueryNode.create(parseTableExpressionOrList(tables), this.#props.withNode),\n        });\n    }\n    /**\n     * Creates a merge query.\n     *\n     * The return value of the query is a {@link MergeResult}.\n     *\n     * See the {@link MergeQueryBuilder.using} method for examples on how to specify\n     * the other table.\n     *\n     * ### Examples\n     *\n     * <!-- siteExample(\"merge\", \"Source row existence\", 10) -->\n     *\n     * Update a target column based on the existence of a source row:\n     *\n     * ```ts\n     * const result = await db\n     *   .mergeInto('person as target')\n     *   .using('pet as source', 'source.owner_id', 'target.id')\n     *   .whenMatchedAnd('target.has_pets', '!=', 'Y')\n     *   .thenUpdateSet({ has_pets: 'Y' })\n     *   .whenNotMatchedBySourceAnd('target.has_pets', '=', 'Y')\n     *   .thenUpdateSet({ has_pets: 'N' })\n     *   .executeTakeFirstOrThrow()\n     *\n     * console.log(result.numChangedRows)\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * merge into \"person\"\n     * using \"pet\"\n     * on \"pet\".\"owner_id\" = \"person\".\"id\"\n     * when matched and \"has_pets\" != $1\n     * then update set \"has_pets\" = $2\n     * when not matched by source and \"has_pets\" = $3\n     * then update set \"has_pets\" = $4\n     * ```\n     *\n     * <!-- siteExample(\"merge\", \"Temporary changes table\", 20) -->\n     *\n     * Merge new entries from a temporary changes table:\n     *\n     * ```ts\n     * const result = await db\n     *   .mergeInto('wine as target')\n     *   .using(\n     *     'wine_stock_change as source',\n     *     'source.wine_name',\n     *     'target.name',\n     *   )\n     *   .whenNotMatchedAnd('source.stock_delta', '>', 0)\n     *   .thenInsertValues(({ ref }) => ({\n     *     name: ref('source.wine_name'),\n     *     stock: ref('source.stock_delta'),\n     *   }))\n     *   .whenMatchedAnd(\n     *     (eb) => eb('target.stock', '+', eb.ref('source.stock_delta')),\n     *     '>',\n     *     0,\n     *   )\n     *   .thenUpdateSet('stock', (eb) =>\n     *     eb('target.stock', '+', eb.ref('source.stock_delta')),\n     *   )\n     *   .whenMatched()\n     *   .thenDelete()\n     *   .executeTakeFirstOrThrow()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * merge into \"wine\" as \"target\"\n     * using \"wine_stock_change\" as \"source\"\n     * on \"source\".\"wine_name\" = \"target\".\"name\"\n     * when not matched and \"source\".\"stock_delta\" > $1\n     * then insert (\"name\", \"stock\") values (\"source\".\"wine_name\", \"source\".\"stock_delta\")\n     * when matched and \"target\".\"stock\" + \"source\".\"stock_delta\" > $2\n     * then update set \"stock\" = \"target\".\"stock\" + \"source\".\"stock_delta\"\n     * when matched\n     * then delete\n     * ```\n     */\n    mergeInto(targetTable) {\n        return new MergeQueryBuilder({\n            queryId: createQueryId(),\n            executor: this.#props.executor,\n            queryNode: MergeQueryNode.create(parseAliasedTable(targetTable), this.#props.withNode),\n        });\n    }\n    /**\n     * Creates a `with` query (Common Table Expression).\n     *\n     * ### Examples\n     *\n     * <!-- siteExample(\"cte\", \"Simple selects\", 10) -->\n     *\n     * Common table expressions (CTE) are a great way to modularize complex queries.\n     * Essentially they allow you to run multiple separate queries within a\n     * single roundtrip to the DB.\n     *\n     * Since CTEs are a part of the main query, query optimizers inside DB\n     * engines are able to optimize the overall query. For example, postgres\n     * is able to inline the CTEs inside the using queries if it decides it's\n     * faster.\n     *\n     * ```ts\n     * const result = await db\n     *   // Create a CTE called `jennifers` that selects all\n     *   // persons named 'Jennifer'.\n     *   .with('jennifers', (db) => db\n     *     .selectFrom('person')\n     *     .where('first_name', '=', 'Jennifer')\n     *     .select(['id', 'age'])\n     *   )\n     *   // Select all rows from the `jennifers` CTE and\n     *   // further filter it.\n     *   .with('adult_jennifers', (db) => db\n     *     .selectFrom('jennifers')\n     *     .where('age', '>', 18)\n     *     .select(['id', 'age'])\n     *   )\n     *   // Finally select all adult jennifers that are\n     *   // also younger than 60.\n     *   .selectFrom('adult_jennifers')\n     *   .where('age', '<', 60)\n     *   .selectAll()\n     *   .execute()\n     * ```\n     *\n     * <!-- siteExample(\"cte\", \"Inserts, updates and deletions\", 20) -->\n     *\n     * Some databases like postgres also allow you to run other queries than selects\n     * in CTEs. On these databases CTEs are extremely powerful:\n     *\n     * ```ts\n     * const result = await db\n     *   .with('new_person', (db) => db\n     *     .insertInto('person')\n     *     .values({\n     *       first_name: 'Jennifer',\n     *       age: 35,\n     *     })\n     *     .returning('id')\n     *   )\n     *   .with('new_pet', (db) => db\n     *     .insertInto('pet')\n     *     .values({\n     *       name: 'Doggo',\n     *       species: 'dog',\n     *       is_favorite: true,\n     *       // Use the id of the person we just inserted.\n     *       owner_id: db\n     *         .selectFrom('new_person')\n     *         .select('id')\n     *     })\n     *     .returning('id')\n     *   )\n     *   .selectFrom(['new_person', 'new_pet'])\n     *   .select([\n     *     'new_person.id as person_id',\n     *     'new_pet.id as pet_id'\n     *   ])\n     *   .execute()\n     * ```\n     *\n     * The CTE name can optionally specify column names in addition to\n     * a name. In that case Kysely requires the expression to retun\n     * rows with the same columns.\n     *\n     * ```ts\n     * await db\n     *   .with('jennifers(id, age)', (db) => db\n     *     .selectFrom('person')\n     *     .where('first_name', '=', 'Jennifer')\n     *     // This is ok since we return columns with the same\n     *     // names as specified by `jennifers(id, age)`.\n     *     .select(['id', 'age'])\n     *   )\n     *   .selectFrom('jennifers')\n     *   .selectAll()\n     *   .execute()\n     * ```\n     *\n     * The first argument can also be a callback. The callback is passed\n     * a `CTEBuilder` instance that can be used to configure the CTE:\n     *\n     * ```ts\n     * await db\n     *   .with(\n     *     (cte) => cte('jennifers').materialized(),\n     *     (db) => db\n     *       .selectFrom('person')\n     *       .where('first_name', '=', 'Jennifer')\n     *       .select(['id', 'age'])\n     *   )\n     *   .selectFrom('jennifers')\n     *   .selectAll()\n     *   .execute()\n     * ```\n     */\n    with(nameOrBuilder, expression) {\n        const cte = parseCommonTableExpression(nameOrBuilder, expression);\n        return new QueryCreator({\n            ...this.#props,\n            withNode: this.#props.withNode\n                ? WithNode.cloneWithExpression(this.#props.withNode, cte)\n                : WithNode.create(cte),\n        });\n    }\n    /**\n     * Creates a recursive `with` query (Common Table Expression).\n     *\n     * Note that recursiveness is a property of the whole `with` statement.\n     * You cannot have recursive and non-recursive CTEs in a same `with` statement.\n     * Therefore the recursiveness is determined by the **first** `with` or\n     * `withRecusive` call you make.\n     *\n     * See the {@link with} method for examples and more documentation.\n     */\n    withRecursive(nameOrBuilder, expression) {\n        const cte = parseCommonTableExpression(nameOrBuilder, expression);\n        return new QueryCreator({\n            ...this.#props,\n            withNode: this.#props.withNode\n                ? WithNode.cloneWithExpression(this.#props.withNode, cte)\n                : WithNode.create(cte, { recursive: true }),\n        });\n    }\n    /**\n     * Returns a copy of this query creator instance with the given plugin installed.\n     */\n    withPlugin(plugin) {\n        return new QueryCreator({\n            ...this.#props,\n            executor: this.#props.executor.withPlugin(plugin),\n        });\n    }\n    /**\n     * Returns a copy of this query creator instance without any plugins.\n     */\n    withoutPlugins() {\n        return new QueryCreator({\n            ...this.#props,\n            executor: this.#props.executor.withoutPlugins(),\n        });\n    }\n    /**\n     * Sets the schema to be used for all table references that don't explicitly\n     * specify a schema.\n     *\n     * This only affects the query created through the builder returned from\n     * this method and doesn't modify the `db` instance.\n     *\n     * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0007-schemas.md)\n     * for a more detailed explanation.\n     *\n     * ### Examples\n     *\n     * ```\n     * await db\n     *   .withSchema('mammals')\n     *   .selectFrom('pet')\n     *   .selectAll()\n     *   .innerJoin('public.person', 'public.person.id', 'pet.owner_id')\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select * from \"mammals\".\"pet\"\n     * inner join \"public\".\"person\"\n     * on \"public\".\"person\".\"id\" = \"mammals\".\"pet\".\"owner_id\"\n     * ```\n     *\n     * `withSchema` is smart enough to not add schema for aliases,\n     * common table expressions or other places where the schema\n     * doesn't belong to:\n     *\n     * ```\n     * await db\n     *   .withSchema('mammals')\n     *   .selectFrom('pet as p')\n     *   .select('p.name')\n     *   .execute()\n     * ```\n     *\n     * The generated SQL (PostgreSQL):\n     *\n     * ```sql\n     * select \"p\".\"name\" from \"mammals\".\"pet\" as \"p\"\n     * ```\n     */\n    withSchema(schema) {\n        return new QueryCreator({\n            ...this.#props,\n            executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),\n        });\n    }\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}