kysely 0.8.1 → 0.9.3

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

@@ -23,6 +23,9 @@ const unique_constraint_node_js_1 = require("../operation-node/unique-constraint
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.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");
+/**
+ * This builder can be used to create a `alter table` query.
+ */
 class AlterTableBuilder {
     #props;
     constructor(props) {

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

@@ -6,11 +6,11 @@ import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export interface ColumnDefinitionBuilderInterface<R> {
     /**
-     * Makes the column automatically incrementing.
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
      *
-     * On some dialects this may change the column type as well. For example
-     * on postgres this sets the column type to `serial` no matter what you
-     * have specified before.
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
      */
     increments(): R;
     /**
@@ -23,6 +23,10 @@ export interface ColumnDefinitionBuilderInterface<R> {
     /**
      * Adds a foreign key constraint for the column.
      *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
      * @example
      * ```ts
      * col.references('person.id')
@@ -31,6 +35,11 @@ export interface ColumnDefinitionBuilderInterface<R> {
     references(ref: string): R;
     /**
      * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
@@ -64,7 +73,7 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', (col) => col.check('number_of_legs < 5', 'integer'))
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
      *   .execute()
      * ```
      */

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

@@ -12,7 +12,7 @@ class CreateSchemaBuilder {
     ifNotExists() {
         return new CreateSchemaBuilder({
             ...this.#props,
-            createSchemaNode: create_schema_node_js_1.CreateSchemaNode.cloneWithModifier(this.#props.createSchemaNode, 'IfNotExists'),
+            createSchemaNode: create_schema_node_js_1.CreateSchemaNode.cloneWith(this.#props.createSchemaNode, { modifier: 'IfNotExists' }),
         });
     }
     toOperationNode() {

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

@@ -7,7 +7,10 @@ import { ColumnDefinitionBuilder } from './column-definition-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 {
+/**
+ * This builder can be used to create a `create table` query.
+ */
+export declare class CreateTableBuilder<TB extends string, C extends string = never> implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateTableBuilderProps);
     /**
@@ -15,7 +18,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      *
      * If the table already exists, no error is thrown if this method has been called.
      */
-    ifNotExists(): CreateTableBuilder;
+    ifNotExists(): CreateTableBuilder<TB, C>;
     /**
      * Adds a column to the table.
      *
@@ -23,44 +26,86 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('int', 'id', (col) => col.increments().primary()),
+     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
      *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('varchar', 'last_name')
-     *   .addColumn('numeric(8, 2)', 'bank_balance')
+     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
+     *   .addColumn('parent_id', 'integer', (col) =>
+     *     col.references('person.id').onDelete('cascade'))
+     *   )
+     * ```
+     *
+     * With this method, it's once again good to remember that Kysely just builds the query
+     * that's as close to the structure of your builder method calls as possible, and doesn't
+     * provide the same API for all databses. For example, some databases like older MySQL
+     * don't support `references` statement in the column definition. Instead foreign key
+     * constraints need to be defined in at the level of the `create table` query. See
+     * the next example:
+     *
+     * @example
+     * ```ts
+     *   .addColumn('parent_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'person_parent_id_fk', ['parent_id'], 'person', ['id'],
+     *     (cb) => cb.onDelete('cascade')
+     *   )
+     * ```
+     *
+     * Another good example is that PostgreSQL doesn't support the `auto_increment`
+     * keyword and you need to define an autoincrementing column for example using
+     * `serial`:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('id', 'serial', (col) => col.primaryKey()),
      * ```
      */
-    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder;
+    addColumn<CN extends string>(columnName: CN, dataType: DataTypeExpression, build?: ColumnBuilderCallback): CreateTableBuilder<TB, C | CN>;
     /**
      * Adds a primary key constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
      * ```
      */
-    addPrimaryKeyConstraint(constraintName: string, columns: string[]): CreateTableBuilder;
+    addPrimaryKeyConstraint(constraintName: string, columns: C[]): CreateTableBuilder<TB, C>;
     /**
      * Adds a unique constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'])
      * ```
      */
-    addUniqueConstraint(constraintName: string, columns: string[]): CreateTableBuilder;
+    addUniqueConstraint(constraintName: string, columns: C[]): CreateTableBuilder<TB, C>;
     /**
      * Adds a check constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addCheckConstraint('check_legs', 'number_of_legs < 5')
      * ```
      */
-    addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder;
+    addCheckConstraint(constraintName: string, checkExpression: string): CreateTableBuilder<TB, C>;
     /**
      * Adds a foreign key constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addForeignKeyConstraint(
@@ -82,7 +127,7 @@ export declare class CreateTableBuilder implements OperationNodeSource, Compilab
      * )
      * ```
      */
-    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder;
+    addForeignKeyConstraint(constraintName: string, columns: C[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder<TB, C>;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -11,6 +11,12 @@ 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");
+const primary_constraint_node_js_1 = require("../operation-node/primary-constraint-node.js");
+const unique_constraint_node_js_1 = require("../operation-node/unique-constraint-node.js");
+const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
+/**
+ * This builder can be used to create a `create table` query.
+ */
 class CreateTableBuilder {
     #props;
     constructor(props) {
@@ -34,18 +40,45 @@ class CreateTableBuilder {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('int', 'id', (col) => col.increments().primary()),
+     *   .addColumn('id', 'integer', (col) => col.increments().primaryKey()),
      *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('varchar', 'last_name')
-     *   .addColumn('numeric(8, 2)', 'bank_balance')
+     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
+     *   .addColumn('parent_id', 'integer', (col) =>
+     *     col.references('person.id').onDelete('cascade'))
+     *   )
+     * ```
+     *
+     * With this method, it's once again good to remember that Kysely just builds the query
+     * that's as close to the structure of your builder method calls as possible, and doesn't
+     * provide the same API for all databses. For example, some databases like older MySQL
+     * don't support `references` statement in the column definition. Instead foreign key
+     * constraints need to be defined in at the level of the `create table` query. See
+     * the next example:
+     *
+     * @example
+     * ```ts
+     *   .addColumn('parent_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'person_parent_id_fk', ['parent_id'], 'person', ['id'],
+     *     (cb) => cb.onDelete('cascade')
+     *   )
+     * ```
+     *
+     * Another good example is that PostgreSQL doesn't support the `auto_increment`
+     * keyword and you need to define an autoincrementing column for example using
+     * `serial`:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('person')
+     *   .addColumn('id', 'serial', (col) => col.primaryKey()),
      * ```
      */
-    addColumn(columnName, dataType, build) {
-        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);
-        }
+    addColumn(columnName, dataType, build = object_utils_js_1.noop) {
+        const columnBuilder = build(new column_definition_builder_js_1.ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.create(columnName, (0, data_type_parser_js_1.parseDataTypeExpression)(dataType))));
         return new CreateTableBuilder({
             ...this.#props,
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWithColumn(this.#props.createTableNode, columnBuilder.toOperationNode()),
@@ -54,6 +87,9 @@ class CreateTableBuilder {
     /**
      * Adds a primary key constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
@@ -62,12 +98,15 @@ class CreateTableBuilder {
     addPrimaryKeyConstraint(constraintName, columns) {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithPrimaryKeyConstraint(this.#props.createTableNode, constraintName, columns),
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, primary_constraint_node_js_1.PrimaryConstraintNode.create(columns, constraintName)),
         });
     }
     /**
      * Adds a unique constraint for one or more columns.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addUniqueConstraint('first_name_last_name_unique', ['first_name', 'last_name'])
@@ -76,12 +115,15 @@ class CreateTableBuilder {
     addUniqueConstraint(constraintName, columns) {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithUniqueConstraint(this.#props.createTableNode, constraintName, columns),
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName)),
         });
     }
     /**
      * Adds a check constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addCheckConstraint('check_legs', 'number_of_legs < 5')
@@ -90,12 +132,15 @@ class CreateTableBuilder {
     addCheckConstraint(constraintName, checkExpression) {
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithCheckConstraint(this.#props.createTableNode, constraintName, checkExpression),
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, check_constraint_node_js_1.CheckConstraintNode.create(checkExpression, constraintName)),
         });
     }
     /**
      * Adds a foreign key constraint.
      *
+     * The constraint name can be anything you want, but it must be unique
+     * across the whole database.
+     *
      * @example
      * ```ts
      * addForeignKeyConstraint(
@@ -117,14 +162,11 @@ class CreateTableBuilder {
      * )
      * ```
      */
-    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);
-        }
+    addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = object_utils_js_1.noop) {
+        const builder = build(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)));
         return new CreateTableBuilder({
             ...this.#props,
-            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithForeignKeyConstraint(this.#props.createTableNode, builder.toOperationNode()),
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, builder.toOperationNode()),
         });
     }
     toOperationNode() {

package/dist/cjs/schema/schema.d.ts

@@ -22,14 +22,49 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'int', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
      *   .execute()
      * ```
+     *
+     * @example
+     * This example creates a table with a foreign key. Not all database
+     * engines support column-level foreign key constraint definitions.
+     * For example if you are using MySQL 5.X see the next example after
+     * this one.
+     *
+     * ```ts
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('owner_id', 'integer', col => col
+     *     .references('person.id')
+     *     .onDelete('cascade')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * @example
+     * This example adds a foreign key constraint for a columns just
+     * like the previous example, but using a table-level statement.
+     * On MySQL 5.X you need to define foreign key constraints like
+     * this:
+     *
+     * ```ts
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('owner_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],
+     *     (constraint) => constraint.onDelete('cascade')
+     *   )
+     *   .execute()
+     * ```
      */
-    createTable(table: string): CreateTableBuilder;
+    createTable<TB extends string>(table: TB): CreateTableBuilder<TB, never>;
     /**
      * Drop a table.
      *

package/dist/cjs/schema/schema.js

@@ -36,12 +36,47 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .createTable('person')
-     *   .addColumn('id', 'int', col => col.primaryKey().increments())
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
      *   .addColumn('first_name', 'varchar', col => col.notNull())
      *   .addColumn('last_name', 'varchar', col => col.notNull())
      *   .addColumn('gender', 'varchar')
      *   .execute()
      * ```
+     *
+     * @example
+     * This example creates a table with a foreign key. Not all database
+     * engines support column-level foreign key constraint definitions.
+     * For example if you are using MySQL 5.X see the next example after
+     * this one.
+     *
+     * ```ts
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('owner_id', 'integer', col => col
+     *     .references('person.id')
+     *     .onDelete('cascade')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * @example
+     * This example adds a foreign key constraint for a columns just
+     * like the previous example, but using a table-level statement.
+     * On MySQL 5.X you need to define foreign key constraints like
+     * this:
+     *
+     * ```ts
+     * await db.schema
+     *   .createTable('pet')
+     *   .addColumn('id', 'integer', col => col.primaryKey().increments())
+     *   .addColumn('owner_id', 'integer')
+     *   .addForeignKeyConstraint(
+     *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],
+     *     (constraint) => constraint.onDelete('cascade')
+     *   )
+     *   .execute()
+     * ```
      */
     createTable(table) {
         return new create_table_builder_js_1.CreateTableBuilder({

package/dist/cjs/util/object-utils.d.ts

@@ -1,18 +1,19 @@
 /// <reference types="node" />
 export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<any> | string | object | Buffer): boolean;
-export declare function isString(obj: any): obj is string;
-export declare function isNumber(obj: any): obj is number;
-export declare function isBoolean(obj: any): obj is boolean;
-export declare function isNull(obj: any): obj is null;
-export declare function isDate(obj: any): obj is Date;
-export declare function isBuffer(obj: any): obj is Buffer;
-export declare function isBigInt(obj: any): obj is BigInt;
-export declare function isPrimitive(obj: any): obj is PrimitiveValue;
-export declare function isFunction(obj: any): obj is Function;
-export declare function isObject(obj: any): obj is Record<string, any>;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isString(obj: unknown): obj is string;
+export declare function isNumber(obj: unknown): obj is number;
+export declare function isBoolean(obj: unknown): obj is boolean;
+export declare function isNull(obj: unknown): obj is null;
+export declare function isDate(obj: unknown): obj is Date;
+export declare function isBuffer(obj: unknown): obj is Buffer;
+export declare function isBigInt(obj: unknown): obj is BigInt;
+export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];
 export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
+export declare function noop<T>(obj: T): T;

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBigInt = exports.isBuffer = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
+exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBigInt = exports.isBuffer = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || Buffer.isBuffer(obj)) {
         return obj.length === 0;
@@ -54,7 +54,7 @@ function isFunction(obj) {
 }
 exports.isFunction = isFunction;
 function isObject(obj) {
-    return obj && typeof obj === 'object';
+    return typeof obj === 'object' && obj !== null;
 }
 exports.isObject = isObject;
 function getLast(arr) {
@@ -87,3 +87,7 @@ function isReadonlyArray(arg) {
     return Array.isArray(arg);
 }
 exports.isReadonlyArray = isReadonlyArray;
+function noop(obj) {
+    return obj;
+}
+exports.noop = noop;

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

@@ -1,4 +1,4 @@
-import { isFunction, isObject } from '../../util/object-utils.js';
+import { isFunction, isNumber, isObject, } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
     #config;
@@ -103,13 +103,13 @@ class MysqlConnection {
     async executeQuery(compiledQuery) {
         const result = await this.#executeQuery(compiledQuery);
         if (isObject(result) && 'insertId' in result && 'affectedRows' in result) {
-            if (result.insertId) {
+            if (isNumber(result.insertId) && result.insertId > 0) {
                 return {
                     insertedPrimaryKey: result.insertId,
                     rows: [],
                 };
             }
-            else {
+            else if (isNumber(result.affectedRows)) {
                 return {
                     numUpdatedOrDeletedRows: result.affectedRows,
                     rows: [],

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

@@ -1,7 +1,5 @@
-import { ColumnDefinitionNode } from '../../operation-node/column-definition-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
-    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected visitReturning(): void;
     protected getSql(): string;
     protected getCurrentParameterPlaceholder(): string;

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

@@ -1,34 +1,5 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export class MysqlQueryCompiler extends DefaultQueryCompiler {
-    visitColumnDefinition(node) {
-        this.visitNode(node.column);
-        this.append(' ');
-        this.visitNode(node.dataType);
-        if (node.defaultTo) {
-            this.append(' default ');
-            this.visitNode(node.defaultTo);
-        }
-        if (!node.isNullable || node.isAutoIncrementing) {
-            this.append(' not null');
-        }
-        if (node.isAutoIncrementing) {
-            this.append(' auto_increment');
-        }
-        if (node.isUnique) {
-            this.append(' unique');
-        }
-        if (node.isPrimaryKey) {
-            this.append(' primary key');
-        }
-        if (node.references) {
-            this.append(' ');
-            this.visitNode(node.references);
-        }
-        if (node.check) {
-            this.append(' ');
-            this.visitNode(node.check);
-        }
-    }
     visitReturning() {
         // Do nothing.
     }

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

@@ -13,5 +13,5 @@ export interface CreateSchemaNode extends OperationNode {
 export declare const CreateSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
     create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;
-    cloneWithModifier(createSchema: CreateSchemaNode, modifier: CreateSchemaNodeModifier): CreateSchemaNode;
+    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
 }>;

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

@@ -14,10 +14,10 @@ export const CreateSchemaNode = freeze({
             ...params,
         });
     },
-    cloneWithModifier(createSchema, modifier) {
+    cloneWith(createSchema, params) {
         return freeze({
             ...createSchema,
-            modifier,
+            ...params,
         });
     },
 });

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

@@ -1,6 +1,5 @@
 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';
@@ -19,8 +18,5 @@ export declare const CreateTableNode: Readonly<{
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
-    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, constraint: ForeignKeyConstraintNode): CreateTableNode;
+    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
 }>;

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

@@ -1,7 +1,4 @@
 import { freeze } from '../util/object-utils.js';
-import { CheckConstraintNode } from './check-constraint-node.js';
-import { PrimaryConstraintNode } from './primary-constraint-node.js';
-import { UniqueConstraintNode } from './unique-constraint-node.js';
 /**
  * @internal
  */
@@ -28,34 +25,7 @@ export const CreateTableNode = freeze({
             modifier,
         });
     },
-    cloneWithPrimaryKeyConstraint(createTable, constraintName, columns) {
-        const constraint = PrimaryConstraintNode.create(columns, constraintName);
-        return freeze({
-            ...createTable,
-            constraints: createTable.constraints
-                ? freeze([...createTable.constraints, constraint])
-                : freeze([constraint]),
-        });
-    },
-    cloneWithUniqueConstraint(createTable, constraintName, columns) {
-        const constraint = UniqueConstraintNode.create(columns, constraintName);
-        return freeze({
-            ...createTable,
-            constraints: createTable.constraints
-                ? freeze([...createTable.constraints, constraint])
-                : freeze([constraint]),
-        });
-    },
-    cloneWithCheckConstraint(createTable, constraintName, sql) {
-        const constraint = CheckConstraintNode.create(sql, constraintName);
-        return freeze({
-            ...createTable,
-            constraints: createTable.constraints
-                ? freeze([...createTable.constraints, constraint])
-                : freeze([constraint]),
-        });
-    },
-    cloneWithForeignKeyConstraint(createTable, constraint) {
+    cloneWithConstraint(createTable, constraint) {
         return freeze({
             ...createTable,
             constraints: createTable.constraints

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

@@ -21,5 +21,6 @@ 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;
+    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
 }>;