kysely 0.19.10 → 0.20.0

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

@@ -10,6 +10,7 @@ import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { NoResultError } from './no-result-error.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -330,5 +331,29 @@ export class UpdateQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes query with `explain` statement before `update` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .updateTable('person')
+     *  .set(updates)
+     *  .where('id', '=', 123)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json update `person` set `first_name` = ?, `last_name` = ? where `id` = ?
+     * ```
+     */
+    async explain(format, options) {
+        const builder = new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: UpdateQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+        });
+        return await builder.execute();
+    }
 }
 preventAwait(UpdateQueryBuilder, "don't await UpdateQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -71,6 +71,7 @@ import { CommonTableExpressionNameNode } from '../operation-node/common-table-ex
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -149,11 +150,17 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitSelectModifier(node: SelectModifierNode): void;
     protected visitCreateType(node: CreateTypeNode): void;
     protected visitDropType(node: DropTypeNode): void;
+    protected visitExplain(node: ExplainNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getExplainOptionAssignment(): string;
+    protected getExplainOptionsDelimiter(): string;
+    protected getRightExplainOptionsWrapper(): string;
+    protected sanitizeIdentifier(identifier: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
 }

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

@@ -30,6 +30,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             !InsertQueryNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
             !UnionNode.is(this.parentNode);
+        if (this.parentNode === undefined && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (wrapInParens) {
             this.append('(');
         }
@@ -125,6 +129,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitInsertQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -132,7 +140,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('insert');
+        this.append(node.replace ? 'replace' : 'insert');
         if (node.ignore) {
             this.append(' ignore');
         }
@@ -169,6 +177,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitDeleteQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -225,7 +237,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
-        this.append(node.identifier);
+        if (!isString(node.identifier)) {
+            throw new Error('a non-string identifier was passed to compileUnwrappedIdentifier.');
+        }
+        this.append(this.sanitizeIdentifier(node.identifier));
     }
     visitFilter(node) {
         if (node.left) {
@@ -309,6 +324,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateTable(node) {
         this.append('create ');
+        if (node.frontModifiers) {
+            this.compileList(node.frontModifiers, ' ');
+            this.append(' ');
+        }
         if (node.temporary) {
             this.append('temporary ');
         }
@@ -324,6 +343,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on commit ');
             this.append(node.onCommit);
         }
+        if (node.endModifiers) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
+        }
     }
     visitColumnDefinition(node) {
         this.visitNode(node.column);
@@ -410,6 +433,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitUpdateQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -804,6 +831,25 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.visitNode(node.name);
     }
+    visitExplain(node) {
+        this.append('explain');
+        if (node.options || node.format) {
+            this.append(' ');
+            this.append(this.getLeftExplainOptionsWrapper());
+            if (node.options) {
+                this.visitNode(node.options);
+                if (node.format) {
+                    this.append(this.getExplainOptionsDelimiter());
+                }
+            }
+            if (node.format) {
+                this.append('format');
+                this.append(this.getExplainOptionAssignment());
+                this.append(node.format);
+            }
+            this.append(this.getRightExplainOptionsWrapper());
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -820,6 +866,33 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     getCurrentParameterPlaceholder() {
         return '$' + this.numParameters;
     }
+    getLeftExplainOptionsWrapper() {
+        return '(';
+    }
+    getExplainOptionAssignment() {
+        return ' ';
+    }
+    getExplainOptionsDelimiter() {
+        return ', ';
+    }
+    getRightExplainOptionsWrapper() {
+        return ')';
+    }
+    sanitizeIdentifier(identifier) {
+        const leftWrap = this.getLeftIdentifierWrapper();
+        const rightWrap = this.getRightIdentifierWrapper();
+        let sanitized = '';
+        for (const c of identifier) {
+            sanitized += c;
+            if (c === leftWrap) {
+                sanitized += leftWrap;
+            }
+            else if (c === rightWrap) {
+                sanitized += rightWrap;
+            }
+        }
+        return sanitized;
+    }
     addParameter(parameter) {
         this.#parameters.push(parameter);
     }

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

@@ -161,6 +161,33 @@ export declare class QueryCreator<DB> {
      * ```
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *

package/dist/esm/query-creator.js

