kysely 0.23.4 → 0.24.0

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

@@ -1,9 +1,16 @@
 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", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->"];
+export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 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", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "not", "-", "exists", "not exists"];
 export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
+export declare type ArithmeticOperator = typeof ARITHMETIC_OPERATORS[number];
+export declare type BinaryOperator = typeof BINARY_OPERATORS[number];
+export declare type UnaryOperator = typeof UNARY_OPERATORS[number];
 export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];
-export declare type Operator = ComparisonOperator | UnaryFilterOperator;
+export declare type Operator = typeof OPERATORS[number];
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';
     readonly operator: Operator;
@@ -15,3 +22,7 @@ export declare const OperatorNode: Readonly<{
     is(node: OperationNode): node is OperatorNode;
     create(operator: Operator): OperatorNode;
 }>;
+export declare function isOperator(op: unknown): op is Operator;
+export declare function isBinaryOperator(op: unknown): op is BinaryOperator;
+export declare function isComparisonOperator(op: unknown): op is ComparisonOperator;
+export declare function isArithmeticOperator(op: unknown): op is ArithmeticOperator;

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

@@ -1,5 +1,5 @@
 /// <reference types="./operator-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
+import { freeze, isString } from '../util/object-utils.js';
 export const COMPARISON_OPERATORS = [
     '=',
     '==',
@@ -29,14 +29,33 @@ export const COMPARISON_OPERATORS = [
     '~',
     '~*',
     '!~*',
-    '&&',
-    '||',
     '@@',
     '@@@',
     '!!',
     '<->',
 ];
+export const ARITHMETIC_OPERATORS = [
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '^',
+    '&',
+    '|',
+    '#',
+    '<<',
+    '>>',
+];
+export const BINARY_OPERATORS = [
+    ...COMPARISON_OPERATORS,
+    ...ARITHMETIC_OPERATORS,
+    '&&',
+    '||',
+];
 export const UNARY_FILTER_OPERATORS = ['exists', 'not exists'];
+export const UNARY_OPERATORS = ['not', '-', ...UNARY_FILTER_OPERATORS];
+export const OPERATORS = [...BINARY_OPERATORS, ...UNARY_OPERATORS];
 /**
  * @internal
  */
@@ -51,3 +70,15 @@ export const OperatorNode = freeze({
         });
     },
 });
+export function isOperator(op) {
+    return isString(op) && OPERATORS.includes(op);
+}
+export function isBinaryOperator(op) {
+    return isString(op) && BINARY_OPERATORS.includes(op);
+}
+export function isComparisonOperator(op) {
+    return isString(op) && COMPARISON_OPERATORS.includes(op);
+}
+export function isArithmeticOperator(op) {
+    return isString(op) && ARITHMETIC_OPERATORS.includes(op);
+}

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

@@ -2,20 +2,37 @@ import { InsertQueryNode } from './insert-query-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
+import { WhereNode } from './where-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
+import { ReturningNode } from './returning-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
-export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
-export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
+import { ExplainNode } from './explain-node.js';
+import { ExplainFormat } from '../util/explainable.js';
+import { Expression } from '../expression/expression.js';
+export declare type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+declare type HasJoins = {
+    joins?: ReadonlyArray<JoinNode>;
+};
+declare type HasWhere = {
+    where?: WhereNode;
+};
+declare type HasReturning = {
+    returning?: ReturningNode;
+};
+declare type HasExplain = {
+    explain?: ExplainNode;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, operation: OperationNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, operation: OperationNode): T_1;
-    cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
-    cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
-    cloneWithoutWhere<T_4 extends FilterableQueryNode>(node: T_4): T_4;
+    cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
+    cloneWithOrWhere<T_1 extends HasWhere>(node: T_1, operation: OperationNode): T_1;
+    cloneWithJoin<T_2 extends HasJoins>(node: T_2, join: JoinNode): T_2;
+    cloneWithReturning<T_3 extends HasReturning>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
+    cloneWithoutWhere<T_4 extends HasWhere>(node: T_4): T_4;
+    cloneWithExplain<T_5 extends HasExplain>(node: T_5, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_5;
 }>;
+export {};

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

@@ -6,15 +6,16 @@ import { DeleteQueryNode } from './delete-query-node.js';
 import { WhereNode } from './where-node.js';
 import { freeze } from '../util/object-utils.js';
 import { ReturningNode } from './returning-node.js';
