kysely 0.2.4 → 0.2.5

package/lib/schema/alter-table-builder.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableAddColumnBuilder = exports.AlterTableExecutor = exports.AlterColumnBuilder = exports.AlterTableBuilder = void 0;
+const __1 = require("..");
+const add_column_node_1 = require("../operation-node/add-column-node");
+const alter_column_node_1 = require("../operation-node/alter-column-node");
+const alter_table_node_1 = require("../operation-node/alter-table-node");
+const column_definition_node_1 = require("../operation-node/column-definition-node");
+const data_type_node_1 = require("../operation-node/data-type-node");
+const drop_column_node_1 = require("../operation-node/drop-column-node");
+const identifier_node_1 = require("../operation-node/identifier-node");
+const operation_node_source_1 = require("../operation-node/operation-node-source");
+const rename_column_node_1 = require("../operation-node/rename-column-node");
+const table_node_1 = require("../operation-node/table-node");
+const value_node_1 = require("../operation-node/value-node");
+const prevent_await_1 = require("../util/prevent-await");
+class AlterTableBuilder {
+    #alterTableNode;
+    #executor;
+    constructor(args) {
+        this.#alterTableNode = args.alterTableNode;
+        this.#executor = args.executor;
+    }
+    renameTo(newTableName) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                renameTo: table_node_1.tableNode.create(newTableName),
+            }),
+        });
+    }
+    setSchema(newSchema) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                setSchema: identifier_node_1.identifierNode.create(newSchema),
+            }),
+        });
+    }
+    alterColumn(column) {
+        return new AlterColumnBuilder({
+            alterTableNode: this.#alterTableNode,
+            alterColumnNode: alter_column_node_1.alterColumnNode.create(column),
+            executor: this.#executor,
+        });
+    }
+    dropColumn(column) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                dropColumn: drop_column_node_1.dropColumnNode.create(column),
+            }),
+        });
+    }
+    renameColumn(column, newColumn) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                renameColumn: rename_column_node_1.renameColumnNode.create(column, newColumn),
+            }),
+        });
+    }
+    addColumn(columnName, dataType) {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: new __1.ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.create(columnName, operation_node_source_1.isOperationNodeSource(dataType)
+                ? dataType.toOperationNode()
+                : data_type_node_1.dataTypeNode.create(dataType))),
+        });
+    }
+}
+exports.AlterTableBuilder = AlterTableBuilder;
+class AlterColumnBuilder {
+    #alterTableNode;
+    #alterColumnNode;
+    #executor;
+    constructor(args) {
+        this.#alterTableNode = args.alterTableNode;
+        this.#alterColumnNode = args.alterColumnNode;
+        this.#executor = args.executor;
+    }
+    setDataType(dataType) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                alterColumn: alter_column_node_1.alterColumnNode.cloneWith(this.#alterColumnNode, {
+                    dataType: data_type_node_1.dataTypeNode.create(dataType),
+                }),
+            }),
+        });
+    }
+    setDefault(value) {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                alterColumn: alter_column_node_1.alterColumnNode.cloneWith(this.#alterColumnNode, {
+                    setDefault: operation_node_source_1.isOperationNodeSource(value)
+                        ? value.toOperationNode()
+                        : value_node_1.valueNode.createImmediate(value),
+                }),
+            }),
+        });
+    }
+    dropDefault() {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                alterColumn: alter_column_node_1.alterColumnNode.cloneWith(this.#alterColumnNode, {
+                    dropDefault: true,
+                }),
+            }),
+        });
+    }
+    setNotNull() {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                alterColumn: alter_column_node_1.alterColumnNode.cloneWith(this.#alterColumnNode, {
+                    setNotNull: true,
+                }),
+            }),
+        });
+    }
+    dropNotNull() {
+        return new AlterTableExecutor({
+            executor: this.#executor,
+            alterTableNode: alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+                alterColumn: alter_column_node_1.alterColumnNode.cloneWith(this.#alterColumnNode, {
+                    dropNotNull: true,
+                }),
+            }),
+        });
+    }
+}
+exports.AlterColumnBuilder = AlterColumnBuilder;
+class AlterTableExecutor {
+    #alterTableNode;
+    #executor;
+    constructor(args) {
+        this.#alterTableNode = args.alterTableNode;
+        this.#executor = args.executor;
+    }
+    toOperationNode() {
+        return this.#executor.transformNode(this.#alterTableNode);
+    }
+    compile() {
+        return this.#executor.compileQuery(this.toOperationNode());
+    }
+    async execute() {
+        await this.#executor.executeQuery(this.compile());
+    }
+}
+exports.AlterTableExecutor = AlterTableExecutor;
+class AlterTableAddColumnBuilder {
+    #alterTableNode;
+    #executor;
+    #columnBuilder;
+    constructor(args) {
+        this.#alterTableNode = args.alterTableNode;
+        this.#executor = args.executor;
+        this.#columnBuilder = args.columnBuilder;
+    }
+    increments() {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.increments(),
+        });
+    }
+    primaryKey() {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.primaryKey(),
+        });
+    }
+    references(ref) {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.references(ref),
+        });
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.onDelete(onDelete),
+        });
+    }
+    unique() {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.unique(),
+        });
+    }
+    notNull() {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.notNull(),
+        });
+    }
+    defaultTo(value) {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.defaultTo(value),
+        });
+    }
+    check(sql) {
+        return new AlterTableAddColumnBuilder({
+            executor: this.#executor,
+            alterTableNode: this.#alterTableNode,
+            columnBuilder: this.#columnBuilder.check(sql),
+        });
+    }
+    toOperationNode() {
+        return this.#executor.transformNode(alter_table_node_1.alterTableNode.cloneWith(this.#alterTableNode, {
+            addColumn: add_column_node_1.addColumnNode.create(this.#columnBuilder.toOperationNode()),
+        }));
+    }
+    compile() {
+        return this.#executor.compileQuery(this.toOperationNode());
+    }
+    async execute() {
+        await this.#executor.executeQuery(this.compile());
+    }
+}
+exports.AlterTableAddColumnBuilder = AlterTableAddColumnBuilder;
+prevent_await_1.preventAwait(AlterTableBuilder, "don't await AlterTableBuilder instances");
+prevent_await_1.preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
+prevent_await_1.preventAwait(AlterTableExecutor, "don't await AlterTableExecutor instances directly. To execute the query you need to call `execute`");
+prevent_await_1.preventAwait(AlterTableAddColumnBuilder, "don't await AlterTableAddColumnBuilder instances directly. To execute the query you need to call `execute`");

