kysely 0.3.4 → 0.3.9

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

@@ -36,7 +36,9 @@ export const selectQueryNode = freeze({
     cloneWithModifier(select, modifier) {
         return freeze({
             ...select,
-            modifier,
+            modifiers: select.modifiers
+                ? freeze([...select.modifiers, modifier])
+                : freeze([modifier]),
         });
     },
     cloneWithOrderByItem(selectNode, item) {
@@ -75,4 +77,10 @@ export const selectQueryNode = freeze({
                 : havingNode.create(filter),
         });
     },
+    cloneWithDistinct(selectNode) {
+        return freeze({
+            ...selectNode,
+            isDistinct: true,
+        });
+    },
 });

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

@@ -1,14 +1,13 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
 import { Operator } from '../operation-node/operator-node.js';
 import { ReferenceExpression } from './reference-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
-export declare type ExistsFilterArg<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB>;
-export declare type FilterOperatorArg = Operator | RawBuilder<any>;
+export declare type ExistsExpression<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type FilterOperator = Operator | AnyRawBuilder;
 export declare type FilterType = 'Where' | 'On' | 'Having';
-export declare function parseFilterArgs(filterType: FilterType, args: any[]): FilterExpressionNode;
-export declare function parseReferenceFilterArgs(lhs: ReferenceExpression<any, any>, op: FilterOperatorArg, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistsFilterArgs(type: 'exists' | 'not exists', arg: ExistsFilterArg<any, any>): FilterNode;
+export declare function parseFilter(filterType: FilterType, args: any[]): FilterExpressionNode;
+export declare function parseReferenceFilter(lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
+export declare function parseExistExpression(type: 'exists' | 'not exists', arg: ExistsExpression<any, any>): FilterNode;
 export declare function createEmptyJoinBuilder(): JoinBuilder<any, any>;

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

@@ -12,12 +12,12 @@ import { createEmptySelectQuery } from '../query-builder/query-builder.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { parseTableExpression } from './table-parser.js';
 import { joinNode } from '../operation-node/join-node.js';
-import { valueNode } from '../index.js';
-export function parseFilterArgs(filterType, args) {
+import { valueNode } from '../operation-node/value-node.js';
+export function parseFilter(filterType, args) {
     if (args.length === 3) {
         return parseThreeArgFilter(args[0], args[1], args[2]);
     }
-    else if (args.length === 1) {
+    else if (args.length === 1 && isFunction(args[0])) {
         if (filterType === 'Where') {
             return parseWhereGrouper(args[0]);
         }
@@ -32,10 +32,10 @@ export function parseFilterArgs(filterType, args) {
         throw new Error(`invalid arguments passed to a filter method ${JSON.stringify(args)}`);
     }
 }
-export function parseReferenceFilterArgs(lhs, op, rhs) {
+export function parseReferenceFilter(lhs, op, rhs) {
     return filterNode.create(parseReferenceExpression(lhs), parseFilterOperator(op), parseReferenceExpression(rhs));
 }
-export function parseExistsFilterArgs(type, arg) {
+export function parseExistExpression(type, arg) {
     const node = isFunction(arg)
         ? arg(new SubQueryBuilder()).toOperationNode()
         : arg.toOperationNode();
@@ -66,9 +66,6 @@ function parseFilterOperator(op) {
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
 function parseWhereGrouper(grouper) {
-    if (!isFunction(grouper)) {
-        throw new Error(`invalid call to queryBuilder.where: ${JSON.stringify(grouper)}`);
-    }
     const query = grouper(createEmptySelectQuery());
     const queryNode = query.toOperationNode();
     if (!queryNode.where) {
@@ -77,9 +74,6 @@ function parseWhereGrouper(grouper) {
     return parensNode.create(queryNode.where.where);
 }
 function parseHavingGrouper(grouper) {
-    if (!isFunction(grouper)) {
-        throw new Error(`invalid call to queryBuilder.having: ${JSON.stringify(grouper)}`);
-    }
     const query = grouper(createEmptySelectQuery());
     const queryNode = query.toOperationNode();
     if (!queryNode.having) {
@@ -88,9 +82,6 @@ function parseHavingGrouper(grouper) {
     return parensNode.create(queryNode.having.having);
 }
 function parseOnGrouper(grouper) {
-    if (!isFunction(grouper)) {
-        throw new Error(`invalid call to joinBuilder.on: ${JSON.stringify(grouper)}`);
-    }
     const joinBuilder = grouper(createEmptyJoinBuilder());
     const joinNode = joinBuilder.toOperationNode();
     if (!joinNode.on) {

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

@@ -1,3 +1,11 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { InsertValuesNode } from '../operation-node/insert-query-node.js';
-export declare function parseInsertValuesArgs(args: any): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
+import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+export declare type InsertObject<DB, TB extends keyof DB> = {
+    [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
+};
+export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | InsertObject<DB, TB>[];
+declare type InsertValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
+export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
+export {};

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

@@ -1,9 +1,10 @@
 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 { isGeneratedPlaceholder } from '../util/generated-placeholder.js';
 import { isPrimitive } from '../util/object-utils.js';
 import { parseMutationValueExpression, } from './mutation-parser.js';
-export function parseInsertValuesArgs(args) {
+export function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
 function parseInsertColumnsAndValues(rows) {
@@ -11,7 +12,8 @@ function parseInsertColumnsAndValues(rows) {
     const values = [];
     for (const row of rows) {
         for (const column of Object.keys(row)) {
-            if (!columns.includes(column)) {
+            const value = row[column];
+            if (!columns.includes(column) && !isGeneratedPlaceholder(value)) {
                 columns.push(column);
             }
         }
@@ -20,7 +22,9 @@ function parseInsertColumnsAndValues(rows) {
         const rowValues = columns.map(() => null);
         for (const column of Object.keys(row)) {
             const columnIdx = columns.indexOf(column);
-            rowValues[columnIdx] = row[column];
+            if (columnIdx !== -1) {
+                rowValues[columnIdx] = row[column];
+            }
         }
         if (rowValues.every(isPrimitive)) {
             values.push(primitiveValueListNode.create(rowValues));

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

@@ -2,6 +2,6 @@ import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../query-builder/type-utils.js';
 import { ExtractAliasFromTableExpression, TableExpressionDatabaseType } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-export declare type JoinReferenceArg<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-export declare type JoinCallbackArg<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
 export declare function parseJoinArgs(joinType: JoinType, args: any[]): JoinNode;

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

@@ -1,6 +1,6 @@
 import { joinNode } from '../operation-node/join-node.js';
 import { parseTableExpression, } from './table-parser.js';
-import { parseReferenceFilterArgs } from './filter-parser.js';
+import { parseReferenceFilter } from './filter-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 export function parseJoinArgs(joinType, args) {
     if (args.length === 2) {
@@ -20,5 +20,5 @@ function parseCallbackJoin(joinType, from, callback) {
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
     const tableNode = parseTableExpression(from);
-    return joinNode.cloneWithOn(joinNode.create(joinType, tableNode), 'and', parseReferenceFilterArgs(lhsColumn, '=', rhsColumn));
+    return joinNode.cloneWithOn(joinNode.create(joinType, tableNode), 'and', parseReferenceFilter(lhsColumn, '=', rhsColumn));
 }

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

@@ -1,11 +1,10 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder } from '../query-builder/type-utils.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { AnyQueryBuilder, AnyRawBuilder } from '../query-builder/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]?: MutationValueExpression<DB[TB][C]>;
 };
-export declare type MutationValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | RawBuilder<any>;
+export declare type MutationValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | AnyRawBuilder;
 export declare function parseMutationValueExpression(value: MutationValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -2,13 +2,18 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../query-builder/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { QueryBuilder } from '../query-builder/query-builder.js';
+export declare type ReferenceExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReferenceExpression<DB, TB>[];
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(str: string): ColumnNode | ReferenceNode;
 export declare function parseAliasedStringReference(str: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
+export {};

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

@@ -1,7 +1,7 @@
 import { aliasNode } from '../operation-node/alias-node.js';
 import { columnNode } from '../operation-node/column-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-import { referenceNode } from '../operation-node/reference-node.js';
+import { referenceNode, } from '../operation-node/reference-node.js';
 import { tableNode } from '../operation-node/table-node.js';
 import { isFunction, isString } from '../util/object-utils.js';
 import { queryNode } from '../operation-node/query-node.js';

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

@@ -1,7 +1,7 @@
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../query-builder/type-utils.js';
-import { SelectResultType } from './select-parser.js';
+import { Selection } from './select-parser.js';
 /**
  * `returning` method output query builder type
  */
-export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? SelectResultType<DB, TB, S> : O extends DeleteResultTypeTag ? SelectResultType<DB, TB, S> : O extends UpdateResultTypeTag ? SelectResultType<DB, TB, S> : O & SelectResultType<DB, TB, S>>;
+export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? Selection<DB, TB, S> : O extends DeleteResultTypeTag ? Selection<DB, TB, S> : O extends UpdateResultTypeTag ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;

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

@@ -1,29 +1,30 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../query-builder/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 /**
  * A selection expression.
  */
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | AliasedRawBuilder<any, any> | AliasedRawBuilderFactory<DB, TB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+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, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? InsertResultTypeTag : O & SelectResultType<DB, TB, S>>;
+export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? InsertResultTypeTag : O & Selection<DB, TB, S>>;
 /**
  * `selectAll` output query builder type.
  */
 export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = QueryBuilder<DB, TB, O & RowType<DB, S>>;
-export declare type SelectResultType<DB, TB extends keyof DB, S> = {
+export declare type Selection<DB, TB extends keyof DB, S> = {
     [A in ExtractAliasFromSelectExpression<S>]: ExtractTypeFromSelectExpression<DB, TB, S, A>;
 };
 declare type ExtractAliasFromSelectExpression<S> = S extends string ? ExtractAliasFromStringSelectExpression<S> : S extends AliasedRawBuilder<any, infer RA> ? RA : S extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : S extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : S extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : S extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<S extends string> = S extends `${string}.${string}.${string} as ${infer A}` ? A : S extends `${string}.${string} as ${infer A}` ? A : S extends `${string} as ${infer A}` ? A : S extends `${string}.${string}.${infer C}` ? C : S extends `${string}.${infer C}` ? C : S;
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, S, A extends keyof any> = S extends string ? ExtractTypeFromStringSelectExpression<DB, TB, S, A> : S extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, S extends string, A extends keyof any, R = RowType<DB, TB>> = S 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 : S 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 : S extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : S 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 : S extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends A ? S extends keyof R ? R[S] : never : never;
-export declare function parseSelectExpressionOrList(selection: SelectExpression<any, any> | SelectExpression<any, any>[]): SelectionNode[];
+export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAllArgs(table?: string | string[]): SelectionNode[];
 export declare function parseSelectAllArg(table: string): SelectionNode;
 export {};

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

@@ -1,10 +1,10 @@
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-import { isFunction, isString } from '../util/object-utils.js';
+import { isFunction, isReadonlyArray, isString } from '../util/object-utils.js';
 import { selectionNode, } from '../operation-node/selection-node.js';
 import { parseAliasedStringReference } from './reference-parser.js';
 import { SubQueryBuilder } from '../query-builder/sub-query-builder.js';
 export function parseSelectExpressionOrList(selection) {
-    if (Array.isArray(selection)) {
+    if (isReadonlyArray(selection)) {
         return selection.map((it) => parseSelectExpression(it));
     }
     else {

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

@@ -1,10 +1,10 @@
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder } from '../query-builder/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB>;
-export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AliasedRawBuilder<any, any>;
+export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
 export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
 export declare type TableExpressionDatabaseType<DB, TE> = DB extends ExtractDatabaseTypeFromTableExpression<DB, TE> ? DB : DB & ExtractDatabaseTypeFromTableExpression<DB, TE>;
 export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;

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

@@ -1,8 +1,7 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type ValueExpression<DB, TB extends keyof DB> = PrimitiveValue | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB> = ValueExpression<DB, TB> | ValueExpression<DB, TB>[];
-export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any>): ValueExpressionNode;
-export declare function parseValueExpression(arg: ValueExpression<any, any>): ValueExpressionNode;
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ValueExpression<DB, TB, RE>[];
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
+export declare function parseValueExpression(arg: ValueExpression<any, any, any>): ValueExpressionNode;

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

@@ -3,9 +3,11 @@ import { isOperationNodeSource } from '../operation-node/operation-node-source.j
 import { primitiveValueListNode, } from '../operation-node/primitive-value-list-node.js';
 import { valueListNode, } from '../operation-node/value-list-node.js';
 import { valueNode } from '../operation-node/value-node.js';
-import { isFunction, isPrimitive, } from '../util/object-utils.js';
+import { isFunction, isPrimitive } from '../util/object-utils.js';
 import { queryNode } from '../operation-node/query-node.js';
 import { SubQueryBuilder } from '../query-builder/sub-query-builder.js';
+import { rawNode } from '../operation-node/raw-node.js';
+import { selectQueryNode } from '../operation-node/select-query-node.js';
 export function parseValueExpressionOrList(arg) {
     if (Array.isArray(arg)) {
         return parseValueExpressionList(arg);
@@ -20,7 +22,7 @@ export function parseValueExpression(arg) {
     }
     else if (isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
-        if (!queryNode.isMutating(node)) {
+        if (rawNode.is(node) || selectQueryNode.is(node)) {
             return node;
         }
     }

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

@@ -2,7 +2,8 @@ import { CommonTableExpressionNode } from '../operation-node/common-table-expres
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | RawBuilder<any>;
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;
 declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends QueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;

package/dist/esm/query-builder/join-builder.d.ts

@@ -1,6 +1,6 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ExistsFilterArg, FilterOperatorArg } from '../parser/filter-parser.js';
+import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -12,7 +12,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      *
      * See {@link QueryBuilder.where} for documentation and examples.
      */
-    on(lhs: ReferenceExpression<DB, TB>, op: FilterOperatorArg, rhs: ValueExpressionOrList<DB, TB>): JoinBuilder<DB, TB>;
+    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     on(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhere} but adds an item to the join's
@@ -20,7 +20,7 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      *
      * See {@link QueryBuilder.orWhere} for documentation and examples.
      */
-    orOn(lhs: ReferenceExpression<DB, TB>, op: FilterOperatorArg, rhs: ValueExpressionOrList<DB, TB>): JoinBuilder<DB, TB>;
+    orOn<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: ValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
     orOn(grouper: (qb: JoinBuilder<DB, TB>) => JoinBuilder<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.whereRef} but adds an item to the join's
@@ -28,41 +28,41 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      *
      * See {@link QueryBuilder.whereRef} for documentation and examples.
      */
-    onRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperatorArg, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    onRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhereRef} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link QueryBuilder.orWhereRef} for documentation and examples.
      */
-    orOnRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperatorArg, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    orOnRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.whereExists} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link QueryBuilder.whereExists} for documentation and examples.
      */
-    onExists(arg: ExistsFilterArg<DB, TB>): JoinBuilder<DB, TB>;
+    onExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.whereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link QueryBuilder.whereNotExists} for documentation and examples.
      */
-    onNotExists(arg: ExistsFilterArg<DB, TB>): JoinBuilder<DB, TB>;
+    onNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhereExists} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link QueryBuilder.orWhereExists} for documentation and examples.
      */
-    orOnExists(arg: ExistsFilterArg<DB, TB>): JoinBuilder<DB, TB>;
+    orOnExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     /**
      * Just like {@link QueryBuilder.orWhereNotExists} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link QueryBuilder.orWhereNotExists} for documentation and examples.
      */
-    orOnNotExists(arg: ExistsFilterArg<DB, TB>): JoinBuilder<DB, TB>;
+    orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
     toOperationNode(): JoinNode;
 }

package/dist/esm/query-builder/join-builder.js

@@ -1,5 +1,5 @@
 import { joinNode } from '../operation-node/join-node.js';
-import { parseExistsFilterArgs, parseFilterArgs, parseReferenceFilterArgs, } from '../parser/filter-parser.js';
+import { parseExistExpression, parseFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
     #joinNode;
@@ -7,10 +7,10 @@ export class JoinBuilder {
         this.#joinNode = joinNode;
     }
     on(...args) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseFilterArgs('On', args)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseFilter('On', args)));
     }
     orOn(...args) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseFilterArgs('On', args)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseFilter('On', args)));
     }
     /**
      * Just like {@link QueryBuilder.whereRef} but adds an item to the join's
@@ -19,7 +19,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.whereRef} for documentation and examples.
      */
     onRef(lhs, op, rhs) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseReferenceFilterArgs(lhs, op, rhs)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseReferenceFilter(lhs, op, rhs)));
     }
     /**
      * Just like {@link QueryBuilder.orWhereRef} but adds an item to the join's
@@ -28,7 +28,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.orWhereRef} for documentation and examples.
      */
     orOnRef(lhs, op, rhs) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseReferenceFilterArgs(lhs, op, rhs)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseReferenceFilter(lhs, op, rhs)));
     }
     /**
      * Just like {@link QueryBuilder.whereExists} but adds an item to the join's
@@ -37,7 +37,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.whereExists} for documentation and examples.
      */
     onExists(arg) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseExistsFilterArgs('exists', arg)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseExistExpression('exists', arg)));
     }
     /**
      * Just like {@link QueryBuilder.whereNotExists} but adds an item to the join's
@@ -46,7 +46,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.whereNotExists} for documentation and examples.
      */
     onNotExists(arg) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseExistsFilterArgs('not exists', arg)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'and', parseExistExpression('not exists', arg)));
     }
     /**
      * Just like {@link QueryBuilder.orWhereExists} but adds an item to the join's
@@ -55,7 +55,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.orWhereExists} for documentation and examples.
      */
     orOnExists(arg) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseExistsFilterArgs('exists', arg)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseExistExpression('exists', arg)));
     }
     /**
      * Just like {@link QueryBuilder.orWhereNotExists} but adds an item to the join's
@@ -64,7 +64,7 @@ export class JoinBuilder {
      * See {@link QueryBuilder.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg) {
-        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseExistsFilterArgs('not exists', arg)));
+        return new JoinBuilder(joinNode.cloneWithOn(this.#joinNode, 'or', parseExistExpression('not exists', arg)));
     }
     toOperationNode() {
         return this.#joinNode;