kysely 0.11.3 → 0.12.2

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

@@ -4,7 +4,7 @@ exports.DefaultParseContext = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
-const query_builder_js_1 = require("../query-builder/query-builder.js");
+const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
 const expression_builder_js_1 = require("../query-builder/expression-builder.js");
 const query_creator_js_1 = require("../query-creator.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
@@ -20,18 +20,12 @@ class DefaultParseContext {
     get adapter() {
         return this.#adapter;
     }
-    createSelectQueryBuilder(tables) {
-        return new query_builder_js_1.QueryBuilder({
+    createSelectQueryBuilder() {
+        return new select_query_builder_js_1.SelectQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#noopExecutor,
             parseContext: this,
-            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this, tables)),
-        });
-    }
-    createJoinBuilder(joinType, table) {
-        return new join_builder_js_1.JoinBuilder({
-            joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(this, table)),
-            parseContext: this,
+            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this, [])),
         });
     }
     createExpressionBuilder() {
@@ -46,5 +40,11 @@ class DefaultParseContext {
             parseContext: this,
         });
     }
+    createJoinBuilder(joinType, table) {
+        return new join_builder_js_1.JoinBuilder({
+            joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(this, table)),
+            parseContext: this,
+        });
+    }
 }
 exports.DefaultParseContext = DefaultParseContext;

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

