kysely 0.23.5 → 0.24.1

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

@@ -104,12 +104,6 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([setOperation]),
         });
     },
-    cloneWithExplain(selectNode, explain) {
-        return (0, object_utils_js_1.freeze)({
-            ...selectNode,
-            explain,
-        });
-    },
     cloneWithoutSelections(select) {
         return (0, object_utils_js_1.freeze)({
             ...select,

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

@@ -33,10 +33,4 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
                 : updates,
         });
     },
-    cloneWithExplain(updateQuery, explain) {
-        return (0, object_utils_js_1.freeze)({
-            ...updateQuery,
-            explain,
-        });
-    },
 });

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFilterExpression = exports.parseReferentialFilter = exports.parseOn = exports.parseHaving = exports.parseWhere = void 0;
+exports.parseOn = exports.parseHaving = exports.parseWhere = exports.parseReferentialComparison = exports.parseValueComparison = exports.parseReferentialBinaryOperation = exports.parseValueBinaryOperation = 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");
@@ -11,54 +11,80 @@ 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 parse_utils_js_1 = require("./parse-utils.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
+const join_node_js_1 = require("../operation-node/join-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+function parseValueBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!(0, operator_node_js_1.isBinaryOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+        throw new Error(`invalid binary operator ${JSON.stringify(operator)}`);
+    }
+    if (isIsComparison(operator, rightOperand)) {
+        return parseIs(leftOperand, operator, rightOperand);
+    }
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(rightOperand));
+}
+exports.parseValueBinaryOperation = parseValueBinaryOperation;
+function parseReferentialBinaryOperation(leftOperand, operator, rightOperand) {
+    if (!(0, operator_node_js_1.isBinaryOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(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));
+}
+exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
+function parseValueComparison(leftOperand, operator, rightOperand) {
+    if (!(0, operator_node_js_1.isComparisonOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseValueBinaryOperation(leftOperand, operator, rightOperand);
+}
+exports.parseValueComparison = parseValueComparison;
+function parseReferentialComparison(leftOperand, operator, rightOperand) {
+    if (!(0, operator_node_js_1.isComparisonOperator)(operator) && !(0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+        throw new Error(`invalid comparison operator ${JSON.stringify(operator)}`);
+    }
+    return parseReferentialBinaryOperation(leftOperand, operator, rightOperand);
+}
+exports.parseReferentialComparison = parseReferentialComparison;
 function parseWhere(args) {
-    return parseFilterExpression('where', args);
+    return parseFilter('where', args);
 }
 exports.parseWhere = parseWhere;
 function parseHaving(args) {
-    return parseFilterExpression('having', args);
+    return parseFilter('having', args);
 }
 exports.parseHaving = parseHaving;
 function parseOn(args) {
-    return parseFilterExpression('on', args);
+    return parseFilter('on', args);
 }
 exports.parseOn = parseOn;
-function parseReferentialFilter(leftOperand, operator, rightOperand) {
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), (0, reference_parser_js_1.parseReferenceExpression)(rightOperand));
-}
-exports.parseReferentialFilter = parseReferentialFilter;
-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);
 }
