kysely 0.7.1 → 0.7.5

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

@@ -3,30 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateSchemaBuilder = void 0;
 const create_schema_node_js_1 = require("../operation-node/create-schema-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class CreateSchemaBuilder {
-    #queryId;
-    #createSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createSchemaNode = args.createSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     ifNotExists() {
         return new CreateSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createSchemaNode: create_schema_node_js_1.CreateSchemaNode.cloneWithModifier(this.#createSchemaNode, 'IfNotExists'),
+            ...this.#props,
+            createSchemaNode: create_schema_node_js_1.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);
     }
 }
 exports.CreateSchemaBuilder = CreateSchemaBuilder;

package/dist/cjs/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/cjs/schema/create-table-builder.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTableBuilder = void 0;
 const column_definition_node_js_1 = require("../operation-node/column-definition-node.js");
 const create_table_node_js_1 = require("../operation-node/create-table-node.js");
-const data_type_node_js_1 = require("../operation-node/data-type-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_builder_js_1 = require("./column-definition-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+const table_node_js_1 = require("../operation-node/table-node.js");
+const foreign_key_constraint_builder_js_1 = require("./foreign-key-constraint-builder.js");
+const data_type_parser_js_1 = require("../parser/data-type-parser.js");
 class CreateTableBuilder {
-    #queryId;
-    #createTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#createTableNode = args.createTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     /**
      * Adds the "if not exists" modifier.
@@ -23,9 +23,8 @@ class CreateTableBuilder {
      */
     ifNotExists() {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithModifier(this.#createTableNode, 'IfNotExists'),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithModifier(this.#props.createTableNode, 'IfNotExists'),
         });
     }
     /**
@@ -43,16 +42,13 @@ class CreateTableBuilder {
      * ```
      */
     addColumn(columnName, dataType, build) {
-        let columnBuilder = new column_definition_builder_js_1.ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.create(columnName, (0, operation_node_source_js_1.isOperationNodeSource)(dataType)
-            ? dataType.toOperationNode()
-            : data_type_node_js_1.DataTypeNode.create(dataType)));
+        let columnBuilder = new column_definition_builder_js_1.ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.create(columnName, (0, data_type_parser_js_1.parseDataTypeExpression)(dataType)));
         if (build) {
             columnBuilder = build(columnBuilder);
         }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithColumn(this.#createTableNode, columnBuilder.toOperationNode()),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithColumn(this.#props.createTableNode, columnBuilder.toOperationNode()),
         });
     }
     /**
@@ -65,9 +61,8 @@ class CreateTableBuilder {
      */
     addPrimaryKeyConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithPrimaryKeyConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithPrimaryKeyConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -80,9 +75,8 @@ class CreateTableBuilder {
      */
     addUniqueConstraint(constraintName, columns) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithUniqueConstraint(this.#createTableNode, constraintName, columns),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithUniqueConstraint(this.#props.createTableNode, constraintName, columns),
         });
     }
     /**
@@ -95,9 +89,8 @@ class CreateTableBuilder {
      */
     addCheckConstraint(constraintName, checkExpression) {
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithCheckConstraint(this.#createTableNode, constraintName, checkExpression),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithCheckConstraint(this.#props.createTableNode, constraintName, checkExpression),
         });
     }
     /**
@@ -112,22 +105,36 @@ 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 foreign_key_constraint_builder_js_1.ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.create(columns.map(column_node_js_1.ColumnNode.create), table_node_js_1.TableNode.create(targetTable), targetColumns.map(column_node_js_1.ColumnNode.create), constraintName));
+        if (build) {
+            builder = build(builder);
+        }
         return new CreateTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithForeignKeyConstraint(this.#createTableNode, constraintName, columns, targetTable, targetColumns),
+            ...this.#props,
+            createTableNode: create_table_node_js_1.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);
     }
 }
 exports.CreateTableBuilder = CreateTableBuilder;

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

package/dist/cjs/schema/drop-index-builder.js

@@ -4,14 +4,11 @@ exports.DropIndexBuilder = void 0;
 const drop_index_node_js_1 = require("../operation-node/drop-index-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropIndexBuilder {
-    #queryId;
-    #dropIndexNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropIndexNode = args.dropIndexNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     /**
      * Specifies the table the index was created for. This is not needed
@@ -19,30 +16,28 @@ class DropIndexBuilder {
      */
     on(table) {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 table: (0, table_parser_js_1.parseTable)(table),
             }),
         });
     }
     ifExists() {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 modifier: 'IfExists',
             }),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropIndexNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropIndexNode, 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);
     }
 }
 exports.DropIndexBuilder = DropIndexBuilder;

