kysely 0.19.3 → 0.19.6

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

@@ -1,10 +1,10 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
-import { TableExpressionDatabase, TableExpressionTables } from './table-parser.js';
+import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
 export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

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

@@ -1,26 +1,17 @@
 import { AliasedQueryBuilder } from '../query-builder/select-query-builder.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AnyAliasedRawBuilder, Nullable } from '../util/type-utils.js';
+import { AnyAliasedRawBuilder } from '../util/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 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> | 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 From<DB, TE> = {
+    [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type 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 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 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;
-export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends 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 : 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;

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

@@ -1,25 +1,26 @@
 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, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-parser.js';
+import { TableExpression } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { Selectable } from '../util/column-type.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
-export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { AliasedQueryBuilder } from './select-query-builder.js';
+import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
@@ -515,23 +516,23 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilderWithInnerJoin<DB, TB, O, TE>;
     /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     * Just like {@link innerJoin} but adds a left join instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilderWithRightJoin<DB, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilderWithRightJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): DeleteQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): DeleteQueryBuilderWithFullJoin<DB, TB, O, TE>;
     /**
      * Allows you to return data from modified rows.
      *
@@ -749,3 +750,24 @@ export interface DeleteQueryBuilderProps {
     readonly queryNode: DeleteQueryNode;
     readonly executor: QueryExecutor;
 }
+export declare type DeleteQueryBuilderWithInnerJoin<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 ? DeleteQueryBuilder<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;
+declare type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? DeleteQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : DeleteQueryBuilder<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 DeleteQueryBuilderWithLeftJoin<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;
+declare type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? DeleteQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : DeleteQueryBuilder<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 DeleteQueryBuilderWithRightJoin<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;
+declare type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = DeleteQueryBuilder<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 DeleteQueryBuilderWithFullJoin<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;
+declare type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = DeleteQueryBuilder<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;
+};
+export {};

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

@@ -1,5 +1,5 @@
 import { SelectQueryBuilder } from './select-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
@@ -83,8 +83,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
     /**
      * See {@link QueryCreator.withSchema}
      */

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

@@ -66,6 +66,10 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * Adds `on true`.
+     */
+    onTrue(): JoinBuilder<DB, TB>;
     toOperationNode(): JoinNode;
 }
 export interface JoinBuilderProps {

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

@@ -1,5 +1,6 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
 import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -92,6 +93,15 @@ export class JoinBuilder {
             joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(arg)),
         });
     }
+    /**
+     * Adds `on true`.
+     */
+    onTrue() {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, RawNode.createWithSql('true')),
+        });
+    }
     toOperationNode() {
         return this.#props.joinNode;
     }

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

@@ -2,12 +2,12 @@ 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, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-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, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, 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';
@@ -15,10 +15,10 @@ import { QueryId } from '../util/query-id.js';
 import { UnionExpression } from '../parser/union-parser.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { JoinInterface } from './join-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