package/lib/schema/{add-column-builder.d.ts → column-definition-builder.d.ts}

@@ -1,11 +1,9 @@
-import { AddColumnNode } from '../operation-node/add-column-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { OnDelete } from '../operation-node/references-node';
 import { RawBuilder } from '../raw-builder/raw-builder';
 import { PrimitiveValue } from '../util/object-utils';
-export declare class AddColumnBuilder implements OperationNodeSource {
-    #private;
-    constructor(node: AddColumnNode);
+import { ColumnDefinitionNode } from '../operation-node/column-definition-node';
+export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Makes the column automatically incrementing.
      *
@@ -13,14 +11,14 @@ export declare class AddColumnBuilder implements OperationNodeSource {
      * on postgres this sets the column type to `serial` no matter what you
      * have specified before.
      */
-    increments(): AddColumnBuilder;
+    increments(): R;
     /**
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
      * {@link TableBuilder.addPrimaryKeyConstraint} method.
      */
-    primaryKey(): AddColumnBuilder;
+    primaryKey(): R;
     /**
      * Adds a foreign key constraint for the column.
      *
@@ -29,19 +27,19 @@ export declare class AddColumnBuilder implements OperationNodeSource {
      * col.references('person.id')
      * ```
      */
-    references(ref: string): AddColumnBuilder;
+    references(ref: string): R;
     /**
      * Adds an `on delete` constraint for the foreign key column.
      */
-    onDelete(onDelete: OnDelete): AddColumnBuilder;
+    onDelete(onDelete: OnDelete): R;
     /**
      * Adds a unique constraint for the column.
      */
-    unique(): AddColumnBuilder;
+    unique(): R;
     /**
      * Adds a `not null` constraint for the column.
      */
-    notNullable(): AddColumnBuilder;
+    notNull(): R;
     /**
      * Adds a default value constraint for the column.
      *
@@ -53,7 +51,7 @@ export declare class AddColumnBuilder implements OperationNodeSource {
      *   .execute()
      * ```
      */
-    defaultTo(value: PrimitiveValue | RawBuilder<any>): AddColumnBuilder;
+    defaultTo(value: PrimitiveValue | RawBuilder<any>): R;
     /**
      * Adds a check constraint for the column.
      *
@@ -65,6 +63,18 @@ export declare class AddColumnBuilder implements OperationNodeSource {
      *   .execute()
      * ```
      */
-    check(sql: string): AddColumnBuilder;
-    toOperationNode(): AddColumnNode;
+    check(sql: string): R;
+}
+export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
+    #private;
+    constructor(node: ColumnDefinitionNode);
+    increments(): ColumnDefinitionBuilder;
+    primaryKey(): ColumnDefinitionBuilder;
+    references(ref: string): ColumnDefinitionBuilder;
+    onDelete(onDelete: OnDelete): ColumnDefinitionBuilder;
+    unique(): ColumnDefinitionBuilder;
+    notNull(): ColumnDefinitionBuilder;
+    defaultTo(value: PrimitiveValue | RawBuilder<any>): ColumnDefinitionBuilder;
+    check(sql: string): ColumnDefinitionBuilder;
+    toOperationNode(): ColumnDefinitionNode;
 }