package/dist/cjs/schema/drop-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 DropSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropSchemaBuilderConstructorArgs);
+    constructor(props: DropSchemaBuilderProps);
     ifExists(): DropSchemaBuilder;
     toOperationNode(): DropSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropSchemaBuilderConstructorArgs {
-    queryId: QueryId;
-    dropSchemaNode: DropSchemaNode;
-    executor: QueryExecutor;
+export interface DropSchemaBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropSchemaNode: DropSchemaNode;
 }

package/dist/cjs/schema/drop-schema-builder.js

@@ -3,30 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DropSchemaBuilder = void 0;
 const drop_schema_node_js_1 = require("../operation-node/drop-schema-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropSchemaBuilder {
-    #queryId;
-    #dropSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropSchemaNode = args.dropSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     ifExists() {
         return new DropSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropSchemaNode: drop_schema_node_js_1.DropSchemaNode.cloneWithModifier(this.#dropSchemaNode, 'IfExists'),
+            ...this.#props,
+            dropSchemaNode: drop_schema_node_js_1.DropSchemaNode.cloneWithModifier(this.#props.dropSchemaNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropSchemaNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropSchemaNode, 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);
     }
 }
 exports.DropSchemaBuilder = DropSchemaBuilder;

package/dist/cjs/schema/drop-table-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 DropTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropTableBuilderConstructorArgs);
+    constructor(props: DropTableBuilderProps);
     ifExists(): DropTableBuilder;
     toOperationNode(): DropTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropTableBuilderConstructorArgs {
-    queryId: QueryId;
-    dropTableNode: DropTableNode;
-    executor: QueryExecutor;
+export interface DropTableBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTableNode: DropTableNode;
 }

package/dist/cjs/schema/drop-table-builder.js

@@ -3,30 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DropTableBuilder = void 0;
 const drop_table_node_js_1 = require("../operation-node/drop-table-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropTableBuilder {
-    #queryId;
-    #dropTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropTableNode = args.dropTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     ifExists() {
         return new DropTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropTableNode: drop_table_node_js_1.DropTableNode.cloneWithModifier(this.#dropTableNode, 'IfExists'),
+            ...this.#props,
+            dropTableNode: drop_table_node_js_1.DropTableNode.cloneWithModifier(this.#props.dropTableNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropTableNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropTableNode, 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);
     }
 }
 exports.DropTableBuilder = DropTableBuilder;

package/dist/cjs/schema/foreign-key-constraint-builder.d.ts

@@ -0,0 +1,14 @@
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
+export interface ForeignKeyConstraintBuilderInterface<R> {
+    onDelete(onDelete: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): R;
+}
+export declare class ForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<ForeignKeyConstraintBuilder>, OperationNodeSource {
+    #private;
+    constructor(node: ForeignKeyConstraintNode);
+    onDelete(onDelete: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    toOperationNode(): ForeignKeyConstraintNode;
+}

package/dist/cjs/schema/foreign-key-constraint-builder.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeyConstraintBuilder = void 0;
+const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class ForeignKeyConstraintBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    onDelete(onDelete) {
+        return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onDelete,
+        }));
+    }
+    onUpdate(onUpdate) {
+        return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onUpdate,
+        }));
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.ForeignKeyConstraintBuilder = ForeignKeyConstraintBuilder;
+(0, prevent_await_js_1.preventAwait)(ForeignKeyConstraintBuilder, "don't await ForeignKeyConstraintBuilder instances directly.");

package/dist/cjs/transformers/with-schema-transformer.d.ts

@@ -22,9 +22,4 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
-    private transformRoot;
-    private collectTables;
-    private collectTablesFromTableExpressionNodes;
-    private collectTablesFromJoins;
-    private collectTablesFromTableExpressionNode;
 }

package/dist/cjs/transformers/with-schema-transformer.js

@@ -12,31 +12,31 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         this.#schema = schema;
     }
     transformSelectQuery(node) {
-        return this.transformRoot(node, (node) => super.transformSelectQuery(node));
+        return this.#transformRoot(node, (node) => super.transformSelectQuery(node));
     }
     transformInsertQuery(node) {
-        return this.transformRoot(node, (node) => super.transformInsertQuery(node));
+        return this.#transformRoot(node, (node) => super.transformInsertQuery(node));
     }
     transformUpdateQuery(node) {
-        return this.transformRoot(node, (node) => super.transformUpdateQuery(node));
+        return this.#transformRoot(node, (node) => super.transformUpdateQuery(node));
     }
     transformDeleteQuery(node) {
-        return this.transformRoot(node, (node) => super.transformDeleteQuery(node));
+        return this.#transformRoot(node, (node) => super.transformDeleteQuery(node));
     }
     transformCreateTable(node) {
-        return this.transformRoot(node, (node) => super.transformCreateTable(node));
+        return this.#transformRoot(node, (node) => super.transformCreateTable(node));
     }
     transformDropTable(node) {
-        return this.transformRoot(node, (node) => super.transformDropTable(node));
+        return this.#transformRoot(node, (node) => super.transformDropTable(node));
     }
     transformCreateIndex(node) {
-        return this.transformRoot(node, (node) => super.transformCreateIndex(node));
+        return this.#transformRoot(node, (node) => super.transformCreateIndex(node));
     }
     transformDropIndex(node) {
-        return this.transformRoot(node, (node) => super.transformDropIndex(node));
+        return this.#transformRoot(node, (node) => super.transformDropIndex(node));
     }
     transformAlterTable(node) {
-        return this.transformRoot(node, (node) => super.transformAlterTable(node));
+        return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }
     transformTable(node) {
         const transformed = super.transformTable(node);
@@ -51,8 +51,8 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
             },
         };
     }
