kysely 0.26.1 → 0.26.3

package/dist/esm/operation-node/operator-node.js

@@ -20,6 +20,7 @@ export const COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '&&',
     '?',
     '?&',
     '!<',
@@ -61,6 +62,8 @@ export const OPERATORS = [
     ...BINARY_OPERATORS,
     ...JSON_OPERATORS,
     ...UNARY_OPERATORS,
+    'between',
+    'between symmetric',
 ];
 /**
  * @internal

package/dist/esm/operation-node/order-by-node.d.ts

@@ -9,6 +9,6 @@ export interface OrderByNode extends OperationNode {
  */
 export declare const OrderByNode: Readonly<{
     is(node: OperationNode): node is OrderByNode;
-    create(item: OrderByItemNode): OrderByNode;
-    cloneWithItem(orderBy: OrderByNode, item: OrderByItemNode): OrderByNode;
+    create(items: ReadonlyArray<OrderByItemNode>): OrderByNode;
+    cloneWithItems(orderBy: OrderByNode, items: ReadonlyArray<OrderByItemNode>): OrderByNode;
 }>;

package/dist/esm/operation-node/order-by-node.js

@@ -7,16 +7,16 @@ export const OrderByNode = freeze({
     is(node) {
         return node.kind === 'OrderByNode';
     },
-    create(item) {
+    create(items) {
         return freeze({
             kind: 'OrderByNode',
-            items: freeze([item]),
+            items: freeze([...items]),
         });
     },
-    cloneWithItem(orderBy, item) {
+    cloneWithItems(orderBy, items) {
         return freeze({
             ...orderBy,
-            items: freeze([...orderBy.items, item]),
+            items: freeze([...orderBy.items, ...items]),
         });
     },
 });

package/dist/esm/operation-node/over-node.d.ts

@@ -14,6 +14,6 @@ export interface OverNode extends OperationNode {
 export declare const OverNode: Readonly<{
     is(node: OperationNode): node is OverNode;
     create(): OverNode;
-    cloneWithOrderByItem(overNode: OverNode, item: OrderByItemNode): OverNode;
+    cloneWithOrderByItems(overNode: OverNode, items: ReadonlyArray<OrderByItemNode>): OverNode;
     cloneWithPartitionByItems(overNode: OverNode, items: ReadonlyArray<PartitionByItemNode>): OverNode;
 }>;

package/dist/esm/operation-node/over-node.js

@@ -14,12 +14,12 @@ export const OverNode = freeze({
             kind: 'OverNode',
         });
     },
-    cloneWithOrderByItem(overNode, item) {
+    cloneWithOrderByItems(overNode, items) {
         return freeze({
             ...overNode,
             orderBy: overNode.orderBy
-                ? OrderByNode.cloneWithItem(overNode.orderBy, item)
-                : OrderByNode.create(item),
+                ? OrderByNode.cloneWithItems(overNode.orderBy, items)
+                : OrderByNode.create(items),
         });
     },
     cloneWithPartitionByItems(overNode, items) {

package/dist/esm/operation-node/select-query-node.d.ts

@@ -16,7 +16,7 @@ import { ExplainNode } from './explain-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
-    readonly from: FromNode;
+    readonly from?: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOn?: ReadonlyArray<OperationNode>;
     readonly joins?: ReadonlyArray<JoinNode>;
@@ -37,17 +37,18 @@ export interface SelectQueryNode extends OperationNode {
  */
 export declare const SelectQueryNode: Readonly<{
     is(node: OperationNode): node is SelectQueryNode;
-    create(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
+    create(withNode?: WithNode): SelectQueryNode;
+    createFrom(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
+    cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
-    cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
+    cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;

package/dist/esm/operation-node/select-query-node.js

@@ -11,7 +11,13 @@ export const SelectQueryNode = freeze({
     is(node) {
         return node.kind === 'SelectQueryNode';
     },
-    create(fromItems, withNode) {
+    create(withNode) {
+        return freeze({
+            kind: 'SelectQueryNode',
+            ...(withNode && { with: withNode }),
+        });
+    },
+    createFrom(fromItems, withNode) {
         return freeze({
             kind: 'SelectQueryNode',
             from: FromNode.create(fromItems),
@@ -50,12 +56,12 @@ export const SelectQueryNode = freeze({
                 : freeze([modifier]),
         });
     },
-    cloneWithOrderByItem(selectNode, item) {
+    cloneWithOrderByItems(selectNode, items) {
         return freeze({
             ...selectNode,
             orderBy: selectNode.orderBy
-                ? OrderByNode.cloneWithItem(selectNode.orderBy, item)
-                : OrderByNode.create(item),
+                ? OrderByNode.cloneWithItems(selectNode.orderBy, items)
+                : OrderByNode.create(items),
         });
     },
     cloneWithGroupByItems(selectNode, items) {
@@ -86,12 +92,12 @@ export const SelectQueryNode = freeze({
                 : HavingNode.create(operation),
         });
     },
-    cloneWithSetOperation(selectNode, setOperation) {
+    cloneWithSetOperations(selectNode, setOperations) {
         return freeze({
             ...selectNode,
             setOperations: selectNode.setOperations
-                ? freeze([...selectNode.setOperations, setOperation])
-                : freeze([setOperation]),
+                ? freeze([...selectNode.setOperations, ...setOperations])
+                : freeze([...setOperations]),
         });
     },
     cloneWithoutSelections(select) {

package/dist/esm/operation-node/tuple-node.d.ts

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface TupleNode extends OperationNode {
+    readonly kind: 'TupleNode';
+    readonly values: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const TupleNode: Readonly<{
+    is(node: OperationNode): node is TupleNode;
+    create(values: ReadonlyArray<OperationNode>): TupleNode;
+}>;

package/dist/esm/operation-node/tuple-node.js

@@ -0,0 +1,16 @@
+/// <reference types="./tuple-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const TupleNode = freeze({
+    is(node) {
+        return node.kind === 'TupleNode';
+    },
+    create(values) {
+        return freeze({
+            kind: 'TupleNode',
+            values: freeze(values),
+        });
+    },
+});

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

@@ -1,17 +1,21 @@
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { ComparisonOperator, ArithmeticOperator, BinaryOperator, Operator } from '../operation-node/operator-node.js';
-import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ComparisonOperator, BinaryOperator, Operator } from '../operation-node/operator-node.js';
+import { ExtractTypeFromReferenceExpression, ExtractTypeFromStringReference, ReferenceExpression, StringReference } from './reference-parser.js';
 import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
+import { SelectType } from '../util/column-type.js';
 export type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 export type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
 export type OperatorExpression = Operator | Expression<unknown>;
 export type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
 export type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
-export type ArithmeticOperatorExpression = ArithmeticOperator | Expression<unknown>;
-export declare function parseFilter(args: any[]): OperationNode;
+export type FilterObject<DB, TB extends keyof DB> = {
+    [R in StringReference<DB, TB>]?: ValueExpressionOrList<DB, TB, SelectType<ExtractTypeFromStringReference<DB, TB, R>>>;
+};
 export declare function parseValueBinaryOperationOrExpression(args: any[]): OperationNode;
-export declare function parseValueBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
-export declare function parseReferentialComparison(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
-export declare function parseReferentialBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
+export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or'): OperationNode;

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

@@ -1,64 +1,57 @@
 /// <reference types="./binary-operation-parser.d.ts" />
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OperatorNode, isComparisonOperator, isBinaryOperator, OPERATORS, } from '../operation-node/operator-node.js';
+import { isBoolean, isNull, isString, isUndefined, } from '../util/object-utils.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
-import { parseValueExpressionOrList, } from './value-parser.js';
+import { parseValueExpression, parseValueExpressionOrList, } from './value-parser.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { isExpression } from '../expression/expression.js';
-import { createExpressionBuilder } from '../expression/expression-builder.js';
-export function parseFilter(args) {
-    if (args.length > 1 && !isComparisonOperatorExpression(args[1])) {
-        throw new Error(`invalid comparison operator ${JSON.stringify(args[1])}`);
-    }
-    return parseValueBinaryOperationOrExpression(args);
-}
+import { AndNode } from '../operation-node/and-node.js';
+import { ParensNode } from '../operation-node/parens-node.js';
+import { OrNode } from '../operation-node/or-node.js';
 export function parseValueBinaryOperationOrExpression(args) {
     if (args.length === 3) {
         return parseValueBinaryOperation(args[0], args[1], args[2]);
     }
     else if (args.length === 1) {
-        return parseExpressionOrFactory(args[0]);
+        return parseValueExpression(args[0]);
     }
     throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
 }
-export function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!isBinaryOperatorExpression(operator)) {
-        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
-    }
-    if (isIsOperator(operator) && isNullOrBoolean(rightOperand)) {
-        return parseIs(leftOperand, operator, rightOperand);
-    }
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseValueExpressionOrList(rightOperand));
-}
-export function parseReferentialComparison(leftOperand, operator, rightOperand) {
-    if (!isComparisonOperatorExpression(operator)) {
-        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+export function parseValueBinaryOperation(left, operator, right) {
+    if (isIsOperator(operator) && needsIsOperator(right)) {
+        return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), ValueNode.createImmediate(right));
     }
-    return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseValueExpressionOrList(right));
 }
-export function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!isBinaryOperatorExpression(operator)) {
-        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
-    }
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseReferenceExpression(rightOperand));
+export function parseReferentialBinaryOperation(left, operator, right) {
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseReferenceExpression(right));
 }
-function isBinaryOperatorExpression(expr) {
-    return isBinaryOperator(expr) || isExpression(expr);
+export function parseFilterObject(obj, combinator) {
+    return parseFilterList(Object.entries(obj)
+        .filter(([, v]) => !isUndefined(v))
+        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-function isComparisonOperatorExpression(expr) {
-    return isComparisonOperator(expr) || isExpression(expr);
+export function parseFilterList(list, combinator) {
+    const combine = combinator === 'and' ? AndNode.create : OrNode.create;
+    if (list.length === 0) {
+        return ValueNode.createImmediate(combinator === 'and');
+    }
+    let node = toOperationNode(list[0]);
+    for (let i = 1; i < list.length; ++i) {
+        node = combine(node, toOperationNode(list[i]));
+    }
+    if (list.length > 1) {
+        return ParensNode.create(node);
+    }
+    return node;
 }
 function isIsOperator(operator) {
     return operator === 'is' || operator === 'is not';
 }
-function isNullOrBoolean(value) {
+function needsIsOperator(value) {
     return isNull(value) || isBoolean(value);
 }
-function parseIs(leftOperand, operator, rightOperand) {
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), ValueNode.createImmediate(rightOperand));
-}
 function parseOperator(operator) {
     if (isString(operator) && OPERATORS.includes(operator)) {
         return OperatorNode.create(operator);
@@ -68,12 +61,8 @@ function parseOperator(operator) {
     }
     throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
-function parseExpressionOrFactory(arg) {
-    if (isFunction(arg)) {
-        return arg(createExpressionBuilder()).toOperationNode();
-    }
-    else if (isOperationNodeSource(arg)) {
-        return arg.toOperationNode();
-    }
-    return ValueNode.create(arg);
+function toOperationNode(nodeOrSource) {
+    return isOperationNodeSource(nodeOrSource)
+        ? nodeOrSource.toOperationNode()
+        : nodeOrSource;
 }

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

@@ -2,12 +2,17 @@ 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 '../expression/expression-builder.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { ShallowRecord } from '../util/type-utils.js';
-export type ExpressionOrFactory<DB, TB extends keyof DB, V> = SelectQueryBuilder<any, any, ShallowRecord<string, V>> | SelectQueryBuilderFactory<DB, TB, ShallowRecord<string, V>> | Expression<V> | ExpressionFactory<DB, TB, V>;
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+/**
+ * Like `Expression<V>` but also accepts a select query with an output
+ * type extending `Record<string, V>`. This type is useful because SQL
+ * treats records with a single column as single values.
+ */
+export type OperandExpression<V> = Expression<V> | SelectQueryBuilderExpression<Record<string, V>>;
+export type ExpressionOrFactory<DB, TB extends keyof DB, V> = OperandExpression<V> | OperandExpressionFactory<DB, TB, V>;
 export type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
-type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => SelectQueryBuilder<any, any, V>;
-type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
+export type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
+type OperandExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => OperandExpression<V>;
 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;

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

@@ -1,8 +1,8 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
-import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
+import { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
 import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
+export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = DrainOuterGeneric<AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>>;
 export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
 type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
 type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;

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 { parseReferentialComparison } from './binary-operation-parser.js';
+import { parseReferentialBinaryOperation } from './binary-operation-parser.js';
 import { createJoinBuilder } from './parse-utils.js';
 export function parseJoin(joinType, args) {
     if (args.length === 3) {
@@ -15,9 +15,8 @@ export function parseJoin(joinType, args) {
     }
 }
 function parseCallbackJoin(joinType, from, callback) {
-    const joinBuilder = callback(createJoinBuilder(joinType, from));
-    return joinBuilder.toOperationNode();
+    return callback(createJoinBuilder(joinType, from)).toOperationNode();
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
-    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialComparison(lhsColumn, '=', rhsColumn));
+    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialBinaryOperation(lhsColumn, '=', rhsColumn));
 }

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

@@ -1,8 +1,12 @@
 import { Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
+import { StringReference } from './reference-parser.js';
 import { ReferenceExpression } from './reference-parser.js';
 export type OrderByDirection = 'asc' | 'desc';
 export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
-export type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type DirectedOrderByStringReference<DB, TB extends keyof DB, O> = `${StringReference<DB, TB> | (keyof O & string)} ${OrderByDirection}`;
+export type UndirectedOrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type OrderByExpression<DB, TB extends keyof DB, O> = UndirectedOrderByExpression<DB, TB, O> | DirectedOrderByStringReference<DB, TB, O>;
 export type OrderByDirectionExpression = OrderByDirection | Expression<any>;
-export declare function parseOrderBy(orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;
+export declare function parseOrderBy(args: any[]): OrderByItemNode[];
+export declare function parseOrderByItem(ref: ReferenceExpression<any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

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

@@ -1,15 +1,50 @@
 /// <reference types="./order-by-parser.d.ts" />
+import { isDynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseReferenceExpression, } from './reference-parser.js';
+import { isExpressionOrFactory, parseExpression } from './expression-parser.js';
+import { parseStringReference } from './reference-parser.js';
 export function isOrderByDirection(thing) {
     return thing === 'asc' || thing === 'desc';
 }
-export function parseOrderBy(orderBy, direction) {
-    return OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
+export function parseOrderBy(args) {
+    if (args.length === 2) {
+        return [parseOrderByItem(args[0], args[1])];
+    }
+    if (args.length === 1) {
+        const [orderBy] = args;
+        if (Array.isArray(orderBy)) {
+            return orderBy.map((item) => parseOrderByItem(item));
+        }
+        return [parseOrderByItem(orderBy)];
+    }
+    throw new Error(`Invalid number of arguments at order by! expected 1-2, received ${args.length}`);
+}
+export function parseOrderByItem(ref, direction) {
+    const parsedRef = parseOrderByExpression(ref);
+    if (OrderByItemNode.is(parsedRef)) {
+        if (direction) {
+            throw new Error('Cannot specify direction twice!');
+        }
+        return parsedRef;
+    }
+    return OrderByItemNode.create(parsedRef, parseOrderByDirectionExpression(direction));
 }
 function parseOrderByExpression(expr) {
-    return parseReferenceExpression(expr);
+    if (isExpressionOrFactory(expr)) {
+        return parseExpression(expr);
+    }
+    if (isDynamicReferenceBuilder(expr)) {
+        return expr.toOperationNode();
+    }
+    const [ref, direction] = expr.split(' ');
+    if (direction) {
+        if (!isOrderByDirection(direction)) {
+            throw new Error(`Invalid order by direction: ${direction}`);
+        }
+        return OrderByItemNode.create(parseStringReference(ref), parseOrderByDirectionExpression(direction));
+    }
+    return parseStringReference(expr);
 }
 function parseOrderByDirectionExpression(expr) {
     if (!expr) {
@@ -18,7 +53,5 @@ function parseOrderByDirectionExpression(expr) {
     if (expr === 'asc' || expr === 'desc') {
         return RawNode.createWithSql(expr);
     }
-    else {
-        return expr.toOperationNode();
-    }
+    return expr.toOperationNode();
 }

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

@@ -4,16 +4,16 @@ import { OverNode } from '../operation-node/over-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.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 { createSelectQueryBuilder as newSelectQueryBuilder, } from '../query-builder/select-query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { createQueryId } from '../util/query-id.js';
 import { parseTableExpression, parseTableExpressionOrList, } from './table-parser.js';
 export function createSelectQueryBuilder() {
-    return new SelectQueryBuilder({
+    return newSelectQueryBuilder({
         queryId: createQueryId(),
         executor: NOOP_QUERY_EXECUTOR,
-        queryNode: SelectQueryNode.create(parseTableExpressionOrList([])),
+        queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList([])),
     });
 }
 export function createQueryCreator() {

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

@@ -2,7 +2,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
@@ -16,7 +16,7 @@ export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyCo
 export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
 export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
 export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
 export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
 export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
 export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;

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

@@ -76,7 +76,7 @@ export function parseOrderedColumnName(column) {
         if (!isOrderByDirection(order)) {
             throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
         }
-        return parseOrderBy(columnName, order);
+        return parseOrderBy([columnName, order])[0];
     }
     else {
         return parseColumnName(column);

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

@@ -1,6 +1,7 @@
 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, AllSelection } from './select-parser.js';
+import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
 export 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 type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult ? CallbackSelection<DB, TB, CB> : O extends DeleteResult ? CallbackSelection<DB, TB, CB> : O extends UpdateResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
 export 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,23 +1,34 @@
 import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } 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 { SelectType } from '../util/column-type.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 export 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 type SelectCallback<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SelectExpression<DB, TB>>;
+/**
+ * Turns a SelectExpression or a union of them into a selection object.
+ */
+export type Selection<DB, TB extends keyof DB, SE> = [DB] extends [unknown] ? {
+    [E in FlattenSelectExpression<SE> as ExtractAliasFromSelectExpression<E>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, E>>;
+} : {};
+/**
+ * Turns a SelectCallback into a selection object.
+ */
+export type CallbackSelection<DB, TB extends keyof DB, CB> = CB extends (eb: any) => ReadonlyArray<infer SE> ? Selection<DB, TB, SE> : never;
 export type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
-export type Selection<DB, TB extends keyof DB, SE> = {
-    [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
-};
+type FlattenSelectExpression<SE> = SE extends DynamicReferenceBuilder<infer RA> ? {
+    [R in RA]: DynamicReferenceBuilder<R>;
+}[RA] : SE;
 type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 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;
-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 ? O[keyof O] | null : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : 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;
-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;
-export type AllSelection<DB, TB extends keyof DB> = Selectable<{
+type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE> : SE extends AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends (eb: any) => AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends AliasedExpression<infer O, any> ? O : SE extends (eb: any) => AliasedExpression<infer O, any> ? O : SE extends DynamicReferenceBuilder<infer RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA> | undefined : never;
+type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string> = SE extends `${infer SC}.${infer T}.${infer C} as ${string}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C} as ${string}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends `${infer C} as ${string}` ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : SE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never;
+export type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [C in AnyColumn<DB, TB>]: {
-        [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+        [T in TB]: SelectType<C extends keyof DB[T] ? DB[T][C] : never>;
     }[TB];
 }>;
 export declare function parseSelectArg(selection: SelectArg<any, any, SelectExpression<any, any>>): SelectionNode[];

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

@@ -1,3 +1,5 @@
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { Expression } from '../expression/expression.js';
 import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
-export declare function parseSetOperation(operator: SetOperator, expression: Expression<any>, all: boolean): SetOperationNode;
+export type SetOperandExpression<DB, O> = Expression<O> | ReadonlyArray<Expression<O>> | ((eb: ExpressionBuilder<DB, never>) => Expression<O> | ReadonlyArray<Expression<O>>);
+export declare function parseSetOperations(operator: SetOperator, expression: SetOperandExpression<any, any>, all: boolean): SetOperationNode[];

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

@@ -1,5 +1,14 @@
 /// <reference types="./set-operation-parser.d.ts" />
+import { createExpressionBuilder, } from '../expression/expression-builder.js';
 import { SetOperationNode, } from '../operation-node/set-operation-node.js';
-export function parseSetOperation(operator, expression, all) {
-    return SetOperationNode.create(operator, expression.toOperationNode(), all);
+import { isFunction, isReadonlyArray } from '../util/object-utils.js';
+import { parseExpression } from './expression-parser.js';
+export function parseSetOperations(operator, expression, all) {
+    if (isFunction(expression)) {
+        expression = expression(createExpressionBuilder());
+    }
+    if (!isReadonlyArray(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => SetOperationNode.create(operator, parseExpression(expr), all));
 }