kysely 0.12.2 → 0.15.0

package/dist/cjs/migration/migrator.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migrator = exports.NO_MIGRATIONS = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const private_symbols_js_1 = require("../util/private-symbols.js");
+exports.MIGRATION_TABLE = 'kysely_migration';
+exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
+exports.MIGRATION_LOCK_ID = 'migration_lock';
+exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true });
+/**
+ * A class for running migrations.
+ *
+ * ### Example
+ *
+ * This example uses the {@link FileMigrationProvider} that reads migrations
+ * files from a single folder. You can easily implement your own
+ * {@link MigrationProvider} if you want to provide migrations some
+ * other way.
+ *
+ * ```ts
+ * const migrator = new Migrator({
+ *   db,
+ *   // The constructor signature of FileMigrationProvider is a
+ *   // bit weird to keep Kysely independent of node.js or any
+ *   // other environment.
+ *   provider: new FileMigrationProvider(
+ *     fs.readdir,
+ *     path.join,
+ *     // Path to the folder that contains all your migrations.
+ *     'migrations'
+ *   )
+ * })
+ * ```
+ */
+class Migrator {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Runs all migrations that have not yet been run.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed. See the examples below.
+     *
+     * This method goes through all possible migrations provided by the provider and runs the
+     * ones whose names come alphabetically after the last migration that has been run. If the
+     * list of executed migrations doesn't match the beginning of the list of possible migrations
+     * an error is thrown.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import * as path from 'path'
+     * import * as fs from 'fs/promises'
+     *
+     * const db = new Kysely<Database>({
+     *   dialect: new PostgresDialect({
+     *     host: 'localhost',
+     *     database: 'kysely_test',
+     *   }),
+     * })
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   // The constructor signature of FileMigrationProvider is a
+     *   // bit weird to keep Kysely independent of node.js or any
+     *   // other environment.
+     *   provider: new FileMigrationProvider(
+     *     fs.readdir,
+     *     path.join,
+     *     // Path to the folder that contains all your migrations.
+     *     'migrations'
+     *   )
+     * })
+     *
+     * const { error, results } = await migrator.migrateToLatest()
+     *
+     * results?.forEach((it) => {
+     *   if (it.status === 'Success') {
+     *     console.log(`migration "${it.migrationName}" was executed successfully`)
+     *   } else if (it.status === 'Error') {
+     *     console.error(`failed to execute migration "${it.migrationName}"`)
+     *   }
+     * })
+     *
+     * if (error) {
+     *   console.error('failed to run `migrateToLatest`')
+     *   console.error(error)
+     * }
+     * ```
+     */
+    async migrateToLatest() {
+        return this.#migrate(({ migrations }) => migrations.length - 1);
+    }
+    /**
+     * Migrate up/down to a specific migration.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateTo('some_migration')
+     * ```
+     *
+     * If you specify the name of the first migration, this method migrates
+     * down to the first migration, but doesn't run the `down` method of
+     * the first migration. In case you want to migrate all the way down,
+     * you can use a special constant `NO_MIGRATIONS`:
+     *
+     * ```ts
+     * await migrator.migrateTo(NO_MIGRATIONS)
+     * ```
+     */
+    async migrateTo(targetMigrationName) {
+        return this.#migrate(({ migrations }) => {
+            if (targetMigrationName === exports.NO_MIGRATIONS) {
+                return -1;
+            }
+            const index = migrations.findIndex((it) => it.name === targetMigrationName);
+            if (index === -1) {
+                throw new Error(`migration "${targetMigrationName}" doesn't exist`);
+            }
+            return index;
+        });
+    }
+    /**
+     * Migrate one step up.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateUp()
+     * ```
+     */
+    async migrateUp() {
+        return this.#migrate(({ currentIndex, migrations }) => Math.min(currentIndex + 1, migrations.length - 1));
+    }
+    /**
+     * Migrate one step down.
+     *
+     * This method returns a {@link MigrationResultSet} instance and _never_ throws.
+     * {@link MigrationResultSet.error} holds the error if something went wrong.
+     * {@link MigrationResultSet.results} contains information about which migrations
+     * were executed and which failed.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await migrator.migrateDown()
+     * ```
+     */
+    async migrateDown() {
+        return this.#migrate(({ currentIndex }) => Math.max(currentIndex - 1, -1));
+    }
+    async #migrate(getTargetMigrationIndex) {
+        try {
+            await this.#ensureMigrationTablesExists();
+            return await this.#runMigrations(getTargetMigrationIndex);
+        }
+        catch (error) {
+            if (error instanceof MigrationResultSetError) {
+                return error.resultSet;
+            }
+            return { error };
+        }
+    }
+    async #ensureMigrationTablesExists() {
+        await this.#ensureMigrationTableExists();
+        await this.#ensureMigrationLockTableExists();
+        await this.#ensureLockRowExists();
+    }
+    async #ensureMigrationTableExists() {
+        if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+            try {
+                await this.#props.db.schema
+                    .createTable(exports.MIGRATION_TABLE)
+                    .ifNotExists()
+                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                    // The migration run time as ISO string. This is not a real date type as we
+                    // can't know which data type is supported by all future dialects.
+                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+                // query doesn't throw if the table already exits. That's why we check if
+                // the table exist here and ignore the error if it does.
+                if (!(await this.#doesTableExists(exports.MIGRATION_TABLE))) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #ensureMigrationLockTableExists() {
+        if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+            try {
+                await this.#props.db.schema
+                    .createTable(exports.MIGRATION_LOCK_TABLE)
+                    .ifNotExists()
+                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+                // query doesn't throw if the table already exits. That's why we check if
+                // the table exist here and ignore the error if it does.
+                if (!(await this.#doesTableExists(exports.MIGRATION_LOCK_TABLE))) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #ensureLockRowExists() {
+        if (!(await this.#doesLockRowExists())) {
+            try {
+                await this.#props.db
+                    .insertInto(exports.MIGRATION_LOCK_TABLE)
+                    .values({ id: exports.MIGRATION_LOCK_ID })
+                    .execute();
+            }
+            catch (error) {
+                if (!(await this.#doesLockRowExists())) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async #doesTableExists(tableName) {
+        const metadata = await this.#props.db.introspection.getMetadata({
+            withInternalKyselyTables: true,
+        });
+        return !!metadata.tables.find((it) => it.name === tableName);
+    }
+    async #doesLockRowExists() {
+        const lockRow = await this.#props.db
+            .selectFrom(exports.MIGRATION_LOCK_TABLE)
+            .where('id', '=', exports.MIGRATION_LOCK_ID)
+            .select('id')
+            .executeTakeFirst();
+        return !!lockRow;
+    }
+    async #runMigrations(getTargetMigrationIndex) {
+        const run = async (db) => {
+            try {
+                await this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].acquireMigrationLock(db);
+                const state = await this.#getState(db);
+                if (state.migrations.length === 0) {
+                    return { results: [] };
+                }
+                const targetIndex = getTargetMigrationIndex(state);
+                if (targetIndex === undefined) {
+                    return { results: [] };
+                }
+                if (targetIndex < state.currentIndex) {
+                    return await this.#migrateDown(db, state, targetIndex);
+                }
+                else if (targetIndex > state.currentIndex) {
+                    return await this.#migrateUp(db, state, targetIndex);
+                }
+                return { results: [] };
+            }
+            finally {
+                await this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].releaseMigrationLock(db);
+            }
+        };
+        if (this.#props.db[private_symbols_js_1.PRIVATE_ADAPTER].supportsTransactionalDdl) {
+            return this.#props.db.transaction().execute(run);
+        }
+        else {
+            return this.#props.db.connection().execute(run);
+        }
+    }
+    async #getState(db) {
+        const migrations = await this.#resolveMigrations();
+        const executedMigrations = await this.#getExecutedMigrations(db);
+        this.#ensureMigrationsNotCorrupted(migrations, executedMigrations);
+        return (0, object_utils_js_1.freeze)({
+            migrations,
+            currentIndex: migrations.findIndex((it) => it.name === (0, object_utils_js_1.getLast)(executedMigrations)),
+        });
+    }
+    async #resolveMigrations() {
+        const allMigrations = await this.#props.provider.getMigrations();
+        return Object.keys(allMigrations)
+            .sort()
+            .map((name) => ({
+            ...allMigrations[name],
+            name,
+        }));
+    }
+    async #getExecutedMigrations(db) {
+        const executedMigrations = await db
+            .selectFrom(exports.MIGRATION_TABLE)
+            .select('name')
+            .orderBy('name')
+            .execute();
+        return executedMigrations.map((it) => it.name);
+    }
+    #ensureMigrationsNotCorrupted(migrations, executedMigrations) {
+        for (const executed of executedMigrations) {
+            if (!migrations.some((it) => it.name === executed)) {
+                throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);
+            }
+        }
+        // Now we know all executed migrations exist in the `migrations` list.
+        // Next we need to make sure that the executed migratiosns are the first
+        // ones in the migration list.
+        for (let i = 0; i < executedMigrations.length; ++i) {
+            if (migrations[i].name !== executedMigrations[i]) {
+                throw new Error(`corrupted migrations: expected previously executed migration ${executedMigrations[i]} to be at index ${i} but ${migrations[i].name} was found in its place. New migrations must always have a name that comes alphabetically after the last executed migration.`);
+            }
+        }
+    }
+    async #migrateDown(db, state, targetIndex) {
+        const results = [];
+        for (let i = state.currentIndex; i > targetIndex; --i) {
+            results.push({
+                migrationName: state.migrations[i].name,
+                direction: 'Down',
+                status: 'NotExecuted',
+            });
+        }
+        for (let i = 0; i < results.length; ++i) {
+            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            try {
+                if (migration.down) {
+                    await migration.down(db);
+                    await db
+                        .deleteFrom(exports.MIGRATION_TABLE)
+                        .where('name', '=', migration.name)
+                        .execute();
+                    results[i] = {
+                        migrationName: migration.name,
+                        direction: 'Down',
+                        status: 'Success',
+                    };
+                }
+            }
+            catch (error) {
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Down',
+                    status: 'Error',
+                };
+                throw new MigrationResultSetError({
+                    error,
+                    results,
+                });
+            }
+        }
+        return { results };
+    }
+    async #migrateUp(db, state, targetIndex) {
+        const results = [];
+        for (let i = state.currentIndex + 1; i <= targetIndex; ++i) {
+            results.push({
+                migrationName: state.migrations[i].name,
+                direction: 'Up',
+                status: 'NotExecuted',
+            });
+        }
+        for (let i = 0; i < results.length; ++i) {
+            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            try {
+                await migration.up(db);
+                await db
+                    .insertInto(exports.MIGRATION_TABLE)
+                    .values({
+                    name: migration.name,
+                    timestamp: new Date().toISOString(),
+                })
+                    .execute();
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Up',
+                    status: 'Success',
+                };
+            }
+            catch (error) {
+                results[i] = {
+                    migrationName: migration.name,
+                    direction: 'Up',
+                    status: 'Error',
+                };
+                throw new MigrationResultSetError({
+                    error,
+                    results,
+                });
+            }
+        }
+        return { results };
+    }
+}
+exports.Migrator = Migrator;
+class MigrationResultSetError extends Error {
+    #resultSet;
+    constructor(result) {
+        super();
+        this.#resultSet = result;
+    }
+    get resultSet() {
+        return this.#resultSet;
+    }
+}