-export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, JoinInterface<DB, TB>, OperationNodeSource, Compilable {
+import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
+export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable {
     #private;
     constructor(props: SelectQueryBuilderProps);
     /**
@@ -856,23 +856,63 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
     /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     * Just like {@link innerJoin} but adds a left join instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral join instead of an inner join.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     */
+    innerJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral left join instead of an inner join.
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .leftJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     * ```
+     */
+    leftJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Adds an `order by` clause to the query.
      *
@@ -1282,3 +1322,24 @@ export declare class AliasedQueryBuilder<DB, TB extends keyof DB, O = undefined,
     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;
+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;
+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;
+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;
+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;
+};
+export {};

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

@@ -235,6 +235,18 @@ export class SelectQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
+    innerJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralInnerJoin', args)),
+        });
+    }
+    leftJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralLeftJoin', args)),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *

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

@@ -1,12 +1,12 @@
 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, TableExpressionDatabase, TableExpressionTables, LeftJoinTableExpressionDatabase, RightJoinTableExpressionDatabase, FullJoinTableExpressionDatabase } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -15,11 +15,12 @@ import { QueryId } from '../util/query-id.js';
 import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { JoinInterface } from './join-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, JoinInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { AliasedQueryBuilder } from './select-query-builder.js';
+import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -433,8 +434,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "pet"."owner_id" = "person"."id"
      * ```
      */
-    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *
@@ -544,23 +545,23 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * on "doggos"."owner_id" = "person"."id"
      * ```
      */
-    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithInnerJoin<DB, UT, TB, O, TE>;
+    innerJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithInnerJoin<DB, UT, TB, O, TE>;
     /**
-     * Just like {@link innerJoin} but adds a left join nstead of an inner join.
+     * Just like {@link innerJoin} but adds a left join instead of an inner join.
      */
-    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    leftJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithLeftJoin<DB, UT, TB, O, TE>;
+    leftJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithLeftJoin<DB, UT, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a right join instead of an inner join.
      */
-    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    rightJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithRightJoin<DB, UT, TB, O, TE>;
+    rightJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithRightJoin<DB, UT, TB, O, TE>;
     /**
      * Just like {@link innerJoin} but adds a full join instead of an inner join.
      */
-    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
+    fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -814,3 +815,24 @@ export interface UpdateQueryBuilderProps {
     readonly queryNode: UpdateQueryNode;
     readonly executor: QueryExecutor;
 }
+export declare type UpdateQueryBuilderWithInnerJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? UpdateQueryBuilder<DB, UT, TB | TE, O> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? InnerJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? InnerJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type InnerJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? UpdateQueryBuilder<InnerJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, R>, UT, 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 UpdateQueryBuilderWithLeftJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? LeftJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? LeftJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type LeftJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? UpdateQueryBuilder<LeftJoinedDB<DB, A, R>, UT, TB | A, O> : UpdateQueryBuilder<DB & Record<A, Nullable<R>>, UT, 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 UpdateQueryBuilderWithRightJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? RightJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? RightJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type RightJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<RightJoinedDB<DB, TB, A, R>, UT, 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 UpdateQueryBuilderWithFullJoin<DB, UT extends keyof DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, UT, TB, O, TE, DB[TE]> : TE extends AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer QO, infer QA> ? OuterJoinedBuilder<DB, UT, TB, O, QA, QO> : TE extends AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : TE extends (qb: any) => AliasedRawBuilder<infer RO, infer RA> ? OuterJoinedBuilder<DB, UT, TB, O, RA, RO> : never;
+declare type OuterJoinedBuilder<DB, UT extends keyof DB, TB extends keyof DB, O, A extends keyof any, R> = UpdateQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, UT, 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;
+};
+export {};

package/dist/esm/query-compiler/default-query-compiler.js

@@ -836,4 +836,6 @@ const JOIN_TYPE_SQL = freeze({
     LeftJoin: 'left join',
     RightJoin: 'right join',
     FullJoin: 'full join',
+    LateralInnerJoin: 'inner join lateral',
+    LateralLeftJoin: 'left join lateral',
 });

package/dist/esm/query-creator.d.ts

@@ -2,7 +2,7 @@ import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
+import { TableExpression, From, FromTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
@@ -120,8 +120,8 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
@@ -180,7 +180,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
@@ -204,7 +204,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/util/type-utils.d.ts

@@ -111,6 +111,9 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+export declare type NullableValues<T> = {
+    [P in keyof T]: Nullable<T[P]>;
+};
 /**
  * Takes all properties from T1 and merges all properties from T2
  * that don't exist in T1 as optional properties.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.3",
+  "version": "0.19.6",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -45,19 +45,19 @@
     "@types/better-sqlite3": "^7.5.0",
     "@types/chai": "^4.3.1",
     "@types/chai-subset": "^1.3.3",
-    "@types/mocha": "^9.1.0",
+    "@types/mocha": "^9.1.1",
     "@types/pg": "^8.6.5",
-    "better-sqlite3": "^7.5.1",
+    "better-sqlite3": "^7.5.3",
     "chai": "^4.3.6",
     "chai-subset": "^1.6.0",
-    "esbuild": "^0.14.36",
-    "mocha": "^9.2.2",
+    "esbuild": "^0.14.47",
+    "mocha": "^10.0.0",
     "mysql2": "^2.3.3",
     "pg": "^8.7.3",
-    "playwright": "^1.21.0",
-    "prettier": "^2.6.2",
-    "tsd": "^0.20.0",
-    "typedoc": "^0.22.15",
-    "typescript": "4.6.3"
+    "playwright": "^1.22.2",
+    "prettier": "^2.7.1",
+    "tsd": "^0.21.0",
+    "typedoc": "^0.22.18",
+    "typescript": "4.7.4"
   }
 }