kysely 0.26.0 → 0.26.2

package/dist/cjs/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/cjs/operation-node/select-query-node.js

@@ -13,7 +13,13 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'SelectQueryNode';
     },
-    create(fromItems, withNode) {
+    create(withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'SelectQueryNode',
+            ...(withNode && { with: withNode }),
+        });
+    },
+    createFrom(fromItems, withNode) {
         return (0, object_utils_js_1.freeze)({
             kind: 'SelectQueryNode',
             from: from_node_js_1.FromNode.create(fromItems),
@@ -52,12 +58,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([modifier]),
         });
     },
-    cloneWithOrderByItem(selectNode, item) {
+    cloneWithOrderByItems(selectNode, items) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
             orderBy: selectNode.orderBy
-                ? order_by_node_js_1.OrderByNode.cloneWithItem(selectNode.orderBy, item)
-                : order_by_node_js_1.OrderByNode.create(item),
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(selectNode.orderBy, items)
+                : order_by_node_js_1.OrderByNode.create(items),
         });
     },
     cloneWithGroupByItems(selectNode, items) {
@@ -88,12 +94,12 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : having_node_js_1.HavingNode.create(operation),
         });
     },
-    cloneWithSetOperation(selectNode, setOperation) {
+    cloneWithSetOperations(selectNode, setOperations) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
             setOperations: selectNode.setOperations
-                ? (0, object_utils_js_1.freeze)([...selectNode.setOperations, setOperation])
-                : (0, object_utils_js_1.freeze)([setOperation]),
+                ? (0, object_utils_js_1.freeze)([...selectNode.setOperations, ...setOperations])
+                : (0, object_utils_js_1.freeze)([...setOperations]),
         });
     },
     cloneWithoutSelections(select) {

package/dist/cjs/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/cjs/operation-node/tuple-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TupleNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.TupleNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'TupleNode';
+    },
+    create(values) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'TupleNode',
+            values: (0, object_utils_js_1.freeze)(values),
+        });
+    },
+});

package/dist/cjs/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/cjs/parser/binary-operation-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseReferentialBinaryOperation = exports.parseReferentialComparison = exports.parseValueBinaryOperation = exports.parseValueBinaryOperationOrExpression = exports.parseFilter = void 0;
+exports.parseFilterList = exports.parseFilterObject = exports.parseReferentialBinaryOperation = exports.parseValueBinaryOperation = exports.parseValueBinaryOperationOrExpression = void 0;
 const binary_operation_node_js_1 = require("../operation-node/binary-operation-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
@@ -8,64 +8,57 @@ const operator_node_js_1 = require("../operation-node/operator-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const value_parser_js_1 = require("./value-parser.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
-const expression_js_1 = require("../expression/expression.js");
-const expression_builder_js_1 = require("../expression/expression-builder.js");
-function parseFilter(args) {
-    if (args.length > 1 && !isComparisonOperatorExpression(args[1])) {
-        throw new Error(`invalid comparison operator ${JSON.stringify(args[1])}`);
-    }
-    return parseValueBinaryOperationOrExpression(args);
-}
-exports.parseFilter = parseFilter;
+const and_node_js_1 = require("../operation-node/and-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
+const or_node_js_1 = require("../operation-node/or-node.js");
 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 (0, value_parser_js_1.parseValueExpression)(args[0]);
     }
     throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
 }
 exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
-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);
+function parseValueBinaryOperation(left, operator, right) {
+    if (isIsOperator(operator) && needsIsOperator(right)) {
+        return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(right));
     }
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(rightOperand));
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(right));
 }
 exports.parseValueBinaryOperation = parseValueBinaryOperation;
-function parseReferentialComparison(leftOperand, operator, rightOperand) {
-    if (!isComparisonOperatorExpression(operator)) {
-        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
-    }
-    return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
-}
-exports.parseReferentialComparison = parseReferentialComparison;
-function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
-    if (!isBinaryOperatorExpression(operator)) {
-        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
-    }
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(rightOperand));
+function parseReferentialBinaryOperation(left, operator, right) {
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(right));
 }
 exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