package/dist/cjs/operation-node/check-constraint-node.d.ts

@@ -11,5 +11,5 @@ export interface CheckConstraintNode extends OperationNode {
  */
 export declare const CheckConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expressionSql: string, constraintName?: string | undefined): CheckConstraintNode;
+    create(expression: RawNode, constraintName?: string | undefined): CheckConstraintNode;
 }>;

package/dist/cjs/operation-node/check-constraint-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckConstraintNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const raw_node_js_1 = require("./raw-node.js");
 const identifier_node_js_1 = require("./identifier-node.js");
 /**
  * @internal
@@ -11,10 +10,10 @@ exports.CheckConstraintNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'CheckConstraintNode';
     },
-    create(expressionSql, constraintName) {
+    create(expression, constraintName) {
         return (0, object_utils_js_1.freeze)({
             kind: 'CheckConstraintNode',
-            expression: raw_node_js_1.RawNode.createWithSql(expressionSql),
+            expression,
             name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
         });
     },

package/dist/cjs/operation-node/column-definition-node.d.ts

@@ -2,24 +2,25 @@ import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
 import { DefaultValueNode } from './default-value-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
+export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;
     readonly dataType: ColumnDataTypeNode;
     readonly references?: ReferencesNode;
-    readonly primaryKey: boolean;
-    readonly autoIncrement: boolean;
-    readonly unique: boolean;
-    readonly nullable: boolean;
+    readonly primaryKey?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly unique?: boolean;
+    readonly notNull?: boolean;
     readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
-    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
+    readonly generated?: GeneratedNode;
+    readonly unsigned?: boolean;
 }
 /**
  * @internal

package/dist/cjs/operation-node/column-definition-node.js

@@ -15,10 +15,6 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             kind: 'ColumnDefinitionNode',
             column: column_node_js_1.ColumnNode.create(column),
             dataType,
-            primaryKey: false,
-            autoIncrement: false,
-            unique: false,
-            nullable: true,
         });
     },
     cloneWith(node, props) {

package/dist/cjs/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb';
+export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
 export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

package/dist/cjs/operation-node/generated-node.d.ts

@@ -0,0 +1,20 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
+export interface GeneratedNode extends OperationNode {
+    readonly kind: 'GeneratedNode';
+    readonly byDefault?: boolean;
+    readonly always?: boolean;
+    readonly identity?: boolean;
+    readonly stored?: boolean;
+    readonly expression?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedNode: Readonly<{
+    is(node: OperationNode): node is GeneratedNode;
+    create(params: GeneratedNodeParams): GeneratedNode;
+    createWithExpression(expression: RawNode): GeneratedNode;
+    cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
+}>;

package/dist/cjs/operation-node/generated-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.GeneratedNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GeneratedNode';
+    },
+    create(params) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedNode',
+            ...params,
+        });
+    },
+    createWithExpression(expression) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedNode',
+            always: true,
+            expression,
+        });
+    },
+    cloneWith(node, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...params,
+        });
+    },
+});

package/dist/cjs/operation-node/on-conflict-node.d.ts

@@ -1,13 +1,19 @@
 import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind'>;
+import { RawNode } from './raw-node.js';
+import { WhereNode } from './where-node.js';
+export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly constraint?: IdentifierNode;
+    readonly indexExpression?: RawNode;
+    readonly indexWhere?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly updateWhere?: WhereNode;
     readonly doNothing?: boolean;
 }
 /**
@@ -15,5 +21,10 @@ export interface OnConflictNode extends OperationNode {
  */
 export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
-    create(props: OnConflictNodeProps): OnConflictNode;
+    create(): OnConflictNode;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
 }>;

package/dist/cjs/operation-node/on-conflict-node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnConflictNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const where_node_js_1 = require("./where-node.js");
 /**
  * @internal
  */
@@ -9,10 +10,47 @@ exports.OnConflictNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'OnConflictNode';
     },
-    create(props) {
+    create() {
         return (0, object_utils_js_1.freeze)({
             kind: 'OnConflictNode',
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
             ...props,
         });
     },
+    cloneWithIndexWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.indexWhere, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithIndexOrWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.indexWhere, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.updateWhere, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateOrWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.updateWhere, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
 });

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -61,7 +61,7 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
@@ -156,7 +156,7 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
-    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;