kysely 0.27.6 → 0.28.0

package/dist/esm/kysely.js

@@ -7,8 +7,7 @@ import { DefaultQueryExecutor } from './query-executor/default-query-executor.js
 import { freeze, isObject, isUndefined } from './util/object-utils.js';
 import { RuntimeDriver } from './driver/runtime-driver.js';
 import { SingleConnectionProvider } from './driver/single-connection-provider.js';
-import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
-import { preventAwait } from './util/prevent-await.js';
+import { validateTransactionSettings, } from './driver/driver.js';
 import { createFunctionModule, } from './query-builder/function-module.js';
 import { Log } from './util/log.js';
 import { createQueryId } from './util/query-id.js';
@@ -17,6 +16,9 @@ import { CaseBuilder } from './query-builder/case-builder.js';
 import { CaseNode } from './operation-node/case-node.js';
 import { parseExpression } from './parser/expression-parser.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
+import { provideControlledConnection, } from './util/provide-controlled-connection.js';
+// @ts-ignore
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
 /**
  * The main Kysely class.
  *
@@ -173,6 +175,9 @@ export class Kysely extends QueryCreator {
      * of type {@link Transaction} which inherits {@link Kysely}. Any query
      * started through the transaction object is executed inside the transaction.
      *
+     * To run a controlled transaction, allowing you to commit and rollback manually,
+     * use {@link startTransaction} instead.
+     *
      * ### Examples
      *
      * <!-- siteExample("transactions", "Simple transaction", 10) -->
@@ -227,6 +232,120 @@ export class Kysely extends QueryCreator {
     transaction() {
         return new TransactionBuilder({ ...this.#props });
     }
+    /**
+     * Creates a {@link ControlledTransactionBuilder} that can be used to run queries inside a controlled transaction.
+     *
+     * The returned {@link ControlledTransactionBuilder} can be used to configure the transaction.
+     * The {@link ControlledTransactionBuilder.execute} method can then be called
+     * to start the transaction and return a {@link ControlledTransaction}.
+     *
+     * A {@link ControlledTransaction} allows you to commit and rollback manually,
+     * execute savepoint commands. It extends {@link Transaction} which extends {@link Kysely},
+     * so you can run queries inside the transaction. Once the transaction is committed,
+     * or rolled back, it can't be used anymore - all queries will throw an error.
+     * This is to prevent accidentally running queries outside the transaction - where
+     * atomicity is not guaranteed anymore.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("transactions", "Controlled transaction", 11) -->
+     *
+     * A controlled transaction allows you to commit and rollback manually, execute
+     * savepoint commands, and queries in general.
+     *
+     * In this example we start a transaction, use it to insert two rows and then commit
+     * the transaction. If an error is thrown, we catch it and rollback the transaction.
+     *
+     * ```ts
+     * const trx = await db.startTransaction().execute()
+     *
+     * try {
+     *   const jennifer = await trx.insertInto('person')
+     *     .values({
+     *       first_name: 'Jennifer',
+     *       last_name: 'Aniston',
+     *       age: 40,
+     *     })
+     *     .returning('id')
+     *     .executeTakeFirstOrThrow()
+     *
+     *   const catto = await trx.insertInto('pet')
+     *     .values({
+     *       owner_id: jennifer.id,
+     *       name: 'Catto',
+     *       species: 'cat',
+     *       is_favorite: false,
+     *     })
+     *     .returningAll()
+     *     .executeTakeFirstOrThrow()
+     *
+     *   await trx.commit().execute()
+     *
+     *   // ...
+     * } catch (error) {
+     *   await trx.rollback().execute()
+     * }
+     * ```
+     *
+     * <!-- siteExample("transactions", "Controlled transaction /w savepoints", 12) -->
+     *
+     * A controlled transaction allows you to commit and rollback manually, execute
+     * savepoint commands, and queries in general.
+     *
+     * In this example we start a transaction, insert a person, create a savepoint,
+     * try inserting a toy and a pet, and if an error is thrown, we rollback to the
+     * savepoint. Eventually we release the savepoint, insert an audit record and
+     * commit the transaction. If an error is thrown, we catch it and rollback the
+     * transaction.
+     *
+     * ```ts
+     * const trx = await db.startTransaction().execute()
+     *
+     * try {
+     *   const jennifer = await trx
+     *     .insertInto('person')
+     *     .values({
+     *       first_name: 'Jennifer',
+     *       last_name: 'Aniston',
+     *       age: 40,
+     *     })
+     *     .returning('id')
+     *     .executeTakeFirstOrThrow()
+     *
+     *   const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+     *
+     *   try {
+     *     const catto = await trxAfterJennifer
+     *       .insertInto('pet')
+     *       .values({
+     *         owner_id: jennifer.id,
+     *         name: 'Catto',
+     *         species: 'cat',
+     *       })
+     *       .returning('id')
+     *       .executeTakeFirstOrThrow()
+     *
+     *     await trxAfterJennifer
+     *       .insertInto('toy')
+     *       .values({ name: 'Bone', price: 1.99, pet_id: catto.id })
+     *       .execute()
+     *   } catch (error) {
+     *     await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+     *   }
+     *
+     *   await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+     *
+     *   await trx.insertInto('audit').values({ action: 'added Jennifer' }).execute()
+     *
+     *   await trx.commit().execute()
+     * } catch (error) {
+     *   await trx.rollback().execute()
+     * }
+     * ```
+     */
+    startTransaction() {
+        return new ControlledTransactionBuilder({ ...this.#props });
+    }
     /**
      * Provides a kysely instance bound to a single database connection.
      *
@@ -342,6 +461,9 @@ export class Kysely extends QueryCreator {
         const compiledQuery = isCompilable(query) ? query.compile() : query;
         return this.getExecutor().executeQuery(compiledQuery, queryId);
     }
+    async [Symbol.asyncDispose]() {
+        await this.destroy();
+    }
 }
 export class Transaction extends Kysely {
     #props;
@@ -409,12 +531,17 @@ export class ConnectionBuilder {
         });
     }
 }
-preventAwait(ConnectionBuilder, "don't await ConnectionBuilder instances directly. To execute the query you need to call the `execute` method");
 export class TransactionBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
+    setAccessMode(accessMode) {
+        return new TransactionBuilder({
+            ...this.#props,
+            accessMode,
+        });
+    }
     setIsolationLevel(isolationLevel) {
         return new TransactionBuilder({
             ...this.#props,
@@ -422,8 +549,8 @@ export class TransactionBuilder {
         });
     }
     async execute(callback) {
-        const { isolationLevel, ...kyselyProps } = this.#props;
-        const settings = { isolationLevel };
+        const { isolationLevel, accessMode, ...kyselyProps } = this.#props;
+        const settings = { isolationLevel, accessMode };
         validateTransactionSettings(settings);
         return this.#props.executor.provideConnection(async (connection) => {
             const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
@@ -444,10 +571,334 @@ export class TransactionBuilder {
         });
     }
 }
-preventAwait(TransactionBuilder, "don't await TransactionBuilder instances directly. To execute the transaction you need to call the `execute` method");
-function validateTransactionSettings(settings) {
-    if (settings.isolationLevel &&
-        !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
-        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+export class ControlledTransactionBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    setAccessMode(accessMode) {
+        return new ControlledTransactionBuilder({
+            ...this.#props,
+            accessMode,
+        });
+    }
+    setIsolationLevel(isolationLevel) {
+        return new ControlledTransactionBuilder({
+            ...this.#props,
+            isolationLevel,
+        });
+    }
+    async execute() {
+        const { isolationLevel, accessMode, ...props } = this.#props;
+        const settings = { isolationLevel, accessMode };
+        validateTransactionSettings(settings);
+        const connection = await provideControlledConnection(this.#props.executor);
+        await this.#props.driver.beginTransaction(connection.connection, settings);
+        return new ControlledTransaction({
+            ...props,
+            connection,
+            executor: this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection.connection)),
+        });
+    }
+}
+export class ControlledTransaction extends Transaction {
+    #props;
+    #compileQuery;
+    #state;
+    constructor(props) {
+        const state = { isCommitted: false, isRolledBack: false };
+        props = {
+            ...props,
+            executor: new NotCommittedOrRolledBackAssertingExecutor(props.executor, state),
+        };
+        const { connection, ...transactionProps } = props;
+        super(transactionProps);
+        this.#props = freeze(props);
+        this.#state = state;
+        const queryId = createQueryId();
+        this.#compileQuery = (node) => props.executor.compileQuery(node, queryId);
+    }
+    get isCommitted() {
+        return this.#state.isCommitted;
+    }
+    get isRolledBack() {
+        return this.#state.isRolledBack;
+    }
+    /**
+     * Commits the transaction.
+     *
+     * See {@link rollback}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Kysely } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
+     * const trx = await db.startTransaction().execute()
+     *
+     * try {
+     *   await doSomething(trx)
+     *
+     *   await trx.commit().execute()
+     * } catch (error) {
+     *   await trx.rollback().execute()
+     * }
+     *
+     * async function doSomething(kysely: Kysely<Database>) {}
+     * ```
+     */
+    commit() {
+        assertNotCommittedOrRolledBack(this.#state);
+        return new Command(async () => {
+            await this.#props.driver.commitTransaction(this.#props.connection.connection);
+            this.#state.isCommitted = true;
+            this.#props.connection.release();
+        });
+    }
+    /**
+     * Rolls back the transaction.
+     *
+     * See {@link commit} and {@link rollbackToSavepoint}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Kysely } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
+     * const trx = await db.startTransaction().execute()
+     *
+     * try {
+     *   await doSomething(trx)
+     *
+     *   await trx.commit().execute()
+     * } catch (error) {
+     *   await trx.rollback().execute()
+     * }
+     *
+     * async function doSomething(kysely: Kysely<Database>) {}
+     * ```
+     */
+    rollback() {
+        assertNotCommittedOrRolledBack(this.#state);
+        return new Command(async () => {
+            await this.#props.driver.rollbackTransaction(this.#props.connection.connection);
+            this.#state.isRolledBack = true;
+            this.#props.connection.release();
+        });
+    }
+    /**
+     * Creates a savepoint with a given name.
+     *
+     * See {@link rollbackToSavepoint} and {@link releaseSavepoint}.
+     *
+     * For a type-safe experience, you should use the returned instance from now on.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Kysely } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
+     * const trx = await db.startTransaction().execute()
+     *
+     * await insertJennifer(trx)
+     *
+     * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+     *
+     * try {
+     *   await doSomething(trxAfterJennifer)
+     * } catch (error) {
+     *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+     * }
+     *
+     * async function insertJennifer(kysely: Kysely<Database>) {}
+     * async function doSomething(kysely: Kysely<Database>) {}
+     * ```
+     */
+    savepoint(savepointName) {
+        assertNotCommittedOrRolledBack(this.#state);
+        return new Command(async () => {
+            await this.#props.driver.savepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            return new ControlledTransaction({ ...this.#props });
+        });
+    }
+    /**
+     * Rolls back to a savepoint with a given name.
+     *
+     * See {@link savepoint} and {@link releaseSavepoint}.
+     *
+     * You must use the same instance returned by {@link savepoint}, or
+     * escape the type-check by using `as any`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Kysely } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
+     * const trx = await db.startTransaction().execute()
+     *
+     * await insertJennifer(trx)
+     *
+     * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+     *
+     * try {
+     *   await doSomething(trxAfterJennifer)
+     * } catch (error) {
+     *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+     * }
+     *
+     * async function insertJennifer(kysely: Kysely<Database>) {}
+     * async function doSomething(kysely: Kysely<Database>) {}
+     * ```
+     */
+    rollbackToSavepoint(savepointName) {
+        assertNotCommittedOrRolledBack(this.#state);
+        return new Command(async () => {
+            await this.#props.driver.rollbackToSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            return new ControlledTransaction({ ...this.#props });
+        });
+    }
+    /**
+     * Releases a savepoint with a given name.
+     *
+     * See {@link savepoint} and {@link rollbackToSavepoint}.
+     *
+     * You must use the same instance returned by {@link savepoint}, or
+     * escape the type-check by using `as any`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Kysely } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
+     * const trx = await db.startTransaction().execute()
+     *
+     * await insertJennifer(trx)
+     *
+     * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+     *
+     * try {
+     *   await doSomething(trxAfterJennifer)
+     * } catch (error) {
+     *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+     * }
+     *
+     * await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+     *
+     * await doSomethingElse(trx)
+     *
+     * async function insertJennifer(kysely: Kysely<Database>) {}
+     * async function doSomething(kysely: Kysely<Database>) {}
+     * async function doSomethingElse(kysely: Kysely<Database>) {}
+     * ```
+     */
+    releaseSavepoint(savepointName) {
+        assertNotCommittedOrRolledBack(this.#state);
+        return new Command(async () => {
+            await this.#props.driver.releaseSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            return new ControlledTransaction({ ...this.#props });
+        });
+    }
+    withPlugin(plugin) {
+        return new ControlledTransaction({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    withoutPlugins() {
+        return new ControlledTransaction({
+            ...this.#props,
+            executor: this.#props.executor.withoutPlugins(),
+        });
+    }
+    withSchema(schema) {
+        return new ControlledTransaction({
+            ...this.#props,
+            executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
+        });
+    }
+    withTables() {
+        return new ControlledTransaction({ ...this.#props });
+    }
+}
+export class Command {
+    #cb;
+    constructor(cb) {
+        this.#cb = cb;
+    }
+    /**
+     * Executes the command.
+     */
+    async execute() {
+        return await this.#cb();
+    }
+}
+function assertNotCommittedOrRolledBack(state) {
+    if (state.isCommitted) {
+        throw new Error('Transaction is already committed');
+    }
+    if (state.isRolledBack) {
+        throw new Error('Transaction is already rolled back');
+    }
+}
+/**
+ * An executor wrapper that asserts that the transaction state is not committed
+ * or rolled back when a query is executed.
+ *
+ * @internal
+ */
+class NotCommittedOrRolledBackAssertingExecutor {
+    #executor;
+    #state;
+    constructor(executor, state) {
+        if (executor instanceof NotCommittedOrRolledBackAssertingExecutor) {
+            this.#executor = executor.#executor;
+        }
+        else {
+            this.#executor = executor;
+        }
+        this.#state = state;
+    }
+    get adapter() {
+        return this.#executor.adapter;
+    }
+    get plugins() {
+        return this.#executor.plugins;
+    }
+    transformQuery(node, queryId) {
+        return this.#executor.transformQuery(node, queryId);
+    }
+    compileQuery(node, queryId) {
+        return this.#executor.compileQuery(node, queryId);
+    }
+    provideConnection(consumer) {
+        return this.#executor.provideConnection(consumer);
+    }
+    executeQuery(compiledQuery, queryId) {
+        assertNotCommittedOrRolledBack(this.#state);
+        return this.#executor.executeQuery(compiledQuery, queryId);
+    }
+    stream(compiledQuery, chunkSize, queryId) {
+        assertNotCommittedOrRolledBack(this.#state);
+        return this.#executor.stream(compiledQuery, chunkSize, queryId);
+    }
+    withConnectionProvider(connectionProvider) {
+        return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withConnectionProvider(connectionProvider), this.#state);
+    }
+    withPlugin(plugin) {
+        return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugin(plugin), this.#state);
+    }
+    withPlugins(plugins) {
+        return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugins(plugins), this.#state);
+    }
+    withPluginAtFront(plugin) {
+        return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPluginAtFront(plugin), this.#state);
+    }
+    withoutPlugins() {
+        return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withoutPlugins(), this.#state);
     }
 }

package/dist/esm/migration/migrator.d.ts

@@ -287,6 +287,14 @@ export interface MigratorProps {
      * Default is `name0.localeCompare(name1)`.
      */
     readonly nameComparator?: (name0: string, name1: string) => number;
+    /**
+     * When `true`, don't run migrations in transactions even if the dialect supports transactional DDL.
+     *
+     * Default is `false`.
+     *
+     * This is useful when some migrations include queries that would fail otherwise.
+     */
+    readonly disableTransactions?: boolean;
 }
 /**
  * All migration methods ({@link Migrator.migrateTo | migrateTo},

package/dist/esm/migration/migrator.js

@@ -424,7 +424,7 @@ export class Migrator {
                 await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
-        if (adapter.supportsTransactionalDdl) {
+        if (adapter.supportsTransactionalDdl && !this.#props.disableTransactions) {
             return this.#props.db.transaction().execute(run);
         }
         else {

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -9,6 +9,7 @@ export interface AggregateFunctionNode extends OperationNode {
     readonly aggregated: readonly OperationNode[];
     readonly distinct?: boolean;
     readonly orderBy?: OrderByNode;
+    readonly withinGroup?: OrderByNode;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
@@ -19,7 +20,7 @@ export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
     create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
-    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>): AggregateFunctionNode;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;

package/dist/esm/operation-node/aggregate-function-node.js

@@ -22,11 +22,12 @@ export const AggregateFunctionNode = freeze({
             distinct: true,
         });
     },
-    cloneWithOrderBy(aggregateFunctionNode, orderItems) {
+    cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
+        const prop = withinGroup ? 'withinGroup' : 'orderBy';
         return freeze({
             ...aggregateFunctionNode,
-            orderBy: aggregateFunctionNode.orderBy
-                ? OrderByNode.cloneWithItems(aggregateFunctionNode.orderBy, orderItems)
+            [prop]: aggregateFunctionNode[prop]
+                ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems)
                 : OrderByNode.create(orderItems),
         });
     },

package/dist/esm/operation-node/alter-table-node.d.ts

@@ -10,7 +10,8 @@ import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { DropIndexNode } from './drop-index-node.js';
 import { AddIndexNode } from './add-index-node.js';
-export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex'>;
+import { RenameConstraintNode } from './rename-constraint-node.js';
+export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
 export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
@@ -20,6 +21,7 @@ export interface AlterTableNode extends OperationNode {
     readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
     readonly addConstraint?: AddConstraintNode;
     readonly dropConstraint?: DropConstraintNode;
+    readonly renameConstraint?: RenameConstraintNode;
     readonly addIndex?: AddIndexNode;
     readonly dropIndex?: DropIndexNode;
 }

package/dist/esm/operation-node/collate-node.d.ts

@@ -0,0 +1,13 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export interface CollateNode extends OperationNode {
+    readonly kind: 'CollateNode';
+    readonly collation: IdentifierNode;
+}
+/**
+ * @internal
+ */
+export declare const CollateNode: {
+    is(node: OperationNode): node is CollateNode;
+    create(collation: string): CollateNode;
+};

package/dist/esm/operation-node/collate-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./collate-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CollateNode = {
+    is(node) {
+        return node.kind === 'CollateNode';
+    },
+    create(collation) {
+        return freeze({
+            kind: 'CollateNode',
+            collation: IdentifierNode.create(collation),
+        });
+    },
+};

package/dist/esm/operation-node/constraint-node.d.ts

@@ -1,5 +1,5 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
-import { PrimaryKeyConstraintNode } from './primary-constraint-node.js';
+import { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
 export type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

package/dist/esm/operation-node/create-type-node.d.ts

@@ -13,5 +13,5 @@ export interface CreateTypeNode extends OperationNode {
 export declare const CreateTypeNode: Readonly<{
     is(node: OperationNode): node is CreateTypeNode;
     create(name: SchemableIdentifierNode): CreateTypeNode;
-    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: readonly string[]): CreateTypeNode;
 }>;

package/dist/esm/operation-node/create-type-node.js

@@ -18,7 +18,7 @@ export const CreateTypeNode = freeze({
     cloneWithEnum(createType, values) {
         return freeze({
             ...createType,
-            enum: ValueListNode.create(values.map((value) => ValueNode.createImmediate(value))),
+            enum: ValueListNode.create(values.map(ValueNode.createImmediate)),
         });
     },
 });

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -32,8 +32,14 @@ export interface DeleteQueryNode extends OperationNode {
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
-    cloneWithOrderByItems(deleteNode: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): DeleteQueryNode;
-    cloneWithoutOrderBy(deleteNode: DeleteQueryNode): DeleteQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>) => DeleteQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node: DeleteQueryNode) => DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;