kysely 0.16.5 → 0.16.9

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -0,0 +1,39 @@
+/// <reference types="./deduplicate-joins-transformer.d.ts" />
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { compare, freeze } from '../../util/object-utils.js';
+export class DeduplicateJoinsTransformer extends OperationNodeTransformer {
+    transformSelectQuery(node) {
+        return this.#transformQuery(super.transformSelectQuery(node));
+    }
+    transformUpdateQuery(node) {
+        return this.#transformQuery(super.transformUpdateQuery(node));
+    }
+    transformDeleteQuery(node) {
+        return this.#transformQuery(super.transformDeleteQuery(node));
+    }
+    #transformQuery(node) {
+        if (!node.joins || node.joins.length === 0) {
+            return node;
+        }
+        return freeze({
+            ...node,
+            joins: this.#deduplicateJoins(node.joins),
+        });
+    }
+    #deduplicateJoins(joins) {
+        const out = [];
+        for (let i = 0; i < joins.length; ++i) {
+            let foundDuplicate = false;
+            for (let j = i + 1; j < joins.length; ++j) {
+                if (compare(joins[i], joins[j])) {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+            if (!foundDuplicate) {
+                out.push(joins[i]);
+            }
+        }
+        return freeze(out);
+    }
+}

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

@@ -6,7 +6,7 @@ import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -16,6 +16,7 @@ import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
+import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
 export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
