kysely 0.22.0 → 0.23.0

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

@@ -1,38 +1,36 @@
-import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
-import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { ColumnDefinitionBuilderCallback } from './column-definition-builder.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
-import { DefaultValueExpression } from '../parser/default-value-parser.js';
+import { Expression } from '../expression/expression.js';
+import { AlterColumnBuilderCallback } from './alter-column-builder.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
-export declare class AlterTableBuilder {
+export declare class AlterTableBuilder implements ColumnAlteringInterface {
     #private;
     constructor(props: AlterTableBuilderProps);
     renameTo(newTableName: string): AlterTableExecutor;
     setSchema(newSchema: string): AlterTableExecutor;
-    alterColumn(column: string): AlterColumnBuilder;
-    dropColumn(column: string): AlterTableExecutor;
-    renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
     /**
      * See {@link CreateTableBuilder.addColumn}
      */
-    addColumn(columnName: string, dataType: DataTypeExpression, build?: AlterTableAddColumnBuilderCallback): AlterTableAddColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
      * is only implemeted by MySQL and oracle AFAIK. On other databases you
      * should use the `alterColumn` method.
      */
-    modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
      * See {@link CreateTableBuilder.addUniqueConstraint}
      */
@@ -40,7 +38,7 @@ export declare class AlterTableBuilder {
     /**
      * See {@link CreateTableBuilder.addCheckConstraint}
      */
-    addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>): AlterTableExecutor;
     /**
      * See {@link CreateTableBuilder.addForeignKeyConstraint}
      *
@@ -50,24 +48,18 @@ export declare class AlterTableBuilder {
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
     dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * See {@link CreateTableBuilder.call}
+     */
+    call<T>(func: (qb: this) => T): T;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
-    readonly alterTableNode: AlterTableNode;
+    readonly node: AlterTableNode;
     readonly executor: QueryExecutor;
 }
-export declare class AlterColumnBuilder {
-    #private;
-    constructor(props: AlterColumnBuilderProps);
-    setDataType(dataType: ColumnDataType): AlterTableExecutor;
-    setDefault(value: DefaultValueExpression): AlterTableExecutor;
-    dropDefault(): AlterTableExecutor;
-    setNotNull(): AlterTableExecutor;
-    dropNotNull(): AlterTableExecutor;
-}
-export interface AlterColumnBuilderProps extends AlterTableBuilderProps {
-    readonly alterColumnNode: AlterColumnNode;
-}
 export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableExecutorProps);
@@ -77,336 +69,42 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
-    #private;
-    constructor(props: AlterTableAddColumnBuilderProps);
-    /**
-     * Adds `auto_increment` or `autoincrement` to the column definition
-     * depending on the dialect.
-     *
-     * Some dialects like PostgreSQL don't support this. On PostgreSQL
-     * you can use the `serial` or `bigserial` data type instead.
-     */
-    autoIncrement(): AlterTableAddColumnBuilder;
-    /**
-     * Makes the column the primary key.
-     *
-     * If you want to specify a composite primary key use the
-     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
-     */
-    primaryKey(): AlterTableAddColumnBuilder;
-    /**
-     * 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 CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id')
-     * ```
-     */
-    references(ref: string): AlterTableAddColumnBuilder;
-    /**
-     * 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 CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onDelete('cascade')
-     * ```
-     */
-    onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
-    /**
-     * Adds an `on update` constraint for the foreign key column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onUpdate('cascade')
-     * ```
-     */
-    onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
-    /**
-     * Adds a unique constraint for the column.
-     */
-    unique(): AlterTableAddColumnBuilder;
+export interface ColumnAlteringInterface {
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): ColumnAlteringInterface;
+    dropColumn(column: string): ColumnAlteringInterface;
+    renameColumn(column: string, newColumn: string): ColumnAlteringInterface;
     /**
-     * Adds a `not null` constraint for the column.
-     */
-    notNull(): AlterTableAddColumnBuilder;
-    /**
-     * Adds a `unsigned` modifier for the column.
-     *
-     * This only works on some dialects like MySQL.
-     */
-    unsigned(): AlterTableAddColumnBuilder;
-    /**
-     * Adds a default value constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
-     *   .execute()
-     * ```
-     *
-     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
-     * an arbitrary SQL expression using the {@link sql} template tag:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn(
-     *     'number_of_legs',
-     *     'integer',
-     *     (col) => col.defaultTo(sql`any SQL here`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    defaultTo(value: DefaultValueExpression): AlterTableAddColumnBuilder;
-    /**
-     * Adds a check constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(sql`number_of_legs < 5`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    check(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
-    /**
-     * Makes the column a generated column using a `generated always as` statement.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
-    /**
-     * Adds the `generated always as identity` specifier on supported dialects.
-     */
-    generatedAlwaysAsIdentity(): AlterTableAddColumnBuilder;
-    /**
-     * Adds the `generated by default as identity` specifier on supported dialects.
+     * See {@link CreateTableBuilder.addColumn}
      */
