kysely 0.22.0 → 0.23.1

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

@@ -1,13 +1,11 @@
 import { AliasNode } from '../operation-node/alias-node.js';
-import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression } from '../parser/table-parser.js';
 import { SelectExpression, QueryBuilderWithSelection, SelectAllQueryBuilder } from '../parser/select-parser.js';
-import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper, HavingGrouper } from '../parser/filter-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -17,12 +15,31 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
-import { SetOperationExpression } from '../parser/set-operation-parser.js';
-export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable, Explainable {
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { ComparisonOperatorExpression, HavingGrouper, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
+export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, Expression<O>, Compilable<O>, Explainable {
     #private;
     constructor(props: SelectQueryBuilderProps);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): O | undefined;
     /**
      * Adds a `where` clause to the query.
      *
@@ -207,16 +224,16 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
     where(grouper: WhereGrouper<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    where(raw: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    where(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
      *
      * The normal `where` method treats the right hand side argument as a
      * value by default. `whereRef` treats it as a column reference. This method is
-     * expecially useful with joins and correclated subqueries.
+     * expecially useful with joins and correlated subqueries.
      *
      * ### Examples
      *
@@ -261,7 +278,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
      *
@@ -325,15 +342,15 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" (where "id" = 1 or "id" = 2)
      * ```
      */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
+    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
     orWhere(grouper: WhereGrouper<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    orWhere(raw: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    orWhere(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
      *
      * Also see {@link orWhere} and {@link where}.
      */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where exists` clause to the query.
      *
@@ -400,37 +417,37 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or exists` clause.
+     * Just like {@link whereExists} but creates an `or exists` clause.
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Just like {@link whereExists} but creates a `or not exists` clause.
+     * Just like {@link whereExists} but creates an `or not exists` clause.
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
      * instead of a `where` statement.
      */
-    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
+    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
     having(grouper: HavingGrouper<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    having(raw: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    having(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    havingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.orWhere | orWhere} but adds a `having` statement
      * instead of a `where` statement.
      */
-    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: FilterOperator, rhs: FilterValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
+    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
     orHaving(grouper: HavingGrouper<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    orHaving(raw: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    orHaving(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.orWhereRef | orWhereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: FilterOperator, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.whereExists | whereExists} but adds a `having` statement
      * instead of a `where` statement.
@@ -627,11 +644,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
     select<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): QueryBuilderWithSelection<DB, TB, O, SE>;
     select<SE extends SelectExpression<DB, TB>>(selection: SE): QueryBuilderWithSelection<DB, TB, O, SE>;
     /**
-     * Adds `distinct on` selections to the select clause.
-     *
-     * Takes the same inputs as the {@link SelectQueryBuilder.select | select} method.
-     * See the {@link SelectQueryBuilder.select | select} method's documentation for
-     * more examples.
+     * Adds `distinct on` expressions to the select clause.
      *
      * ### Examples
      *
@@ -653,8 +666,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * where "pet"."name" = $1
      * ```
      */
-    distinctOn<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, TB, O>;
-    distinctOn<SE extends SelectExpression<DB, TB>>(selection: SE): SelectQueryBuilder<DB, TB, O>;
+    distinctOn<RE extends ReferenceExpression<DB, TB>>(selections: ReadonlyArray<RE>): SelectQueryBuilder<DB, TB, O>;
+    distinctOn<RE extends ReferenceExpression<DB, TB>>(selection: RE): SelectQueryBuilder<DB, TB, O>;
     /**
      * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
      *
@@ -674,7 +687,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * from `person`
      * ```
      */
-    modifyFront(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    modifyFront(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * This can be used to add any additional SQL to the end of the query.
      *
@@ -698,7 +711,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * for update
      * ```
      */
-    modifyEnd(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    modifyEnd(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Makes the selection distinct.
      *
@@ -1202,7 +1215,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    union(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    union(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union all`.
      *
@@ -1217,7 +1230,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    unionAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    unionAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect`.
      *
@@ -1232,7 +1245,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    intersect(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersect(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect all`.
      *
@@ -1247,7 +1260,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    intersectAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersectAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except`.
      *
@@ -1262,7 +1275,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    except(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    except(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except all`.
      *
@@ -1277,7 +1290,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .orderBy('name')
      * ```
      */
-    exceptAll(expression: SetOperationExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    exceptAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the given function passing `this` as the only argument.
      *
@@ -1371,7 +1384,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * pets[0].owner_first_name
      * ```
      */
-    as<A extends string>(alias: A): AliasedQueryBuilder<DB, TB, O, A>;
+    as<A extends string>(alias: A): AliasedSelectQueryBuilder<DB, TB, O, A>;
     /**
      * Change the output type of the query.
      *
@@ -1383,8 +1396,22 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
      */
     withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
     toOperationNode(): SelectQueryNode;
-    compile(): CompiledQuery;
+    compile(): CompiledQuery<O>;
     /**
      * Executes the query and returns an array of rows.
      *
@@ -1467,7 +1494,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * explain (analyze, format json) select * from "person" where "gender" = $1
      * ```
      */
-    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<ER[]>;
 }
 export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;
@@ -1477,36 +1504,40 @@ export interface SelectQueryBuilderProps {
 /**
  * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
  */
-export declare class AliasedQueryBuilder<DB, TB extends keyof DB, O = undefined, A extends string = never> {
+export declare class AliasedSelectQueryBuilder<DB, TB extends keyof DB, O = undefined, A extends string = never> implements AliasedExpression<O, A> {
     #private;
     constructor(queryBuilder: SelectQueryBuilder<DB, TB, O>, alias: A);
+    /** @private */
     /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedQueryBuilder with any A
-     * as long as D, TB and O are the same.
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<O>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
      */
-    protected get alias(): A;
     toOperationNode(): AliasNode;
 }
-export declare type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & Record<A, R>, TB | A, O>;
 declare type InnerJoinedDB<DB, A extends string, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 };
-export declare type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & Record<A, Nullable<R>>, TB | A, O>;
 declare type LeftJoinedDB<DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 };
-export declare type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
 declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 };
-export declare type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, TB, O, RA, RO> : never;
+export declare type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
 declare type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
 declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = {
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;

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

@@ -3,7 +3,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
-import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
+import { parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
@@ -15,106 +15,112 @@ import { parseGroupBy, } from '../parser/group-by-parser.js';
 import { NoResultError } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { ExplainNode } from '../operation-node/explain-node.js';
-import { parseSetOperation, } from '../parser/set-operation-parser.js';
+import { parseSetOperation } from '../parser/set-operation-parser.js';
+import { parseHaving, parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 export class SelectQueryBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
     where(...args) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhere(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(args)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhere(args)),
         });
     }
     orWhereRef(lhs, op, rhs) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     whereExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExists(arg)),
         });
     }
     whereNotExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     orWhereExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExists(arg)),
         });
     }
     orWhereNotExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     having(...args) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseHavingFilter(args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseHaving(args)),
         });
     }
     havingRef(lhs, op, rhs) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     orHaving(...args) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseHavingFilter(args)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseHaving(args)),
         });
     }
     orHavingRef(lhs, op, rhs) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseReferenceFilter(lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
         });
     }
     havingExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseExists(arg)),
         });
     }
     havingNotExist(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     orHavingExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseExistFilter(arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseExists(arg)),
         });
     }
     orHavingNotExists(arg) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseNotExistFilter(arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseNotExists(arg)),
         });
     }
     select(selection) {
@@ -126,7 +132,7 @@ export class SelectQueryBuilder {
     distinctOn(selection) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(selection)),
+            queryNode: SelectQueryNode.cloneWithDistinctOn(this.#props.queryNode, parseReferenceExpressionOrList(selection)),
         });
     }
     /**
@@ -151,7 +157,7 @@ export class SelectQueryBuilder {
     modifyFront(modifier) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+            queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode())),
         });
     }
     /**
@@ -180,7 +186,7 @@ export class SelectQueryBuilder {
     modifyEnd(modifier) {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode())),
         });
     }
     /**
@@ -676,7 +682,7 @@ export class SelectQueryBuilder {
      * ```
      */
     as(alias) {
-        return new AliasedQueryBuilder(this, alias);
+        return new AliasedSelectQueryBuilder(this, alias);
     }
     /**
      * Change the output type of the query.
@@ -762,8 +768,8 @@ export class SelectQueryBuilder {
      * ```
      */
     async *stream(chunkSize = 100) {
-        const compildQuery = this.compile();
-        const stream = this.#props.executor.stream(compildQuery, chunkSize, this.#props.queryId);
+        const compiledQuery = this.compile();
+        const stream = this.#props.executor.stream(compiledQuery, chunkSize, this.#props.queryId);
         for await (const item of stream) {
             yield* item.rows;
         }
@@ -806,7 +812,7 @@ export class SelectQueryBuilder {
     async explain(format, options) {
         const builder = new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+            queryNode: SelectQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options?.toOperationNode())),
         });
         return await builder.execute();
     }
@@ -815,26 +821,22 @@ preventAwait(SelectQueryBuilder, "don't await SelectQueryBuilder instances direc
 /**
  * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
  */
-export class AliasedQueryBuilder {
+export class AliasedSelectQueryBuilder {
     #queryBuilder;
     #alias;
     constructor(queryBuilder, alias) {
         this.#queryBuilder = queryBuilder;
         this.#alias = alias;
     }
-    /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedQueryBuilder with any A
-     * as long as D, TB and O are the same.
-     */
+    /** @private */
+    get expression() {
+        return this.#queryBuilder;
+    }
+    /** @private */
     get alias() {
         return this.#alias;
     }
     toOperationNode() {
-        const node = this.#queryBuilder.toOperationNode();
-        return AliasNode.create(node, IdentifierNode.create(this.#alias));
+        return AliasNode.create(this.#queryBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
     }
 }