kysely 0.25.0 → 0.26.1

package/dist/esm/query-builder/update-query-builder.js

@@ -9,8 +9,7 @@ import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
-import { parseReferentialComparison, parseWhere, } from '../parser/binary-operation-parser.js';
-import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
+import { parseReferentialComparison, parseFilter, } from '../parser/binary-operation-parser.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -19,7 +18,7 @@ export class UpdateQueryBuilder {
     where(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhere(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseFilter(args)),
         });
     }
     whereRef(lhs, op, rhs) {
@@ -28,42 +27,6 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
-    orWhere(...args) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhere(args)),
-        });
-    }
-    orWhereRef(lhs, op, rhs) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
-        });
-    }
-    whereExists(arg) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExists(arg)),
-        });
-    }
-    whereNotExists(arg) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExists(arg)),
-        });
-    }
-    orWhereExists(arg) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExists(arg)),
-        });
-    }
-    orWhereNotExists(arg) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExists(arg)),
-        });
-    }
     clearWhere() {
         return new UpdateQueryBuilder({
             ...this.#props,
@@ -144,12 +107,6 @@ export class UpdateQueryBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -194,12 +151,6 @@ export class UpdateQueryBuilder {
             ...this.#props,
         });
     }
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if(condition, func) {
-        return this.$if(condition, func);
-    }
     /**
      * Change the output type of the query.
      *
@@ -209,12 +160,6 @@ export class UpdateQueryBuilder {
     $castTo() {
         return new UpdateQueryBuilder(this.#props);
     }
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo() {
-        return this.$castTo();
-    }
     /**
      * Narrows (parts of) the output type of the query.
      *
@@ -308,12 +253,6 @@ export class UpdateQueryBuilder {
     $assertType() {
         return new UpdateQueryBuilder(this.#props);
     }
-    /**
-     * @deprecated Use `$assertType` instead.
-     */
-    assertType() {
-        return new UpdateQueryBuilder(this.#props);
-    }
     /**
      * Returns a copy of this UpdateQueryBuilder instance with the given plugin installed.
      */
@@ -344,7 +283,8 @@ export class UpdateQueryBuilder {
         return [
             new UpdateResult(
             // TODO: remove numUpdatedOrDeletedRows.
-            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? BigInt(0)),
+            // TODO: https://github.com/kysely-org/kysely/pull/431#discussion_r1172330899
+            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? BigInt(0), result.numChangedRows),
         ];
     }
     /**

package/dist/esm/query-builder/update-result.d.ts

@@ -1,5 +1,5 @@
 export declare class UpdateResult {
-    #private;
-    constructor(numUpdatedRows: bigint);
-    get numUpdatedRows(): bigint;
+    readonly numUpdatedRows: bigint;
+    readonly numChangedRows?: bigint;
+    constructor(numUpdatedRows: bigint, numChangedRows: bigint | undefined);
 }

package/dist/esm/query-builder/update-result.js

@@ -1,13 +1,9 @@
 /// <reference types="./update-result.d.ts" />
 export class UpdateResult {
-    #numUpdatedRows;
-    constructor(numUpdatedRows) {
-        this.#numUpdatedRows = numUpdatedRows;
-    }
-    get numUpdatedRows() {
-        return this.#numUpdatedRows;
+    numUpdatedRows;
+    numChangedRows;
+    constructor(numUpdatedRows, numChangedRows) {
+        this.numUpdatedRows = numUpdatedRows;
+        this.numChangedRows = numChangedRows;
     }
 }
-Object.defineProperty(UpdateResult.prototype, 'numUpdatedRows', {
-    enumerable: true,
-});

package/dist/esm/query-builder/where-interface.d.ts

@@ -1,9 +1,8 @@
 import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { WhereExpressionBuilder } from './deprecated-where-expression-builder.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
 export interface WhereInterface<DB, TB extends keyof DB> {
     /**
      * Adds a `where` expression to the query.
@@ -14,6 +13,10 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *
      * ### Examples
      *
+     * <!-- siteExample("where", "Simple where clause", 10) -->
+     *
+     * `where` method calls are combined with `AND`:
+     *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
@@ -36,9 +39,71 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * sql`your operator`
      * ```
      *
+     * <!-- siteExample("where", "Where in", 20) -->
+     *
+     * Find multiple items using a list of identifiers:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', 'in', ['1', '2', '3'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" in ($1, $2, $3)
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 30) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
+     *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
+     * const firstName: string | undefined = 'Jennifer'
+     * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
+     *
      * let query = db
      *   .selectFrom('person')
      *   .selectAll()
@@ -53,6 +118,23 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -105,22 +187,30 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
+     * <!-- siteExample("where", "Complex where clause", 50) -->
+     *
      * For complex `where` expressions you can pass in a single callback and
-     * use the {@link ExpressionBuilder} to build your expression:
+     * use the `ExpressionBuilder` to build your expression:
      *
      * ```ts
+     * const firstName = 'Jennifer'
+     * const maxAge = 60
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
-     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *       selectFrom('pet')
+     *         .select('pet.id')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
      *     ))
      *   ]))
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -241,38 +331,6 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * from "person"
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhere(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhere(expression: Expression<any>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    whereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    whereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
      * Clears all where expressions from the query.
      *
@@ -293,4 +351,4 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     clearWhere(): WhereInterface<DB, TB>;
 }
-export declare type WhereExpressionFactory<DB, TB extends keyof DB> = (eb: WhereExpressionBuilder<DB, TB>) => Expression<SqlBool> | WhereExpressionBuilder<DB, TB>;
+export type WhereExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;

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

@@ -5,5 +5,5 @@ export interface CompiledQuery<O = unknown> {
     readonly parameters: ReadonlyArray<unknown>;
 }
 export declare const CompiledQuery: Readonly<{
-    raw(sql: string): CompiledQuery;
+    raw(sql: string, parameters?: unknown[]): CompiledQuery;
 }>;

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

@@ -2,11 +2,11 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { freeze } from '../util/object-utils.js';
 export const CompiledQuery = freeze({
-    raw(sql) {
+    raw(sql, parameters = []) {
         return freeze({
             sql,
             query: RawNode.createWithSql(sql),
-            parameters: freeze([]),
+            parameters: freeze(parameters),
         });
     },
 });

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

@@ -83,6 +83,10 @@ import { UsingNode } from '../operation-node/using-node.js';
 import { FunctionNode } from '../operation-node/function-node.js';
 import { CaseNode } from '../operation-node/case-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
+import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
+import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -174,6 +178,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitFunction(node: FunctionNode): void;
     protected visitCase(node: CaseNode): void;
     protected visitWhen(node: WhenNode): void;
+    protected visitJSONReference(node: JSONReferenceNode): void;
+    protected visitJSONPath(node: JSONPathNode): void;
+    protected visitJSONPathLeg(node: JSONPathLegNode): void;
+    protected visitJSONOperatorChain(node: JSONOperatorChainNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -228,8 +228,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.alias);
     }
     visitReference(node) {
-        this.visitNode(node.table);
-        this.append('.');
+        if (node.table) {
+            this.visitNode(node.table);
+            this.append('.');
+        }
         this.visitNode(node.column);
     }
     visitSelectAll(_) {
@@ -953,6 +955,39 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.result);
         }
     }
+    visitJSONReference(node) {
+        this.visitNode(node.reference);
+        this.visitNode(node.traversal);
+    }
+    visitJSONPath(node) {
+        if (node.inOperator) {
+            this.visitNode(node.inOperator);
+        }
+        this.append("'$");
+        for (const pathLeg of node.pathLegs) {
+            this.visitNode(pathLeg);
+        }
+        this.append("'");
+    }
+    visitJSONPathLeg(node) {
+        const isArrayLocation = node.type === 'ArrayLocation';
+        this.append(isArrayLocation ? '[' : '.');
+        this.append(String(node.value));
+        if (isArrayLocation) {
+            this.append(']');
+        }
+    }
+    visitJSONOperatorChain(node) {
+        for (let i = 0, len = node.values.length; i < len; i++) {
+            if (i === len - 1) {
+                this.visitNode(node.operator);
+            }
+            else {
+                this.append('->');
+            }
+            this.visitNode(node.values[i]);
+        }
+    }
     append(str) {
         this.#sql += str;
     }

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

@@ -12,7 +12,7 @@ import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
+export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

package/dist/esm/query-creator.d.ts

@@ -201,12 +201,14 @@ export declare class QueryCreator<DB> {
      *
      * ### Examples
      *
-     * Deleting person with id 1:
+     * <!-- siteExample("delete", "Single row", 10) -->
+     *
+     * Delete a single row:
      *
      * ```ts
      * const result = await db
      *   .deleteFrom('person')
-     *   .where('person.id', '=', 1)
+     *   .where('person.id', '=', '1')
      *   .executeTakeFirst()
      *
      * console.log(result.numDeletedRows)

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

@@ -3,8 +3,8 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
 export declare class AlterColumnBuilder {
-    protected readonly alterColumnNode: AlterColumnNode;
-    constructor(alterColumnNode: AlterColumnNode);
+    #private;
+    constructor(column: string);
     setDataType(dataType: DataTypeExpression): AlteredColumnBuilder;
     setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
     dropDefault(): AlteredColumnBuilder;
@@ -17,7 +17,7 @@ export declare class AlterColumnBuilder {
     $call<T>(func: (qb: this) => T): T;
 }
 /**
- * Allows us to force consumers to do something, anything, when altering a column.
+ * Allows us to force consumers to do exactly one alteration to a column.
  *
  * Basically, deny the following:
  *
@@ -25,9 +25,15 @@ export declare class AlterColumnBuilder {
  * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
  * ```
  *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac.dropNotNull().setNotNull())
+ * ```
+ *
  * Which would now throw a compilation error, instead of a runtime error.
  */
-export declare class AlteredColumnBuilder extends AlterColumnBuilder implements OperationNodeSource {
+export declare class AlteredColumnBuilder implements OperationNodeSource {
+    #private;
+    constructor(alterColumnNode: AlterColumnNode);
     toOperationNode(): AlterColumnNode;
 }
-export declare type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;

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

@@ -3,34 +3,24 @@ import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 export class AlterColumnBuilder {
-    alterColumnNode;
-    constructor(alterColumnNode) {
-        this.alterColumnNode = alterColumnNode;
+    #column;
+    constructor(column) {
+        this.#column = column;
     }
     setDataType(dataType) {
-        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            dataType: parseDataTypeExpression(dataType),
-        }));
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dataType', parseDataTypeExpression(dataType)));
     }
     setDefault(value) {
-        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            setDefault: parseDefaultValueExpression(value),
-        }));
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setDefault', parseDefaultValueExpression(value)));
     }
     dropDefault() {
-        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            dropDefault: true,
-        }));
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropDefault', true));
     }
     setNotNull() {
-        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            setNotNull: true,
-        }));
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setNotNull', true));
     }
     dropNotNull() {
-        return new AlteredColumnBuilder(AlterColumnNode.cloneWith(this.alterColumnNode, {
-            dropNotNull: true,
-        }));
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropNotNull', true));
     }
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
@@ -41,7 +31,7 @@ export class AlterColumnBuilder {
     }
 }
 /**
- * Allows us to force consumers to do something, anything, when altering a column.
+ * Allows us to force consumers to do exactly one alteration to a column.
  *
  * Basically, deny the following:
  *
@@ -49,10 +39,18 @@ export class AlterColumnBuilder {
  * db.schema.alterTable('person').alterColumn('age', (ac) => ac)
  * ```
  *
+ * ```ts
+ * db.schema.alterTable('person').alterColumn('age', (ac) => ac.dropNotNull().setNotNull())
+ * ```
+ *
  * Which would now throw a compilation error, instead of a runtime error.
  */
