kysely 0.26.0 → 0.26.2

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

@@ -3,11 +3,16 @@ 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>;
+/**
+ * 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> | SelectQueryBuilder<any, any, 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.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/select-parser.d.ts

@@ -1,6 +1,6 @@
 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';
@@ -8,18 +8,18 @@ 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 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> = {
+export type Selection<DB, TB extends keyof DB, SE> = DrainOuterGeneric<{
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
-};
+}>;
 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<{
+export type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<Selectable<{
     [C in AnyColumn<DB, TB>]: {
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];
-}>;
+}>>;
 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/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));
 }

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

@@ -0,0 +1,47 @@
+import { DrainOuterGeneric } from '../util/type-utils.js';
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import { ExtractTypeFromValueExpression } from './value-parser.js';
+export type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>
+]>;
+export type RefTuple3<DB, TB extends keyof DB, R1, R2, R3> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>
+]>;
+export type RefTuple4<DB, TB extends keyof DB, R1, R2, R3, R4> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>
+]>;
+export type RefTuple5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>,
+    ExtractTypeFromReferenceExpression<DB, TB, R5>
+]>;
+export type ValTuple2<V1, V2> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>
+]>;
+export type ValTuple3<V1, V2, V3> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>
+]>;
+export type ValTuple4<V1, V2, V3, V4> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>
+]>;
+export type ValTuple5<V1, V2, V3, V4, V5> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>,
+    ExtractTypeFromValueExpression<V5>
+]>;

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

@@ -0,0 +1,2 @@
+/// <reference types="./tuple-parser.d.ts" />
+export {};

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

@@ -1,3 +1,4 @@
+import { ValueNode } from '../operation-node/value-node.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
@@ -5,7 +6,8 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 export type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
 export type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
-type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
+export 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 {};
+export declare function isSafeImmediateValue(value: unknown): value is number | boolean | null;
+export declare function parseSafeImmediateValue(value: number | boolean | null): ValueNode;

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

@@ -2,7 +2,7 @@
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { isReadonlyArray } from '../util/object-utils.js';
+import { isBoolean, isNull, isNumber, isReadonlyArray, } from '../util/object-utils.js';
 import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
@@ -16,6 +16,15 @@ export function parseValueExpression(exp) {
     }
     return ValueNode.create(exp);
 }
+export function isSafeImmediateValue(value) {
+    return isNumber(value) || isBoolean(value) || isNull(value);
+}
+export function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return ValueNode.createImmediate(value);
+}
 function parseValueExpressionList(arg) {
     if (arg.some(isExpressionOrFactory)) {
         return ValueListNode.create(arg.map((it) => parseValueExpression(it)));

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

@@ -1,10 +1,11 @@
 import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
 import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
 import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
-import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
 import { Expression } from '../expression/expression.js';
 import { ShallowRecord } from '../util/type-utils.js';
+import { CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
     [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
@@ -40,5 +41,5 @@ type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */
 type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
-export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
+export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
 export {};