package/lib/schema/column-definition-builder.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnDefinitionBuilder = void 0;
+const check_constraint_node_1 = require("../operation-node/check-constraint-node");
+const operation_node_source_1 = require("../operation-node/operation-node-source");
+const reference_node_1 = require("../operation-node/reference-node");
+const references_node_1 = require("../operation-node/references-node");
+const select_all_node_1 = require("../operation-node/select-all-node");
+const value_node_1 = require("../operation-node/value-node");
+const reference_parser_1 = require("../parser/reference-parser");
+const prevent_await_1 = require("../util/prevent-await");
+const column_definition_node_1 = require("../operation-node/column-definition-node");
+class ColumnDefinitionBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    increments() {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, { isAutoIncrementing: true }));
+    }
+    primaryKey() {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, { isPrimaryKey: true }));
+    }
+    references(ref) {
+        const references = reference_parser_1.parseStringReference(ref);
+        if (!reference_node_1.referenceNode.is(references) || select_all_node_1.selectAllNode.is(references.column)) {
+            throw new Error(`invalid call references('${ref}'). The reference must have format table.column or schema.table.column`);
+        }
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, {
+            references: references_node_1.referencesNode.create(references.table, [
+                references.column,
+            ]),
+        }));
+    }
+    onDelete(onDelete) {
+        if (!this.#node.references) {
+            throw new Error('on delete constraint can only be added for foreign keys');
+        }
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, {
+            references: references_node_1.referencesNode.cloneWithOnDelete(this.#node.references, onDelete),
+        }));
+    }
+    unique() {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, { isUnique: true }));
+    }
+    notNull() {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, { isNullable: false }));
+    }
+    defaultTo(value) {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, {
+            defaultTo: operation_node_source_1.isOperationNodeSource(value)
+                ? value.toOperationNode()
+                : value_node_1.valueNode.createImmediate(value),
+        }));
+    }
+    check(sql) {
+        return new ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.cloneWith(this.#node, {
+            check: check_constraint_node_1.checkConstraintNode.create(sql),
+        }));
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.ColumnDefinitionBuilder = ColumnDefinitionBuilder;
+prevent_await_1.preventAwait(ColumnDefinitionBuilder, "don't await ColumnBuilder instances directly.");

package/lib/schema/create-index-builder.d.ts

@@ -2,10 +2,10 @@ import { CreateIndexNode, IndexType } from '../operation-node/create-index-node'
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ createIndexNode, executor, }: CreateIndexBuilderConstructorArgs);
+    constructor(args: CreateIndexBuilderConstructorArgs);
     /**
      * Makes the index unique.
      */

package/lib/schema/create-index-builder.js