@@ -589,23 +590,61 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.deleteFrom('person')
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function deletePerson(id: number, returnLastName: boolean) {
+     *   return await db
+     *     .deleteFrom('person')
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `deletePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<DB, TB, O2>): DeleteQueryBuilder<DB, TB, O2 extends DeleteResult ? DeleteResult : O extends DeleteResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -613,6 +652,9 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
     compile(): CompiledQuery;

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

@@ -99,25 +99,70 @@ export class DeleteQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
      * db.deleteFrom('person')
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function deletePerson(id: number, returnLastName: boolean) {
+     *   return await db
+     *     .deleteFrom('person')
+     *     .where('id', '=', id)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `deletePerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new DeleteQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -127,6 +172,9 @@ export class DeleteQueryBuilder {
     castTo() {
         return new DeleteQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this DeleteQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new DeleteQueryBuilder({
             ...this.#props,

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

@@ -4,6 +4,9 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
+ * You can always use {@link Kysely.raw} to call functions and build arbitrary
+ * expressions. This module simply has shortcuts for most common function calls.
+ *
  * ### Examples
  *
  * ```ts
@@ -35,12 +38,33 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
     constructor(props: FunctionBuilderProps);
     /**
      * Calls the `max` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
      */
-    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
     /**
      * Calls the `min` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
      */
-    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
     /**
      * Calls the `avg` function for the column given as the argument.
      *
@@ -58,7 +82,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { avg } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price'))
+     *   .select(avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      */
@@ -80,7 +104,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
@@ -102,7 +126,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('price'))
+     *   .select(count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */

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

@@ -5,6 +5,9 @@ import { createQueryId } from '../util/query-id.js';
 /**
  * Helpers for type safe SQL function calls.
  *
+ * You can always use {@link Kysely.raw} to call functions and build arbitrary
+ * expressions. This module simply has shortcuts for most common function calls.
+ *
  * ### Examples
  *
  * ```ts
@@ -43,15 +46,36 @@ export class FunctionBuilder {
     }
     /**
      * Calls the `max` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { max } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(max('price').as('max_price'))
+     *   .execute()
+     * ```
      */
-    min(column) {
-        return this.#oneArgFunction('min', column);
+    max(column) {
+        return this.#oneArgFunction('max', column);
     }
     /**
      * Calls the `min` function for the column given as the argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { min } = db.fn
+     *
+     * db.selectFrom('toy')
+     *   .select(min('price').as('min_price'))
+     *   .execute()
+     * ```
+     *
      */
-    max(column) {
-        return this.#oneArgFunction('max', column);
+    min(column) {
+        return this.#oneArgFunction('min', column);
     }
     /**
      * Calls the `avg` function for the column given as the argument.
@@ -70,7 +94,7 @@ export class FunctionBuilder {
      * const { avg } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price'))
+     *   .select(avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      */
@@ -94,7 +118,7 @@ export class FunctionBuilder {
      * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
@@ -118,7 +142,7 @@ export class FunctionBuilder {
      * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('price'))
+     *   .select(count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */

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

@@ -3,12 +3,13 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { SingleResultType } from '../util/type-utils.js';
+import { MergePartial, SingleResultType } from '../util/type-utils.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
@@ -448,24 +449,62 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.onConflict((oc) => oc.column('something').doNothing())
-     *     } else {
-     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
-     *     }
-     *   })
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.updateTable('person')
+     *   .set(values)
+     *   .call(log)
      *   .execute()
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function insertPerson(values: InsertablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .insertInto('person')
+     *     .values(values)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `insertPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if<O2>(condition: boolean, func: (qb: this) => InsertQueryBuilder<DB, TB, O2>): InsertQueryBuilder<DB, TB, O2 extends InsertResult ? InsertResult : O extends InsertResult ? Partial<O2> : MergePartial<O, O2>>;
     /**
      * Change the output type of the query.
      *
@@ -473,6 +512,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * don't support your use case.
      */
     castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): InsertQueryBuilder<DB, TB, O>;
     toOperationNode(): InsertQueryNode;
     compile(): CompiledQuery;

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

@@ -315,26 +315,71 @@ export class InsertQueryBuilder {
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
+     * The next example uses a helper funtion `log` to log a query:
+     *
      * ```ts
-     * db.insertInto('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.onConflict((oc) => oc.column('something').doNothing())
-     *     } else {
-     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
-     *     }
-     *   })
+     * function log<T extends Compilable>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.updateTable('person')
+     *   .set(values)
+     *   .call(log)
      *   .execute()
      * ```
      */
     call(func) {
         return func(this);
     }
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `returning` or `returningAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * You can also call any other methods inside the callback.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function insertPerson(values: InsertablePerson, returnLastName: boolean) {
+     *   return await db
+     *     .insertInto('person')
+     *     .values(values)
+     *     .returning(['id', 'first_name'])
+     *     .if(returnLastName, (qb) => qb.returning('last_name'))
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `insertPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     */
+    if(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new InsertQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Change the output type of the query.
      *
@@ -344,6 +389,9 @@ export class InsertQueryBuilder {
     castTo() {
         return new InsertQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this InsertQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new InsertQueryBuilder({
             ...this.#props,

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

@@ -7,7 +7,7 @@ import { SelectExpression, QueryBuilderWithSelection, SelectAllQueryBuilder } fr
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper, HavingGrouper } from '../parser/filter-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { AnyRawBuilder, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -1116,27 +1116,15 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
-     * This method can be useful when adding optional method calls:
+     * If you want to conditionally call a method on `this`, see
+     * the {@link if} method.
      *
      * ### Examples
      *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
-     *   .execute()
-     * ```
-     *
      * The next example uses a helper funtion `log` to log a query:
      *
      * ```ts
-     * function log<T extends AnyQueryBuilder>(qb: T): T {
+     * function log<T extends Compilable>(qb: T): T {
      *   console.log(qb.compile())
      *   return qb
      * }
@@ -1148,6 +1136,57 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     call<T>(func: (qb: this) => T): T;
+    /**
+     * Call `func(this)` if `condition` is true.
+     *
+     * This method is especially handy with optional selects. Any `select` or `selectAll`
+     * method calls add columns as optional fields to the output type when called inside
+     * the `func` callback. This is because we can't know if those selections were actually
+     * made before running the code.
+     *
+     * Also see [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/conditional-selects.md)
+     *
+     * ### Examples
+     *
+     * ```ts
+     * async function getPerson(id: number, withLastName: boolean) {
+     *   return await db
+     *     .selectFrom('person')
+     *     .select(['id', 'first_name'])
+     *     .if(withLastName, (qb) => qb.select('last_name'))
+     *     .where('id', '=', id)
+     *     .executeTakeFirstOrThrow()
+     * }
+     * ```
+     *
+     * Any selections added inside the `if` callback will be added as optional fields to the
+     * output type since we can't know if the selections were actually made before running
+     * the code. In the example above the return type of the `getPerson` function is:
+     *
+     * ```ts
+     * {
+     *   id: number
+     *   first_name: string
+     *   last_name?: string
+     * }
+     * ```
+     *
+     * You can also call any other methods inside the callback:
+     *
+     * ```ts
+     * const { count } = db.fn
+     *
+     * db.selectFrom('person')
+     *   .select('person.id')
+     *   .if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
+     *   .if(filterByPetCount, (qb) => qb
+     *     .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *     .having(count('pet.id'), '>', petCountLimit)
+     *     .groupBy('person.id')
+     *   )
+     * ```
+     */
+    if<O2 extends O>(condition: boolean, func: (qb: this) => SelectQueryBuilder<DB, TB, O2>): SelectQueryBuilder<DB, TB, MergePartial<O, O2>>;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -1173,6 +1212,9 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    /**
+     * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O>;
     toOperationNode(): SelectQueryNode;
     compile(): CompiledQuery;