-function isBinaryOperatorExpression(expr) {
-    return (0, operator_node_js_1.isBinaryOperator)(expr) || (0, expression_js_1.isExpression)(expr);
+function parseFilterObject(obj, combinator) {
+    return parseFilterList(Object.entries(obj)
+        .filter(([, v]) => !(0, object_utils_js_1.isUndefined)(v))
+        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-function isComparisonOperatorExpression(expr) {
-    return (0, operator_node_js_1.isComparisonOperator)(expr) || (0, expression_js_1.isExpression)(expr);
+exports.parseFilterObject = parseFilterObject;
+function parseFilterList(list, combinator) {
+    const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
+    if (list.length === 0) {
+        return value_node_js_1.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 parens_node_js_1.ParensNode.create(node);
+    }
+    return node;
 }
+exports.parseFilterList = parseFilterList;
 function isIsOperator(operator) {
     return operator === 'is' || operator === 'is not';
 }
-function isNullOrBoolean(value) {
+function needsIsOperator(value) {
     return (0, object_utils_js_1.isNull)(value) || (0, object_utils_js_1.isBoolean)(value);
 }
-function parseIs(leftOperand, operator, rightOperand) {
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(rightOperand));
-}
 function parseOperator(operator) {
     if ((0, object_utils_js_1.isString)(operator) && operator_node_js_1.OPERATORS.includes(operator)) {
         return operator_node_js_1.OperatorNode.create(operator);
@@ -75,12 +68,8 @@ function parseOperator(operator) {
     }
     throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
-function parseExpressionOrFactory(arg) {
-    if ((0, object_utils_js_1.isFunction)(arg)) {
-        return arg((0, expression_builder_js_1.createExpressionBuilder)()).toOperationNode();
-    }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        return arg.toOperationNode();
-    }
-    return value_node_js_1.ValueNode.create(arg);
+function toOperationNode(nodeOrSource) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(nodeOrSource)
+        ? nodeOrSource.toOperationNode()
+        : nodeOrSource;
 }

package/dist/cjs/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/cjs/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/cjs/parser/join-parser.js

@@ -18,9 +18,8 @@ function parseJoin(joinType, args) {
 }
 exports.parseJoin = parseJoin;
 function parseCallbackJoin(joinType, from, callback) {
-    const joinBuilder = callback((0, parse_utils_js_1.createJoinBuilder)(joinType, from));
-    return joinBuilder.toOperationNode();
+    return callback((0, parse_utils_js_1.createJoinBuilder)(joinType, from)).toOperationNode();
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
-    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(from), (0, binary_operation_parser_js_1.parseReferentialComparison)(lhsColumn, '=', rhsColumn));
+    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(from), (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhsColumn, '=', rhsColumn));
 }

package/dist/cjs/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/cjs/parser/order-by-parser.js

@@ -1,19 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOrderBy = exports.isOrderByDirection = void 0;
+exports.parseOrderByItem = exports.parseOrderBy = exports.isOrderByDirection = void 0;
+const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
 const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 function isOrderByDirection(thing) {
     return thing === 'asc' || thing === 'desc';
 }
 exports.isOrderByDirection = isOrderByDirection;
-function parseOrderBy(orderBy, direction) {
-    return order_by_item_node_js_1.OrderByItemNode.create(parseOrderByExpression(orderBy), parseOrderByDirectionExpression(direction));
+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}`);
 }
 exports.parseOrderBy = parseOrderBy;
+function parseOrderByItem(ref, direction) {
+    const parsedRef = parseOrderByExpression(ref);
+    if (order_by_item_node_js_1.OrderByItemNode.is(parsedRef)) {
+        if (direction) {
+            throw new Error('Cannot specify direction twice!');
+        }
+        return parsedRef;
+    }
+    return order_by_item_node_js_1.OrderByItemNode.create(parsedRef, parseOrderByDirectionExpression(direction));
+}
+exports.parseOrderByItem = parseOrderByItem;
 function parseOrderByExpression(expr) {
-    return (0, reference_parser_js_1.parseReferenceExpression)(expr);
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(expr)) {
+        return (0, expression_parser_js_1.parseExpression)(expr);
+    }
+    if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(expr)) {
+        return expr.toOperationNode();
+    }
+    const [ref, direction] = expr.split(' ');
+    if (direction) {
+        if (!isOrderByDirection(direction)) {
+            throw new Error(`Invalid order by direction: ${direction}`);
+        }
+        return order_by_item_node_js_1.OrderByItemNode.create((0, reference_parser_js_1.parseStringReference)(ref), parseOrderByDirectionExpression(direction));
+    }
+    return (0, reference_parser_js_1.parseStringReference)(expr);
 }
 function parseOrderByDirectionExpression(expr) {
     if (!expr) {
@@ -22,7 +58,5 @@ function parseOrderByDirectionExpression(expr) {
     if (expr === 'asc' || expr === 'desc') {
         return raw_node_js_1.RawNode.createWithSql(expr);
     }
-    else {
-        return expr.toOperationNode();
-    }
+    return expr.toOperationNode();
 }

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

@@ -12,10 +12,10 @@ const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.
 const query_id_js_1 = require("../util/query-id.js");
 const table_parser_js_1 = require("./table-parser.js");
 function createSelectQueryBuilder() {
-    return new select_query_builder_js_1.SelectQueryBuilder({
+    return (0, select_query_builder_js_1.createSelectQueryBuilder)({
         queryId: (0, query_id_js_1.createQueryId)(),
         executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
-        queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)([])),
+        queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)([])),
     });
 }
 exports.createSelectQueryBuilder = createSelectQueryBuilder;

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

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

package/dist/cjs/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/cjs/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/cjs/parser/set-operation-parser.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSetOperation = void 0;
+exports.parseSetOperations = void 0;
+const expression_builder_js_1 = require("../expression/expression-builder.js");
 const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
-function parseSetOperation(operator, expression, all) {
-    return set_operation_node_js_1.SetOperationNode.create(operator, expression.toOperationNode(), all);
+const object_utils_js_1 = require("../util/object-utils.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+function parseSetOperations(operator, expression, all) {
+    if ((0, object_utils_js_1.isFunction)(expression)) {
+        expression = expression((0, expression_builder_js_1.createExpressionBuilder)());
+    }
+    if (!(0, object_utils_js_1.isReadonlyArray)(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => set_operation_node_js_1.SetOperationNode.create(operator, (0, expression_parser_js_1.parseExpression)(expr), all));
 }
-exports.parseSetOperation = parseSetOperation;
+exports.parseSetOperations = parseSetOperations;

package/dist/cjs/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/cjs/parser/tuple-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/parser/value-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
+exports.parseSafeImmediateValue = exports.isSafeImmediateValue = exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
@@ -20,6 +20,17 @@ function parseValueExpression(exp) {
     return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
+function isSafeImmediateValue(value) {
+    return (0, object_utils_js_1.isNumber)(value) || (0, object_utils_js_1.isBoolean)(value) || (0, object_utils_js_1.isNull)(value);
+}
+exports.isSafeImmediateValue = isSafeImmediateValue;
+function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return value_node_js_1.ValueNode.createImmediate(value);
+}
+exports.parseSafeImmediateValue = parseSafeImmediateValue;
 function parseValueExpressionList(arg) {
     if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));

package/dist/cjs/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 {};