kysely 0.19.2 → 0.19.5

package/README.md

@@ -95,7 +95,7 @@ interface PersonTable {
   // automatically by Kysely.
   last_name: string | null
 
-  // You can specity a different type for each operation (select, insert and
+  // You can specify a different type for each operation (select, insert and
   // update) using the `ColumnType<SelectType, InsertType, UpdateType>`
   // wrapper. Here we define a column `modified_at` that is selected as
   // a `Date`, can optionally be provided as a `string` in inserts and
@@ -324,7 +324,7 @@ have. You will probably want to add a simple migration script to your projects l
 ```ts
 import * as path from 'path'
 import { Pool } from 'pg'
-import { promises: fs } from 'fs'
+import { promises as fs } from 'fs'
 import {
   Kysely,
   Migrator,

package/dist/cjs/dialect/mysql/mysql-driver.d.ts

@@ -11,11 +11,6 @@ export declare class MysqlDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/dialect/postgres/postgres-driver.d.ts

@@ -11,11 +11,6 @@ export declare class PostgresDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/dialect/sqlite/sqlite-driver.d.ts

@@ -9,11 +9,6 @@ export declare class SqliteDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -37,7 +37,6 @@ class SqliteIntrospector {
         const columns = await db
             .selectFrom((0, sql_js_1.sql) `PRAGMA_TABLE_INFO(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull'])
-            .castTo()
             .execute();
         return {
             name: table,

package/dist/cjs/driver/driver.d.ts

@@ -10,11 +10,6 @@ export interface Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/driver/dummy-driver.d.ts

@@ -42,11 +42,6 @@ export declare class DummyDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/driver/runtime-driver.d.ts

@@ -14,11 +14,6 @@ export declare class RuntimeDriver implements Driver {
      *
      * After calling this method the driver should be usable and `acquireConnection` etc.
      * methods should be callable.
-     *
-     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
-     * should be imported inside this function, not at the top of the driver file! This is
-     * important so that Kysely is usable without installing all database driver libraries
-     * it supports.
      */
     init(): Promise<void>;
     /**

package/dist/cjs/index.d.ts

@@ -1,7 +1,6 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/where-interface.js';
-export * from './query-builder/join-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
 export * from './query-builder/select-query-builder.js';

package/dist/cjs/index.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./kysely.js"), exports);
 __exportStar(require("./query-creator.js"), exports);
 __exportStar(require("./query-builder/where-interface.js"), exports);
-__exportStar(require("./query-builder/join-interface.js"), exports);
 __exportStar(require("./query-builder/returning-interface.js"), exports);
 __exportStar(require("./query-builder/having-interface.js"), exports);
 __exportStar(require("./query-builder/select-query-builder.js"), exports);

package/dist/cjs/migration/file-migration-provider.js

@@ -27,9 +27,10 @@ class FileMigrationProvider {
         const migrations = {};
         const files = await this.#props.fs.readdir(this.#props.migrationFolder);
         for (const fileName of files) {
-            if ((fileName.endsWith('.js') || fileName.endsWith('.ts')) &&
+            if ((fileName.endsWith('.js') || fileName.endsWith('.ts') || fileName.endsWith('.mjs')) &&
                 !fileName.endsWith('.d.ts')) {
-                const migration = await Promise.resolve().then(() => require(this.#props.path.join(this.#props.migrationFolder, fileName)));
+                const migration = await Promise.resolve().then(() => require(
+                /* webpackIgnore: true */ this.#props.path.join(this.#props.migrationFolder, fileName)));
                 if (isMigration(migration)) {
                     migrations[fileName.substring(0, fileName.length - 3)] = migration;
                 }

package/dist/cjs/operation-node/check-constraint-node.d.ts

@@ -11,5 +11,5 @@ export interface CheckConstraintNode extends OperationNode {
  */
 export declare const CheckConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: RawNode, constraintName?: string | undefined): CheckConstraintNode;
+    create(expression: RawNode, constraintName?: string): CheckConstraintNode;
 }>;

package/dist/cjs/operation-node/common-table-expression-name-node.d.ts

@@ -11,5 +11,5 @@ export interface CommonTableExpressionNameNode extends OperationNode {
  */
 export declare const CommonTableExpressionNameNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNameNode;
-    create(tableName: string, columnNames?: readonly string[] | undefined): CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: ReadonlyArray<string>): CommonTableExpressionNameNode;
 }>;

package/dist/cjs/operation-node/create-schema-node.d.ts

@@ -11,6 +11,6 @@ export interface CreateSchemaNode extends OperationNode {
  */
 export declare const CreateSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
-    create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;
+    create(schema: string, params?: CreateSchemaNodeParams): CreateSchemaNode;
     cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
 }>;

package/dist/cjs/operation-node/delete-query-node.d.ts

@@ -23,7 +23,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: TableExpressionNode, withNode?: WithNode | undefined): DeleteQueryNode;
+    create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
 }>;

package/dist/cjs/operation-node/drop-constraint-node.d.ts

@@ -1,8 +1,11 @@
 import { OperationNode } from './operation-node.js';
 import { IdentifierNode } from './identifier-node.js';
