kysely 0.16.3 → 0.16.7

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

@@ -101,25 +101,70 @@ 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.
      *
@@ -129,6 +174,9 @@ 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/cjs/query-builder/expression-builder.d.ts

@@ -3,8 +3,8 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
 import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
-import { RawBuilder } from '../index-nodeless.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);

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

@@ -8,7 +8,7 @@ const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugi
 const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const function_builder_js_1 = require("./function-builder.js");
-const index_nodeless_js_1 = require("../index-nodeless.js");
+const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -69,7 +69,7 @@ class ExpressionBuilder {
      * See {@link QueryCreator.raw}.
      */
     raw(sql, parameters) {
-        return new index_nodeless_js_1.RawBuilder({
+        return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
             sql,

package/dist/cjs/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/cjs/query-builder/function-builder.js

@@ -7,6 +7,9 @@ const query_id_js_1 = require("../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
@@ -45,15 +48,36 @@ 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.
@@ -72,7 +96,7 @@ class FunctionBuilder {
      * const { avg } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(avg<number>('price'))
+     *   .select(avg<number>('price').as('avg_price'))
      *   .execute()
      * ```
      */
@@ -96,7 +120,7 @@ class FunctionBuilder {
      * const { sum } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(sum<number>('price'))
+     *   .select(sum<number>('price').as('total_price'))
      *   .execute()
      * ```
      */
@@ -120,7 +144,7 @@ class FunctionBuilder {
      * const { count } = db.fn
      *
      * db.selectFrom('toy')
-     *   .select(count<number>('price'))
+     *   .select(count<number>('id').as('num_toys'))
      *   .execute()
      * ```
      */

package/dist/cjs/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/cjs/query-builder/insert-query-builder.js

@@ -317,26 +317,71 @@ 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.
      *
@@ -346,6 +391,9 @@ 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/cjs/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;

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

@@ -427,27 +427,15 @@ class SelectQueryBuilder {
     /**
      * 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
      * }
@@ -461,6 +449,64 @@ class SelectQueryBuilder {
     call(func) {
         return func(this);
     }
+    /**
+     * 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(condition, func) {
+        if (condition) {
+            return func(this);
+        }
+        return new SelectQueryBuilder({
+            ...this.#props,
+        });
+    }
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -490,6 +536,9 @@ class SelectQueryBuilder {
     castTo() {
         return new SelectQueryBuilder(this.#props);
     }
+    /**
+     * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
+     */
     withPlugin(plugin) {
         return new SelectQueryBuilder({
             ...this.#props,