@@ -10,9 +10,9 @@ const prevent_await_1 = require("../util/prevent-await");
 class CreateIndexBuilder {
     #createIndexNode;
     #executor;
-    constructor({ createIndexNode, executor, }) {
-        this.#createIndexNode = createIndexNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#createIndexNode = args.createIndexNode;
+        this.#executor = args.executor;
     }
     /**
      * Makes the index unique.

package/lib/schema/create-schema-builder.d.ts

@@ -2,10 +2,10 @@ import { CreateSchemaNode } from '../operation-node/create-schema-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class CreateSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ createSchemaNode, executor, }: CreateSchemaBuilderConstructorArgs);
+    constructor(args: CreateSchemaBuilderConstructorArgs);
     ifNotExists(): CreateSchemaBuilder;
     toOperationNode(): CreateSchemaNode;
     compile(): CompiledQuery;

package/lib/schema/create-schema-builder.js

@@ -6,9 +6,9 @@ const prevent_await_1 = require("../util/prevent-await");
 class CreateSchemaBuilder {
     #createSchemaNode;
     #executor;
-    constructor({ createSchemaNode, executor, }) {
-        this.#createSchemaNode = createSchemaNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#createSchemaNode = args.createSchemaNode;
+        this.#executor = args.executor;
     }
     ifNotExists() {
         return new CreateSchemaBuilder({

package/lib/schema/create-table-builder.d.ts

@@ -4,11 +4,11 @@ import { ColumnDataType } from '../operation-node/data-type-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
-import { AddColumnBuilder } from './add-column-builder';
+import { QueryExecutor } from '../query-executor/query-executor';
+import { ColumnDefinitionBuilder } from './column-definition-builder';
 export declare class CreateTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ createTableNode, executor, }: CreateTableBuilderConstructorArgs);
+    constructor(args: CreateTableBuilderConstructorArgs);
     /**
      * Adds the "if not exists" modifier.
      *
@@ -23,7 +23,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      * await db.schema
      *   .createTable('person')
      *   .addColumn('int', 'id', (col) => col.increments().primary()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNullable())
+     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
      *   .addColumn('varchar', 'last_name')
      *   .addColumn('numeric(8, 2)', 'bank_balance')
      *   .addColumn('data', db.raw('customtype'))
@@ -53,10 +53,24 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *
      * @example
      * ```ts
-     * addCheckConstraint('number_of_legs < 5')
+     * addCheckConstraint('check_legs', 'number_of_legs < 5')
      * ```
      */
     addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder;
+    /**
+     * Adds a foreign key constraint.
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id'],
+     *   'person',
+     *   ['id'],
+     * )
+     * ```
+     */
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): CreateTableBuilder;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -65,4 +79,4 @@ export interface CreateTableBuilderConstructorArgs {
     createTableNode: CreateTableNode;
     executor: QueryExecutor;
 }
