kysely 0.27.5 → 0.28.0

package/dist/cjs/kysely.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionBuilder = exports.ConnectionBuilder = exports.Transaction = exports.Kysely = void 0;
+exports.Command = exports.ControlledTransaction = exports.ControlledTransactionBuilder = exports.TransactionBuilder = exports.ConnectionBuilder = exports.Transaction = exports.Kysely = void 0;
 exports.isKyselyProps = isKyselyProps;
 const schema_js_1 = require("./schema/schema.js");
 const dynamic_js_1 = require("./dynamic/dynamic.js");
@@ -11,7 +11,6 @@ const object_utils_js_1 = require("./util/object-utils.js");
 const runtime_driver_js_1 = require("./driver/runtime-driver.js");
 const single_connection_provider_js_1 = require("./driver/single-connection-provider.js");
 const driver_js_1 = require("./driver/driver.js");
-const prevent_await_js_1 = require("./util/prevent-await.js");
 const function_module_js_1 = require("./query-builder/function-module.js");
 const log_js_1 = require("./util/log.js");
 const query_id_js_1 = require("./util/query-id.js");
@@ -20,6 +19,9 @@ const case_builder_js_1 = require("./query-builder/case-builder.js");
 const case_node_js_1 = require("./operation-node/case-node.js");
 const expression_parser_js_1 = require("./parser/expression-parser.js");
 const with_schema_plugin_js_1 = require("./plugin/with-schema/with-schema-plugin.js");
+const provide_controlled_connection_js_1 = require("./util/provide-controlled-connection.js");
+// @ts-ignore
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
 /**
  * The main Kysely class.
  *
@@ -176,6 +178,9 @@ class Kysely extends query_creator_js_1.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) -->
@@ -230,6 +235,120 @@ class Kysely extends query_creator_js_1.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.
      *
@@ -345,6 +464,9 @@ class Kysely extends query_creator_js_1.QueryCreator {
         const compiledQuery = (0, compilable_js_1.isCompilable)(query) ? query.compile() : query;
         return this.getExecutor().executeQuery(compiledQuery, queryId);
     }
+    async [Symbol.asyncDispose]() {
+        await this.destroy();
+    }
 }
 exports.Kysely = Kysely;
 class Transaction extends Kysely {
@@ -415,12 +537,17 @@ class ConnectionBuilder {
     }
 }
 exports.ConnectionBuilder = ConnectionBuilder;
-(0, prevent_await_js_1.preventAwait)(ConnectionBuilder, "don't await ConnectionBuilder instances directly. To execute the query you need to call the `execute` method");
 class TransactionBuilder {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    setAccessMode(accessMode) {
+        return new TransactionBuilder({
+            ...this.#props,
+            accessMode,
+        });
+    }
     setIsolationLevel(isolationLevel) {
         return new TransactionBuilder({
             ...this.#props,
@@ -428,9 +555,9 @@ class TransactionBuilder {
         });
     }
     async execute(callback) {
-        const { isolationLevel, ...kyselyProps } = this.#props;
-        const settings = { isolationLevel };
-        validateTransactionSettings(settings);
+        const { isolationLevel, accessMode, ...kyselyProps } = this.#props;
+        const settings = { isolationLevel, accessMode };
+        (0, driver_js_1.validateTransactionSettings)(settings);
         return this.#props.executor.provideConnection(async (connection) => {
             const executor = this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection));
             const transaction = new Transaction({
@@ -451,10 +578,337 @@ class TransactionBuilder {
     }
 }
 exports.TransactionBuilder = TransactionBuilder;
-(0, prevent_await_js_1.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 &&
-        !driver_js_1.TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
-        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+class ControlledTransactionBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.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 };
+        (0, driver_js_1.validateTransactionSettings)(settings);
+        const connection = await (0, provide_controlled_connection_js_1.provideControlledConnection)(this.#props.executor);
+        await this.#props.driver.beginTransaction(connection.connection, settings);
+        return new ControlledTransaction({
+            ...props,
+            connection,
+            executor: this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection.connection)),
+        });
+    }
+}
+exports.ControlledTransactionBuilder = ControlledTransactionBuilder;
+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 = (0, object_utils_js_1.freeze)(props);
+        this.#state = state;
+        const queryId = (0, query_id_js_1.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 with_schema_plugin_js_1.WithSchemaPlugin(schema)),
+        });
+    }
+    withTables() {
+        return new ControlledTransaction({ ...this.#props });
+    }
+}
+exports.ControlledTransaction = ControlledTransaction;
+class Command {
+    #cb;
+    constructor(cb) {
+        this.#cb = cb;
+    }
+    /**
+     * Executes the command.
+     */
+    async execute() {
+        return await this.#cb();
+    }
+}
+exports.Command = Command;
+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/cjs/migration/migrator.d.ts

@@ -271,7 +271,7 @@ export interface MigratorProps {
      *
      * When false, migrations must be run in their exact alpha-numeric order.
      * This is checked against the migrations already run in the database
-     * (`migrationTableName'). This ensures your migrations are always run in
+     * (`migrationTableName`). This ensures your migrations are always run in
      * the same order and is the safest option.
      *
      * When true, migrations are still run in alpha-numeric order, but
@@ -280,6 +280,21 @@ export interface MigratorProps {
      * order.
      */
     readonly allowUnorderedMigrations?: boolean;
+    /**
+     * A function that compares migration names, used when sorting migrations in
+     * ascending order.
+     *
+     * 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/cjs/migration/migrator.js

@@ -63,6 +63,7 @@ class Migrator {
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
                 .select(['name', 'timestamp'])
+                .$narrowType()
                 .execute()
             : [];
         const migrations = await this.#resolveMigrations();
@@ -425,7 +426,7 @@ class Migrator {
                 await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
-        if (adapter.supportsTransactionalDdl) {
+        if (adapter.supportsTransactionalDdl && !this.#props.disableTransactions) {
             return this.#props.db.transaction().execute(run);
         }
         else {
@@ -465,10 +466,19 @@ class Migrator {
         const executedMigrations = await db
             .withPlugin(this.#schemaPlugin)
             .selectFrom(this.#migrationTable)
-            .select('name')
-            .orderBy(['timestamp', 'name'])
+            .select(['name', 'timestamp'])
+            .$narrowType()
             .execute();
-        return executedMigrations.map((it) => it.name);
+        const nameComparator = this.#props.nameComparator || ((a, b) => a.localeCompare(b));
+        return (executedMigrations
+            // https://github.com/kysely-org/kysely/issues/843
+            .sort((a, b) => {
+            if (a.timestamp === b.timestamp) {
+                return nameComparator(a.name, b.name);
+            }
+            return (new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        })
+            .map((it) => it.name));
     }
     #ensureNoMissingMigrations(migrations, executedMigrations) {
         // Ensure all executed migrations exist in the `migrations` list.

package/dist/cjs/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/cjs/operation-node/aggregate-function-node.js

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

package/dist/cjs/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/cjs/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;
+};