kysely 0.26.1 → 0.26.3

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,11 +1,11 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 export declare const JSON_OPERATORS: readonly ["->", "->>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

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

@@ -22,6 +22,7 @@ exports.COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '&&',
     '?',
     '?&',
     '!<',
@@ -63,6 +64,8 @@ exports.OPERATORS = [
     ...exports.BINARY_OPERATORS,
     ...exports.JSON_OPERATORS,
     ...exports.UNARY_OPERATORS,
+    'between',
+    'between symmetric',
 ];
 /**
  * @internal

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

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

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

@@ -16,12 +16,12 @@ exports.OverNode = (0, object_utils_js_1.freeze)({
             kind: 'OverNode',
         });
     },
-    cloneWithOrderByItem(overNode, item) {
+    cloneWithOrderByItems(overNode, items) {
         return (0, object_utils_js_1.freeze)({
             ...overNode,
             orderBy: overNode.orderBy
-                ? order_by_node_js_1.OrderByNode.cloneWithItem(overNode.orderBy, item)
-                : order_by_node_js_1.OrderByNode.create(item),
+                ? order_by_node_js_1.OrderByNode.cloneWithItems(overNode.orderBy, items)
+                : order_by_node_js_1.OrderByNode.create(items),
         });
     },
     cloneWithPartitionByItems(overNode, items) {

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

@@ -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/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.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/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/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/cjs/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[];