kysely 0.23.5 → 0.24.1

package/dist/esm/parser/coalesce-parser.js

@@ -1,8 +1,2 @@
 /// <reference types="./coalesce-parser.d.ts" />
-import { RawNode } from '../operation-node/raw-node.js';
-import { parseReferenceExpressionOrList, } from './reference-parser.js';
-export function parseCoalesce(values) {
-    return RawNode.create(values.length > 1
-        ? ['coalesce(', ...new Array(values.length - 1).fill(', '), ')']
-        : ['coalesce(', ')'], parseReferenceExpressionOrList(values));
-}
+export {};

package/dist/esm/parser/expression-parser.d.ts

@@ -1,10 +1,14 @@
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
-import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-export declare type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, Record<string, V>> | ((eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, Record<string, V>>) | Expression<V> | ((eb: ExpressionBuilder<DB, TB>) => Expression<V>);
-export declare type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | ((qb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>);
+export declare type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, Record<string, V>> | SelectQueryBuilderFactory<DB, TB, Record<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
+export declare type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
+declare type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, V>;
+declare type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
+declare type AliasedExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>;
 export declare function parseExpression(exp: ExpressionOrFactory<any, any, any>): OperationNode;
 export declare function parseAliasedExpression(exp: AliasedExpressionOrFactory<any, any>): AliasNode;
 export declare function isExpressionOrFactory(obj: unknown): obj is ExpressionOrFactory<any, any, any>;
+export {};

package/dist/esm/parser/expression-parser.js

@@ -1,14 +1,14 @@
 /// <reference types="./expression-parser.d.ts" />
 import { isAliasedExpression, isExpression, } from '../expression/expression.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
 import { isFunction } from '../util/object-utils.js';
-import { createExpressionBuilder } from './parse-utils.js';
 export function parseExpression(exp) {
     if (isOperationNodeSource(exp)) {
         return exp.toOperationNode();
     }
     else if (isFunction(exp)) {
-        return exp(createExpressionBuilder()).toOperationNode();
+        return exp(expressionBuilder()).toOperationNode();
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
@@ -17,7 +17,7 @@ export function parseAliasedExpression(exp) {
         return exp.toOperationNode();
     }
     else if (isFunction(exp)) {
-        return exp(createExpressionBuilder()).toOperationNode();
+        return exp(expressionBuilder()).toOperationNode();
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }

package/dist/esm/parser/group-by-parser.d.ts

@@ -1,5 +1,6 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare type GroupByExpressionOrList<DB, TB extends keyof DB, O> = ReadonlyArray<GroupByExpression<DB, TB, O>> | GroupByExpression<DB, TB, O>;
-export declare function parseGroupBy(groupBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];
+export declare type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
+export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

package/dist/esm/parser/group-by-parser.js

@@ -1,6 +1,9 @@
 /// <reference types="./group-by-parser.d.ts" />
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
 import { parseReferenceExpressionOrList, } from './reference-parser.js';
 export function parseGroupBy(groupBy) {
+    groupBy = isFunction(groupBy) ? groupBy(expressionBuilder()) : groupBy;
     return parseReferenceExpressionOrList(groupBy).map(GroupByItemNode.create);
 }

package/dist/esm/parser/insert-values-parser.d.ts

@@ -2,10 +2,13 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 } & {
     [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
+export declare type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
+export declare type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
+export declare function parseInsertExpression(arg: InsertExpression<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

package/dist/esm/parser/insert-values-parser.js

@@ -2,13 +2,18 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
-import { freeze, isUndefined } from '../util/object-utils.js';
+import { freeze, isFunction, isReadonlyArray, isUndefined, } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { isExpressionOrFactory } from './expression-parser.js';
 import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
-export function parseInsertObjectOrList(args) {
-    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
+import { expressionBuilder, } from '../expression/expression-builder.js';
+export function parseInsertExpression(arg) {
+    const objectOrList = isFunction(arg) ? arg(expressionBuilder()) : arg;
+    const list = isReadonlyArray(objectOrList)
+        ? objectOrList
+        : freeze([objectOrList]);
+    return parseInsertColumnsAndValues(list);
 }
 function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
@@ -34,19 +39,20 @@ function parseRowValues(row, columns) {
     const rowValues = Array.from({
         length: columns.size,
     });
-    let complexColumn = false;
+    let hasUndefinedOrComplexColumns = false;
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
-        if (columnIdx !== undefined) {
-            const value = row[col];
-            if (isExpressionOrFactory(value)) {
-                complexColumn = true;
-            }
-            rowValues[columnIdx] = value;
+        if (isUndefined(columnIdx)) {
+            continue;
+        }
+        const value = row[col];
+        if (isUndefined(value) || isExpressionOrFactory(value)) {
+            hasUndefinedOrComplexColumns = true;
         }
+        rowValues[columnIdx] = value;
     }
-    const columnMissing = rowColumns.length < columns.size;
-    if (columnMissing || complexColumn) {
+    const hasMissingColumns = rowColumns.length < columns.size;
+    if (hasMissingColumns || hasUndefinedOrComplexColumns) {
         const defaultValue = DefaultInsertValueNode.create();
         return ValueListNode.create(rowValues.map((it) => isUndefined(it) ? defaultValue : parseValueExpression(it)));
     }

package/dist/esm/parser/join-parser.js

@@ -1,7 +1,7 @@
 /// <reference types="./join-parser.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
-import { parseReferentialFilter } from './binary-operation-parser.js';
+import { parseReferentialComparison } from './binary-operation-parser.js';
 import { createJoinBuilder } from './parse-utils.js';
 export function parseJoin(joinType, args) {
     if (args.length === 3) {
@@ -19,5 +19,5 @@ function parseCallbackJoin(joinType, from, callback) {
     return joinBuilder.toOperationNode();
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
-    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialFilter(lhsColumn, '=', rhsColumn));
+    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialComparison(lhsColumn, '=', rhsColumn));
 }

package/dist/esm/parser/parse-utils.d.ts

@@ -1,12 +1,10 @@
 import { JoinType } from '../operation-node/join-node.js';
-import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { TableExpression } from './table-parser.js';
 export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
-export declare function createExpressionBuilder(): ExpressionBuilder<any, any>;
 export declare function createQueryCreator(): QueryCreator<any>;
 export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
 export declare function createOverBuilder(): OverBuilder<any, any>;

package/dist/esm/parser/parse-utils.js

@@ -2,7 +2,6 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { OverNode } from '../operation-node/over-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { OverBuilder } from '../query-builder/over-builder.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
@@ -17,11 +16,6 @@ export function createSelectQueryBuilder() {
         queryNode: SelectQueryNode.create(parseTableExpressionOrList([])),
     });
 }
-export function createExpressionBuilder() {
-    return new ExpressionBuilder({
-        executor: NOOP_QUERY_EXECUTOR,
-    });
-}
 export function createQueryCreator() {
     return new QueryCreator({
         executor: NOOP_QUERY_EXECUTOR,

package/dist/esm/parser/returning-parser.d.ts

@@ -1,5 +1,6 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
-import { Selection } from './select-parser.js';
+import { Selection, AllSelection } from './select-parser.js';
 export declare type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export declare type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

package/dist/esm/parser/select-parser.d.ts

@@ -1,21 +1,13 @@
-import { AliasedSelectQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
 import { AliasedExpression } from '../expression/expression.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
-export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
-/**
- * Given a selection expression returns a query builder type that
- * has the selection.
- */
-export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, SE> = SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>;
-/**
- * `selectAll` output query builder type.
- */
-export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & AllSelection<DB, S>>;
+export declare type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
@@ -23,11 +15,11 @@ declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractA
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
-declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+export declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];
 }>;
-export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
+export declare function parseSelectArg(selection: SelectArg<any, any, SelectExpression<any, any>>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/esm/parser/select-parser.js

@@ -1,12 +1,16 @@
 /// <reference types="./select-parser.d.ts" />
-import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { isFunction, isReadonlyArray, isString } from '../util/object-utils.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { parseAliasedStringReference } from './reference-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
 import { parseAliasedExpression, } from './expression-parser.js';
 import { parseTable } from './table-parser.js';
-export function parseSelectExpressionOrList(selection) {
-    if (isReadonlyArray(selection)) {
+import { expressionBuilder, } from '../expression/expression-builder.js';
+export function parseSelectArg(selection) {
+    if (isFunction(selection)) {
+        return parseSelectArg(selection(expressionBuilder()));
+    }
+    else if (isReadonlyArray(selection)) {
         return selection.map((it) => parseSelectExpression(it));
     }
     else {

package/dist/esm/parser/table-parser.d.ts

@@ -3,17 +3,19 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
-export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
+export declare type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
 export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
+export declare type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never;
+export declare type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? Record<A, DB[TB]> : never : never;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? ExtractTableAlias<DB, TE> : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
 declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
-declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
 export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;

package/dist/esm/parser/unary-operation-parser.d.ts

@@ -1,5 +1,8 @@
+import { UnaryOperator } from '../operation-node/operator-node.js';
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 import { ExpressionOrFactory } from './expression-parser.js';
+import { ReferenceExpression } from './reference-parser.js';
 export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
-export declare function parseExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
-export declare function parseNotExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseUnaryOperation(operator: UnaryOperator, operand: ReferenceExpression<any, any>): UnaryOperationNode;

package/dist/esm/parser/unary-operation-parser.js

@@ -1,13 +1,13 @@
 /// <reference types="./unary-operation-parser.d.ts" />
-import { OperatorNode, } from '../operation-node/operator-node.js';
+import { OperatorNode } from '../operation-node/operator-node.js';
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
-import { parseValueExpressionOrList } from './value-parser.js';
-export function parseExists(arg) {
-    return parseUnaryOperation('exists', arg);
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
 }
-export function parseNotExists(arg) {
-    return parseUnaryOperation('not exists', arg);
+export function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
 }
-function parseUnaryOperation(type, arg) {
-    return UnaryOperationNode.create(OperatorNode.create(type), parseValueExpressionOrList(arg));
+export function parseUnaryOperation(operator, operand) {
+    return UnaryOperationNode.create(OperatorNode.create(operator), parseReferenceExpression(operand));
 }

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,7 +1,10 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
 export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
-export declare function parseUpdateObject(update: UpdateObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
+export declare type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export declare function parseUpdateExpression(update: UpdateExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/update-set-parser.js

@@ -1,9 +1,14 @@
 /// <reference types="./update-set-parser.d.ts" />
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { expressionBuilder } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
-export function parseUpdateObject(update) {
-    return Object.entries(update)
+export function parseUpdateExpression(update) {
+    const updateObj = isFunction(update)
+        ? update(expressionBuilder())
+        : update;
+    return Object.entries(updateObj)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {
         return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));

package/dist/esm/parser/value-parser.d.ts

@@ -1,6 +1,11 @@
 import { ExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
+import { Expression } from '../expression/expression.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export declare type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
+declare type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
 export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
+export {};

package/dist/esm/parser/value-parser.js

@@ -8,9 +8,7 @@ export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return parseValueExpressionList(arg);
     }
-    else {
-        return parseValueExpression(arg);
-    }
+    return parseValueExpression(arg);
 }
 export function parseValueExpression(exp) {
     if (isExpressionOrFactory(exp)) {

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -5,7 +5,7 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
  */
 export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
     #private;

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

@@ -3,7 +3,7 @@ import { DeduplicateJoinsTransformer } from './deduplicate-joins-transformer.js'
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
  */
 export class DeduplicateJoinsPlugin {
     #transformer = new DeduplicateJoinsTransformer();

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

@@ -3,8 +3,9 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { WhereExpressionFactory } from './where-interface.js';
 export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
@@ -88,22 +89,19 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'female')
-     *         .as('female_count'),
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'male')
-     *         .as('male_count'),
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('gender', '=', 'other')
-     *         .as('other_count'),
+     *   .select((eb) => [
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'female')
+     *       .as('female_count'),
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'male')
+     *       .as('male_count'),
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'other')
+     *       .as('other_count'),
      *   ])
      *   .executeTakeFirstOrThrow()
      * ```
@@ -119,52 +117,14 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    filterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Adds a `filter` clause with a nested `where exists` clause after the function.
-     *
-     * Similar to {@link WhereInterface}'s `whereExists` method.
-     *
-     * ### Examples
-     *
-     * Count pet owners versus general public:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('person.id')
-     *         .filterWhereExists((qb) =>
-     *           qb
-     *             .selectFrom('pet')
-     *             .select('pet.id')
-     *             .whereRef('pet.owner_id', '=', 'person.id')
-     *         )
-     *         .as('pet_owner_count'),
-     *     (eb) => eb.fn.count<number>('person.id').as('total_count'),
-     *   ])
-     *   .executeTakeFirstOrThrow()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select count("person"."id") filter(where exists (
-     *   select "pet"."id"
-     *   from "pet"
-     *   where "pet"."owner_id" = "person"."id"
-     * )) as "pet_ower_count",
-     *   count("person"."id") as "total_count"
-     * from "person"
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     filterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
-     * the `filter` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     filterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
@@ -180,13 +140,12 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhereRef('first_name', '=', 'last_name')
-     *         .as('repeat_name_count'),
-     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   .select((eb) => [
+     *     eb.fn
+     *       .count<number>('id')
+     *       .filterWhereRef('first_name', '=', 'last_name')
+     *       .as('repeat_name_count'),
+     *     eb.fn.count<number>('id').as('total_count'),
      *   ])
      *   .executeTakeFirstOrThrow()
      * ```
@@ -202,64 +161,27 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      */
     filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Adds a `filter` clause with a nested `or where` clause after the function.
-     * Otherwise works just like {@link filterWhere}.
-     *
-     * Similar to {@link WhereInterface}'s `orWhere` method.
-     *
-     * ### Examples
-     *
-     * For some reason you're tasked with counting adults (18+) or people called
-     * "Bob" versus general public:
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     (eb) =>
-     *       eb.fn
-     *         .count<number>('id')
-     *         .filterWhere('age', '>=', '18')
-     *         .orFilterWhere('first_name', '=', 'Bob')
-     *         .as('adult_or_bob_count'),
-     *     (eb) => eb.fn.count<number>('id').as('total_count'),
-     *   ])
-     *   .executeTakeFirstOrThrow()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select
-     *   count("id") filter(where "age" >= $1 or "first_name" = $2) as "adult_or_bob_count",
-     *   count("id") as "total_count"
-     * from "person"
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    orFilterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orFilterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orFilterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Just like {@link filterWhereExists} but creates an `or exists` clause inside
-     * the `filter` clause.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereExists` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Just like {@link filterWhereExists} but creates an `or not exists` clause inside
-     * the `filter` clause.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereNotExists` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Adds an `or where` clause inside the `filter` clause. Otherwise works just
-     * like {@link filterWhereRef}.
-     *
-     * Also see {@link orFilterWhere} and {@link filterWhere}.
-     *
-     * Similar to {@link WhereInterface}'s `orWhereRef` method.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orFilterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
@@ -305,6 +227,11 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *