kysely 0.11.2 → 0.12.1

package/dist/esm/query-builder/delete-query-builder.js

@@ -0,0 +1,181 @@
+import { parseJoin, } from '../parser/join-parser.js';
+import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
+import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
+import { QueryNode } from '../operation-node/query-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { NoResultError } from './no-result-error.js';
+import { DeleteResult } from './delete-result.js';
+export class DeleteQueryBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    where(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    whereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    orWhereRef(lhs, op, rhs) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    whereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    whereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    orWhereNotExists(arg) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    innerJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'InnerJoin', args)),
+        });
+    }
+    leftJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'LeftJoin', args)),
+        });
+    }
+    rightJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'RightJoin', args)),
+        });
+    }
+    fullJoin(...args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'FullJoin', args)),
+        });
+    }
+    returning(selection) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
+        });
+    }
+    returningAll() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, 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.deleteFrom('person')
+     *   .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 DeleteQueryBuilder(this.#props);
+    }
+    withPlugin(plugin) {
+        return new DeleteQueryBuilder({
+            ...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 DeleteResult(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 = NoResultError) {
+        const result = await this.executeTakeFirst();
+        if (result === undefined) {
+            throw new errorConstructor(this.toOperationNode());
+        }
+        return result;
+    }
+}
+preventAwait(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/esm/query-builder/expression-builder.d.ts

@@ -1,4 +1,5 @@
-import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
+import { SelectQueryBuilder } from './select-query-builder.js';
+import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
@@ -43,7 +44,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * The query builder returned by this method is typed in a way that you can refer to
      * all tables of the parent query in addition to the subquery's tables.
      *
-     * @example
+     * ### Examples
+     *
      * This example shows that you can refer to both `pet.owner_id` and `person.id`
      * columns from the subquery. This is needed to be able to create correlated
      * subqueries:
@@ -52,7 +54,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * const result = await db.selectFrom('pet')
      *   .select([
      *     'pet.name',
-     *     (qb) => qb.subQuery('person')
+     *     (qb) => qb.selectFrom('person')
      *       .whereRef('person.id', '=', 'pet.owner_id')
      *       .select('person.first_name')
      *       .as('owner_name')
@@ -74,12 +76,12 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * from "pet"
      * ```
      *
-     * You can use a normal query in place of `(qb) => qb.subQuery(...)` but in
+     * You can use a normal query in place of `(qb) => qb.selectFrom(...)` but in
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    subQuery<F extends TableExpression<DB, TB>>(from: F[]): QueryBuilderWithTable<DB, TB, {}, F>;
-    subQuery<F extends TableExpression<DB, TB>>(from: F): QueryBuilderWithTable<DB, TB, {}, F>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/esm/query-builder/expression-builder.js

@@ -1,4 +1,4 @@
-import { QueryBuilder } from './query-builder.js';
+import { SelectQueryBuilder } from './select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
@@ -44,8 +44,8 @@ export class ExpressionBuilder {
     get fn() {
         return new FunctionBuilder({ executor: this.#props.executor });
     }
-    subQuery(table) {
-        return new QueryBuilder({
+    selectFrom(table) {
+        return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
             parseContext: this.#props.parseContext,

package/dist/esm/query-builder/function-builder.d.ts

@@ -4,7 +4,8 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const { count } = db.fn
  *

package/dist/esm/query-builder/function-builder.js

@@ -4,7 +4,8 @@ import { createQueryId } from '../util/query-id.js';
 /**
  * Helpers for type safe SQL function calls.
  *
- * @example
+ * ### Examples
+ *
  * ```ts
  * const { count } = db.fn
  *

package/dist/esm/query-builder/having-interface.d.ts

@@ -0,0 +1,49 @@
+import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, HavingGrouper } from '../parser/filter-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+export interface HavingInterface<DB, TB extends keyof DB> {
+    /**
+     * Just like {@link WhereInterface.where | where} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    having(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
+    having(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhere | orWhere} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): HavingInterface<DB, TB>;
+    orHaving(grouper: HavingGrouper<DB, TB>): HavingInterface<DB, TB>;
+    orHaving(raw: AnyRawBuilder): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereRef | orWhereRef} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereExists | whereExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereNotExists | whereNotExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    havingNotExist(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereExists | orWhereExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.orWhereNotExists | orWhereNotExists} but adds a `having` statement
+     * instead of a `where` statement.
+     */
+    orHavingNotExists(arg: ExistsExpression<DB, TB>): HavingInterface<DB, TB>;
+}

package/dist/esm/query-builder/having-interface.js

@@ -0,0 +1 @@
+export {};