-    transformRoot(node, transform) {
-        const tables = this.collectTables(node);
+    #transformRoot(node, transform) {
+        const tables = this.#collectTables(node);
         for (const table of tables) {
             this.#tables.add(table);
         }
@@ -62,33 +62,33 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         }
         return transformed;
     }
-    collectTables(node) {
+    #collectTables(node) {
         const tables = new Set();
         if ('from' in node && node.from) {
-            this.collectTablesFromTableExpressionNodes(node.from.froms, tables);
+            this.#collectTablesFromTableExpressionNodes(node.from.froms, tables);
         }
         if ('into' in node && node.into) {
-            this.collectTablesFromTableExpressionNode(node.into, tables);
+            this.#collectTablesFromTableExpressionNode(node.into, tables);
         }
         if ('table' in node && node.table) {
-            this.collectTablesFromTableExpressionNode(node.table, tables);
+            this.#collectTablesFromTableExpressionNode(node.table, tables);
         }
         if ('joins' in node && node.joins) {
-            this.collectTablesFromJoins(node.joins, tables);
+            this.#collectTablesFromJoins(node.joins, tables);
         }
         return tables;
     }
-    collectTablesFromTableExpressionNodes(nodes, tables) {
+    #collectTablesFromTableExpressionNodes(nodes, tables) {
         for (const node of nodes) {
-            this.collectTablesFromTableExpressionNode(node, tables);
+            this.#collectTablesFromTableExpressionNode(node, tables);
         }
     }
-    collectTablesFromJoins(nodes, tables) {
+    #collectTablesFromJoins(nodes, tables) {
         for (const node of nodes) {
-            this.collectTablesFromTableExpressionNode(node.table, tables);
+            this.#collectTablesFromTableExpressionNode(node.table, tables);
         }
     }
-    collectTablesFromTableExpressionNode(node, tables) {
+    #collectTablesFromTableExpressionNode(node, tables) {
         const table = table_node_js_1.TableNode.is(node)
             ? node
             : alias_node_js_1.AliasNode.is(node) && table_node_js_1.TableNode.is(node.node)

package/dist/esm/dialect/dialect-adapter.d.ts

@@ -1,13 +1,5 @@
 import { Kysely } from '../kysely.js';
-/**
- * The `DialectAdapter` encapsulates all differences between dialects outside
- * the `Driver` and `QueryCompiler`.
- *
- * For example, some databases support transactional DDL and therefore we want
- * to run migrations inside a transaction, while other databases don't support
- * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
- */
-export interface DialectAdapter {
+export interface DialectSupports {
     /**
      * Whether or not this dialect supports transactional DDL.
      *
@@ -19,6 +11,16 @@ export interface DialectAdapter {
      * upates and deletes.
      */
     readonly supportsReturning: boolean;
+}
+/**
+ * The `DialectAdapter` encapsulates all differences between dialects outside
+ * the `Driver` and `QueryCompiler`.
+ *
+ * For example, some databases support transactional DDL and therefore we want
+ * to run migrations inside a transaction, while other databases don't support
+ * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
+ */
+export interface DialectAdapter extends DialectSupports {
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration processes to run in parallel.

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

@@ -3,8 +3,8 @@ import { Kysely } from '../../kysely.js';
 import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
-import { DatabaseConnection } from '../../index.js';
 import { DialectAdapter } from '../dialect-adapter.js';
+import { DatabaseConnection } from '../../driver/database-connection.js';
 export declare class MysqlDialect implements Dialect {
     #private;
     constructor(config: MysqlDialectConfig);

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

@@ -47,6 +47,7 @@ export class MysqlDriver {
     }
     async beginTransaction(connection, settings) {
         if (settings.isolationLevel) {
+            // On mysql this sets the isolation level of the next transaction.
             await connection.executeQuery({
                 sql: `set transaction isolation level ${settings.isolationLevel}`,
                 bindings: [],