-export class AlteredColumnBuilder extends AlterColumnBuilder {
+export class AlteredColumnBuilder {
+    #alterColumnNode;
+    constructor(alterColumnNode) {
+        this.#alterColumnNode = alterColumnNode;
+    }
     toOperationNode() {
-        return this.alterColumnNode;
+        return this.#alterColumnNode;
     }
 }

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

@@ -55,10 +55,6 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
      * See {@link CreateTableBuilder.$call}
      */
     $call<T>(func: (qb: this) => T): T;
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call<T>(func: (qb: this) => T): T;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;

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

@@ -1,6 +1,5 @@
 /// <reference types="./alter-table-builder.d.ts" />
 import { AddColumnNode } from '../operation-node/add-column-node.js';
-import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { DropColumnNode } from '../operation-node/drop-column-node.js';
@@ -48,7 +47,7 @@ export class AlterTableBuilder {
         });
     }
     alterColumn(column, alteration) {
-        const builder = alteration(new AlterColumnBuilder(AlterColumnNode.create(column)));
+        const builder = alteration(new AlterColumnBuilder(column));
         return new AlterTableColumnAlteringBuilder({
             ...this.#props,
             node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),
@@ -131,12 +130,6 @@ export class AlterTableBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
 }
 export class AlterTableColumnAlteringBuilder {
     #props;
@@ -144,7 +137,7 @@ export class AlterTableColumnAlteringBuilder {
         this.#props = freeze(props);
     }
     alterColumn(column, alteration) {
-        const builder = alteration(new AlterColumnBuilder(AlterColumnNode.create(column)));
+        const builder = alteration(new AlterColumnBuilder(column));
         return new AlterTableColumnAlteringBuilder({
             ...this.#props,
             node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode()),

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

@@ -212,4 +212,4 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): ColumnDefinitionNode;
 }
-export declare type ColumnDefinitionBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export type ColumnDefinitionBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;

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

@@ -1,6 +1,5 @@
 /// <reference types="./column-definition-builder.d.ts" />
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
 import { ReferencesNode, } from '../operation-node/references-node.js';
 import { SelectAllNode } from '../operation-node/select-all-node.js';
 import { parseStringReference } from '../parser/reference-parser.js';
@@ -49,7 +48,7 @@ export class ColumnDefinitionBuilder {
      */
     references(ref) {
         const references = parseStringReference(ref);
-        if (!ReferenceNode.is(references) || SelectAllNode.is(references.column)) {
+        if (!references.table || SelectAllNode.is(references.column)) {
             throw new Error(`invalid call references('${ref}'). The reference must have format table.column or schema.table.column`);
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {