kysely 0.21.6 → 0.23.0

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -9,7 +9,6 @@ import { DataTypeNode } from '../operation-node/data-type-node.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
-import { FilterNode } from '../operation-node/filter-node.js';
 import { FromNode } from '../operation-node/from-node.js';
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { GroupByNode } from '../operation-node/group-by-node.js';
@@ -60,7 +59,6 @@ import { ColumnDefinitionNode } from '../operation-node/column-definition-node.j
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { UnionNode } from '../operation-node/union-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { GeneratedNode } from '../operation-node/generated-node.js';
@@ -74,6 +72,13 @@ import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { ExplainNode } from '../operation-node/explain-node.js';
 import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
 import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { OverNode } from '../operation-node/over-node.js';
+import { PartitionByNode } from '../operation-node/partition-by-node.js';
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { SetOperationNode } from '../operation-node/set-operation-node.js';
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -83,7 +88,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitFrom(node: FromNode): void;
     protected visitSelection(node: SelectionNode): void;
     protected visitColumn(node: ColumnNode): void;
-    protected compileDistinctOn(selections: ReadonlyArray<SelectionNode>): void;
+    protected compileDistinctOn(expressions: ReadonlyArray<OperationNode>): void;
     protected compileList(nodes: ReadonlyArray<OperationNode>, separator?: string): void;
     protected visitWhere(node: WhereNode): void;
     protected visitHaving(node: HavingNode): void;
@@ -96,7 +101,6 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitSelectAll(_: SelectAllNode): void;
     protected visitIdentifier(node: IdentifierNode): void;
     protected compileUnwrappedIdentifier(node: IdentifierNode): void;
-    protected visitFilter(node: FilterNode): void;
     protected visitAnd(node: AndNode): void;
     protected visitOr(node: OrNode): void;
     protected visitValue(node: ValueNode): void;
@@ -145,7 +149,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitModifyColumn(node: ModifyColumnNode): void;
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
-    protected visitUnion(node: UnionNode): void;
+    protected visitSetOperation(node: SetOperationNode): void;
     protected visitCreateView(node: CreateViewNode): void;
     protected visitDropView(node: DropViewNode): void;
     protected visitGenerated(node: GeneratedNode): void;
@@ -155,6 +159,12 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitDropType(node: DropTypeNode): void;
     protected visitExplain(node: ExplainNode): void;
     protected visitDefaultInsertValue(_: DefaultInsertValueNode): void;