@@ -70,6 +70,39 @@ export class QueryCreator {
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto(table) {
+        return new InsertQueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true),
+        });
+    }
     /**
      * Creates a delete query.
      *

package/dist/esm/query-executor/query-executor-base.d.ts

@@ -36,6 +36,12 @@ export declare abstract class QueryExecutorBase implements QueryExecutor {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

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

@@ -1,5 +1,6 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { Deferred } from '../util/deferred.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -34,6 +35,24 @@ export class QueryExecutorBase {
             return this.#transformResult(result, queryId);
         });
     }
+    async *stream(compiledQuery, chunkSize, queryId) {
+        const connectionDefer = new Deferred();
+        const connectionReleaseDefer = new Deferred();
+        this.provideConnection(async (connection) => {
+            connectionDefer.resolve(connection);
+            // Lets wait until we don't need connection before returning here (returning releases connection)
+            return await connectionReleaseDefer.promise;
+        }).catch((ex) => connectionDefer.reject(ex));
+        const connection = await connectionDefer.promise;
+        try {
+            for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
+                yield await this.#transformResult(result, queryId);
+            }
+        }
+        finally {
+            connectionReleaseDefer.resolve();
+        }
+    }
     async #transformResult(result, queryId) {
         for (const plugin of this.#plugins) {
             result = await plugin.transformResult({ result, queryId });

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

@@ -37,6 +37,17 @@ export interface QueryExecutor extends ConnectionProvider {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, 
+    /**
+     * How many rows should be pulled from the database at once. Supported
+     * only by the postgres driver.
+     */
+    chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

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

@@ -1,5 +1,101 @@
 import { RawBuilder } from './raw-builder.js';
 export interface Sql {
+    /**
+     * Template tag for creating raw SQL snippets and queries.
+     *
+     * ```ts
+     * 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.
+     *
+     * 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},
+     * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
+     *
+     * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
+     * something can't be done using the Kysely API, you should be able to drop down to
+     * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
+     * of methods:
+     *
+     * ```ts
+     * const persons = await db
+     *   .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.
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .where(sql`birthdate between ${date1} and ${date2}`)
+     *   // Here we assume we have list of nicknames for the person
+     *   // (a list of strings) and we use the PostgreSQL `@>` operator
+     *   // to test if all of them are valid nicknames for the user.
+     *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
+     *   .orderBy(sql`concat(first_name, ' ', last_name)`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * where birthdate between $1 and $2
+     * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
+     * order by concat(first_name, ' ', last_name)
+     * ```
+     *
+     * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
+     * instance as the only argument:
+     *
+     * ```ts
+     * const result = await sql<Person[]>`select * from person`.execute(db)
+     * ```
+     *
+     * You can merge other `sql` expressions and queries using substitutions:
+     *
+     * ```ts
+     * const petName = db.selectFrom('pet').select('name').limit(1)
+     * const fullName = sql`concat(first_name, ' ', last_name)`
+     *
+     * sql`
+     *   select ${fullName} as full_name, ${petName} as pet_name
+     *   from person
+     * `
+     * ```
+     *
+     * Substitutions also handle {@link ExpressionBuilder.ref},
+     * {@link DynamicModule.ref} and pretty much anything else you
+     * throw at it. Here's an example of calling a function in a
+     * type-safe way:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select([
+     *     'first_name',
+     *     'last_name',
+     *     (eb) => {
+     *       // The `eb.ref` method is type-safe and only accepts
+     *       // column references that are possible.
+     *       const firstName = eb.ref('first_name')
+     *       const lastName = eb.ref('last_name')
+     *
+     *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+     *       return fullName.as('full_name')
+     *     }
+     *   ])
+     * ```
+     *
+     * don't know if that amount of ceremony is worth the small increase in
+     * type-safety though... But it's possible.
+     */
     <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
     /**
      * This can be used to add runtime column references to SQL snippets.
@@ -232,100 +328,4 @@ export interface Sql {
      */
     join(array: unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
 }
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * 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.
- *
- * 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},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .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.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 export declare const sql: Sql;

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

@@ -7,102 +7,6 @@ import { parseTable } from '../parser/table-parser.js';
 import { parseValueExpression } from '../parser/value-parser.js';
 import { createQueryId } from '../util/query-id.js';
 import { RawBuilder } from './raw-builder.js';
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * 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.
- *
- * 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},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .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.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 export const sql = Object.assign((sqlFragments, ...parameters) => {
     return new RawBuilder({
         queryId: createQueryId(),

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

@@ -9,6 +9,7 @@ import { ColumnDefinitionNode } from '../operation-node/column-definition-node.j
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
 import { GeneratedNode } from '../operation-node/generated-node.js';
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
+import { parseOnModifyForeignAction } from '../parser/on-modify-action-parser.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -36,7 +37,7 @@ export class ColumnDefinitionBuilder {
             throw new Error('on delete constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            references: ReferencesNode.cloneWithOnDelete(this.#node.references, onDelete),
+            references: ReferencesNode.cloneWithOnDelete(this.#node.references, parseOnModifyForeignAction(onDelete)),
         }));
     }
     onUpdate(onUpdate) {
@@ -44,7 +45,7 @@ export class ColumnDefinitionBuilder {
             throw new Error('on update constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            references: ReferencesNode.cloneWithOnUpdate(this.#node.references, onUpdate),
+            references: ReferencesNode.cloneWithOnUpdate(this.#node.references, parseOnModifyForeignAction(onUpdate)),
         }));
     }
     unique() {