+import { ExplainNode } from './explain-node.js';
 /**
  * @internal
  */
 export const QueryNode = freeze({
     is(node) {
-        return (DeleteQueryNode.is(node) ||
+        return (SelectQueryNode.is(node) ||
             InsertQueryNode.is(node) ||
             UpdateQueryNode.is(node) ||
-            SelectQueryNode.is(node));
+            DeleteQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return freeze({
@@ -52,4 +53,10 @@ export const QueryNode = freeze({
             where: undefined,
         });
     },
+    cloneWithExplain(node, format, options) {
+        return freeze({
+            ...node,
+            explain: ExplainNode.create(format, options?.toOperationNode()),
+        });
+    },
 });

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

@@ -49,7 +49,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperation(selectNode: SelectQueryNode, setOperation: SetOperationNode): SelectQueryNode;
-    cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;

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

@@ -102,12 +102,6 @@ export const SelectQueryNode = freeze({
                 : freeze([setOperation]),
         });
     },
-    cloneWithExplain(selectNode, explain) {
-        return freeze({
-            ...selectNode,
-            explain,
-        });
-    },
     cloneWithoutSelections(select) {
         return freeze({
             ...select,

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

@@ -28,5 +28,4 @@ export declare const UpdateQueryNode: Readonly<{
     create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
-    cloneWithExplain(updateQuery: UpdateQueryNode, explain: ExplainNode): UpdateQueryNode;
 }>;

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

@@ -31,10 +31,4 @@ export const UpdateQueryNode = freeze({
                 : updates,
         });
     },
-    cloneWithExplain(updateQuery, explain) {
-        return freeze({
-            ...updateQuery,
-            explain,
-        });
-    },
 });

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

@@ -1,20 +1,19 @@
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { ComparisonOperator } from '../operation-node/operator-node.js';
+import { ComparisonOperator, ArithmeticOperator, BinaryOperator, Operator } from '../operation-node/operator-node.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
 import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
-import { WhereInterface } from '../query-builder/where-interface.js';
-import { HavingInterface } from '../query-builder/having-interface.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 export declare type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 export declare type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
-export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
-export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
-export declare type ComparisonOperatorExpression = ComparisonOperator | Expression<any>;
-declare type FilterExpressionType = 'where' | 'having' | 'on';
+export declare type OperatorExpression = Operator | Expression<unknown>;
+export declare type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
+export declare type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
+export declare type ArithmeticOperatorExpression = ArithmeticOperator | Expression<unknown>;
+export declare function parseValueBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseReferentialBinaryOperation(leftOperand: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseValueComparison(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseReferentialComparison(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
 export declare function parseWhere(args: any[]): OperationNode;
 export declare function parseHaving(args: any[]): OperationNode;
 export declare function parseOn(args: any[]): OperationNode;
-export declare function parseReferentialFilter(leftOperand: ReferenceExpression<any, any>, operator: ComparisonOperatorExpression, rightOperand: ReferenceExpression<any, any>): BinaryOperationNode;
-export declare function parseFilterExpression(type: FilterExpressionType, args: any[]): OperationNode;
-export {};

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

@@ -3,55 +3,79 @@ import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
 import { freeze, isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { OperatorNode, COMPARISON_OPERATORS, } from '../operation-node/operator-node.js';
+import { OperatorNode, isComparisonOperator, isBinaryOperator, OPERATORS, } from '../operation-node/operator-node.js';
 import { ParensNode } from '../operation-node/parens-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
 import { parseValueExpressionOrList, } from './value-parser.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { createJoinBuilder, createSelectQueryBuilder } from './parse-utils.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { JoinNode } from '../operation-node/join-node.js';
+import { expressionBuilder } from '../expression/expression-builder.js';
+export function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    if (isIsComparison(operator, rightOperand)) {
+        return parseIs(leftOperand, operator, rightOperand);
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseValueExpressionOrList(rightOperand));
+}
+export function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!isBinaryOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), parseReferenceExpression(rightOperand));
+}
+export function parseValueComparison(leftOperand, operator, rightOperand) {
+    if (!isComparisonOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseValueBinaryOperation(leftOperand, operator, rightOperand);
+}
+export function parseReferentialComparison(leftOperand, operator, rightOperand) {
+    if (!isComparisonOperator(operator) && !isOperationNodeSource(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
+}
 export function parseWhere(args) {
-    return parseFilterExpression('where', args);
+    return parseFilter('where', args);
 }
 export function parseHaving(args) {
-    return parseFilterExpression('having', args);
+    return parseFilter('having', args);
 }
 export function parseOn(args) {
-    return parseFilterExpression('on', args);
+    return parseFilter('on', args);
 }
-export function parseReferentialFilter(leftOperand, operator, rightOperand) {
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), parseReferenceExpression(rightOperand));
-}
-export function parseFilterExpression(type, args) {
+function parseFilter(type, args) {
     if (args.length === 3) {
-        return parseFilter(args[0], args[1], args[2]);
+        return parseValueComparison(args[0], args[1], args[2]);
     }
     if (args.length === 1) {
         return parseOneArgFilterExpression(type, args[0]);
     }
     throw createFilterExpressionError(type, args);
 }
-function parseFilter(leftOperand, operator, rightOperand) {
-    if ((operator === 'is' || operator === 'is not') &&
-        (isNull(rightOperand) || isBoolean(rightOperand))) {
-        return parseIs(leftOperand, operator, rightOperand);
-    }
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), parseValueExpressionOrList(rightOperand));
+function isIsComparison(operator, rightOperand) {
+    return ((operator === 'is' || operator === 'is not') &&
+        (isNull(rightOperand) || isBoolean(rightOperand)));
 }
 function parseIs(leftOperand, operator, rightOperand) {
-    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseComparisonOperatorExpression(operator), ValueNode.createImmediate(rightOperand));
+    return BinaryOperationNode.create(parseReferenceExpression(leftOperand), parseOperator(operator), ValueNode.createImmediate(rightOperand));
 }
-function parseComparisonOperatorExpression(operator) {
-    if (isString(operator) && COMPARISON_OPERATORS.includes(operator)) {
+function parseOperator(operator) {
+    if (isString(operator) && OPERATORS.includes(operator)) {
         return OperatorNode.create(operator);
     }
-    else if (isOperationNodeSource(operator)) {
+    if (isOperationNodeSource(operator)) {
         return operator.toOperationNode();
     }
-    throw new Error(`invalid comparison operator ${JSON.stringify(operator)} passed to a filter method`);
+    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
 }
 function parseOneArgFilterExpression(type, arg) {
     if (isFunction(arg)) {
-        return GROUP_PARSERS[type](arg);
+        return CALLBACK_PARSERS[type](arg);
     }
     else if (isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
@@ -64,29 +88,53 @@ function parseOneArgFilterExpression(type, arg) {
 function createFilterExpressionError(type, args) {
     return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
-const GROUP_PARSERS = freeze({
+const CALLBACK_PARSERS = freeze({
     where(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.where) {
-            throw new Error('no `where` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const whereBuilder = createSelectQueryBuilder();
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(whereBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (SelectQueryNode.is(node)) {
+            if (!node.where) {
+                throw new Error('no `where` methods called inside a group callback');
+            }
+            return ParensNode.create(node.where.where);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(queryNode.where.where);
     },
     having(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.having) {
-            throw new Error('no `having` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const havingBuilder = createSelectQueryBuilder();
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(havingBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (SelectQueryNode.is(node)) {
+            if (!node.having) {
+                throw new Error('no `having` methods called inside a group callback');
+            }
+            return ParensNode.create(node.having.having);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(queryNode.having.having);
     },
     on(callback) {
-        const joinBuilder = callback(createJoinBuilder('InnerJoin', 'table'));
-        const joinNode = joinBuilder.toOperationNode();
-        if (!joinNode.on) {
-            throw new Error('no `on` methods called inside a group callback');
+        // TODO: Remove this once the grouper overload is removed.
+        const onBuilder = createJoinBuilder('InnerJoin', 'table');
+        const exprBuilder = expressionBuilder();
+        const res = callback(Object.assign(onBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (JoinNode.is(node)) {
+            if (!node.on) {
+                throw new Error('no `on` methods called inside a group callback');
+            }
+            return ParensNode.create(node.on.on);
+        }
+        else {
+            return node;
         }
-        return ParensNode.create(joinNode.on.on);
     },
 });

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

@@ -1,4 +1,2 @@
-import { RawNode } from '../operation-node/raw-node.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
 export declare type CoalesceReferenceExpressionList<DB, TB extends keyof DB, RE extends unknown[], O = never> = RE extends [] ? O : RE extends [infer L, ...infer R] ? L extends ReferenceExpression<any, any> ? null extends ExtractTypeFromReferenceExpression<DB, TB, L> ? CoalesceReferenceExpressionList<DB, TB, R extends ReferenceExpression<any, any>[] ? R : never, O | ExtractTypeFromReferenceExpression<DB, TB, L>> : Exclude<O, null> | ExtractTypeFromReferenceExpression<DB, TB, L> : never : never;
-export declare function parseCoalesce(values: ReferenceExpression<any, any>[]): RawNode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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