+    protected visitAggregateFunction(node: AggregateFunctionNode): void;
+    protected visitOver(node: OverNode): void;
+    protected visitPartitionBy(node: PartitionByNode): void;
+    protected visitPartitionByItem(node: PartitionByItemNode): void;
+    protected visitBinaryOperation(node: BinaryOperationNode): void;
+    protected visitUnaryOperation(node: UnaryOperationNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -2,10 +2,9 @@
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
-import { UnionNode } from '../operation-node/union-node.js';
+import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
+import { SetOperationNode } from '../operation-node/set-operation-node.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sql = '';
     #parameters = [];
@@ -29,7 +28,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         const wrapInParens = this.parentNode !== undefined &&
             !InsertQueryNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
-            !UnionNode.is(this.parentNode);
+            !SetOperationNode.is(this.parentNode);
         if (this.parentNode === undefined && node.explain) {
             this.visitNode(node.explain);
             this.append(' ');
@@ -42,8 +41,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('select ');
-        if (node.distinctOnSelections) {
-            this.compileDistinctOn(node.distinctOnSelections);
+        if (node.distinctOn) {
+            this.compileDistinctOn(node.distinctOn);
             this.append(' ');
         }
         if (node.frontModifiers && node.frontModifiers.length > 0) {
@@ -71,9 +70,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.having);
         }
-        if (node.union) {
+        if (node.setOperations) {
             this.append(' ');
-            this.compileList(node.union, ' ');
+            this.compileList(node.setOperations, ' ');
         }
         if (node.orderBy) {
             this.append(' ');
@@ -105,16 +104,16 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     visitColumn(node) {
         this.visitNode(node.column);
     }
-    compileDistinctOn(selections) {
+    compileDistinctOn(expressions) {
         this.append('distinct on (');
-        this.compileList(selections);
+        this.compileList(expressions);
         this.append(')');
     }
     compileList(nodes, separator = ', ') {
-        const lastNode = getLast(nodes);
-        for (const node of nodes) {
-            this.visitNode(node);
-            if (node !== lastNode) {
+        const lastIndex = nodes.length - 1;
+        for (let i = 0; i <= lastIndex; i++) {
+            this.visitNode(nodes[i]);
+            if (i < lastIndex) {
                 this.append(separator);
             }
         }
@@ -242,15 +241,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.append(this.sanitizeIdentifier(node.name));
     }
-    visitFilter(node) {
-        if (node.left) {
-            this.visitNode(node.left);
-            this.append(' ');
-        }
-        this.visitNode(node.op);
-        this.append(' ');
-        this.visitNode(node.right);
-    }
     visitAnd(node) {
         this.visitNode(node.left);
         this.append(' and ');
@@ -327,7 +317,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateTable(node) {
         this.append('create ');
-        if (node.frontModifiers) {
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
             this.compileList(node.frontModifiers, ' ');
             this.append(' ');
         }
@@ -346,7 +336,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on commit ');
             this.append(node.onCommit);
         }
-        if (node.endModifiers) {
+        if (node.endModifiers && node.endModifiers.length > 0) {
             this.append(' ');
             this.compileList(node.endModifiers, ' ');
         }
@@ -358,6 +348,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.unsigned) {
             this.append(' unsigned');
         }
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.frontModifiers, ' ');
+        }
         if (node.generated) {
             this.append(' ');
             this.visitNode(node.generated);
@@ -387,6 +381,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.check);
         }
+        if (node.endModifiers && node.endModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
+        }
     }
     getAutoIncrement() {
         return 'auto_increment';
@@ -542,13 +540,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         if (node.expression) {
             this.append(' (');
-            if (RawNode.is(node.expression)) {
-                this.append('(');
-            }
             this.visitNode(node.expression);
-            if (RawNode.is(node.expression)) {
-                this.append(')');
-            }
             this.append(')');
         }
     }
@@ -673,20 +665,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.dropConstraint) {
             this.visitNode(node.dropConstraint);
         }
-        if (node.renameColumn) {
-            this.visitNode(node.renameColumn);
-        }
-        if (node.addColumn) {
-            this.visitNode(node.addColumn);
-        }
-        if (node.dropColumn) {
-            this.visitNode(node.dropColumn);
-        }
-        if (node.alterColumn) {
-            this.visitNode(node.alterColumn);
-        }
-        if (node.modifyColumn) {
-            this.visitNode(node.modifyColumn);
+        if (node.columnAlterations) {
+            this.compileList(node.columnAlterations);
         }
     }
     visitAddColumn(node) {
@@ -750,12 +730,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' restrict');
         }
     }
-    visitUnion(node) {
-        this.append('union ');
+    visitSetOperation(node) {
+        this.append(node.operator);
+        this.append(' ');
         if (node.all) {
             this.append('all ');
         }
-        this.visitNode(node.union);
+        this.visitNode(node.expression);
     }
     visitCreateView(node) {
         this.append('create ');
@@ -868,6 +849,56 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     visitDefaultInsertValue(_) {
         this.append('default');
     }
+    visitAggregateFunction(node) {
+        this.append(node.func);
+        this.append('(');
+        if (node.distinct) {
+            this.append('distinct ');
+        }
+        this.visitNode(node.column);
+        this.append(')');
+        if (node.filter) {
+            this.append(' filter(');
+            this.visitNode(node.filter);
+            this.append(')');
+        }
+        if (node.over) {
+            this.append(' ');
+            this.visitNode(node.over);
+        }
+    }
+    visitOver(node) {
+        this.append('over(');
+        if (node.partitionBy) {
+            this.visitNode(node.partitionBy);
+            if (node.orderBy) {
+                this.append(' ');
+            }
+        }
+        if (node.orderBy) {
+            this.visitNode(node.orderBy);
+        }
+        this.append(')');
+    }
+    visitPartitionBy(node) {
+        this.append('partition by ');
+        this.compileList(node.items);
+    }
+    visitPartitionByItem(node) {
+        this.visitNode(node.partitionBy);
+    }
+    visitBinaryOperation(node) {
+        this.visitNode(node.leftOperand);
+        this.append(' ');
+        this.visitNode(node.operator);
+        this.append(' ');
+        this.visitNode(node.rightOperand);
+    }
+    visitUnaryOperation(node) {
+        this.visitNode(node.operator);
+        this.append(' ');
+        this.visitNode(node.operand);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/query-executor/query-executor-base.js

@@ -1,6 +1,7 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { Deferred } from '../util/deferred.js';
+import { logOnce } from '../util/log-once.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -32,7 +33,10 @@ export class QueryExecutorBase {
     async executeQuery(compiledQuery, queryId) {
         return await this.provideConnection(async (connection) => {
             const result = await connection.executeQuery(compiledQuery);
-            return this.#transformResult(result, queryId);
+            const transformedResult = await this.#transformResult(result, queryId);
+            // TODO: remove.
+            warnOfOutdatedDriverOrPlugins(result, transformedResult);
+            return transformedResult;
         });
     }
     async *stream(compiledQuery, chunkSize, queryId) {
@@ -60,3 +64,14 @@ export class QueryExecutorBase {
         return result;
     }
 }
+// TODO: remove.
+function warnOfOutdatedDriverOrPlugins(result, transformedResult) {
+    const { numAffectedRows } = result;
+    if ((numAffectedRows === undefined &&
+        result.numUpdatedOrDeletedRows === undefined) ||
+        (numAffectedRows !== undefined &&
+            transformedResult.numAffectedRows !== undefined)) {
+        return;
+    }
+    logOnce('kysely:warning: outdated driver/plugin detected! QueryResult.numUpdatedOrDeletedRows is deprecated and will be removed in a future release.');
+}

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -1,20 +1,37 @@
 import { QueryResult } from '../driver/database-connection.js';
 import { AliasNode } from '../operation-node/alias-node.js';
-import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { AliasedExpression, Expression } from '../expression/expression.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
  * You shouldn't need to create `RawBuilder` instances directly. Instead you should
  * use the {@link sql} template tag.
  */
-export declare class RawBuilder<O = unknown> implements OperationNodeSource {
+export declare class RawBuilder<O> implements Expression<O> {
     #private;
     constructor(props: RawBuilderProps);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): O | undefined;
     /**
      * Returns an aliased version of the SQL expression.
      *
@@ -69,7 +86,7 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
-    as<A extends string = never>(alias: AnyRawBuilder): AliasedRawBuilder<O, A>;
+    as<A extends string = never>(alias: Expression<any>): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
@@ -81,25 +98,44 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * Adds a plugin for this SQL snippet.
      */
     withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
     toOperationNode(): RawNode;
     execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
 }
+export declare function isRawBuilder(obj: unknown): obj is RawBuilder<unknown>;
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
  */
-export declare class AliasedRawBuilder<O = unknown, A extends string = never> implements OperationNodeSource {
+export declare class AliasedRawBuilder<O = unknown, A extends string = never> implements AliasedExpression<O, A> {
     #private;
+    constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<any>);
+    /** @private */
     /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedRawBuilder with any A
-     * as long as O is the same.
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<O>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
      */
-    protected get alias(): A | AnyRawBuilder;
     toOperationNode(): AliasNode;
-    constructor(rawBuilder: RawBuilder<O>, alias: A | AnyRawBuilder);
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;

package/dist/esm/raw-builder/raw-builder.js

@@ -1,10 +1,10 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
 import { preventAwait } from '../util/prevent-await.js';
-import { freeze } from '../util/object-utils.js';
+import { freeze, isFunction, isObject } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -16,6 +16,10 @@ export class RawBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
@@ -58,6 +62,14 @@ export class RawBuilder {
         return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
+export function isRawBuilder(obj) {
+    return (isObject(obj) &&
+        isFunction(obj.as) &&
+        isFunction(obj.castTo) &&
+        isFunction(obj.withPlugin) &&
+        isFunction(obj.toOperationNode) &&
+        isFunction(obj.execute));
+}
 preventAwait(RawBuilder, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
@@ -65,14 +77,15 @@ preventAwait(RawBuilder, "don't await RawBuilder instances directly. To execute
 export class AliasedRawBuilder {
     #rawBuilder;
     #alias;
-    /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedRawBuilder with any A
-     * as long as O is the same.
-     */
+    constructor(rawBuilder, alias) {
+        this.#rawBuilder = rawBuilder;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#rawBuilder;
+    }
+    /** @private */
     get alias() {
         return this.#alias;
     }
@@ -81,8 +94,4 @@ export class AliasedRawBuilder {
             ? this.#alias.toOperationNode()
             : IdentifierNode.create(this.#alias));
     }
-    constructor(rawBuilder, alias) {
-        this.#rawBuilder = rawBuilder;
-        this.#alias = alias;
-    }
 }

package/dist/esm/raw-builder/sql.d.ts

@@ -7,13 +7,14 @@ export interface Sql {
      * import { sql } from 'kysely'
      *
      * const id = 123
-     *
      * const snippet = sql<Person[]>`select * from person where id = ${id}`
      * ```
      *
      * Substitutions (the things inside `${}`) are automatically passed to the database
-     * as parameters and are NOT interpolated to the SQL string. There's no need to worry
-     * about SQL injection vulnerabilities.
+     * as parameters and are never interpolated to the SQL string. There's no need to worry
+     * about SQL injection vulnerabilities. Substitutions can be values, other `sql`
+     * expressions, queries and almost anything else Kysely can produce and they get
+     * handled correctly. See the examples below.
      *
      * If you need your substitutions to be interpreted as identifiers, value literals or
      * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
@@ -29,8 +30,7 @@ export interface Sql {
      *   .selectFrom('person')
      *   .select(
      *     // If you use `sql` in a select statement, remember to call the `as`
-     *     // method to give it an alias. Otherwise Kysely is not able to add
-     *     // the column to the result type.
+     *     // method to give it an alias.
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
      *   )
      *   .where(sql`birthdate between ${date1} and ${date2}`)
@@ -97,6 +97,14 @@ export interface Sql {
      * type-safety though... But it's possible.
      */
     <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
+    /**
+     * `sql.value(value)` is a shortcut for:
+     *
+     * ```ts
+     * sql<ValueType>`${value}`
+     * ```
+     */
+    value<T>(value: T): RawBuilder<T>;
     /**
      * This can be used to add runtime column references to SQL snippets.
      *
@@ -226,7 +234,7 @@ export interface Sql {
      * select "public"."person"."first_name" from "public"."person"
      * ```
      */
-    id(...ids: string[]): RawBuilder<unknown>;
+    id(...ids: readonly string[]): RawBuilder<unknown>;
     /**
      * This can be used to add literal values to SQL snippets.
      *
@@ -326,6 +334,6 @@ export interface Sql {
      * BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER
      * ```
      */
-    join(array: unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
+    join(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
 }
 export declare const sql: Sql;

package/dist/esm/raw-builder/sql.js

@@ -19,6 +19,12 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
             rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
         });
     },
+    value(value) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseValueExpression(value)),
+        });
+    },
     table(tableReference) {
         return new RawBuilder({
             queryId: createQueryId(),

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

@@ -0,0 +1,28 @@
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import { ColumnDataType } from '../operation-node/data-type-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
+export declare class AlterColumnBuilder {
+    protected readonly alterColumnNode: AlterColumnNode;
+    constructor(alterColumnNode: AlterColumnNode);
+    setDataType(dataType: ColumnDataType): AlteredColumnBuilder;
+    setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
+    dropDefault(): AlteredColumnBuilder;
+    setNotNull(): AlteredColumnBuilder;
+    dropNotNull(): AlteredColumnBuilder;
+}
+/**
+ * Allows us to force consumers to do something, anything, when altering a column.
+ *
+ * Basically, deny the following:
+ *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export declare class AlteredColumnBuilder extends AlterColumnBuilder implements OperationNodeSource {
+    toOperationNode(): AlterColumnNode;
+}
+export declare type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;

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

@@ -0,0 +1,51 @@
+/// <reference types="./alter-column-builder.d.ts" />
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+export class AlterColumnBuilder {
+    alterColumnNode;
+    constructor(alterColumnNode) {
+        this.alterColumnNode = alterColumnNode;
+    }
+    setDataType(dataType) {
+        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dataType: DataTypeNode.create(dataType),
+        }));
+    }
+    setDefault(value) {
+        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
+            setDefault: parseDefaultValueExpression(value),
+        }));
+    }
+    dropDefault() {
+        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dropDefault: true,
+        }));
+    }
+    setNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
+            setNotNull: true,
+        }));
+    }
+    dropNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
+            dropNotNull: true,
+        }));
+    }
+}
+/**
+ * Allows us to force consumers to do something, anything, when altering a column.
+ *
+ * Basically, deny the following:
+ *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export class AlteredColumnBuilder extends AlterColumnBuilder {
+    toOperationNode() {
+        return this.alterColumnNode;
+    }
+}