-export declare type ColumnBuilderCallback = (tableBuilder: AddColumnBuilder) => AddColumnBuilder;
+export declare type ColumnBuilderCallback = (tableBuilder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;

package/lib/schema/create-table-builder.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTableBuilder = void 0;
-const add_column_node_1 = require("../operation-node/add-column-node");
+const column_definition_node_1 = require("../operation-node/column-definition-node");
 const create_table_node_1 = require("../operation-node/create-table-node");
 const data_type_node_1 = require("../operation-node/data-type-node");
 const operation_node_source_1 = require("../operation-node/operation-node-source");
 const prevent_await_1 = require("../util/prevent-await");
-const add_column_builder_1 = require("./add-column-builder");
+const column_definition_builder_1 = require("./column-definition-builder");
 class CreateTableBuilder {
     #createTableNode;
     #executor;
-    constructor({ createTableNode, executor, }) {
-        this.#createTableNode = createTableNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#createTableNode = args.createTableNode;
+        this.#executor = args.executor;
     }
     /**
      * Adds the "if not exists" modifier.
@@ -33,14 +33,14 @@ class CreateTableBuilder {
      * await db.schema
      *   .createTable('person')
      *   .addColumn('int', 'id', (col) => col.increments().primary()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNullable())
+     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
      *   .addColumn('varchar', 'last_name')
      *   .addColumn('numeric(8, 2)', 'bank_balance')
      *   .addColumn('data', db.raw('customtype'))
      * ```
      */
     addColumn(columnName, dataType, build) {
-        let columnBuilder = new add_column_builder_1.AddColumnBuilder(add_column_node_1.addColumnNode.create(columnName, operation_node_source_1.isOperationNodeSource(dataType)
+        let columnBuilder = new column_definition_builder_1.ColumnDefinitionBuilder(column_definition_node_1.columnDefinitionNode.create(columnName, operation_node_source_1.isOperationNodeSource(dataType)
             ? dataType.toOperationNode()
             : data_type_node_1.dataTypeNode.create(dataType)));
         if (build) {
@@ -84,7 +84,7 @@ class CreateTableBuilder {
      *
      * @example
      * ```ts
-     * addCheckConstraint('number_of_legs < 5')
+     * addCheckConstraint('check_legs', 'number_of_legs < 5')
      * ```
      */
     addCheckConstraint(constraintName, checkExpression) {
@@ -93,6 +93,25 @@ class CreateTableBuilder {
             createTableNode: create_table_node_1.createTableNode.cloneWithCheckConstraint(this.#createTableNode, constraintName, checkExpression),
         });
     }
+    /**
+     * Adds a foreign key constraint.
+     *
+     * @example
+     * ```ts
+     * addForeignKeyConstraint(
+     *   'owner_id_foreign',
+     *   ['owner_id'],
+     *   'person',
+     *   ['id'],
+     * )
+     * ```
+     */
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
+        return new CreateTableBuilder({
+            executor: this.#executor,
+            createTableNode: create_table_node_1.createTableNode.cloneWithForeignKeyConstraint(this.#createTableNode, constraintName, columns, targetTable, targetColumns),
+        });
+    }
     toOperationNode() {
         return this.#executor.transformNode(this.#createTableNode);
     }

package/lib/schema/drop-index-builder.d.ts

@@ -2,10 +2,10 @@ import { DropIndexNode } from '../operation-node/drop-index-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class DropIndexBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ dropIndexNode, executor }: DropIndexBuilderConstructorArgs);
+    constructor(args: DropIndexBuilderConstructorArgs);
     ifExists(): DropIndexBuilder;
     toOperationNode(): DropIndexNode;
     compile(): CompiledQuery;

package/lib/schema/drop-index-builder.js

@@ -6,9 +6,9 @@ const prevent_await_1 = require("../util/prevent-await");
 class DropIndexBuilder {
     #dropIndexNode;
     #executor;
-    constructor({ dropIndexNode, executor }) {
-        this.#dropIndexNode = dropIndexNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#dropIndexNode = args.dropIndexNode;
+        this.#executor = args.executor;
     }
     ifExists() {
         return new DropIndexBuilder({

package/lib/schema/drop-schema-builder.d.ts

@@ -2,10 +2,10 @@ import { DropSchemaNode } from '../operation-node/drop-schema-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class DropSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ dropSchemaNode, executor }: DropSchemaBuilderConstructorArgs);
+    constructor(args: DropSchemaBuilderConstructorArgs);
     ifExists(): DropSchemaBuilder;
     toOperationNode(): DropSchemaNode;
     compile(): CompiledQuery;

package/lib/schema/drop-schema-builder.js

@@ -6,9 +6,9 @@ const prevent_await_1 = require("../util/prevent-await");
 class DropSchemaBuilder {
     #dropSchemaNode;
     #executor;
-    constructor({ dropSchemaNode, executor }) {
-        this.#dropSchemaNode = dropSchemaNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#dropSchemaNode = args.dropSchemaNode;
+        this.#executor = args.executor;
     }
     ifExists() {
         return new DropSchemaBuilder({

package/lib/schema/drop-table-builder.d.ts

@@ -2,10 +2,10 @@ import { DropTableNode } from '../operation-node/drop-table-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { CompiledQuery } from '../query-compiler/compiled-query';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class DropTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor({ dropTableNode, executor }: DropTableBuilderConstructorArgs);
+    constructor(args: DropTableBuilderConstructorArgs);
     ifExists(): DropTableBuilder;
     toOperationNode(): DropTableNode;
     compile(): CompiledQuery;

package/lib/schema/drop-table-builder.js

@@ -6,9 +6,9 @@ const prevent_await_1 = require("../util/prevent-await");
 class DropTableBuilder {
     #dropTableNode;
     #executor;
-    constructor({ dropTableNode, executor }) {
-        this.#dropTableNode = dropTableNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#dropTableNode = args.dropTableNode;
+        this.#executor = args.executor;
     }
     ifExists() {
         return new DropTableBuilder({