-    generatedByDefaultAsIdentity(): AlterTableAddColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
     /**
-     * Makes a generated column stored instead of virtual. This method can only
-     * be used with {@link generatedAlwaysAs}
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)', (col) => col
-     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
-     *     .stored()
-     *   )
-     *   .execute()
-     * ```
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
      */
-    stored(): AlterTableAddColumnBuilder;
-    toOperationNode(): AlterTableNode;
-    compile(): CompiledQuery;
-    execute(): Promise<void>;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build: ColumnDefinitionBuilderCallback): ColumnAlteringInterface;
 }
-export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
-    readonly columnBuilder: ColumnDefinitionBuilder;
-}
-export declare type AlterTableAddColumnBuilderCallback = (builder: AlterTableAddColumnBuilder) => AlterTableAddColumnBuilder;
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
+export declare class AlterTableColumnAlteringBuilder implements ColumnAlteringInterface, OperationNodeSource, Compilable {
     #private;
-    constructor(props: AlterTableModifyColumnBuilderProps);
-    /**
-     * Adds `auto_increment` or `autoincrement` to the column definition
-     * depending on the dialect.
-     *
-     * Some dialects like PostgreSQL don't support this. On PostgreSQL
-     * you can use the `serial` or `bigserial` data type instead.
-     */
-    autoIncrement(): AlterTableModifyColumnBuilder;
-    /**
-     * Makes the column the primary key.
-     *
-     * If you want to specify a composite primary key use the
-     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
-     */
-    primaryKey(): AlterTableModifyColumnBuilder;
-    /**
-     * 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 CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id')
-     * ```
-     */
-    references(ref: string): AlterTableModifyColumnBuilder;
-    /**
-     * 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 CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onDelete('cascade')
-     * ```
-     */
-    onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
-    /**
-     * Adds an `on update` constraint for the foreign key column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onUpdate('cascade')
-     * ```
-     */
-    onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a unique constraint for the column.
-     */
-    unique(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a `not null` constraint for the column.
-     */
-    notNull(): AlterTableModifyColumnBuilder;
+    constructor(props: AlterTableColumnAlteringBuilderProps);
+    alterColumn(column: string, alteration: AlterColumnBuilderCallback): AlterTableColumnAlteringBuilder;
+    dropColumn(column: string): AlterTableColumnAlteringBuilder;
+    renameColumn(column: string, newColumn: string): AlterTableColumnAlteringBuilder;
     /**
-     * Adds a `unsigned` modifier for the column.
-     *
-     * This only works on some dialects like MySQL.
-     */
-    unsigned(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a default value constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
-     *   .execute()
-     * ```
-     *
-     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
-     * an arbitrary SQL expression using the {@link sql} template tag:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn(
-     *     'number_of_legs',
-     *     'integer',
-     *     (col) => col.defaultTo(sql`any SQL here`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    defaultTo(value: DefaultValueExpression): AlterTableModifyColumnBuilder;
-    /**
-     * Adds a check constraint for the column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(sql`number_of_legs < 5`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    check(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
-    /**
-     * Makes the column a generated column using a `generated always as` statement.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
-     *   )
-     *   .execute()
-     * ```
-     */
-    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
-    /**
-     * Adds the `generated always as identity` specifier on supported dialects.
-     */
-    generatedAlwaysAsIdentity(): AlterTableModifyColumnBuilder;
-    /**
-     * Adds the `generated by default as identity` specifier on supported dialects.
+     * See {@link CreateTableBuilder.addColumn}
      */
-    generatedByDefaultAsIdentity(): AlterTableModifyColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     /**
-     * Makes a generated column stored instead of virtual. This method can only
-     * be used with {@link generatedAlwaysAs}
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)', (col) => col
-     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
-     *     .stored()
-     *   )
-     *   .execute()
-     * ```
+     * Creates an `alter table modify column` query. The `modify column` statement
+     * is only implemeted by MySQL and oracle AFAIK. On other databases you
+     * should use the `alterColumn` method.
      */
-    stored(): AlterTableModifyColumnBuilder;
+    modifyColumn(columnName: string, dataType: DataTypeExpression, build?: ColumnDefinitionBuilderCallback): AlterTableColumnAlteringBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface AlterTableModifyColumnBuilderProps extends AlterTableBuilderProps {
-    readonly columnBuilder: ColumnDefinitionBuilder;
+export interface AlterTableColumnAlteringBuilderProps extends AlterTableBuilderProps {
 }
 export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
     #private;