kysely 0.7.2 → 0.7.6

package/dist/esm/schema/alter-table-builder.js

@@ -13,6 +13,13 @@ import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder, } from './column-definition-builder.js';
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
+import { ForeignKeyConstraintBuilder, } from './foreign-key-constraint-builder.js';
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
+import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
 export class AlterTableBuilder {
     #props;
     constructor(props) {
@@ -59,9 +66,7 @@ export class AlterTableBuilder {
     addColumn(columnName, dataType) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-                ? dataType.toOperationNode()
-                : DataTypeNode.create(dataType))),
+            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))),
         });
     }
     /**
@@ -72,9 +77,29 @@ export class AlterTableBuilder {
     modifyColumn(columnName, dataType) {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-                ? dataType.toOperationNode()
-                : DataTypeNode.create(dataType))),
+            columnBuilder: new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))),
+        });
+    }
+    addUniqueConstraint(constraintName, columns) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                addConstraint: AddConstraintNode.create(UniqueConstraintNode.create(columns, constraintName)),
+            }),
+        });
+    }
+    addCheckConstraint(constraintName, checkExpression) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
+                addConstraint: AddConstraintNode.create(CheckConstraintNode.create(checkExpression, constraintName)),
+            }),
+        });
+    }
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
 }
@@ -180,6 +205,12 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.onDelete(onDelete),
         });
     }
+    onUpdate(onDelete) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.onUpdate(onDelete),
+        });
+    }
     unique() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -245,6 +276,12 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.onDelete(onDelete),
         });
     }
+    onUpdate(onUpdate) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.onUpdate(onUpdate),
+        });
+    }
     unique() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
@@ -281,8 +318,38 @@ export class AlterTableModifyColumnBuilder {
         await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
+export class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
+            addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
 preventAwait(AlterTableBuilder, "don't await AlterTableBuilder instances");
 preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 preventAwait(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");
 preventAwait(AlterTableAddColumnBuilder, "don't await AlterTableAddColumnBuilder instances directly. To execute the query you need to call `execute`");
 preventAwait(AlterTableModifyColumnBuilder, "don't await AlterTableModifyColumnBuilder instances directly. To execute the query you need to call `execute`");
+preventAwait(AlterTableAddForeignKeyConstraintBuilder, "don't await AlterTableAddForeignKeyConstraintBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/column-definition-builder.d.ts

@@ -1,8 +1,9 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OnDelete } from '../operation-node/references-node.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Makes the column automatically incrementing.
@@ -31,7 +32,11 @@ export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Adds an `on delete` constraint for the foreign key column.
      */
-    onDelete(onDelete: OnDelete): R;
+    onDelete(onDelete: OnModifyForeignAction): R;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     */
+    onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
      * Adds a unique constraint for the column.
      */
@@ -71,10 +76,11 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     increments(): ColumnDefinitionBuilder;
     primaryKey(): ColumnDefinitionBuilder;
     references(ref: string): ColumnDefinitionBuilder;
-    onDelete(onDelete: OnDelete): ColumnDefinitionBuilder;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
     unique(): ColumnDefinitionBuilder;
     notNull(): ColumnDefinitionBuilder;
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilder;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/esm/schema/column-definition-builder.js

@@ -1,12 +1,11 @@
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { ReferencesNode } from '../operation-node/references-node.js';
+import { ReferencesNode, } from '../operation-node/references-node.js';
 import { SelectAllNode } from '../operation-node/select-all-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
 import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -37,6 +36,14 @@ export class ColumnDefinitionBuilder {
             references: ReferencesNode.cloneWithOnDelete(this.#node.references, onDelete),
         }));
     }
+    onUpdate(onUpdate) {
+        if (!this.#node.references) {
+            throw new Error('on update constraint can only be added for foreign keys');
+        }
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            references: ReferencesNode.cloneWithOnUpdate(this.#node.references, onUpdate),
+        }));
+    }
     unique() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { isUnique: true }));
     }