-exports.parseFilterExpression = parseFilterExpression;
-function parseFilter(leftOperand, operator, rightOperand) {
-    if ((operator === 'is' || operator === 'is not') &&
-        ((0, object_utils_js_1.isNull)(rightOperand) || (0, object_utils_js_1.isBoolean)(rightOperand))) {
-        return parseIs(leftOperand, operator, rightOperand);
-    }
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), (0, value_parser_js_1.parseValueExpressionOrList)(rightOperand));
+function isIsComparison(operator, rightOperand) {
+    return ((operator === 'is' || operator === 'is not') &&
+        ((0, object_utils_js_1.isNull)(rightOperand) || (0, object_utils_js_1.isBoolean)(rightOperand)));
 }
 function parseIs(leftOperand, operator, rightOperand) {
-    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(leftOperand), parseComparisonOperatorExpression(operator), value_node_js_1.ValueNode.createImmediate(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 parseComparisonOperatorExpression(operator) {
-    if ((0, object_utils_js_1.isString)(operator) && operator_node_js_1.COMPARISON_OPERATORS.includes(operator)) {
+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);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+    if ((0, operation_node_source_js_1.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 ((0, object_utils_js_1.isFunction)(arg)) {
-        return GROUP_PARSERS[type](arg);
+        return CALLBACK_PARSERS[type](arg);
     }
     else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
         const node = arg.toOperationNode();
@@ -71,29 +97,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 = (0, object_utils_js_1.freeze)({
+const CALLBACK_PARSERS = (0, object_utils_js_1.freeze)({
     where(callback) {
-        const query = callback((0, parse_utils_js_1.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 = (0, parse_utils_js_1.createSelectQueryBuilder)();
+        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
+        const res = callback(Object.assign(whereBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (select_query_node_js_1.SelectQueryNode.is(node)) {
+            if (!node.where) {
+                throw new Error('no `where` methods called inside a group callback');
+            }
+            return parens_node_js_1.ParensNode.create(node.where.where);
+        }
+        else {
+            return node;
         }
-        return parens_node_js_1.ParensNode.create(queryNode.where.where);
     },
     having(callback) {
-        const query = callback((0, parse_utils_js_1.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 = (0, parse_utils_js_1.createSelectQueryBuilder)();
+        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
+        const res = callback(Object.assign(havingBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (select_query_node_js_1.SelectQueryNode.is(node)) {
+            if (!node.having) {
+                throw new Error('no `having` methods called inside a group callback');
+            }
+            return parens_node_js_1.ParensNode.create(node.having.having);
+        }
+        else {
+            return node;
         }
-        return parens_node_js_1.ParensNode.create(queryNode.having.having);
     },
     on(callback) {
-        const joinBuilder = callback((0, parse_utils_js_1.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 = (0, parse_utils_js_1.createJoinBuilder)('InnerJoin', 'table');
+        const exprBuilder = (0, expression_builder_js_1.expressionBuilder)();
+        const res = callback(Object.assign(onBuilder, exprBuilder));
+        const node = res.toOperationNode();
+        if (join_node_js_1.JoinNode.is(node)) {
+            if (!node.on) {
+                throw new Error('no `on` methods called inside a group callback');
+            }
+            return parens_node_js_1.ParensNode.create(node.on.on);
+        }
+        else {
+            return node;
         }
-        return parens_node_js_1.ParensNode.create(joinNode.on.on);
     },
 });

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

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCoalesce = void 0;
-const raw_node_js_1 = require("../operation-node/raw-node.js");
-const reference_parser_js_1 = require("./reference-parser.js");
-function parseCoalesce(values) {
-    return raw_node_js_1.RawNode.create(values.length > 1
-        ? ['coalesce(', ...new Array(values.length - 1).fill(', '), ')']
-        : ['coalesce(', ')'], (0, reference_parser_js_1.parseReferenceExpressionOrList)(values));
-}
-exports.parseCoalesce = parseCoalesce;

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

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isExpressionOrFactory = exports.parseAliasedExpression = exports.parseExpression = void 0;
 const expression_js_1 = require("../expression/expression.js");
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const parse_utils_js_1 = require("./parse-utils.js");
 function parseExpression(exp) {
     if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
         return exp.toOperationNode();
     }
     else if ((0, object_utils_js_1.isFunction)(exp)) {
-        return exp((0, parse_utils_js_1.createExpressionBuilder)()).toOperationNode();
+        return exp((0, expression_builder_js_1.expressionBuilder)()).toOperationNode();
     }
     throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
 }
@@ -20,7 +20,7 @@ function parseAliasedExpression(exp) {
         return exp.toOperationNode();
     }
     else if ((0, object_utils_js_1.isFunction)(exp)) {
-        return exp((0, parse_utils_js_1.createExpressionBuilder)()).toOperationNode();
+        return exp((0, expression_builder_js_1.expressionBuilder)()).toOperationNode();
     }
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGroupBy = void 0;
 const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 function parseGroupBy(groupBy) {
+    groupBy = (0, object_utils_js_1.isFunction)(groupBy) ? groupBy((0, expression_builder_js_1.expressionBuilder)()) : groupBy;
     return (0, reference_parser_js_1.parseReferenceExpressionOrList)(groupBy).map(group_by_item_node_js_1.GroupByItemNode.create);
 }
 exports.parseGroupBy = parseGroupBy;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInsertObjectOrList = void 0;
+exports.parseInsertExpression = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 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");
@@ -9,10 +9,15 @@ const value_parser_js_1 = require("./value-parser.js");
 const values_node_js_1 = require("../operation-node/values-node.js");
 const expression_parser_js_1 = require("./expression-parser.js");
 const default_insert_value_node_js_1 = require("../operation-node/default-insert-value-node.js");
-function parseInsertObjectOrList(args) {
-    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+function parseInsertExpression(arg) {
+    const objectOrList = (0, object_utils_js_1.isFunction)(arg) ? arg((0, expression_builder_js_1.expressionBuilder)()) : arg;
+    const list = (0, object_utils_js_1.isReadonlyArray)(objectOrList)
+        ? objectOrList
+        : (0, object_utils_js_1.freeze)([objectOrList]);
+    return parseInsertColumnsAndValues(list);
 }
-exports.parseInsertObjectOrList = parseInsertObjectOrList;
+exports.parseInsertExpression = parseInsertExpression;
 function parseInsertColumnsAndValues(rows) {
     const columns = parseColumnNamesAndIndexes(rows);
     return [
@@ -37,19 +42,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 ((0, expression_parser_js_1.isExpressionOrFactory)(value)) {
-                complexColumn = true;
-            }
-            rowValues[columnIdx] = value;
+        if ((0, object_utils_js_1.isUndefined)(columnIdx)) {
+            continue;
+        }
+        const value = row[col];
+        if ((0, object_utils_js_1.isUndefined)(value) || (0, expression_parser_js_1.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 = default_insert_value_node_js_1.DefaultInsertValueNode.create();
         return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, object_utils_js_1.isUndefined)(it) ? defaultValue : (0, value_parser_js_1.parseValueExpression)(it)));
     }

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

@@ -22,5 +22,5 @@ function parseCallbackJoin(joinType, from, callback) {
     return joinBuilder.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.parseReferentialFilter)(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));
 }

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOverBuilder = exports.createJoinBuilder = exports.createQueryCreator = exports.createExpressionBuilder = exports.createSelectQueryBuilder = void 0;
+exports.createOverBuilder = exports.createJoinBuilder = exports.createQueryCreator = exports.createSelectQueryBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const over_node_js_1 = require("../operation-node/over-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
-const expression_builder_js_1 = require("../query-builder/expression-builder.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
 const over_builder_js_1 = require("../query-builder/over-builder.js");
 const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
@@ -20,12 +19,6 @@ function createSelectQueryBuilder() {
     });
 }
 exports.createSelectQueryBuilder = createSelectQueryBuilder;
-function createExpressionBuilder() {
-    return new expression_builder_js_1.ExpressionBuilder({
-        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
-    });
-}
-exports.createExpressionBuilder = createExpressionBuilder;
 function createQueryCreator() {
     return new query_creator_js_1.QueryCreator({
         executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,

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

@@ -1,5 +1,6 @@
 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 } from './select-parser.js';
+import { Selection, AllSelection } from './select-parser.js';
 export declare 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 declare 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,21 +1,13 @@
-import { AliasedSelectQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } 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 { AliasedExpression } from '../expression/expression.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 export declare 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 declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
-/**
- * Given a selection expression returns a query builder type that
- * has the selection.
- */
-export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, SE> = SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>;
-/**
- * `selectAll` output query builder type.
- */
-export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & AllSelection<DB, S>>;
+export declare type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
@@ -23,11 +15,11 @@ declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractA
 declare 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;
 declare 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 ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : 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;
 declare 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;
-declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+export declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];
 }>;
-export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
+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/select-parser.js

@@ -1,21 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSelectAll = exports.parseSelectExpressionOrList = void 0;
+exports.parseSelectAll = exports.parseSelectArg = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const selection_node_js_1 = require("../operation-node/selection-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
 const expression_parser_js_1 = require("./expression-parser.js");
 const table_parser_js_1 = require("./table-parser.js");
-function parseSelectExpressionOrList(selection) {
-    if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+function parseSelectArg(selection) {
+    if ((0, object_utils_js_1.isFunction)(selection)) {
+        return parseSelectArg(selection((0, expression_builder_js_1.expressionBuilder)()));
+    }
+    else if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
         return selection.map((it) => parseSelectExpression(it));
     }
     else {
         return [parseSelectExpression(selection)];
     }
 }
-exports.parseSelectExpressionOrList = parseSelectExpressionOrList;
+exports.parseSelectArg = parseSelectArg;
 function parseSelectExpression(selection) {
     if ((0, object_utils_js_1.isString)(selection)) {
         return selection_node_js_1.SelectionNode.create((0, reference_parser_js_1.parseAliasedStringReference)(selection));

package/dist/cjs/parser/table-parser.d.ts

@@ -3,17 +3,19 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
-export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
+export declare type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
 export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
+export declare type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never;
+export declare type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? Record<A, DB[TB]> : never : never;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? ExtractTableAlias<DB, TE> : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
 declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
-declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
 export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;

package/dist/cjs/parser/unary-operation-parser.d.ts

@@ -1,5 +1,8 @@
+import { UnaryOperator } from '../operation-node/operator-node.js';
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 import { ExpressionOrFactory } from './expression-parser.js';
+import { ReferenceExpression } from './reference-parser.js';
 export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
-export declare function parseExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
-export declare function parseNotExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseUnaryOperation(operator: UnaryOperator, operand: ReferenceExpression<any, any>): UnaryOperationNode;