kysely 0.7.1 → 0.7.5

package/dist/esm/dialect/mysql/mysql-introspector.d.ts

@@ -4,5 +4,4 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-    private parseTableMetadata;
 }

package/dist/esm/dialect/mysql/mysql-introspector.js

@@ -18,10 +18,10 @@ export class MysqlIntrospector {
         }
         const rawColumns = await query.execute();
         return {
-            tables: this.parseTableMetadata(rawColumns),
+            tables: this.#parseTableMetadata(rawColumns),
         };
     }
-    parseTableMetadata(columns) {
+    #parseTableMetadata(columns) {
         return columns.reduce((tables, it) => {
             let table = tables.find((tbl) => tbl.name === it.TABLE_NAME);
             if (!table) {

package/dist/esm/dialect/mysql/mysql-query-compiler.d.ts

@@ -1,12 +1,8 @@
 import { ColumnDefinitionNode } from '../../operation-node/column-definition-node.js';
-import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
-import { OnConflictNode } from '../../operation-node/on-conflict-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected visitColumnDefinition(node: ColumnDefinitionNode): void;
-    protected visitOnConflict(node: OnConflictNode): void;
     protected visitReturning(): void;
-    protected getInsertInto(node: InsertQueryNode): string;
     protected getSql(): string;
     protected getCurrentParameterPlaceholder(): string;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/dialect/mysql/mysql-query-compiler.js

@@ -29,27 +29,9 @@ export class MysqlQueryCompiler extends DefaultQueryCompiler {
             this.visitNode(node.check);
         }
     }
-    visitOnConflict(node) {
-        if (node.doNothing) {
-            // This is already handled by `getInsertInto`.
-            return;
-        }
-        if (node.updates) {
-            this.append('on duplicate key update ');
-            this.compileList(node.updates);
-        }
-    }
     visitReturning() {
         // Do nothing.
     }
-    getInsertInto(node) {
-        if (node.onConflict?.doNothing) {
-            return 'insert ignore into';
-        }
-        else {
-            return 'insert into';
-        }
-    }
     getSql() {
         return super.getSql().trimEnd();
     }

package/dist/esm/dialect/postgres/postgres-introspector.d.ts

@@ -4,5 +4,4 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
     getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-    private parseTableMetadata;
 }

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -30,10 +30,10 @@ export class PostgresIntrospector {
         }
         const rawColumns = await query.execute();
         return {
-            tables: this.parseTableMetadata(rawColumns),
+            tables: this.#parseTableMetadata(rawColumns),
         };
     }
-    parseTableMetadata(columns) {
+    #parseTableMetadata(columns) {
         return columns.reduce((tables, it) => {
             let table = tables.find((tbl) => tbl.name === it.table && tbl.schema === it.schema);
             if (!table) {

package/dist/esm/driver/database-connection.d.ts

@@ -14,7 +14,8 @@ export interface QueryResult<O> {
      */
     readonly insertedPrimaryKey?: number;
     /**
-     * This is defined if the query returned any rows.
+     * The rows returned by the query. This is always defined and is
+     * empty if the query returned no rows.
      */
     readonly rows: O[];
 }

package/dist/esm/driver/driver.d.ts

@@ -45,7 +45,7 @@ export interface Driver {
     destroy(): Promise<void>;
 }
 export interface TransactionSettings {
-    isolationLevel?: IsolationLevel;
+    readonly isolationLevel?: IsolationLevel;
 }
 export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable"];
 export declare type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;

package/dist/esm/driver/single-connection-provider.d.ts

@@ -4,5 +4,4 @@ export declare class SingleConnectionProvider implements ConnectionProvider {
     #private;
     constructor(connection: DatabaseConnection);
     withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
-    private run;
 }

package/dist/esm/driver/single-connection-provider.js

@@ -8,7 +8,7 @@ export class SingleConnectionProvider {
         while (this.#runningPromise) {
             await this.#runningPromise;
         }
-        const promise = this.run(runner);
+        const promise = this.#run(runner);
         this.#runningPromise = promise
             .then(() => {
             this.#runningPromise = undefined;
@@ -20,7 +20,7 @@ export class SingleConnectionProvider {
     }
     // Run the runner in an async function to make sure it doesn't
     // throw synchronous errors.
-    async run(runner) {
+    async #run(runner) {
         return await runner(this.#connection);
     }
 }

package/dist/esm/index.d.ts

@@ -2,7 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/sub-query-builder.js';
+export * from './query-builder/expression-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -17,6 +17,7 @@ export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
 export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
+export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';

package/dist/esm/index.js

@@ -2,7 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/sub-query-builder.js';
+export * from './query-builder/expression-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -17,6 +17,7 @@ export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
 export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
+export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';

package/dist/esm/kysely.d.ts

@@ -8,7 +8,7 @@ import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { GeneratedPlaceholder } from './query-builder/type-utils.js';
 import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
-import { DialectAdapter } from './dialect/dialect-adapter.js';
+import { ParseContext } from './parser/parse-context.js';
 /**
  * The main Kysely class.
  *
@@ -152,7 +152,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      *   .execute(async (db) => {
      *     // `db` is an instance of `Kysely` that's bound to a single
      *     // database connection. All queries executed through `db` use
-     *     // the same donnection and not the connection pool.
+     *     // the same connection.
      *     await doStuff(db)
      *   })
      * ```
@@ -186,7 +186,7 @@ export interface KyselyProps {
     readonly driver: Driver;
     readonly executor: QueryExecutor;
     readonly dialect: Dialect;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {
@@ -198,14 +198,15 @@ export declare class ConnectionBuilder<DB> {
     constructor(props: ConnectionBuilderProps);
     execute<T>(callback: (db: Kysely<DB>) => Promise<T>): Promise<T>;
 }
-export interface ConnectionBuilderProps extends KyselyProps {
+interface ConnectionBuilderProps extends KyselyProps {
 }
 export declare class TransactionBuilder<DB> {
     #private;
-    constructor(props: TransactionBuilerProps);
+    constructor(props: TransactionBuilderProps);
     setIsolationLevel(isolationLevel: IsolationLevel): TransactionBuilder<DB>;
     execute<T>(callback: (trx: Transaction<DB>) => Promise<T>): Promise<T>;
 }
-export interface TransactionBuilerProps extends KyselyProps {
+interface TransactionBuilderProps extends KyselyProps {
     readonly isolationLevel?: IsolationLevel;
 }
+export {};

package/dist/esm/kysely.js

@@ -10,6 +10,7 @@ import { RuntimeDriver } from './driver/runtime-driver.js';
 import { SingleConnectionProvider } from './driver/single-connection-provider.js';
 import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
 import { preventAwait } from './util/prevent-await.js';
+import { DefaultParseContext } from './parser/parse-context.js';
 /**
  * The main Kysely class.
  *
@@ -54,7 +55,7 @@ export class Kysely extends QueryCreator {
     #props;
     constructor(args) {
         if (isKyselyProps(args)) {
-            super({ executor: args.executor, adapter: args.adapter });
+            super({ executor: args.executor, parseContext: args.parseContext });
             this.#props = freeze(args);
         }
         else {
@@ -62,16 +63,17 @@ export class Kysely extends QueryCreator {
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const parseContext = new DefaultParseContext(adapter);
             const runtimeDriver = new RuntimeDriver(driver);
             const connectionProvider = new DefaultConnectionProvider(runtimeDriver);
             const executor = new DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
-            super({ executor, adapter });
+            super({ executor, parseContext });
             this.#props = freeze({
                 config: args,
                 executor,
-                adapter,
                 dialect,
                 driver,
+                parseContext,
             });
         }
     }
@@ -85,7 +87,7 @@ export class Kysely extends QueryCreator {
      * Returns the {@link MigrationModule} module for managing and running migrations.
      */
     get migration() {
-        return new MigrationModule(this, this.#props.adapter);
+        return new MigrationModule(this, this.#props.parseContext.adapter);
     }
     /**
      * Returns a the {@link DynamicModule} module.
@@ -186,7 +188,7 @@ export class Kysely extends QueryCreator {
      *   .execute(async (db) => {
      *     // `db` is an instance of `Kysely` that's bound to a single
      *     // database connection. All queries executed through `db` use
-     *     // the same donnection and not the connection pool.
+     *     // the same connection.
      *     await doStuff(db)
      *   })
      * ```
@@ -243,7 +245,7 @@ export function isKyselyProps(obj) {
         isObject(obj.driver) &&
         isObject(obj.executor) &&
         isObject(obj.dialect) &&
-        isObject(obj.adapter));
+        isObject(obj.parseContext));
 }
 export class ConnectionBuilder {
     #props;

package/dist/esm/migration/migration.js

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import { promises as fs } from 'fs';
-import { getLast, isFunction, isString } from '../util/object-utils.js';
+import { getLast, isFunction, isObject, isString, } from '../util/object-utils.js';
 export const MIGRATION_TABLE = 'kysely_migration';
 export const MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 export const MIGRATION_LOCK_ID = 'migration_lock';
@@ -11,20 +11,21 @@ export class MigrationModule {
         this.#db = db;
         this.#adapter = adapter;
     }
-    async migrateToLatest(migrationsFolderPath) {
+    async migrateToLatest(migrationsOrFolderPath) {
         await ensureMigrationTablesExists(this.#db);
-        if (isString(migrationsFolderPath)) {
-            return this.#migrateToLatest(await readMigrationsFromFolder(migrationsFolderPath));
-        }
-        else {
-            return this.#migrateToLatest(migrationsFolderPath);
-        }
+        const allMigrations = await this.#getAllMigrations(migrationsOrFolderPath);
+        await this.#migrateToLatest(allMigrations);
+    }
+    async #getAllMigrations(migrationsOrFolderPath) {
+        return isString(migrationsOrFolderPath)
+            ? await readMigrationsFromFolder(migrationsOrFolderPath)
+            : migrationsOrFolderPath;
     }
-    async #migrateToLatest(migrations) {
+    async #migrateToLatest(allMigrations) {
         const run = async (db) => {
             try {
                 await this.#adapter.acquireMigrationLock(db);
-                await runNewMigrations(db, migrations);
+                await runNewMigrations(db, allMigrations);
             }
             finally {
                 await this.#adapter.releaseMigrationLock(db);
@@ -178,5 +179,5 @@ function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNam
     }
 }
 function isMigration(obj) {
-    return obj && isFunction(obj.up) && isFunction(obj.down);
+    return isObject(obj) && isFunction(obj.up) && isFunction(obj.down);
 }

package/dist/esm/operation-node/alter-column-node.d.ts

@@ -3,7 +3,7 @@ import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
 import { ValueNode } from './value-node.js';
 import { RawNode } from './raw-node.js';
-export declare type AlterColumnNodeParams = Omit<Partial<AlterColumnNode>, 'kind' | 'column'>;
+export declare type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
     readonly kind: 'AlterColumnNode';
     readonly column: ColumnNode;
@@ -20,5 +20,5 @@ export interface AlterColumnNode extends OperationNode {
 export declare const AlterColumnNode: Readonly<{
     is(node: OperationNode): node is AlterColumnNode;
     create(column: string): AlterColumnNode;
-    cloneWith(node: AlterColumnNode, params: AlterColumnNodeParams): AlterColumnNode;
+    cloneWith(node: AlterColumnNode, props: AlterColumnNodeProps): AlterColumnNode;
 }>;

package/dist/esm/operation-node/alter-column-node.js

@@ -13,10 +13,10 @@ export const AlterColumnNode = freeze({
             column: ColumnNode.create(column),
         });
     },
-    cloneWith(node, params) {
+    cloneWith(node, props) {
         return freeze({
             ...node,
-            ...params,
+            ...props,
         });
     },
 });

package/dist/esm/operation-node/alter-table-node.d.ts

@@ -8,7 +8,7 @@ import { AlterColumnNode } from './alter-column-node.js';
 import { AddConstraintNode } from './add-constraint-node.js';
 import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
-export declare type AlterTableNodeParams = Omit<Partial<AlterTableNode>, 'kind' | 'table'>;
+export declare type AlterTableNodeProps = Omit<AlterTableNode, 'kind' | 'table'>;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
     readonly table: TableNode;
@@ -28,5 +28,5 @@ export interface AlterTableNode extends OperationNode {
 export declare const AlterTableNode: Readonly<{
     is(node: OperationNode): node is AlterTableNode;
     create(table: string): AlterTableNode;
-    cloneWith(node: AlterTableNode, params: AlterTableNodeParams): AlterTableNode;
+    cloneWith(node: AlterTableNode, props: AlterTableNodeProps): AlterTableNode;
 }>;

package/dist/esm/operation-node/alter-table-node.js

@@ -13,10 +13,10 @@ export const AlterTableNode = freeze({
             table: TableNode.create(table),
         });
     },
-    cloneWith(node, params) {
+    cloneWith(node, props) {
         return freeze({
             ...node,
-            ...params,
+            ...props,
         });
     },
 });

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -5,7 +5,7 @@ import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
 import { ValueNode } from './value-node.js';
-export declare type ColumnDefinitionNodeParams = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
@@ -25,5 +25,5 @@ export interface ColumnDefinitionNode extends OperationNode {
 export declare const ColumnDefinitionNode: Readonly<{
     is(node: OperationNode): node is ColumnDefinitionNode;
     create(column: string, dataType: ColumnDataTypeNode): ColumnDefinitionNode;
-    cloneWith(node: ColumnDefinitionNode, params: ColumnDefinitionNodeParams): ColumnDefinitionNode;
+    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): ColumnDefinitionNode;
 }>;

package/dist/esm/operation-node/column-definition-node.js

@@ -18,10 +18,10 @@ export const ColumnDefinitionNode = freeze({
             isNullable: true,
         });
     },
-    cloneWith(node, params) {
+    cloneWith(node, props) {
         return freeze({
             ...node,
-            ...params,
+            ...props,
         });
     },
 });

package/dist/esm/operation-node/create-index-node.d.ts

@@ -4,7 +4,7 @@ import { ListNode } from './list-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
-export declare type CreateIndexNodeParams = Omit<Partial<CreateIndexNode>, 'kind'>;
+export declare type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
 export declare type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
 export interface CreateIndexNode extends OperationNode {
     readonly kind: 'CreateIndexNode';
@@ -20,5 +20,5 @@ export interface CreateIndexNode extends OperationNode {
 export declare const CreateIndexNode: Readonly<{
     is(node: OperationNode): node is CreateIndexNode;
     create(name: string): CreateIndexNode;
-    cloneWith(node: CreateIndexNode, params: CreateIndexNodeParams): CreateIndexNode;
+    cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): CreateIndexNode;
 }>;

package/dist/esm/operation-node/create-index-node.js

@@ -13,10 +13,10 @@ export const CreateIndexNode = freeze({
             name: IdentifierNode.create(name),
         });
     },
-    cloneWith(node, params) {
+    cloneWith(node, props) {
         return freeze({
             ...node,
-            ...params,
+            ...props,
         });
     },
 });

package/dist/esm/operation-node/create-table-node.d.ts

@@ -1,5 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 export declare type CreateTableNodeModifier = 'IfNotExists';
@@ -21,5 +22,5 @@ export declare const CreateTableNode: Readonly<{
     cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
-    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraintName: string, sourceColumns: string[], targetTable: string, targetColumns: string[]): CreateTableNode;
+    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraint: ForeignKeyConstraintNode): CreateTableNode;
 }>;

package/dist/esm/operation-node/create-table-node.js

@@ -1,10 +1,7 @@
 import { freeze } from '../util/object-utils.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
-import { TableNode } from './table-node.js';
 import { PrimaryConstraintNode } from './primary-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
-import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
-import { ColumnNode } from './column-node.js';
 /**
  * @internal
  */
@@ -58,8 +55,7 @@ export const CreateTableNode = freeze({
                 : freeze([constraint]),
         });
     },
-    cloneWithForeignKeyConstraint(createTable, constraintName, sourceColumns, targetTable, targetColumns) {
-        const constraint = ForeignKeyConstraintNode.create(sourceColumns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName);
+    cloneWithForeignKeyConstraint(createTable, constraint) {
         return freeze({
             ...createTable,
             constraints: createTable.constraints

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

@@ -1,7 +1,7 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
-export declare type DropIndexNodeParams = Omit<Partial<DropIndexNode>, 'kind' | 'name'>;
+export declare type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
 export declare type DropIndexNodeModifier = 'IfExists';
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
@@ -14,6 +14,6 @@ export interface DropIndexNode extends OperationNode {
  */
 export declare const DropIndexNode: Readonly<{
     is(node: OperationNode): node is DropIndexNode;
-    create(name: string, params?: DropIndexNodeParams | undefined): DropIndexNode;
-    cloneWith(dropIndex: DropIndexNode, params: DropIndexNodeParams): DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps | undefined): DropIndexNode;
+    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
 }>;

package/dist/esm/operation-node/drop-index-node.js

@@ -14,10 +14,10 @@ export const DropIndexNode = freeze({
             ...params,
         });
     },
-    cloneWith(dropIndex, params) {
+    cloneWith(dropIndex, props) {
         return freeze({
             ...dropIndex,
-            ...params,
+            ...props,
         });
     },
 });

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

@@ -1,12 +1,15 @@
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferencesNode } from './references-node.js';
+import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
 import { TableNode } from './table-node.js';
+export declare type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
     readonly name?: IdentifierNode;
 }
 /**
@@ -15,4 +18,12 @@ 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;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
+        name?: IdentifierNode | undefined;
+        onDelete?: OnModifyForeignAction | undefined;
+        onUpdate?: OnModifyForeignAction | undefined;
+        kind: 'ForeignKeyConstraintNode';
+        columns: ReadonlyArray<ColumnNode>;
+        references: ReferencesNode;
+    }>;
 }>;

package/dist/esm/operation-node/foreign-key-constraint-node.js

@@ -16,4 +16,10 @@ export const ForeignKeyConstraintNode = freeze({
             name: constraintName ? IdentifierNode.create(constraintName) : undefined,
         });
     },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
 });

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

@@ -1,5 +1,6 @@
 import { ColumnNode } from './column-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
+import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
 import { PrimitiveValueListNode } from './primitive-value-list-node.js';
 import { ReturningNode } from './returning-node.js';
@@ -7,6 +8,7 @@ import { TableNode } from './table-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WithNode } from './with-node.js';
 export declare type InsertValuesNode = ValueListNode | PrimitiveValueListNode;
+export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
@@ -14,7 +16,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly values?: ReadonlyArray<InsertValuesNode>;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
+    readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
+    readonly ignore?: boolean;
 }
 /**
  * @internal
@@ -22,6 +26,5 @@ export interface InsertQueryNode extends OperationNode {
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode | undefined): InsertQueryNode;
-    cloneWithColumnsAndValues(insertQuery: InsertQueryNode, columns: ReadonlyArray<ColumnNode>, values: ReadonlyArray<InsertValuesNode>): InsertQueryNode;
-    cloneWithOnConflict(insertQuery: InsertQueryNode, onConflict: OnConflictNode): InsertQueryNode;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

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

@@ -13,17 +13,10 @@ export const InsertQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
-    cloneWithColumnsAndValues(insertQuery, columns, values) {
+    cloneWith(insertQuery, props) {
         return freeze({
             ...insertQuery,
-            columns,
-            values,
-        });
-    },
-    cloneWithOnConflict(insertQuery, onConflict) {
-        return freeze({
-            ...insertQuery,
-            onConflict,
+            ...props,
         });
     },
 });

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

@@ -20,5 +20,6 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
     cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
 }>;

package/dist/esm/operation-node/join-node.js

@@ -16,6 +16,14 @@ export const JoinNode = freeze({
             on: undefined,
         });
     },
+    createWithOn(joinType, table, on) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on,
+        });
+    },
     cloneWithOn(joinNode, op, on) {
         return freeze({
             ...joinNode,