@@ -45,9 +52,7 @@ export class ColumnDefinitionBuilder {
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: isOperationNodeSource(value)
-                ? value.toOperationNode()
-                : ValueNode.createImmediate(value),
+            defaultTo: parseDefaultValueExpression(value),
         }));
     }
     check(sql) {
@@ -59,4 +64,4 @@ export class ColumnDefinitionBuilder {
         return this.#node;
     }
 }
-preventAwait(ColumnDefinitionBuilder, "don't await ColumnBuilder instances directly.");
+preventAwait(ColumnDefinitionBuilder, "don't await ColumnDefinitionBuilder instances directly.");

package/dist/esm/schema/create-index-builder.d.ts

@@ -6,7 +6,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateIndexBuilderConstructorArgs);
+    constructor(props: CreateIndexBuilderProps);
     /**
      * Makes the index unique.
      */
@@ -49,8 +49,8 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateIndexBuilderConstructorArgs {
-    queryId: QueryId;
-    createIndexNode: CreateIndexNode;
-    executor: QueryExecutor;
+export interface CreateIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createIndexNode: CreateIndexNode;
 }

package/dist/esm/schema/create-index-builder.js

@@ -4,23 +4,19 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { parseColumnName } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class CreateIndexBuilder {
-    #queryId;
-    #createIndexNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createIndexNode = args.createIndexNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     /**
      * Makes the index unique.
      */
     unique() {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 unique: true,
             }),
         });
@@ -30,9 +26,8 @@ export class CreateIndexBuilder {
      */
     on(table) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 table: parseTable(table),
             }),
         });
@@ -44,9 +39,8 @@ export class CreateIndexBuilder {
      */
     column(column) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: parseColumnName(column),
             }),
         });
@@ -58,9 +52,8 @@ export class CreateIndexBuilder {
      */
     columns(columns) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: ListNode.create(columns.map(parseColumnName)),
             }),
         });
@@ -79,30 +72,28 @@ export class CreateIndexBuilder {
      */
     expression(expression) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 expression: RawNode.createWithSql(expression),
             }),
         });
     }
     using(indexType) {
         return new CreateIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createIndexNode: CreateIndexNode.cloneWith(this.#createIndexNode, {
+            ...this.#props,
+            createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
                 using: RawNode.createWithSql(indexType),
             }),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createIndexNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createIndexNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 preventAwait(CreateIndexBuilder, "don't await CreateIndexBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/create-schema-builder.d.ts

@@ -6,14 +6,14 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class CreateSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateSchemaBuilderConstructorArgs);
+    constructor(props: CreateSchemaBuilderProps);
     ifNotExists(): CreateSchemaBuilder;
     toOperationNode(): CreateSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateSchemaBuilderConstructorArgs {
-    queryId: QueryId;
-    createSchemaNode: CreateSchemaNode;
-    executor: QueryExecutor;
+export interface CreateSchemaBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createSchemaNode: CreateSchemaNode;
 }

package/dist/esm/schema/create-schema-builder.js

@@ -1,29 +1,25 @@
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
 export class CreateSchemaBuilder {
-    #queryId;
-    #createSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createSchemaNode = args.createSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     ifNotExists() {
         return new CreateSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createSchemaNode: CreateSchemaNode.cloneWithModifier(this.#createSchemaNode, 'IfNotExists'),
+            ...this.#props,
+            createSchemaNode: CreateSchemaNode.cloneWithModifier(this.#props.createSchemaNode, 'IfNotExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createSchemaNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createSchemaNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 preventAwait(CreateSchemaBuilder, "don't await CreateSchemaBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/create-table-builder.d.ts

@@ -1,15 +1,15 @@
 import { CreateTableNode } from '../operation-node/create-table-node.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { ColumnDefinitionBuilder } from './column-definition-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryId } from '../util/query-id.js';
+import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
+import { DataTypeExpression } from '../parser/data-type-parser.js';
 export declare class CreateTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: CreateTableBuilderConstructorArgs);
+    constructor(props: CreateTableBuilderProps);
     /**
      * Adds the "if not exists" modifier.
      *
@@ -30,7 +30,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *   .addColumn('data', db.raw('customtype'))
      * ```
      */
-    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder, build?: ColumnBuilderCallback): CreateTableBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder;
     /**
      * Adds a primary key constraint for one or more columns.
      *
@@ -70,15 +70,27 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *   ['id'],
      * )
      * ```
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id1', 'owner_id2'],
+     *   'person',
+     *   ['id1', 'id2'],
+     *   (cb) => cb.onDelete('cascade')
+     * )
+     * ```
      */
