kysely 0.11.2 → 0.12.1

package/dist/cjs/query-builder/update-query-builder.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateQueryBuilder = void 0;
+const join_parser_js_1 = require("../parser/join-parser.js");
+const select_parser_js_1 = require("../parser/select-parser.js");
+const filter_parser_js_1 = require("../parser/filter-parser.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
+const update_query_node_js_1 = require("../operation-node/update-query-node.js");
+const update_set_parser_js_1 = require("../parser/update-set-parser.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const update_result_js_1 = require("./update-result.js");
+const no_result_error_js_1 = require("./no-result-error.js");
+class UpdateQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    where(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+        });
+    }
+    whereRef(lhs, op, rhs) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+        });
+    }
+    orWhereRef(lhs, op, rhs) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    whereExists(arg) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    whereNotExists(arg) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereExists(arg) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereNotExists(arg) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+        });
+    }
+    innerJoin(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'InnerJoin', args)),
+        });
+    }
+    leftJoin(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'LeftJoin', args)),
+        });
+    }
+    rightJoin(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'RightJoin', args)),
+        });
+    }
+    fullJoin(...args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'FullJoin', args)),
+        });
+    }
+    /**
+     * Sets the values to update for an {@link Kysely.updateTable | update} query.
+     *
+     * This method takes an object whose keys are column names and values are
+     * values to update. In addition to the column's type, the values can be `raw`
+     * instances or select queries.
+     *
+     * The return value of an update query is an instance of {@link UpdateResult}.
+     * You can use the {@link returning} method on supported databases to get out
+     * the updated rows.
+     *
+     * ### Examples
+     *
+     * Update a row in `person` table:
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .where('id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3
+     * ```
+     *
+     * On PostgreSQL you ca chain `returning` to the query to get
+     * the updated rows' columns (or any other expression) as the
+     * return value:
+     *
+     * ```ts
+     * const row = await db
+     *   .updateTable('person')
+     *   .set({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .where('id', '=', 1)
+     *   .returning('id')
+     *   .executeTakeFirstOrThrow()
+     *
+     * row.id
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3 returning "id"
+     * ```
+     *
+     * In addition to primitives, the values can also be `raw` expressions or
+     * select queries:
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set({
+     *     first_name: 'Jennifer',
+     *     last_name: db.raw('? || ?', ['Ani', 'ston']),
+     *     age: db.selectFrom('person').select(raw('avg(age)')),
+     *   })
+     *   .where('id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person" set
+     * "first_name" = $1,
+     * "last_name" = $2 || $3,
+     * "age" = (select avg(age) from "person")
+     * where "id" = $4
+     * ```
+     */
+    set(row) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, (0, update_set_parser_js_1.parseUpdateObject)(this.#props.parseContext, row)),
+        });
+    }
+    returning(selection) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
+        });
+    }
+    returningAll() {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
+        });
+    }
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .set(values)
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.where('something', '=', something)
+     *     } else {
+     *       return qb.where('somethingElse', '=', somethingElse)
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
+    /**
+     * Change the output type of the query.
+     *
+     * You should only use this method as the last resort if the types
+     * don't support your use case.
+     */
+    castTo() {
+        return new UpdateQueryBuilder(this.#props);
+    }
+    withPlugin(plugin) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    /**
+     * Executes the query and returns an array of rows.
+     *
+     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
+     */
+    async execute() {
+        const compildQuery = this.compile();
+        const query = compildQuery.query;
+        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        if (this.#props.parseContext.adapter.supportsReturning && query.returning) {
+            return result.rows;
+        }
+        else {
+            return [new update_result_js_1.UpdateResult(result.numUpdatedOrDeletedRows)];
+        }
+    }
+    /**
+     * Executes the query and returns the first result or undefined if
+     * the query returned no result.
+     */
+    async executeTakeFirst() {
+        const [result] = await this.execute();
+        return result;
+    }
+    /**
+     * Executes the query and returns the first result or throws if
+     * the query returned no result.
+     *
+     * By default an instance of {@link NoResultError} is thrown, but you can
+     * provide a custom error class as the only argument to throw a different
+     * error.
+     */
+    async executeTakeFirstOrThrow(errorConstructor = no_result_error_js_1.NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            throw new errorConstructor(this.toOperationNode());
+        }
+        return result;
+    }
+}
+exports.UpdateQueryBuilder = UpdateQueryBuilder;
+(0, prevent_await_js_1.preventAwait)(UpdateQueryBuilder, "don't await UpdateQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/cjs/query-builder/where-interface.d.ts

@@ -0,0 +1,378 @@
+import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+export interface WhereInterface<DB, TB extends keyof DB> {
+    /**
+     * Adds a `where` clause to the query.
+     *
+     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     *
+     * ### Examples
+     *
+     * Find a row by column value:
+     *
+     * ```ts
+     * const person = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '=', 100)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" = $1
+     * ```
+     *
+     * Operator can be any supported operator or if the typings don't support it
+     * you can always use `db.raw('your operator')`.
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '>', 100)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" > $1
+     * ```
+     *
+     * The `where` methods don't change the type of the query. You can add
+     * conditional `where`s easily by doing something like this:
+     *
+     * ```ts
+     * let query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *
+     * if (firstName) {
+     *   query = query.where('first_name', '=', firstName)
+     * }
+     *
+     * const persons = await query.execute()
+     * ```
+     *
+     * This is true for basically all methods execpt the `select` and
+     * `returning` methods, which DO change the return type of the
+     * query.
+     *
+     * Both the first and third argument can also be subqueries.
+     * A subquery is defined by passing a function and calling
+     * the `selectFrom` method of the object passed into the
+     * function:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(
+     *     (qb) => qb.selectFrom('pet')
+     *       .select('pet.name')
+     *       .whereRef('pet.owner_id', '=', 'person.id')
+     *       .limit(1),
+     *     '=',
+     *     'Fluffy'
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   select "pet"."name"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     *   limit $1
+     * ) = $2
+     * ```
+     *
+     * A `where in` query can be built by using the `in` operator and an array
+     * of values. The values in the array can also be subqueries or raw
+     * instances.
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('person.id', 'in', [100, 200, 300])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" in ($1, $2, $3)
+     * ```
+     *
+     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * as any of the arguments, including the operator:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(
+     *     db.raw('coalesce(first_name, last_name)'),
+     *     'like',
+     *     '%' + name + '%',
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
+     * ```
+     *
+     * If you only pass one function argument to this method, it can be
+     * used to create parentheses around other where statements:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .where('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     *
+     * In all examples above the columns were known at compile time
+     * (except for the `raw` expressions). By default kysely only allows
+     * you to refer to columns that exist in the database **and** can be
+     * referred to in the current query and context.
+     *
+     * Sometimes you may want to refer to columns that come from the user
+     * input and thus are not available at compile time.
+     *
+     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * uses both:
+     *
+     * ```ts
+     * const { ref } = db.dynamic
+     *
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where(ref(columnFromUserInput), '=', 1)
+     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .execute()
+     * ```
+     */
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
+    where(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
+    where(raw: AnyRawBuilder): WhereInterface<DB, TB>;
+    /**
+     * Adds a `where` clause where both sides of the operator are references
+     * to columns.
+     *
+     * The normal `where` method treats the right hand side argument as a
+     * value by default. `whereRef` treats it as a column reference. This method is
+     * expecially useful with joins and correclated subqueries.
+     *
+     * ### Examples
+     *
+     * Usage with a join:
+     *
+     * ```ts
+     * db.selectFrom(['person', 'pet'])
+     *   .selectAll()
+     *   .whereRef('person.first_name', '=', 'pet.name')
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person", "pet" where "person"."first_name" = "pet"."name"
+     * ```
+     *
+     * Usage in a subquery:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll('person')
+     *   .select((qb) => qb
+     *     .selectFrom('pet')
+     *     .select('name')
+     *     .whereRef('pet.owner_id', '=', 'person.id')
+     *     .limit(1)
+     *     .as('pet_name')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*, (
+     *   select "name"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     *   limit $1
+     * ) as "pet_name"
+     * from "person"
+     */
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
+     *
+     * It's often necessary to wrap `or where` clauses in parentheses to control
+     * precendence. You can use the one argument version of the `where` method
+     * for that. See the examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', '=', 1)
+     *   .orWhere('id', '=', 2)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" = 1 or "id" = 2
+     * ```
+     *
+     * Grouping with parentheses:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .where('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     *
+     * Even the first `where` can be an `orWhere`. This is useful
+     * if you are looping through a set of conditions:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where((qb) => qb
+     *     .orWhere('id', '=', 1)
+     *     .orWhere('id', '=', 2)
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" (where "id" = 1 or "id" = 2)
+     * ```
+     */
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
+    orWhere(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
+    orWhere(raw: AnyRawBuilder): WhereInterface<DB, TB>;
+    /**
+     * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
+     *
+     * Also see {@link orWhere} and {@link where}.
+     */
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * Adds a `where exists` clause to the query.
+     *
+     * You can either use a subquery or a raw instance.
+     *
+     * ### Examples
+     *
+     * The query below selets all persons that own a pet named Catto:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .whereExists((qb) => qb
+     *     .selectFrom('pet')
+     *     .select('pet.id')
+     *     .whereRef('person.id', '=', 'pet.owner_id')
+     *     .where('pet.name', '=', 'Catto')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where exists (
+     *   select "pet"."id"
+     *   from "pet"
+     *   where "person"."id" = "pet"."owner_id"
+     *   and "pet"."name" = $1
+     * )
+     * ```
+     *
+     * The same query as in the previous example but with using raw:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .whereExists(
+     *     db.raw(
+     *       '(select pet.id from pet where person.id = pet.owner_id and pet.name = ?)',
+     *       ['Catto']
+     *     )
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where exists (
+     *   select pet.id
+     *   from pet
+     *   where person.id = pet.owner_id
+     *   and pet.name = $1
+     * )
+     * ```
+     */
+    whereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * Just like {@link whereExists} but creates a `not exists` clause.
+     */
+    whereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * Just like {@link whereExists} but creates a `or exists` clause.
+     */
+    orWhereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * Just like {@link whereExists} but creates a `or not exists` clause.
+     */
+    orWhereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
+}

package/dist/cjs/query-builder/where-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/query-compiler/default-query-compiler.d.ts

@@ -67,6 +67,7 @@ import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-node.js';
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
 import { OnNode } from '../operation-node/on-node.js';
+import { ValuesNode } from '../operation-node/values-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -81,6 +82,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitWhere(node: WhereNode): void;
     protected visitHaving(node: HavingNode): void;
     protected visitInsertQuery(node: InsertQueryNode): void;
+    protected visitValues(node: ValuesNode): void;
     protected visitDeleteQuery(node: DeleteQueryNode): void;
     protected visitReturning(node: ReturningNode): void;
     protected visitAlias(node: AliasNode): void;