@@ -3,18 +3,19 @@ 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 { PrimitiveValue } from '../util/object-utils.js';
-import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../util/type-utils.js';
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+import { ComplexExpression } from './complex-expression-parser.js';
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<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 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 SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, R = RowType<DB, TB>> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends keyof R ? R[RE] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
-export declare function parseReferenceExpression(ctx: ParseContext, arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
+export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;
 export declare function parseAliasedStringReference(ref: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;

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

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const reference_node_js_1 = require("../operation-node/reference-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
 function parseReferenceExpressionOrList(ctx, arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(ctx, it));
@@ -17,23 +17,14 @@ function parseReferenceExpressionOrList(ctx, arg) {
     }
 }
 exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
-function parseReferenceExpression(ctx, arg) {
-    if ((0, object_utils_js_1.isString)(arg)) {
-        return parseStringReference(arg);
+function parseReferenceExpression(ctx, exp) {
+    if ((0, object_utils_js_1.isString)(exp)) {
+        return parseStringReference(exp);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
+    else if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(exp)) {
+        return exp.toOperationNode();
     }
-    throw new Error(`invalid reference expression ${JSON.stringify(arg)}`);
+    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
 }
 exports.parseReferenceExpression = parseReferenceExpression;
 function parseStringReference(ref) {

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

@@ -1,9 +1,5 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
 import { UpdateResult } from '../query-builder/update-result.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 InsertResult ? Selection<DB, TB, S> : O extends DeleteResult ? Selection<DB, TB, S> : O extends UpdateResult ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;
+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>;

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

@@ -1,30 +1,28 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
+import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.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> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+import { AliasedComplexExpression } from './complex-expression-parser.js';
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<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, S> = QueryBuilder<DB, TB, O & Selection<DB, TB, S>>;
+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> = QueryBuilder<DB, TB, O & RowType<DB, S>>;
-export declare type Selection<DB, TB extends keyof DB, S> = {
-    [A in ExtractAliasFromSelectExpression<S>]: ExtractTypeFromSelectExpression<DB, TB, S, A>;
+export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = SelectQueryBuilder<DB, TB, O & RowType<DB, S>>;
+export declare type Selection<DB, TB extends keyof DB, SE> = {
+    [A in ExtractAliasFromSelectExpression<SE>]: ExtractTypeFromSelectExpression<DB, TB, SE, 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;
+declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+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 AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<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, R = RowType<DB, TB>> = 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 keyof R ? R[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 keyof R ? R[SE] : never : never;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSelectAll = exports.parseSelectExpressionOrList = void 0;
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 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 complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseSelectExpressionOrList(ctx, selection) {
     if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
         return selection.map((it) => parseSelectExpression(ctx, it));
@@ -18,14 +19,11 @@ function parseSelectExpression(ctx, selection) {
     if ((0, object_utils_js_1.isString)(selection)) {
         return selection_node_js_1.SelectionNode.create((0, reference_parser_js_1.parseAliasedStringReference)(selection));
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(selection)) {
+    else if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(selection)) {
         return selection_node_js_1.SelectionNode.create(selection.toOperationNode());
     }
-    else if ((0, object_utils_js_1.isFunction)(selection)) {
-        return selection_node_js_1.SelectionNode.create(selection(ctx.createExpressionBuilder()).toOperationNode());
-    }
     else {
-        throw new Error(`invalid value passed to select method: ${JSON.stringify(selection)}`);
+        return selection_node_js_1.SelectionNode.create((0, complex_expression_parser_js_1.parseAliasedComplexExpression)(ctx, selection));
     }
 }
 function parseSelectAll(table) {
@@ -44,7 +42,5 @@ function parseSelectAllArg(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return selection_node_js_1.SelectionNode.createSelectAllFromTable(table);
     }
-    else {
-        throw new Error(`invalid value passed to selectAll method: ${JSON.stringify(table)}`);
-    }
+    throw new Error(`invalid value selectAll expression: ${JSON.stringify(table)}`);
 }

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

@@ -1,32 +1,30 @@
-import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
+import { AliasedQueryBuilder } from '../query-builder/select-query-builder.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
+import { AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB>;
+import { AliasedComplexExpression } from './complex-expression-parser.js';
+export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<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, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
-export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AnyAliasedRawBuilder;
 export declare type TableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
 export declare type LeftJoinTableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
 export declare type RightJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
-export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
 export declare type FullJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
 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 AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : 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 AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
-declare type AnyAliasedTable<DB, TB extends keyof DB, A extends string> = TB extends string ? `${TB} as ${A}` : never;
-declare type AnyTable<DB> = keyof DB;
+export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+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 AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
+declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
+declare type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(ctx: ParseContext, table: TableExpressionOrList<any, any>): TableExpressionNode[];
 export declare function parseTableExpression(ctx: ParseContext, table: TableExpression<any, any>): TableExpressionNode;
 export declare function parseAliasedTable(from: string): TableExpressionNode;

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

@@ -4,7 +4,7 @@ exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression =
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseTableExpressionOrList(ctx, table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
         return table.map((it) => parseTableExpression(ctx, it));
@@ -18,14 +18,8 @@ function parseTableExpression(ctx, table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(table)) {
-        return table.toOperationNode();
-    }
-    else if ((0, object_utils_js_1.isFunction)(table)) {
-        return table(ctx.createExpressionBuilder()).toOperationNode();
-    }
     else {
-        throw new Error(`invalid table expression ${JSON.stringify(table)}`);
+        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(ctx, table);
     }
 }
 exports.parseTableExpression = parseTableExpression;

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

@@ -1,5 +1,5 @@
 import { UnionNode } from '../operation-node/union-node.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type UnionExpression<DB, O> = QueryBuilder<DB, any, O> | RawBuilder<O>;
+export declare type UnionExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
 export declare function parseUnion(union: UnionExpression<any, any>, all: boolean): UnionNode;

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

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUnion = void 0;
-const query_node_js_1 = require("../operation-node/query-node.js");
 const union_node_js_1 = require("../operation-node/union-node.js");
 function parseUnion(union, all) {
-    const node = union.toOperationNode();
-    if (query_node_js_1.QueryNode.isMutating(node)) {
-        throw new Error("can't combine insert, update or delete queries using union");
-    }
-    return union_node_js_1.UnionNode.create(node, all);
+    return union_node_js_1.UnionNode.create(union.toOperationNode(), all);
 }
 exports.parseUnion = parseUnion;

package/dist/cjs/parser/update-set-parser.d.ts

@@ -1,13 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
-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, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.js';
+import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]?: MutationValueExpression<DB, TB, DB[TB][C]>;
+    [C in keyof DB[TB]]?: ValueExpression<DB, TB, DB[TB][C]>;
 };
-export declare type MutationValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
 export declare function parseUpdateObject(ctx: ParseContext, row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
-export declare function parseMutationValueExpression(ctx: ParseContext, value: MutationValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

package/dist/cjs/parser/update-set-parser.js

@@ -1,34 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMutationValueExpression = exports.parseUpdateObject = void 0;
+exports.parseUpdateObject = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
-const object_utils_js_1 = require("../util/object-utils.js");
+const value_parser_js_1 = require("./value-parser.js");
 function parseUpdateObject(ctx, row) {
-    return Object.entries(row).map(([key, value]) => {
-        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), parseMutationValueExpression(ctx, value));
+    return Object.entries(row)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(ctx, value));
     });
 }
 exports.parseUpdateObject = parseUpdateObject;
-function parseMutationValueExpression(ctx, value) {
-    if ((0, object_utils_js_1.isPrimitive)(value)) {
-        return value_node_js_1.ValueNode.create(value);
-    }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(value)) {
-        const node = value.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(value)) {
-        const node = value(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`unsupported value for mutation object ${JSON.stringify(value)}`);
-}
-exports.parseMutationValueExpression = parseMutationValueExpression;

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

@@ -1,8 +1,11 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { PrimitiveValue } from '../util/object-utils.js';
 import { ParseContext } from './parse-context.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> | ReadonlyArray<ValueExpression<DB, TB, RE>>;
-export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
-export declare function parseValueExpression(ctx: ParseContext, arg: ValueExpression<any, any, any>): ValueExpressionNode;
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { ComplexExpression } from './complex-expression-parser.js';
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB>;
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export declare function parseValueExpressionOrList(ctx: ParseContext, arg: ValueExpressionOrList<any, any, PrimitiveValue>): ValueExpressionNode;
+export declare function parseValueExpression(ctx: ParseContext, exp: ValueExpression<any, any, PrimitiveValue>): ValueNode | SelectQueryNode | RawNode;

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

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
-const column_node_js_1 = require("../operation-node/column-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.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");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseValueExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(ctx, arg);
     }
     else {
@@ -17,23 +15,11 @@ function parseValueExpressionOrList(ctx, arg) {
     }
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
-function parseValueExpression(ctx, arg) {
-    if ((0, object_utils_js_1.isPrimitive)(arg)) {
-        return value_node_js_1.ValueNode.create(arg);
+function parseValueExpression(ctx, exp) {
+    if ((0, object_utils_js_1.isPrimitive)(exp)) {
+        return value_node_js_1.ValueNode.create(exp);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`invalid value expression ${JSON.stringify(arg)}`);
+    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(ctx, arg) {
@@ -41,14 +27,5 @@ function parseValueExpressionList(ctx, arg) {
         // Optimization for large lists of primitive values.
         return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
     }
-    return value_list_node_js_1.ValueListNode.create(arg.map((it) => {
-        const node = parseValueExpression(ctx, it);
-        if (column_node_js_1.ColumnNode.is(node)) {
-            throw new Error('value lists cannot have column references');
-        }
-        if (value_list_node_js_1.ValueListNode.is(node) || primitive_value_list_node_js_1.PrimitiveValueListNode.is(node)) {
-            throw new Error('value lists cannot have nested lists');
-        }
-        return node;
-    }));
+    return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
 }

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

@@ -1,11 +1,41 @@
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.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(ctx: ParseContext, name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;
+export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
+export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
+export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+/**
+ * Given a common CommonTableExpression CTE extracts the row type from it.
+ *
+ * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
+ * would result in `Pick<Person, 'id' | 'first_name'>`.
+ */
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+/**
+ * Extracts 'person' from a string like 'person(id, first_name)'.
+ */
+declare type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
+/**
+ * Parses a string like 'person(id, first_name)' into a type:
+ *
+ * {
+ *   id: any,
+ *   first_name: any
+ * }
+ *
+ */
+declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
+    [C in ExtractColumnNamesFromColumnList<CL>]: any;
+} : Record<string, any>;
+/**
+ * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
+ */
+declare type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
+export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
 export {};

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

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCommonTableExpression = void 0;
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
 function parseCommonTableExpression(ctx, name, expression) {
     const builder = expression(ctx.createQueryCreator());
-    return common_table_expression_node_js_1.CommonTableExpressionNode.create(identifier_node_js_1.IdentifierNode.create(name), builder.toOperationNode());
+    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
 }
 exports.parseCommonTableExpression = parseCommonTableExpression;
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(name);
+    }
+}

package/dist/cjs/plugin/camel-case/camel-case-plugin.d.ts

@@ -94,7 +94,41 @@ export interface CamelCasePluginOptions {
 export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
     constructor(opt?: CamelCasePluginOptions);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
     protected mapRow(row: UnknownRow): UnknownRow;
     protected snakeCase(str: string): string;