-    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): CreateTableBuilder;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface CreateTableBuilderConstructorArgs {
-    queryId: QueryId;
-    createTableNode: CreateTableNode;
-    executor: QueryExecutor;
+export interface CreateTableBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTableNode: CreateTableNode;
 }
-export declare type ColumnBuilderCallback = (tableBuilder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export declare type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export declare type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;

package/dist/esm/schema/create-table-builder.js

@@ -1,17 +1,17 @@
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
-import { DataTypeNode, } from '../operation-node/data-type-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder } from './column-definition-builder.js';
+import { freeze } from '../util/object-utils.js';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 export class CreateTableBuilder {
-    #queryId;
-    #createTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createTableNode = args.createTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
     }
     /**
      * Adds the "if not exists" modifier.
@@ -20,9 +20,8 @@ export class CreateTableBuilder {
      */
     ifNotExists() {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithModifier(this.#createTableNode, 'IfNotExists'),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
         });
     }
     /**
@@ -40,16 +39,13 @@ export class CreateTableBuilder {
      * ```
      */
     addColumn(columnName, dataType, build) {
-        let columnBuilder = new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, isOperationNodeSource(dataType)
-            ? dataType.toOperationNode()
-            : DataTypeNode.create(dataType)));
+        let columnBuilder = new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType)));
         if (build) {
             columnBuilder = build(columnBuilder);
         }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithColumn(this.#createTableNode, columnBuilder.toOperationNode()),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithColumn(this.#props.createTableNode, columnBuilder.toOperationNode()),
         });
     }
     /**
@@ -62,9 +58,8 @@ export class CreateTableBuilder {
      */
     addPrimaryKeyConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithPrimaryKeyConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithPrimaryKeyConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -77,9 +72,8 @@ export class CreateTableBuilder {
      */
     addUniqueConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithUniqueConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithUniqueConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -92,9 +86,8 @@ export class CreateTableBuilder {
      */
     addCheckConstraint(constraintName, checkExpression) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithCheckConstraint(this.#createTableNode, constraintName, checkExpression),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithCheckConstraint(this.#props.createTableNode, constraintName, checkExpression),
         });
     }
     /**
@@ -109,22 +102,36 @@ export class CreateTableBuilder {
      *   ['id'],
      * )
      * ```
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id1', 'owner_id2'],
+     *   'person',
+     *   ['id1', 'id2'],
+     *   (cb) => cb.onDelete('cascade')
+     * )
+     * ```
      */
-    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build) {
+        let builder = new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName));
+        if (build) {
+            builder = build(builder);
+        }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: CreateTableNode.cloneWithForeignKeyConstraint(this.#createTableNode, constraintName, columns, targetTable, targetColumns),
+            ...this.#props,
+            createTableNode: CreateTableNode.cloneWithForeignKeyConstraint(this.#props.createTableNode, builder.toOperationNode()),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#createTableNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.createTableNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 preventAwait(CreateTableBuilder, "don't await CreateTableBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-index-builder.d.ts

@@ -6,7 +6,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class DropIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropIndexBuilderConstructorArgs);
+    constructor(props: DropIndexBuilderProps);
     /**
      * Specifies the table the index was created for. This is not needed
      * in all dialects.
@@ -17,8 +17,8 @@ export declare class DropIndexBuilder implements OperationNodeSource, Compilable
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropIndexBuilderConstructorArgs {
-    queryId: QueryId;
-    dropIndexNode: DropIndexNode;
-    executor: QueryExecutor;
+export interface DropIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropIndexNode: DropIndexNode;
 }