+export declare type DropConstraintNodeProps = Omit<DropConstraintNode, 'kind' | 'constraintName'>;
 export interface DropConstraintNode extends OperationNode {
     readonly kind: 'DropConstraintNode';
     readonly constraintName: IdentifierNode;
+    readonly ifExists?: boolean;
+    readonly modifier?: 'cascade' | 'restrict';
 }
 /**
  * @internal
@@ -10,4 +13,5 @@ export interface DropConstraintNode extends OperationNode {
 export declare const DropConstraintNode: Readonly<{
     is(node: OperationNode): node is DropConstraintNode;
     create(constraintName: string): DropConstraintNode;
+    cloneWith(dropConstraint: DropConstraintNode, props: DropConstraintNodeProps): DropConstraintNode;
 }>;

package/dist/cjs/operation-node/drop-constraint-node.js

@@ -16,4 +16,10 @@ exports.DropConstraintNode = (0, object_utils_js_1.freeze)({
             constraintName: identifier_node_js_1.IdentifierNode.create(constraintName),
         });
     },
+    cloneWith(dropConstraint, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropConstraint,
+            ...props,
+        });
+    },
 });

package/dist/cjs/operation-node/drop-index-node.d.ts

@@ -13,6 +13,6 @@ export interface DropIndexNode extends OperationNode {
  */
 export declare const DropIndexNode: Readonly<{
     is(node: OperationNode): node is DropIndexNode;
-    create(name: string, params?: DropIndexNodeProps | undefined): DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps): DropIndexNode;
     cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
 }>;

package/dist/cjs/operation-node/drop-schema-node.d.ts

@@ -11,6 +11,6 @@ export interface DropSchemaNode extends OperationNode {
  */
 export declare const DropSchemaNode: Readonly<{
     is(node: OperationNode): node is DropSchemaNode;
-    create(schema: string, params?: DropSchemaNodeParams | undefined): DropSchemaNode;
+    create(schema: string, params?: DropSchemaNodeParams): DropSchemaNode;
     cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
 }>;

package/dist/cjs/operation-node/drop-table-node.d.ts

@@ -11,6 +11,6 @@ export interface DropTableNode extends OperationNode {
  */
 export declare const DropTableNode: Readonly<{
     is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropTablexNodeParams | undefined): DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams): DropTableNode;
     cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
 }>;

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -17,7 +17,7 @@ export interface ForeignKeyConstraintNode extends OperationNode {
  */
 export declare const ForeignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
-    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
     cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
         name?: IdentifierNode | undefined;
         onDelete?: OnModifyForeignAction | undefined;

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -25,6 +25,6 @@ export interface InsertQueryNode extends OperationNode {
  */
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode | undefined): InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/cjs/operation-node/join-node.d.ts

@@ -4,7 +4,7 @@ import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type JoinTableNode = TableNode | AliasNode;
-export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin';
+export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -545,6 +545,8 @@ class OperationNodeTransformer {
         return {
             kind: 'DropConstraintNode',
             constraintName: this.transformNode(node.constraintName),
+            ifExists: node.ifExists,
+            modifier: node.modifier,
         };
     }
     transformCreateView(node) {

package/dist/cjs/operation-node/order-by-item-node.d.ts

@@ -11,5 +11,5 @@ export interface OrderByItemNode extends OperationNode {
  */
 export declare const OrderByItemNode: Readonly<{
     is(node: OperationNode): node is OrderByItemNode;
-    create(orderBy: ReferenceExpressionNode, direction?: RawNode | undefined): OrderByItemNode;
+    create(orderBy: ReferenceExpressionNode, direction?: RawNode): OrderByItemNode;
 }>;

package/dist/cjs/operation-node/primary-constraint-node.d.ts

@@ -11,5 +11,5 @@ export interface PrimaryKeyConstraintNode extends OperationNode {
  */
 export declare const PrimaryConstraintNode: Readonly<{
     is(node: OperationNode): node is PrimaryKeyConstraintNode;
-    create(columns: string[], constraintName?: string | undefined): PrimaryKeyConstraintNode;
+    create(columns: string[], constraintName?: string): PrimaryKeyConstraintNode;
 }>;

package/dist/cjs/operation-node/select-query-node.d.ts

@@ -36,7 +36,7 @@ export interface SelectQueryNode extends OperationNode {
  */
 export declare const SelectQueryNode: Readonly<{
     is(node: OperationNode): node is SelectQueryNode;
-    create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode | undefined): SelectQueryNode;
+    create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOnSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithModifier(select: SelectQueryNode, modifier: SelectModifier): SelectQueryNode;

package/dist/cjs/operation-node/unique-constraint-node.d.ts

@@ -11,5 +11,5 @@ export interface UniqueConstraintNode extends OperationNode {
  */
 export declare const UniqueConstraintNode: Readonly<{
     is(node: OperationNode): node is UniqueConstraintNode;
-    create(columns: string[], constraintName?: string | undefined): UniqueConstraintNode;
+    create(columns: string[], constraintName?: string): UniqueConstraintNode;
 }>;

package/dist/cjs/operation-node/update-query-node.d.ts

@@ -24,7 +24,7 @@ export interface UpdateQueryNode extends OperationNode {
  */
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
-    create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;
+    create(table: TableExpressionNode, withNode?: WithNode): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
 }>;

package/dist/cjs/operation-node/with-node.d.ts

@@ -11,6 +11,6 @@ export interface WithNode extends OperationNode {
  */
 export declare const WithNode: Readonly<{
     is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode, params?: WithNodeParams | undefined): WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams): WithNode;
     cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): WithNode;
 }>;

package/dist/cjs/package.json

@@ -1 +1 @@
-{"type":"commonjs"}
+{"type":"commonjs","sideEffects":false}

package/dist/cjs/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/cjs/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/cjs/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/cjs/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}
      */